Adding upstream version 7.0.6-dfsg.upstream/7.0.6-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 412 insertions, 0 deletions

diff --git a/src/libs/xpcom18a4/nsprpub/pr/tests/thruput.c b/src/libs/xpcom18a4/nsprpub/pr/tests/thruput.c
new file mode 100644
index 00000000..e6319dbe
--- /dev/null
+++ b/src/libs/xpcom18a4/nsprpub/pr/tests/thruput.c
@@ -0,0 +1,412 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the Netscape Portable Runtime (NSPR).
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/*
+** File:        thruput.c
+** Description: Test server's throughput capability comparing various
+**              implmentation strategies.
+**
+** Note:        Requires a server machine and an aribitrary number of
+**              clients to bang on it. Trust the numbers on the server
+**              more than those being displayed by the various clients.
+*/
+
+#include "prerror.h"
+#include "prinrval.h"
+#include "prinit.h"
+#include "prio.h"
+#include "prlock.h"
+#include "prmem.h"
+#include "prnetdb.h"
+#include "prprf.h"
+#include "prthread.h"
+
+#include "pprio.h"
+
+#include "plerror.h"
+#include "plgetopt.h"
+
+#define ADDR_BUFFER 100
+#define PORT_NUMBER 51877
+#define SAMPLING_INTERVAL 10
+#define BUFFER_SIZE (32 * 1024)
+
+static PRInt32 domain = PR_AF_INET;
+static PRInt32 protocol = 6;  /* TCP */
+static PRFileDesc *err = NULL;
+static PRIntn concurrency = 1;
+static PRInt32 xport_buffer = -1;
+static PRUint32 initial_streams = 1;
+static PRInt32 buffer_size = BUFFER_SIZE;
+static PRThreadScope thread_scope = PR_LOCAL_THREAD;
+
+typedef struct Shared
+{
+    PRLock *ml;
+    PRUint32 sampled;
+    PRUint32 threads;
+    PRIntervalTime timein;
+    PRNetAddr server_address;
+} Shared;
+
+static Shared *shared = NULL;
+
+static PRStatus PrintAddress(const PRNetAddr* address)
+{
+    char buffer[ADDR_BUFFER];
+    PRStatus rv = PR_NetAddrToString(address, buffer, sizeof(buffer));
+    if (PR_SUCCESS == rv)
+        PR_fprintf(err, "%s:%u\n", buffer, PR_ntohs(address->inet.port));
+    else PL_FPrintError(err, "PR_NetAddrToString");
+    return rv;
+}  /* PrintAddress */
+
+
+static void PR_CALLBACK Clientel(void *arg)
+{
+    PRStatus rv;
+    PRFileDesc *xport;
+    PRInt32 bytes, sampled;
+    PRIntervalTime now, interval;
+    PRBool do_display = PR_FALSE;
+    Shared *shared = (Shared*)arg;
+    char *buffer = (char*)PR_Malloc(buffer_size);
+    PRNetAddr *server_address = &shared->server_address;
+    PRIntervalTime connect_timeout = PR_SecondsToInterval(5);
+    PRIntervalTime sampling_interval = PR_SecondsToInterval(SAMPLING_INTERVAL);
+
+    PR_fprintf(err, "Client connecting to ");
+    (void)PrintAddress(server_address);
+
+    do
+    {
+        xport = PR_Socket(domain, PR_SOCK_STREAM, protocol);
+        if (NULL == xport)
+        {
+            PL_FPrintError(err, "PR_Socket");
+            return;
+        }
+
+        if (xport_buffer != -1)
+        {
+            PRSocketOptionData data;
+            data.option = PR_SockOpt_RecvBufferSize;
+            data.value.recv_buffer_size = (PRSize)xport_buffer;
+            rv = PR_SetSocketOption(xport, &data);
+            if (PR_FAILURE == rv)
+                PL_FPrintError(err, "PR_SetSocketOption - ignored");
+            data.option = PR_SockOpt_SendBufferSize;
+            data.value.send_buffer_size = (PRSize)xport_buffer;
+            rv = PR_SetSocketOption(xport, &data);
+            if (PR_FAILURE == rv)
+                PL_FPrintError(err, "PR_SetSocketOption - ignored");
+        }
+
+        rv = PR_Connect(xport, server_address, connect_timeout);
+        if (PR_FAILURE == rv)
+        {
+            PL_FPrintError(err, "PR_Connect");
+            if (PR_IO_TIMEOUT_ERROR != PR_GetError())
+                PR_Sleep(connect_timeout);
+            PR_Close(xport);  /* delete it and start over */
+        }
+    } while (PR_FAILURE == rv);
+
+    do
+    {
+        bytes = PR_Recv(
+            xport, buffer, buffer_size, 0, PR_INTERVAL_NO_TIMEOUT);
+        PR_Lock(shared->ml);
+        now = PR_IntervalNow();
+        shared->sampled += bytes;
+        interval = now - shared->timein;
+        if (interval > sampling_interval)
+        {
+            sampled = shared->sampled;
+            shared->timein = now;
+            shared->sampled = 0;
+            do_display = PR_TRUE;
+        }
+        PR_Unlock(shared->ml);
+
+        if (do_display)
+        {
+            PRUint32 rate = sampled / PR_IntervalToMilliseconds(interval);
+            PR_fprintf(err, "%u streams @ %u Kbytes/sec\n", shared->threads, rate);
+            do_display = PR_FALSE;
+        }
+
+    } while (bytes > 0);
+}  /* Clientel */
+
+static void Client(const char *server_name)
+{
+    PRStatus rv;
+    PRHostEnt host;
+    char buffer[PR_NETDB_BUF_SIZE];
+    PRIntervalTime dally = PR_SecondsToInterval(60);
+    PR_fprintf(err, "Translating the name %s\n", server_name);
+    rv = PR_GetHostByName(server_name, buffer, sizeof(buffer), &host);
+    if (PR_FAILURE == rv)
+        PL_FPrintError(err, "PR_GetHostByName");
+    else
+    {
+        if (PR_EnumerateHostEnt(
+            0, &host, PORT_NUMBER, &shared->server_address) < 0)
+            PL_FPrintError(err, "PR_EnumerateHostEnt");
+        else
+        {
+            do
+            {
+                shared->threads += 1;
+                (void)PR_CreateThread(
+                    PR_USER_THREAD, Clientel, shared,
+                    PR_PRIORITY_NORMAL, thread_scope,
+                    PR_UNJOINABLE_THREAD, 8 * 1024);
+                if (shared->threads == initial_streams)
+                {
+                    PR_Sleep(dally);
+                    initial_streams += 1;
+                }
+            } while (PR_TRUE);
+        }
+    }
+}
+
+static void PR_CALLBACK Servette(void *arg)
+{
+    PRInt32 bytes, sampled;
+    PRIntervalTime now, interval;
+    PRBool do_display = PR_FALSE;
+    PRFileDesc *client = (PRFileDesc*)arg;
+    char *buffer = (char*)PR_Malloc(buffer_size);
+    PRIntervalTime sampling_interval = PR_SecondsToInterval(SAMPLING_INTERVAL);
+
+    if (xport_buffer != -1)
+    {
+        PRStatus rv;
+        PRSocketOptionData data;
+        data.option = PR_SockOpt_RecvBufferSize;
+        data.value.recv_buffer_size = (PRSize)xport_buffer;
+        rv = PR_SetSocketOption(client, &data);
+        if (PR_FAILURE == rv)
+            PL_FPrintError(err, "PR_SetSocketOption - ignored");
+        data.option = PR_SockOpt_SendBufferSize;
+        data.value.send_buffer_size = (PRSize)xport_buffer;
+        rv = PR_SetSocketOption(client, &data);
+        if (PR_FAILURE == rv)
+            PL_FPrintError(err, "PR_SetSocketOption - ignored");
+    }
+
+    do
+    {
+        bytes = PR_Send(
+            client, buffer, buffer_size, 0, PR_INTERVAL_NO_TIMEOUT);
+
+        PR_Lock(shared->ml);
+        now = PR_IntervalNow();
+        shared->sampled += bytes;
+        interval = now - shared->timein;
+        if (interval > sampling_interval)
+        {
+            sampled = shared->sampled;
+            shared->timein = now;
+            shared->sampled = 0;
+            do_display = PR_TRUE;
+        }
+        PR_Unlock(shared->ml);
+
+        if (do_display)
+        {
+            PRUint32 rate = sampled / PR_IntervalToMilliseconds(interval);
+            PR_fprintf(err, "%u streams @ %u Kbytes/sec\n", shared->threads, rate);
+            do_display = PR_FALSE;
+        }
+    } while (bytes > 0);
+}  /* Servette */
+
+static void Server(void)
+{
+    PRStatus rv;
+    PRNetAddr server_address, client_address;
+    PRFileDesc *xport = PR_Socket(domain, PR_SOCK_STREAM, protocol);
+
+    if (NULL == xport)
+    {
+        PL_FPrintError(err, "PR_Socket");
+        return;
+    }
+
+    rv = PR_InitializeNetAddr(PR_IpAddrAny, PORT_NUMBER, &server_address);
+    if (PR_FAILURE == rv) PL_FPrintError(err, "PR_InitializeNetAddr");
+    else
+    {
+        rv = PR_Bind(xport, &server_address);
+        if (PR_FAILURE == rv) PL_FPrintError(err, "PR_Bind");
+        else
+        {
+            PRFileDesc *client;
+            rv = PR_Listen(xport, 10);
+            PR_fprintf(err, "Server listening on ");
+            (void)PrintAddress(&server_address);
+            do
+            {
+                client = PR_Accept(
+                    xport, &client_address, PR_INTERVAL_NO_TIMEOUT);
+                if (NULL == client) PL_FPrintError(err, "PR_Accept");
+                else
+                {
+                    PR_fprintf(err, "Server accepting from ");
+                    (void)PrintAddress(&client_address);
+                    shared->threads += 1;
+                    (void)PR_CreateThread(
+                        PR_USER_THREAD, Servette, client,
+                        PR_PRIORITY_NORMAL, thread_scope,
+                        PR_UNJOINABLE_THREAD, 8 * 1024);
+                }
+            } while (PR_TRUE);
+
+        }
+    }
+}  /* Server */
+
+static void Help(void)
+{
+    PR_fprintf(err, "Usage: [-h] [<server>]\n");
+    PR_fprintf(err, "\t-s <n>   Initial # of connections        (default: 1)\n");
+    PR_fprintf(err, "\t-C <n>   Set 'concurrency'               (default: 1)\n");
+    PR_fprintf(err, "\t-b <nK>  Client buffer size              (default: 32k)\n");
+    PR_fprintf(err, "\t-B <nK>  Transport recv/send buffer size (default: sys)\n");
+    PR_fprintf(err, "\t-G       Use GLOBAL threads              (default: LOCAL)\n");
+    PR_fprintf(err, "\t-X       Use XTP transport               (default: TCP)\n");
+    PR_fprintf(err, "\t-6       Use IPv6                        (default: IPv4)\n");
+    PR_fprintf(err, "\t-h       This message and nothing else\n");
+    PR_fprintf(err, "\t<server> DNS name of server\n");
+    PR_fprintf(err, "\t\tIf <server> is not specified, this host will be\n");
+    PR_fprintf(err, "\t\tthe server and not act as a client.\n");
+}  /* Help */
+
+PRIntn main(PRIntn argc, char **argv)
+{
+    PLOptStatus os;
+    const char *server_name = NULL;
+    PLOptState *opt = PL_CreateOptState(argc, argv, "hGX6C:b:s:B:");
+
+    err = PR_GetSpecialFD(PR_StandardError);
+
+    while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
+    {
+        if (PL_OPT_BAD == os) continue;
+        switch (opt->option)
+        {
+        case 0:  /* Name of server */
+            server_name = opt->value;
+            break;
+        case 'G':  /* Globular threads */
+            thread_scope = PR_GLOBAL_THREAD;
+            break;
+        case 'X':  /* Use XTP as the transport */
+            protocol = 36;
+            break;
+        case '6':  /* Use IPv6 */
+            domain = PR_AF_INET6;
+            break;
+        case 's':  /* initial_streams */
+            initial_streams = atoi(opt->value);
+            break;
+        case 'C':  /* concurrency */
+            concurrency = atoi(opt->value);
+            break;
+        case 'b':  /* buffer size */
+            buffer_size = 1024 * atoi(opt->value);
+            break;
+        case 'B':  /* buffer size */
+            xport_buffer = 1024 * atoi(opt->value);
+            break;
+        case 'h':  /* user wants some guidance */
+        default:
+            Help();  /* so give him an earful */
+            return 2;  /* but not a lot else */
+        }
+    }
+    PL_DestroyOptState(opt);
+
+    shared = PR_NEWZAP(Shared);
+    shared->ml = PR_NewLock();
+
+    PR_fprintf(err,
+        "This machine is %s\n",
+        (NULL == server_name) ? "the SERVER" : "a CLIENT");
+
+    PR_fprintf(err,
+        "Transport being used is %s\n",
+        (6 == protocol) ? "TCP" : "XTP");
+
+    if (PR_GLOBAL_THREAD == thread_scope)
+    {
+        if (1 != concurrency)
+        {
+            PR_fprintf(err, "  **Concurrency > 1 and GLOBAL threads!?!?\n");
+            PR_fprintf(err, "  **Ignoring concurrency\n");
+            concurrency = 1;
+        }
+    }
+
+    if (1 != concurrency)
+    {
+        PR_SetConcurrency(concurrency);
+        PR_fprintf(err, "Concurrency set to %u\n", concurrency);
+    }
+
+    PR_fprintf(err,
+        "All threads will be %s\n",
+        (PR_GLOBAL_THREAD == thread_scope) ? "GLOBAL" : "LOCAL");
+
+    PR_fprintf(err, "Client buffer size will be %u\n", buffer_size);
+   
+    if (-1 != xport_buffer)
+    PR_fprintf(
+        err, "Transport send & receive buffer size will be %u\n", xport_buffer);
+    
+
+    if (NULL == server_name) Server();
+    else Client(server_name);
+
+}  /* main */
+
+/* thruput.c */
+