BLOG | DOCUMENTATION | TRAC

Home --> Documentations --> PJLIB Reference

Test: Thread Test

This file contains thread_test() definition.

Scope of Test

This tests:

  • whether PJ_THREAD_SUSPENDED flag works.
  • whether multithreading works.
  • whether thread timeslicing works, and threads have equal time-slice proportion.

APIs tested:

This file is pjlib-test/thread.c

/* $Id$ */
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "test.h"
#if INCLUDE_THREAD_TEST
#include <pjlib.h>
#define THIS_FILE "thread_test"
static volatile int quit_flag=0;
#if 0
# define TRACE__(args) PJ_LOG(3,args)
#else
# define TRACE__(args)
#endif
/*
* The thread's entry point.
*
* Each of the thread mainly will just execute the loop which
* increments a variable.
*/
static void* thread_proc(pj_uint32_t *pcounter)
{
/* Test that pj_thread_register() works. */
pj_thread_t *this_thread;
unsigned id;
id = *pcounter;
PJ_UNUSED_ARG(id); /* Warning about unused var if TRACE__ is disabled */
TRACE__((THIS_FILE, " thread %d running..", id));
pj_bzero(desc, sizeof(desc));
rc = pj_thread_register("thread", desc, &this_thread);
if (rc != PJ_SUCCESS) {
app_perror("...error in pj_thread_register", rc);
return NULL;
}
/* Test that pj_thread_this() works */
this_thread = pj_thread_this();
if (this_thread == NULL) {
PJ_LOG(3,(THIS_FILE, "...error: pj_thread_this() returns NULL!"));
return NULL;
}
/* Test that pj_thread_get_name() works */
if (pj_thread_get_name(this_thread) == NULL) {
PJ_LOG(3,(THIS_FILE, "...error: pj_thread_get_name() returns NULL!"));
return NULL;
}
/* Main loop */
for (;!quit_flag;) {
(*pcounter)++;
//Must sleep if platform doesn't do time-slicing.
//pj_thread_sleep(0);
}
TRACE__((THIS_FILE, " thread %d quitting..", id));
return NULL;
}
/*
* simple_thread()
*/
static int simple_thread(const char *title, unsigned flags)
{
pj_pool_t *pool;
pj_thread_t *thread;
pj_uint32_t counter = 0;
PJ_LOG(3,(THIS_FILE, "..%s", title));
pool = pj_pool_create(mem, NULL, 4000, 4000, NULL);
if (!pool)
return -1000;
quit_flag = 0;
TRACE__((THIS_FILE, " Creating thread 0.."));
rc = pj_thread_create(pool, "thread", (pj_thread_proc*)&thread_proc,
&counter,
flags,
&thread);
if (rc != PJ_SUCCESS) {
app_perror("...error: unable to create thread", rc);
return -1010;
}
TRACE__((THIS_FILE, " Main thread waiting.."));
TRACE__((THIS_FILE, " Main thread resuming.."));
if (flags & PJ_THREAD_SUSPENDED) {
/* Check that counter is still zero */
if (counter != 0) {
PJ_LOG(3,(THIS_FILE, "...error: thread is not suspended"));
return -1015;
}
rc = pj_thread_resume(thread);
if (rc != PJ_SUCCESS) {
app_perror("...error: resume thread error", rc);
return -1020;
}
}
PJ_LOG(3,(THIS_FILE, "..waiting for thread to quit.."));
quit_flag = 1;
pj_thread_join(thread);
if (counter == 0) {
PJ_LOG(3,(THIS_FILE, "...error: thread is not running"));
return -1025;
}
PJ_LOG(3,(THIS_FILE, "...%s success", title));
return PJ_SUCCESS;
}
/*
* timeslice_test()
*/
static int timeslice_test(void)
{
enum { NUM_THREADS = 4 };
pj_pool_t *pool;
pj_uint32_t counter[NUM_THREADS], lowest, highest, diff;
pj_thread_t *thread[NUM_THREADS];
unsigned i;
quit_flag = 0;
pool = pj_pool_create(mem, NULL, 4000, 4000, NULL);
if (!pool)
return -10;
PJ_LOG(3,(THIS_FILE, "..timeslice testing with %d threads", NUM_THREADS));
/* Create all threads in suspended mode. */
for (i=0; i<NUM_THREADS; ++i) {
counter[i] = i;
rc = pj_thread_create(pool, "thread", (pj_thread_proc*)&thread_proc,
&counter[i],
PJ_THREAD_SUSPENDED,
&thread[i]);
if (rc!=PJ_SUCCESS) {
app_perror("...ERROR in pj_thread_create()", rc);
return -20;
}
}
/* Sleep for 1 second.
* The purpose of this is to test whether all threads are suspended.
*/
TRACE__((THIS_FILE, " Main thread waiting.."));
TRACE__((THIS_FILE, " Main thread resuming.."));
/* Check that all counters are still zero. */
for (i=0; i<NUM_THREADS; ++i) {
if (counter[i] > i) {
PJ_LOG(3,(THIS_FILE, "....ERROR! Thread %d-th is not suspended!",
i));
return -30;
}
}
/* Now resume all threads. */
for (i=0; i<NUM_THREADS; ++i) {
TRACE__((THIS_FILE, " Resuming thread %d [%p]..", i, thread[i]));
rc = pj_thread_resume(thread[i]);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_thread_resume()", rc);
return -40;
}
}
/* Main thread sleeps for some time to allow threads to run.
* The longer we sleep, the more accurate the calculation will be,
* but it'll make user waits for longer for the test to finish.
*/
TRACE__((THIS_FILE, " Main thread waiting (5s).."));
TRACE__((THIS_FILE, " Main thread resuming.."));
/* Signal all threads to quit. */
quit_flag = 1;
/* Wait until all threads quit, then destroy. */
for (i=0; i<NUM_THREADS; ++i) {
TRACE__((THIS_FILE, " Main thread joining thread %d [%p]..",
i, thread[i]));
rc = pj_thread_join(thread[i]);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_thread_join()", rc);
return -50;
}
TRACE__((THIS_FILE, " Destroying thread %d [%p]..", i, thread[i]));
rc = pj_thread_destroy(thread[i]);
if (rc != PJ_SUCCESS) {
app_perror("...ERROR in pj_thread_destroy()", rc);
return -60;
}
}
TRACE__((THIS_FILE, " Main thread calculating time slices.."));
/* Now examine the value of the counters.
* Check that all threads had equal proportion of processing.
*/
lowest = 0xFFFFFFFF;
highest = 0;
for (i=0; i<NUM_THREADS; ++i) {
if (counter[i] < lowest)
lowest = counter[i];
if (counter[i] > highest)
highest = counter[i];
}
/* Check that all threads are running. */
if (lowest < 2) {
PJ_LOG(3,(THIS_FILE, "...ERROR: not all threads were running!"));
return -70;
}
/* The difference between lowest and higest should be lower than 50%.
*/
diff = (highest-lowest)*100 / ((highest+lowest)/2);
if ( diff >= 50) {
PJ_LOG(3,(THIS_FILE,
"...ERROR: thread didn't have equal timeslice!"));
PJ_LOG(3,(THIS_FILE,
".....lowest counter=%u, highest counter=%u, diff=%u%%",
lowest, highest, diff));
return -80;
} else {
PJ_LOG(3,(THIS_FILE,
"...info: timeslice diff between lowest & highest=%u%%",
diff));
}
return 0;
}
int thread_test(void)
{
int rc;
rc = simple_thread("simple thread test", 0);
if (rc != PJ_SUCCESS)
return rc;
rc = simple_thread("suspended thread test", PJ_THREAD_SUSPENDED);
if (rc != PJ_SUCCESS)
return rc;
rc = timeslice_test();
if (rc != PJ_SUCCESS)
return rc;
return rc;
}
#else
/* To prevent warning about "translation unit is empty"
* when this test is disabled.
*/
int dummy_thread_test;
#endif /* INCLUDE_THREAD_TEST */
pj_pool_t * pj_pool_create(pj_pool_factory *factory, const char *name, pj_size_t initial_size, pj_size_t increment_size, pj_pool_callback *callback)
pj_status_t pj_thread_create(pj_pool_t *pool, const char *thread_name, pj_thread_proc *proc, void *arg, pj_size_t stack_size, unsigned flags, pj_thread_t **thread)
struct pj_thread_t pj_thread_t
Definition: types.h:236
void pj_bzero(void *dst, pj_size_t size)
Definition: string.h:751
pj_status_t pj_thread_join(pj_thread_t *thread)
pj_status_t pj_thread_sleep(unsigned msec)
Definition: pool.h:310
pj_status_t pj_thread_register(const char *thread_name, pj_thread_desc desc, pj_thread_t **thread)
void pj_pool_release(pj_pool_t *pool)
int pj_status_t
Definition: types.h:68
pj_status_t pj_thread_destroy(pj_thread_t *thread)
#define PJ_UNUSED_ARG(arg)
Definition: config.h:1303
@ PJ_SUCCESS
Definition: types.h:93
unsigned int pj_uint32_t
Definition: types.h:43
pj_status_t pj_thread_resume(pj_thread_t *thread)
pj_thread_t * pj_thread_this(void)
#define PJ_LOG(level, arg)
Definition: log.h:107
const char * pj_thread_get_name(pj_thread_t *thread)
#define PJ_THREAD_DEFAULT_STACK_SIZE
Definition: config.h:605
long pj_thread_desc[(64)]
Definition: os.h:171

 


PJLIB Open Source, high performance, small footprint, and very very portable framework
Copyright (C) 2006-2009 Teluu Inc.