mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/nsprpub/pr/tests/thruput.c

415 строки
12 KiB
C
Исходник Ответственный История

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
** 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
#ifdef DEBUG
#define PORT_INC_DO +100
#else
#define PORT_INC_DO
#endif
#ifdef IS_64
#define PORT_INC_3264 +200
#else
#define PORT_INC_3264
#endif
#define PORT_NUMBER 51877 PORT_INC_DO PORT_INC_3264
#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 */
int main(int 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);
}
return 0;
} /* main */
/* thruput.c */
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку