kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-09-03 03:20:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add new threadpool test and fix some taskprocessor bugs.

Browse Source 
The new thread creation test fails because Asterisk locks up
while trying to lock a taskprocessor.

While trying to debug that, I found a race condition during taskprocessor
creation where a default taskprocessor listener could try to operate on
a partially started taskprocessor. This was fixed by adding a new callback
to taskprocessor listeners.

Then while testing that change, I found some bugs in the taskprocessor
tests where I was not properly unlocking when done with a lock. Scoped
locks have spoiled me a bit.

I still have not figured out why the threadpool thread creation test
is locking up.



git-svn-id: https://origsvn.digium.com/svn/asterisk/team/mmichelson/threadpool@377368 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Mark Michelson
2012-12-07 00:30:35 +00:00
parent 62981d2032
commit 4590bfd93d
5 changed files with 106 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
tests/test_threadpool.c
View File

@@ -36,6 +36,7 @@
#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/astobj2.h"
#include "asterisk/logger.h"
struct test_listener_data {
int num_active;
@@ -66,6 +67,7 @@ static void test_state_changed(struct ast_threadpool *pool,
{
struct test_listener_data *tld = listener->private_data;
SCOPED_MUTEX(lock, &tld->lock);
ast_log(LOG_NOTICE, "State changed: num_active: %d, num_idle: %d\n", active_threads, idle_threads);
tld->num_active = active_threads;
tld->num_idle = idle_threads;
ast_cond_signal(&tld->cond);
@@ -95,6 +97,7 @@ static void test_emptied(struct ast_threadpool *pool,
static void test_destroy(void *private_data)
{
struct test_listener_data *tld = private_data;
ast_debug(1, "Poop\n");
ast_cond_destroy(&tld->cond);
ast_mutex_destroy(&tld->lock);
ast_free(tld);
@@ -135,6 +138,15 @@ static int simple_task(void *data)
return 0;
}
#define WAIT_WHILE(tld, condition) \
{\
ast_mutex_lock(&tld->lock);\
while ((condition)) {\
ast_cond_wait(&tld->cond, &tld->lock);\
}\
ast_mutex_unlock(&tld->lock);\
}\
static void wait_for_task_pushed(struct ast_threadpool_listener *listener)
{
struct test_listener_data *tld = listener->private_data;
@@ -246,15 +258,64 @@ end:
return res;
}
AST_TEST_DEFINE(threadpool_thread_creation)
{
struct ast_threadpool *pool = NULL;
struct ast_threadpool_listener *listener = NULL;
enum ast_test_result_state res = AST_TEST_FAIL;
struct test_listener_data *tld;
switch (cmd) {
case TEST_INIT:
info->name = "threadpool_thread_creation";
info->category = "/main/threadpool_thread_creation/";
info->summary = "Test threadpool thread creation";
info->description =
"Ensure that threads can be added to a threadpool";
return AST_TEST_NOT_RUN;
case TEST_EXECUTE:
break;
}
listener = ast_threadpool_listener_alloc(&test_callbacks);
if (!listener) {
return AST_TEST_FAIL;
}
tld = listener->private_data;
pool = ast_threadpool_create(listener, 0);
if (!pool) {
goto end;
}
/* Now let's create a thread. It should start active, then go
* idle immediately
*/
ast_threadpool_set_size(pool, 1);
WAIT_WHILE(tld, tld->num_idle == 0);
res = listener_check(test, listener, 0, 0, 0, 0, 1, 0);
end:
if (pool) {
ast_threadpool_shutdown(pool);
}
ao2_cleanup(listener);
return res;
}
static int unload_module(void)
{
ast_test_unregister(threadpool_push);
ast_test_unregister(threadpool_thread_creation);
return 0;
}
static int load_module(void)
{
ast_test_register(threadpool_push);
ast_test_register(threadpool_thread_creation);
return AST_MODULE_LOAD_SUCCESS;
}