static int tcp_test(void)
{
pj_sock_t cs, ss;
pj_status_t rc = 0, retval;
PJ_LOG(3,("test", "...tcp_test()"));
rc = app_socketpair(pj_AF_INET(), pj_SOCK_STREAM(), 0, &ss, &cs);
if (rc != PJ_SUCCESS) {
app_perror("...error: app_socketpair():", rc);
return -2000;
}
/* Test send/recv with send() and recv() */
retval = send_recv_test(pj_SOCK_STREAM(), ss, cs, NULL, NULL, 0);
rc = pj_sock_close(cs);
if (rc != PJ_SUCCESS) {
app_perror("...error in closing socket", rc);
return -2000;
}
rc = pj_sock_close(ss);
if (rc != PJ_SUCCESS) {
app_perror("...error in closing socket", rc);
return -2010;
}
return retval;
}
/* Calculate the bandwidth for the specific test configuration.
* The test is simple:
* - create sockpair_cnt number of producer-consumer socket pair.
* - create thread_cnt number of worker threads.
* - each producer will send buffer_size bytes data as fast and
* as soon as it can.
* - each consumer will read buffer_size bytes of data as fast
* as it could.
* - measure the total bytes received by all consumers during a
* period of time.
*/
static int perform_test(pj_bool_t allow_concur,
int sock_type, const char *type_name,
unsigned thread_cnt, unsigned sockpair_cnt,
pj_size_t buffer_size,
pj_size_t *p_bandwidth)
{
enum { MSEC_DURATION = 5000 };
pj_pool_t *pool;
test_item *items;
pj_thread_t **thread;
pj_ioqueue_t *ioqueue;
pj_status_t rc;
pj_ioqueue_callback ioqueue_callback;
pj_uint32_t total_elapsed_usec, total_received;
pj_highprec_t bandwidth;
pj_timestamp start, stop;
unsigned i;
TRACE_((THIS_FILE, " starting test.."));
ioqueue_callback.on_read_complete = &on_read_complete;
ioqueue_callback.on_write_complete = &on_write_complete;
thread_quit_flag = 0;
pool = pj_pool_create(mem, NULL, 4096, 4096, NULL);
if (!pool)
return -10;
items = (test_item*) pj_pool_alloc(pool, sockpair_cnt*sizeof(test_item));
thread = (pj_thread_t**)
pj_pool_alloc(pool, thread_cnt*sizeof(pj_thread_t*));
TRACE_((THIS_FILE, " creating ioqueue.."));
rc = pj_ioqueue_create(pool, sockpair_cnt*2, &ioqueue);
if (rc != PJ_SUCCESS) {
app_perror("...error: unable to create ioqueue", rc);
return -15;
}
rc = pj_ioqueue_set_default_concurrency(ioqueue, allow_concur);
if (rc != PJ_SUCCESS) {
app_perror("...error: pj_ioqueue_set_default_concurrency()", rc);
return -16;
}
/* Initialize each producer-consumer pair. */
for (i=0; i<sockpair_cnt; ++i) {
pj_ssize_t bytes;
items[i].ioqueue = ioqueue;
items[i].buffer_size = buffer_size;
items[i].outgoing_buffer = (char*) pj_pool_alloc(pool, buffer_size);
items[i].incoming_buffer = (char*) pj_pool_alloc(pool, buffer_size);
items[i].bytes_recv = items[i].bytes_sent = 0;
/* randomize outgoing buffer. */
pj_create_random_string(items[i].outgoing_buffer, buffer_size);
/* Create socket pair. */
TRACE_((THIS_FILE, " calling socketpair.."));
rc = app_socketpair(pj_AF_INET(), sock_type, 0,
&items[i].server_fd, &items[i].client_fd);
if (rc != PJ_SUCCESS) {
app_perror("...error: unable to create socket pair", rc);
return -20;
}
/* Register server socket to ioqueue. */
TRACE_((THIS_FILE, " register(1).."));
rc = pj_ioqueue_register_sock(pool, ioqueue,
items[i].server_fd,
&items[i], &ioqueue_callback,
&items[i].server_key);
if (rc != PJ_SUCCESS) {
app_perror("...error: registering server socket to ioqueue", rc);
return -60;
}
/* Register client socket to ioqueue. */
TRACE_((THIS_FILE, " register(2).."));
rc = pj_ioqueue_register_sock(pool, ioqueue,
items[i].client_fd,
&items[i], &ioqueue_callback,
&items[i].client_key);
if (rc != PJ_SUCCESS) {
app_perror("...error: registering server socket to ioqueue", rc);
return -70;
}
/* Start reading. */
TRACE_((THIS_FILE, " pj_ioqueue_recv.."));
bytes = items[i].buffer_size;
rc = pj_ioqueue_recv(items[i].server_key, &items[i].recv_op,
items[i].incoming_buffer, &bytes,
0);
if (rc != PJ_EPENDING) {
app_perror("...error: pj_ioqueue_recv", rc);
return -73;
}
/* Start writing. */
TRACE_((THIS_FILE, " pj_ioqueue_write.."));
bytes = items[i].buffer_size;
rc = pj_ioqueue_send(items[i].client_key, &items[i].send_op,
items[i].outgoing_buffer, &bytes, 0);
if (rc != PJ_SUCCESS && rc != PJ_EPENDING) {
app_perror("...error: pj_ioqueue_write", rc);
return -76;
}
items[i].has_pending_send = (rc==PJ_EPENDING);
}
/* Create the threads. */
for (i=0; i<thread_cnt; ++i) {
struct thread_arg *arg;
arg = (struct thread_arg*) pj_pool_zalloc(pool, sizeof(*arg));
arg->id = i;
arg->ioqueue = ioqueue;
arg->counter = 0;
rc = pj_thread_create( pool, NULL,
&worker_thread,
arg,
PJ_THREAD_DEFAULT_STACK_SIZE,
PJ_THREAD_SUSPENDED, &thread[i] );
if (rc != PJ_SUCCESS) {
app_perror("...error: unable to create thread", rc);
return -80;
}
}
/* Mark start time. */
rc = pj_get_timestamp(&start);
if (rc != PJ_SUCCESS)
return -90;
/* Start the thread. */
TRACE_((THIS_FILE, " resuming all threads.."));
for (i=0; i<thread_cnt; ++i) {
rc = pj_thread_resume(thread[i]);
if (rc != 0)
return -100;
}
/* Wait for MSEC_DURATION seconds.
* This should be as simple as pj_thread_sleep(MSEC_DURATION) actually,
* but unfortunately it doesn't work when system doesn't employ
* timeslicing for threads.
*/
TRACE_((THIS_FILE, " wait for few seconds.."));
do {
pj_thread_sleep(1);
/* Mark end time. */
rc = pj_get_timestamp(&stop);
if (thread_quit_flag) {
TRACE_((THIS_FILE, " transfer limit reached.."));
break;
}
if (pj_elapsed_usec(&start,&stop)<MSEC_DURATION * 1000) {
TRACE_((THIS_FILE, " time limit reached.."));
break;
}
} while (1);
/* Terminate all threads. */
TRACE_((THIS_FILE, " terminating all threads.."));
thread_quit_flag = 1;
for (i=0; i<thread_cnt; ++i) {
TRACE_((THIS_FILE, " join thread %d..", i));
pj_thread_join(thread[i]);
}
/* Close all sockets. */
TRACE_((THIS_FILE, " closing all sockets.."));
for (i=0; i<sockpair_cnt; ++i) {
pj_ioqueue_unregister(items[i].server_key);
pj_ioqueue_unregister(items[i].client_key);
}
/* Destroy threads */
for (i=0; i<thread_cnt; ++i) {
pj_thread_destroy(thread[i]);
}
/* Destroy ioqueue. */
TRACE_((THIS_FILE, " destroying ioqueue.."));
pj_ioqueue_destroy(ioqueue);
/* Calculate actual time in usec. */
total_elapsed_usec = pj_elapsed_usec(&start, &stop);
/* Calculate total bytes received. */
total_received = 0;
for (i=0; i<sockpair_cnt; ++i) {
total_received = (pj_uint32_t)items[i].bytes_recv;
}
/* bandwidth = total_received*1000/total_elapsed_usec */
bandwidth = total_received;
pj_highprec_mul(bandwidth, 1000);
pj_highprec_div(bandwidth, total_elapsed_usec);
*p_bandwidth = (pj_uint32_t)bandwidth;
PJ_LOG(3,(THIS_FILE, " %.4s %2d %2d %8d KB/s",
type_name, thread_cnt, sockpair_cnt,
*p_bandwidth));
/* Done. */
pj_pool_release(pool);
TRACE_((THIS_FILE, " done.."));
return 0;
}
/*
* sock_producer_consumer()
*
* Simple producer-consumer benchmarking. Send loop number of
* buf_size size packets as fast as possible.
*/
static int sock_producer_consumer(int sock_type,
unsigned buf_size,
unsigned loop,
unsigned *p_bandwidth)
{
pj_sock_t consumer, producer;
pj_pool_t *pool;
char *outgoing_buffer, *incoming_buffer;
pj_timestamp start, stop;
unsigned i;
pj_highprec_t elapsed, bandwidth;
pj_size_t total_received;
pj_status_t rc;
/* Create pool. */
pool = pj_pool_create(mem, NULL, 4096, 4096, NULL);
if (!pool)
return -10;
/* Create producer-consumer pair. */
rc = app_socketpair(PJ_AF_INET, sock_type, 0, &consumer, &producer);
if (rc != PJ_SUCCESS) {
app_perror("...error: create socket pair", rc);
return -20;
}
/* Create buffers. */
outgoing_buffer = pj_pool_alloc(pool, buf_size);
incoming_buffer = pj_pool_alloc(pool, buf_size);
/* Start loop. */
pj_get_timestamp(&start);
total_received = 0;
for (i=0; i<loop; ++i) {
pj_ssize_t sent, part_received, received;
pj_time_val delay;
sent = buf_size;
rc = pj_sock_send(producer, outgoing_buffer, &sent, 0);
if (rc != PJ_SUCCESS || sent != (pj_ssize_t)buf_size) {
app_perror("...error: send()", rc);
return -61;
}
/* Repeat recv() until all data is part_received.
* This applies only for non-UDP of course, since for UDP
* we would expect all data to be part_received in one packet.
*/
received = 0;
do {
part_received = buf_size-received;
rc = pj_sock_recv(consumer, incoming_buffer+received,
&part_received, 0);
if (rc != PJ_SUCCESS) {
app_perror("...recv error", rc);
return -70;
}
if (part_received <= 0) {
PJ_LOG(3,("", "...error: socket has closed (part_received=%d)!",
part_received));
return -73;
}
if ((pj_size_t)part_received != buf_size-received) {
if (sock_type != PJ_SOCK_STREAM) {
PJ_LOG(3,("", "...error: expecting %u bytes, got %u bytes",
buf_size-received, part_received));
return -76;
}
}
received += part_received;
} while ((pj_size_t)received < buf_size);
total_received += received;
/* Stop test if it's been runnign for more than 10 secs. */
pj_get_timestamp(&stop);
delay = pj_elapsed_time(&start, &stop);
if (delay.sec > 10)
break;
}
/* Stop timer. */
pj_get_timestamp(&stop);
elapsed = pj_elapsed_usec(&start, &stop);
/* bandwidth = total_received * 1000 / elapsed */
bandwidth = total_received;
pj_highprec_mul(bandwidth, 1000);
pj_highprec_div(bandwidth, elapsed);
*p_bandwidth = (pj_uint32_t)bandwidth;
/* Close sockets. */
pj_sock_close(consumer);
pj_sock_close(producer);
/* Done */
pj_pool_release(pool);
return 0;
}
/*
* Perform unregistration test.
*
* This will create ioqueue and register a server socket. Depending
* on the test method, either the callback or the main thread will
* unregister and destroy the server socket after some period of time.
*/
static int perform_unreg_test(pj_ioqueue_t *ioqueue,
pj_pool_t *test_pool,
const char *title,
pj_bool_t other_socket)
{
enum { WORKER_CNT = 1, MSEC = 500, QUIT_MSEC = 500 };
int i;
pj_thread_t *thread[WORKER_CNT];
struct sock_data osd;
pj_ioqueue_callback callback;
pj_time_val end_time;
pj_status_t status;
/* Sometimes its important to have other sockets registered to
* the ioqueue, because when no sockets are registered, the ioqueue
* will return from the poll early.
*/
if (other_socket) {
status = app_socket(pj_AF_INET(), pj_SOCK_DGRAM(), 0, 56127, &osd.sock);
if (status != PJ_SUCCESS) {
app_perror("Error creating other socket", status);
return -12;
}
pj_bzero(&callback, sizeof(callback));
status = pj_ioqueue_register_sock(test_pool, ioqueue, osd.sock,
NULL, &callback, &osd.key);
if (status != PJ_SUCCESS) {
app_perror("Error registering other socket", status);
return -13;
}
} else {
osd.key = NULL;
osd.sock = PJ_INVALID_SOCKET;
}
/* Init both time duration of testing */
thread_quitting = 0;
pj_gettimeofday(&time_to_unregister);
time_to_unregister.msec += MSEC;
pj_time_val_normalize(&time_to_unregister);
end_time = time_to_unregister;
end_time.msec += QUIT_MSEC;
pj_time_val_normalize(&end_time);
/* Create polling thread */
for (i=0; i<WORKER_CNT; ++i) {
status = pj_thread_create(test_pool, "unregtest", &worker_thread,
ioqueue, 0, 0, &thread[i]);
if (status != PJ_SUCCESS) {
app_perror("Error creating thread", status);
return -20;
}
}
/* Create pair of client/server sockets */
status = app_socketpair(pj_AF_INET(), pj_SOCK_DGRAM(), 0,
&sock_data.sock, &sock_data.csock);
if (status != PJ_SUCCESS) {
app_perror("app_socketpair error", status);
return -30;
}
/* Initialize test data */
sock_data.pool = pj_pool_create(mem, "sd", 1000, 1000, NULL);
sock_data.buffer = (char*) pj_pool_alloc(sock_data.pool, 128);
sock_data.bufsize = 128;
sock_data.op_key = (pj_ioqueue_op_key_t*)
pj_pool_alloc(sock_data.pool,
sizeof(*sock_data.op_key));
sock_data.received = 0;
sock_data.unregistered = 0;
pj_ioqueue_op_key_init(sock_data.op_key, sizeof(*sock_data.op_key));
status = pj_mutex_create_simple(sock_data.pool, "sd", &sock_data.mutex);
if (status != PJ_SUCCESS) {
app_perror("create_mutex() error", status);
return -35;
}
/* Register socket to ioqueue */
pj_bzero(&callback, sizeof(callback));
callback.on_read_complete = &on_read_complete;
status = pj_ioqueue_register_sock(sock_data.pool, ioqueue, sock_data.sock,
NULL, &callback, &sock_data.key);
if (status != PJ_SUCCESS) {
app_perror("pj_ioqueue_register error", status);
return -40;
}
/* Bootstrap the first send/receive */
on_read_complete(sock_data.key, sock_data.op_key, 0);
/* Loop until test time ends */
for (;;) {
pj_time_val now, timeout;
pj_gettimeofday(&now);
if (test_method == UNREGISTER_IN_APP &&
PJ_TIME_VAL_GTE(now, time_to_unregister) &&
sock_data.pool)
{
pj_mutex_lock(sock_data.mutex);
sock_data.unregistered = 1;
pj_ioqueue_unregister(sock_data.key);
pj_mutex_unlock(sock_data.mutex);
pj_mutex_destroy(sock_data.mutex);
pj_pool_release(sock_data.pool);
sock_data.pool = NULL;
}
if (PJ_TIME_VAL_GT(now, end_time) && sock_data.unregistered)
break;
timeout.sec = 0; timeout.msec = 10;
pj_ioqueue_poll(ioqueue, &timeout);
//pj_thread_sleep(1);
}
thread_quitting = 1;
for (i=0; i<WORKER_CNT; ++i) {
pj_thread_join(thread[i]);
pj_thread_destroy(thread[i]);
}
if (other_socket) {
pj_ioqueue_unregister(osd.key);
}
pj_sock_close(sock_data.csock);
PJ_LOG(3,(THIS_FILE, "....%s: done (%d KB/s)",
title, sock_data.received * 1000 / MSEC / 1000));
return 0;
}
static int tcp_perf_test(void)
{
enum { COUNT=100000 };
pj_pool_t *pool = NULL;
pj_ioqueue_t *ioqueue = NULL;
pj_sock_t sock1=PJ_INVALID_SOCKET, sock2=PJ_INVALID_SOCKET;
pj_activesock_t *asock1 = NULL, *asock2 = NULL;
pj_activesock_cb cb;
struct tcp_state *state1, *state2;
unsigned i;
pj_status_t status;
pool = pj_pool_create(mem, "tcpperf", 256, 256, NULL);
status = app_socketpair(pj_AF_INET(), pj_SOCK_STREAM(), 0, &sock1,
&sock2);
if (status != PJ_SUCCESS) {
status = -100;
goto on_return;
}
status = pj_ioqueue_create(pool, 4, &ioqueue);
if (status != PJ_SUCCESS) {
status = -110;
goto on_return;
}
pj_bzero(&cb, sizeof(cb));
cb.on_data_read = &tcp_on_data_read;
cb.on_data_sent = &tcp_on_data_sent;
state1 = PJ_POOL_ZALLOC_T(pool, struct tcp_state);
status = pj_activesock_create(pool, sock1, pj_SOCK_STREAM(), NULL, ioqueue,
&cb, state1, &asock1);
if (status != PJ_SUCCESS) {
status = -120;
goto on_return;
}
state2 = PJ_POOL_ZALLOC_T(pool, struct tcp_state);
status = pj_activesock_create(pool, sock2, pj_SOCK_STREAM(), NULL, ioqueue,
&cb, state2, &asock2);
if (status != PJ_SUCCESS) {
status = -130;
goto on_return;
}
status = pj_activesock_start_read(asock1, pool, 1000, 0);
if (status != PJ_SUCCESS) {
status = -140;
goto on_return;
}
/* Send packet as quickly as possible */
for (i=0; i<COUNT && !state1->err && !state2->err; ++i) {
struct tcp_pkt *pkt;
struct send_key send_key[2], *op_key;
pj_ssize_t len;
pkt = (struct tcp_pkt*)state2->pkt;
pkt->signature = SIGNATURE;
pkt->seq = i;
pj_memset(pkt->fill, 'a', sizeof(pkt->fill));
op_key = &send_key[i%2];
pj_ioqueue_op_key_init(&op_key->op_key, sizeof(*op_key));
state2->sent = PJ_FALSE;
len = sizeof(*pkt);
status = pj_activesock_send(asock2, &op_key->op_key, pkt, &len, 0);
if (status == PJ_EPENDING) {
do {
#if PJ_SYMBIAN
pj_symbianos_poll(-1, -1);
#else
pj_ioqueue_poll(ioqueue, NULL);
#endif
} while (!state2->sent);
} else {
#if PJ_SYMBIAN
/* The Symbian socket always returns PJ_SUCCESS for TCP send,
* eventhough the remote end hasn't received the data yet.
* If we continue sending, eventually send() will block,
* possibly because the send buffer is full. So we need to
* poll the ioqueue periodically, to let receiver gets the
* data.
*/
pj_symbianos_poll(-1, 0);
#endif
if (status != PJ_SUCCESS) {
PJ_LOG(1,("", " err: send status=%d", status));
status = -180;
break;
} else if (status == PJ_SUCCESS) {
if (len != sizeof(*pkt)) {
PJ_LOG(1,("", " err: shouldn't report partial sent"));
status = -190;
break;
}
}
}
}
/* Wait until everything has been sent/received */
if (state1->next_recv_seq < COUNT) {
#ifdef PJ_SYMBIAN
while (pj_symbianos_poll(-1, 1000) == PJ_TRUE)
;
#else
pj_time_val delay = {0, 100};
while (pj_ioqueue_poll(ioqueue, &delay) > 0)
;
#endif
}
if (status == PJ_EPENDING)
status = PJ_SUCCESS;
if (status != 0)
goto on_return;
if (state1->err) {
status = -183;
goto on_return;
}
if (state2->err) {
status = -186;
goto on_return;
}
if (state1->next_recv_seq != COUNT) {
PJ_LOG(3,("", " err: only %u packets received, expecting %u",
state1->next_recv_seq, COUNT));
status = -195;
goto on_return;
}
on_return:
if (asock2)
pj_activesock_close(asock2);
if (asock1)
pj_activesock_close(asock1);
if (ioqueue)
pj_ioqueue_destroy(ioqueue);
if (pool)
pj_pool_release(pool);
return status;
}