static int tcp_ioqueue_test_impl(pj_bool_t allow_concur)
{
int status;
PJ_LOG(3,(THIS_FILE, "..testing with concurency=%d", allow_concur));
PJ_LOG(3, (THIS_FILE, "..%s compliance test 0 (success scenario)",
pj_ioqueue_name()));
if ((status=compliance_test_0(allow_concur)) != 0) {
PJ_LOG(1, (THIS_FILE, "....FAILED (status=%d)\n", status));
return status;
}
PJ_LOG(3, (THIS_FILE, "..%s compliance test 1 (failed scenario)",
pj_ioqueue_name()));
if ((status=compliance_test_1(allow_concur)) != 0) {
PJ_LOG(1, (THIS_FILE, "....FAILED (status=%d)\n", status));
return status;
}
PJ_LOG(3, (THIS_FILE, "..%s compliance test 2 (repeated accept)",
pj_ioqueue_name()));
if ((status=compliance_test_2(allow_concur)) != 0) {
PJ_LOG(1, (THIS_FILE, "....FAILED (status=%d)\n", status));
return status;
}
return 0;
}
int tcp_ioqueue_test()
{
int status;
PJ_LOG(3, (THIS_FILE, "..%s compliance test 0 (success scenario)",
pj_ioqueue_name()));
if ((status=compliance_test_0()) != 0) {
PJ_LOG(1, (THIS_FILE, "....FAILED (status=%d)\n", status));
return status;
}
PJ_LOG(3, (THIS_FILE, "..%s compliance test 1 (failed scenario)",
pj_ioqueue_name()));
if ((status=compliance_test_1()) != 0) {
PJ_LOG(1, (THIS_FILE, "....FAILED (status=%d)\n", status));
return status;
}
PJ_LOG(3, (THIS_FILE, "..%s compliance test 2 (repeated accept)",
pj_ioqueue_name()));
if ((status=compliance_test_2()) != 0) {
PJ_LOG(1, (THIS_FILE, "....FAILED (status=%d)\n", status));
return status;
}
return 0;
}
static int udp_ioqueue_test_imp(pj_bool_t allow_concur)
{
int status;
int bufsize, sock_count;
PJ_LOG(3,(THIS_FILE, "..testing with concurency=%d", allow_concur));
//goto pass1;
PJ_LOG(3, (THIS_FILE, "...compliance test (%s)", pj_ioqueue_name()));
if ((status=compliance_test(allow_concur)) != 0) {
return status;
}
PJ_LOG(3, (THIS_FILE, "....compliance test ok"));
PJ_LOG(3, (THIS_FILE, "...unregister test (%s)", pj_ioqueue_name()));
if ((status=unregister_test(allow_concur)) != 0) {
return status;
}
PJ_LOG(3, (THIS_FILE, "....unregister test ok"));
if ((status=many_handles_test(allow_concur)) != 0) {
return status;
}
//return 0;
PJ_LOG(4, (THIS_FILE, "...benchmarking different buffer size:"));
PJ_LOG(4, (THIS_FILE, "... note: buf=bytes sent, fds=# of fds, "
"elapsed=in timer ticks"));
//pass1:
PJ_LOG(3, (THIS_FILE, "...Benchmarking poll times for %s:", pj_ioqueue_name()));
PJ_LOG(3, (THIS_FILE, "...====================================="));
PJ_LOG(3, (THIS_FILE, "...Buf.size #inactive-socks Time/poll"));
PJ_LOG(3, (THIS_FILE, "... (bytes) (nanosec)"));
PJ_LOG(3, (THIS_FILE, "...====================================="));
//goto pass2;
for (bufsize=BUF_MIN_SIZE; bufsize <= BUF_MAX_SIZE; bufsize *= 2) {
if ((status=bench_test(allow_concur, bufsize, SOCK_INACTIVE_MIN)) != 0)
return status;
}
//pass2:
bufsize = 512;
for (sock_count=SOCK_INACTIVE_MIN+2;
sock_count<=SOCK_INACTIVE_MAX+2;
sock_count *= 2)
{
//PJ_LOG(3,(THIS_FILE, "...testing with %d fds", sock_count));
if ((status=bench_test(allow_concur, bufsize, sock_count-2)) != 0)
return status;
}
return 0;
}
int echo_srv_common_loop(pj_atomic_t *bytes_counter)
{
pj_highprec_t last_received, avg_bw, highest_bw;
pj_time_val last_print;
unsigned count;
const char *ioqueue_name;
last_received = 0;
pj_gettimeofday(&last_print);
avg_bw = highest_bw = 0;
count = 0;
ioqueue_name = pj_ioqueue_name();
for (;;) {
pj_highprec_t received, cur_received, bw;
unsigned msec;
pj_time_val now, duration;
pj_thread_sleep(1000);
received = cur_received = pj_atomic_get(bytes_counter);
cur_received = cur_received - last_received;
pj_gettimeofday(&now);
duration = now;
PJ_TIME_VAL_SUB(duration, last_print);
msec = PJ_TIME_VAL_MSEC(duration);
bw = cur_received;
pj_highprec_mul(bw, 1000);
pj_highprec_div(bw, msec);
last_print = now;
last_received = received;
avg_bw = avg_bw + bw;
count++;
PJ_LOG(3,("", "%s UDP (%d threads): %u KB/s (avg=%u KB/s) %s",
ioqueue_name,
ECHO_SERVER_MAX_THREADS,
(unsigned)(bw / 1000),
(unsigned)(avg_bw / count / 1000),
(count==20 ? "<ses avg>" : "")));
if (count==20) {
if (avg_bw/count > highest_bw)
highest_bw = avg_bw/count;
count = 0;
avg_bw = 0;
PJ_LOG(3,("", "Highest average bandwidth=%u KB/s",
(unsigned)(highest_bw/1000)));
}
}
PJ_UNREACHED(return 0;)
}
PJ_DEF(void) pj_dump_config(void)
{
PJ_LOG(3, (id, "PJLIB (c)2008-2009 Teluu Inc."));
PJ_LOG(3, (id, "Dumping configurations:"));
PJ_LOG(3, (id, " PJ_VERSION : %s", PJ_VERSION));
PJ_LOG(3, (id, " PJ_M_NAME : %s", PJ_M_NAME));
PJ_LOG(3, (id, " PJ_HAS_PENTIUM : %d", PJ_HAS_PENTIUM));
PJ_LOG(3, (id, " PJ_OS_NAME : %s", PJ_OS_NAME));
PJ_LOG(3, (id, " PJ_CC_NAME/VER_(1,2,3) : %s-%d.%d.%d", PJ_CC_NAME,
PJ_CC_VER_1, PJ_CC_VER_2, PJ_CC_VER_3));
PJ_LOG(3, (id, " PJ_IS_(BIG/LITTLE)_ENDIAN : %s",
(PJ_IS_BIG_ENDIAN?"big-endian":"little-endian")));
PJ_LOG(3, (id, " PJ_HAS_INT64 : %d", PJ_HAS_INT64));
PJ_LOG(3, (id, " PJ_HAS_FLOATING_POINT : %d", PJ_HAS_FLOATING_POINT));
PJ_LOG(3, (id, " PJ_DEBUG : %d", PJ_DEBUG));
PJ_LOG(3, (id, " PJ_FUNCTIONS_ARE_INLINED : %d", PJ_FUNCTIONS_ARE_INLINED));
PJ_LOG(3, (id, " PJ_LOG_MAX_LEVEL : %d", PJ_LOG_MAX_LEVEL));
PJ_LOG(3, (id, " PJ_LOG_MAX_SIZE : %d", PJ_LOG_MAX_SIZE));
PJ_LOG(3, (id, " PJ_LOG_USE_STACK_BUFFER : %d", PJ_LOG_USE_STACK_BUFFER));
PJ_LOG(3, (id, " PJ_POOL_DEBUG : %d", PJ_POOL_DEBUG));
PJ_LOG(3, (id, " PJ_HAS_POOL_ALT_API : %d", PJ_HAS_POOL_ALT_API));
PJ_LOG(3, (id, " PJ_HAS_TCP : %d", PJ_HAS_TCP));
PJ_LOG(3, (id, " PJ_MAX_HOSTNAME : %d", PJ_MAX_HOSTNAME));
PJ_LOG(3, (id, " ioqueue type : %s", pj_ioqueue_name()));
PJ_LOG(3, (id, " PJ_IOQUEUE_MAX_HANDLES : %d", PJ_IOQUEUE_MAX_HANDLES));
PJ_LOG(3, (id, " PJ_IOQUEUE_HAS_SAFE_UNREG : %d", PJ_IOQUEUE_HAS_SAFE_UNREG));
PJ_LOG(3, (id, " PJ_HAS_THREADS : %d", PJ_HAS_THREADS));
PJ_LOG(3, (id, " PJ_LOG_USE_STACK_BUFFER : %d", PJ_LOG_USE_STACK_BUFFER));
PJ_LOG(3, (id, " PJ_HAS_SEMAPHORE : %d", PJ_HAS_SEMAPHORE));
PJ_LOG(3, (id, " PJ_HAS_EVENT_OBJ : %d", PJ_HAS_EVENT_OBJ));
PJ_LOG(3, (id, " PJ_ENABLE_EXTRA_CHECK : %d", PJ_ENABLE_EXTRA_CHECK));
PJ_LOG(3, (id, " PJ_HAS_EXCEPTION_NAMES : %d", PJ_HAS_EXCEPTION_NAMES));
PJ_LOG(3, (id, " PJ_MAX_EXCEPTION_ID : %d", PJ_MAX_EXCEPTION_ID));
PJ_LOG(3, (id, " PJ_EXCEPTION_USE_WIN32_SEH: %d", PJ_EXCEPTION_USE_WIN32_SEH));
PJ_LOG(3, (id, " PJ_TIMESTAMP_USE_RDTSC: : %d", PJ_TIMESTAMP_USE_RDTSC));
PJ_LOG(3, (id, " PJ_OS_HAS_CHECK_STACK : %d", PJ_OS_HAS_CHECK_STACK));
PJ_LOG(3, (id, " PJ_HAS_HIGH_RES_TIMER : %d", PJ_HAS_HIGH_RES_TIMER));
}
static int ioqueue_perf_test_imp(pj_bool_t allow_concur)
{
enum { BUF_SIZE = 512 };
int i, rc;
struct {
int type;
const char *type_name;
int thread_cnt;
int sockpair_cnt;
} test_param[] =
{
{ pj_SOCK_DGRAM(), "udp", 1, 1},
{ pj_SOCK_DGRAM(), "udp", 1, 2},
{ pj_SOCK_DGRAM(), "udp", 1, 4},
{ pj_SOCK_DGRAM(), "udp", 1, 8},
{ pj_SOCK_DGRAM(), "udp", 2, 1},
{ pj_SOCK_DGRAM(), "udp", 2, 2},
{ pj_SOCK_DGRAM(), "udp", 2, 4},
{ pj_SOCK_DGRAM(), "udp", 2, 8},
{ pj_SOCK_DGRAM(), "udp", 4, 1},
{ pj_SOCK_DGRAM(), "udp", 4, 2},
{ pj_SOCK_DGRAM(), "udp", 4, 4},
{ pj_SOCK_DGRAM(), "udp", 4, 8},
{ pj_SOCK_DGRAM(), "udp", 4, 16},
{ pj_SOCK_STREAM(), "tcp", 1, 1},
{ pj_SOCK_STREAM(), "tcp", 1, 2},
{ pj_SOCK_STREAM(), "tcp", 1, 4},
{ pj_SOCK_STREAM(), "tcp", 1, 8},
{ pj_SOCK_STREAM(), "tcp", 2, 1},
{ pj_SOCK_STREAM(), "tcp", 2, 2},
{ pj_SOCK_STREAM(), "tcp", 2, 4},
{ pj_SOCK_STREAM(), "tcp", 2, 8},
{ pj_SOCK_STREAM(), "tcp", 4, 1},
{ pj_SOCK_STREAM(), "tcp", 4, 2},
{ pj_SOCK_STREAM(), "tcp", 4, 4},
{ pj_SOCK_STREAM(), "tcp", 4, 8},
{ pj_SOCK_STREAM(), "tcp", 4, 16},
/*
{ pj_SOCK_DGRAM(), "udp", 32, 1},
{ pj_SOCK_DGRAM(), "udp", 32, 1},
{ pj_SOCK_DGRAM(), "udp", 32, 1},
{ pj_SOCK_DGRAM(), "udp", 32, 1},
{ pj_SOCK_DGRAM(), "udp", 1, 32},
{ pj_SOCK_DGRAM(), "udp", 1, 32},
{ pj_SOCK_DGRAM(), "udp", 1, 32},
{ pj_SOCK_DGRAM(), "udp", 1, 32},
{ pj_SOCK_STREAM(), "tcp", 32, 1},
{ pj_SOCK_STREAM(), "tcp", 32, 1},
{ pj_SOCK_STREAM(), "tcp", 32, 1},
{ pj_SOCK_STREAM(), "tcp", 32, 1},
{ pj_SOCK_STREAM(), "tcp", 1, 32},
{ pj_SOCK_STREAM(), "tcp", 1, 32},
{ pj_SOCK_STREAM(), "tcp", 1, 32},
{ pj_SOCK_STREAM(), "tcp", 1, 32},
*/
};
pj_size_t best_bandwidth;
int best_index = 0;
PJ_LOG(3,(THIS_FILE, " Benchmarking %s ioqueue:", pj_ioqueue_name()));
PJ_LOG(3,(THIS_FILE, " Testing with concurency=%d", allow_concur));
PJ_LOG(3,(THIS_FILE, " ======================================="));
PJ_LOG(3,(THIS_FILE, " Type Threads Skt.Pairs Bandwidth"));
PJ_LOG(3,(THIS_FILE, " ======================================="));
best_bandwidth = 0;
for (i=0; i<(int)(sizeof(test_param)/sizeof(test_param[0])); ++i) {
pj_size_t bandwidth;
rc = perform_test(allow_concur,
test_param[i].type,
test_param[i].type_name,
test_param[i].thread_cnt,
test_param[i].sockpair_cnt,
BUF_SIZE,
&bandwidth);
if (rc != 0)
return rc;
if (bandwidth > best_bandwidth)
best_bandwidth = bandwidth, best_index = i;
/* Give it a rest before next test, to allow system to close the
* sockets properly.
*/
pj_thread_sleep(500);
}
PJ_LOG(3,(THIS_FILE,
" Best: Type=%s Threads=%d, Skt.Pairs=%d, Bandwidth=%u KB/s",
test_param[best_index].type_name,
test_param[best_index].thread_cnt,
test_param[best_index].sockpair_cnt,
best_bandwidth));
PJ_LOG(3,(THIS_FILE, " (Note: packet size=%d, total errors=%u)",
BUF_SIZE, last_error_counter));
return 0;
}
static int udp_ioqueue_unreg_test_imp(pj_bool_t allow_concur)
{
enum { LOOP = 10 };
int i, rc;
char title[30];
pj_ioqueue_t *ioqueue;
pj_pool_t *test_pool;
PJ_LOG(3,(THIS_FILE, "..testing with concurency=%d", allow_concur));
test_method = UNREGISTER_IN_APP;
test_pool = pj_pool_create(mem, "unregtest", 4000, 4000, NULL);
rc = pj_ioqueue_create(test_pool, 16, &ioqueue);
if (rc != PJ_SUCCESS) {
app_perror("Error creating ioqueue", rc);
return -10;
}
rc = pj_ioqueue_set_default_concurrency(ioqueue, allow_concur);
if (rc != PJ_SUCCESS) {
app_perror("Error in pj_ioqueue_set_default_concurrency()", rc);
return -12;
}
PJ_LOG(3, (THIS_FILE, "...ioqueue unregister stress test 0/3 (%s)",
pj_ioqueue_name()));
for (i=0; i<LOOP; ++i) {
pj_ansi_sprintf(title, "repeat %d/%d", i, LOOP);
rc = perform_unreg_test(ioqueue, test_pool, title, 0);
if (rc != 0)
return rc;
}
PJ_LOG(3, (THIS_FILE, "...ioqueue unregister stress test 1/3 (%s)",
pj_ioqueue_name()));
for (i=0; i<LOOP; ++i) {
pj_ansi_sprintf(title, "repeat %d/%d", i, LOOP);
rc = perform_unreg_test(ioqueue, test_pool, title, 1);
if (rc != 0)
return rc;
}
test_method = UNREGISTER_IN_CALLBACK;
PJ_LOG(3, (THIS_FILE, "...ioqueue unregister stress test 2/3 (%s)",
pj_ioqueue_name()));
for (i=0; i<LOOP; ++i) {
pj_ansi_sprintf(title, "repeat %d/%d", i, LOOP);
rc = perform_unreg_test(ioqueue, test_pool, title, 0);
if (rc != 0)
return rc;
}
PJ_LOG(3, (THIS_FILE, "...ioqueue unregister stress test 3/3 (%s)",
pj_ioqueue_name()));
for (i=0; i<LOOP; ++i) {
pj_ansi_sprintf(title, "repeat %d/%d", i, LOOP);
rc = perform_unreg_test(ioqueue, test_pool, title, 1);
if (rc != 0)
return rc;
}
pj_ioqueue_destroy(ioqueue);
pj_pool_release(test_pool);
return 0;
}