tests/test_threadpool.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2012, Digium, Inc.
   5  *
   6  * Mark Michelson <mmichelson@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*!
  20  * \file
  21  * \brief threadpool unit tests
  22  *
  23  * \author Mark Michelson <mmichelson@digium.com>
  24  *
  25  */
  26
  27 /*** MODULEINFO
  28         <depend>TEST_FRAMEWORK</depend>
  29         <support_level>core</support_level>
  30  ***/
  31
  32 #include "asterisk.h"
  33
  34 #include "asterisk/test.h"
  35 #include "asterisk/threadpool.h"
  36 #include "asterisk/module.h"
  37 #include "asterisk/lock.h"
  38 #include "asterisk/astobj2.h"
  39 #include "asterisk/logger.h"
  40
  41 struct test_listener_data {
  42         int num_active;
  43         int num_idle;
  44         int task_pushed;
  45         int num_tasks;
  46         int empty_notice;
  47         int was_empty;
  48         ast_mutex_t lock;
  49         ast_cond_t cond;
  50 };
  51
  52 static void *test_alloc(struct ast_threadpool_listener *listener)
  53 {
  54         struct test_listener_data *tld = ast_calloc(1, sizeof(*tld));
  55         if (!tld) {
  56                 return NULL;
  57         }
  58         ast_mutex_init(&tld->lock);
  59         ast_cond_init(&tld->cond, NULL);
  60         return tld;
  61 }
  62
  63 static void test_state_changed(struct ast_threadpool *pool,
  64                 struct ast_threadpool_listener *listener,
  65                 int active_threads,
  66                 int idle_threads)
  67 {
  68         struct test_listener_data *tld = listener->private_data;
  69         SCOPED_MUTEX(lock, &tld->lock);
  70         ast_log(LOG_NOTICE, "State changed: num_active: %d, num_idle: %d\n", active_threads, idle_threads);
  71         tld->num_active = active_threads;
  72         tld->num_idle = idle_threads;
  73         ast_cond_signal(&tld->cond);
  74 }
  75
  76 static void test_task_pushed(struct ast_threadpool *pool,
  77                 struct ast_threadpool_listener *listener,
  78                 int was_empty)
  79 {
  80         struct test_listener_data *tld = listener->private_data;
  81         SCOPED_MUTEX(lock, &tld->lock);
  82         tld->task_pushed = 1;
  83         ++tld->num_tasks;
  84         tld->was_empty = was_empty;
  85         ast_cond_signal(&tld->cond);
  86 }
  87
  88 static void test_emptied(struct ast_threadpool *pool,
  89                 struct ast_threadpool_listener *listener)
  90 {
  91         struct test_listener_data *tld = listener->private_data;
  92         SCOPED_MUTEX(lock, &tld->lock);
  93         tld->empty_notice = 1;
  94         ast_cond_signal(&tld->cond);
  95 }
  96
  97 static void test_destroy(void *private_data)
  98 {
  99         struct test_listener_data *tld = private_data;
 100         ast_debug(1, "Poop\n");
 101         ast_cond_destroy(&tld->cond);
 102         ast_mutex_destroy(&tld->lock);
 103         ast_free(tld);
 104 }
 105
 106 static const struct ast_threadpool_listener_callbacks test_callbacks = {
 107         .alloc = test_alloc,
 108         .state_changed = test_state_changed,
 109         .task_pushed = test_task_pushed,
 110         .emptied = test_emptied,
 111         .destroy = test_destroy,
 112 };
 113
 114 struct simple_task_data {
 115         int task_executed;
 116         ast_mutex_t lock;
 117         ast_cond_t cond;
 118 };
 119
 120 static struct simple_task_data *simple_task_data_alloc(void)
 121 {
 122         struct simple_task_data *std = ast_calloc(1, sizeof(*std));
 123
 124         if (!std) {
 125                 return NULL;
 126         }
 127         ast_mutex_init(&std->lock);
 128         ast_cond_init(&std->cond, NULL);
 129         return std;
 130 }
 131
 132 static int simple_task(void *data)
 133 {
 134         struct simple_task_data *std = data;
 135         SCOPED_MUTEX(lock, &std->lock);
 136         std->task_executed = 1;
 137         ast_cond_signal(&std->cond);
 138         return 0;
 139 }
 140
 141 #define WAIT_WHILE(tld, condition) \
 142 {\
 143         ast_mutex_lock(&tld->lock);\
 144         while ((condition)) {\
 145                 ast_cond_wait(&tld->cond, &tld->lock);\
 146         }\
 147         ast_mutex_unlock(&tld->lock);\
 148 }\
 149
 150 static void wait_for_task_pushed(struct ast_threadpool_listener *listener)
 151 {
 152         struct test_listener_data *tld = listener->private_data;
 153         struct timeval start = ast_tvnow();
 154         struct timespec end = {
 155                 .tv_sec = start.tv_sec + 5,
 156                 .tv_nsec = start.tv_usec * 1000
 157         };
 158         SCOPED_MUTEX(lock, &tld->lock);
 159
 160         while (!tld->task_pushed) {
 161                 ast_cond_timedwait(&tld->cond, lock, &end);
 162         }
 163 }
 164
 165 static enum ast_test_result_state listener_check(
 166                 struct ast_test *test,
 167                 struct ast_threadpool_listener *listener,
 168                 int task_pushed,
 169                 int was_empty,
 170                 int num_tasks,
 171                 int num_active,
 172                 int num_idle,
 173                 int empty_notice)
 174 {
 175         struct test_listener_data *tld = listener->private_data;
 176         enum ast_test_result_state res = AST_TEST_PASS;
 177
 178         if (tld->task_pushed != task_pushed) {
 179                 ast_test_status_update(test, "Expected task %sto be pushed, but it was%s\n",
 180                                 task_pushed ? "" : "not ", tld->task_pushed ? "" : " not");
 181                 res = AST_TEST_FAIL;
 182         }
 183         if (tld->was_empty != was_empty) {
 184                 ast_test_status_update(test, "Expected %sto be empty, but it was%s\n",
 185                                 was_empty ? "" : "not ", tld->task_pushed ? "" : " not");
 186                 res = AST_TEST_FAIL;
 187         }
 188         if (tld->num_tasks!= num_tasks) {
 189                 ast_test_status_update(test, "Expected %d tasks to be pushed, but got %d\n",
 190                                 num_tasks, tld->num_tasks);
 191                 res = AST_TEST_FAIL;
 192         }
 193         if (tld->num_active != num_active) {
 194                 ast_test_status_update(test, "Expected %d active threads, but got %d\n",
 195                                 num_active, tld->num_active);
 196                 res = AST_TEST_FAIL;
 197         }
 198         if (tld->num_idle != num_idle) {
 199                 ast_test_status_update(test, "Expected %d idle threads, but got %d\n",
 200                                 num_idle, tld->num_idle);
 201                 res = AST_TEST_FAIL;
 202         }
 203         if (tld->empty_notice != empty_notice) {
 204                 ast_test_status_update(test, "Expected %s empty notice, but got %s\n",
 205                                 was_empty ? "an" : "no", tld->task_pushed ? "one" : "none");
 206                 res = AST_TEST_FAIL;
 207         }
 208
 209         return res;
 210 }
 211
 212 AST_TEST_DEFINE(threadpool_push)
 213 {
 214         struct ast_threadpool *pool = NULL;
 215         struct ast_threadpool_listener *listener = NULL;
 216         struct simple_task_data *std = NULL;
 217         enum ast_test_result_state res = AST_TEST_FAIL;
 218
 219         switch (cmd) {
 220         case TEST_INIT:
 221                 info->name = "threadpool_push";
 222                 info->category = "/main/threadpool/";
 223                 info->summary = "Test task";
 224                 info->description =
 225                         "Basic threadpool test";
 226                 return AST_TEST_NOT_RUN;
 227         case TEST_EXECUTE:
 228                 break;
 229         }
 230
 231         listener = ast_threadpool_listener_alloc(&test_callbacks);
 232         if (!listener) {
 233                 return AST_TEST_FAIL;
 234         }
 235
 236         pool = ast_threadpool_create(listener, 0);
 237         if (!pool) {
 238                 goto end;
 239         }
 240
 241         std = simple_task_data_alloc();
 242         if (!std) {
 243                 goto end;
 244         }
 245
 246         ast_threadpool_push(pool, simple_task, std);
 247
 248         wait_for_task_pushed(listener);
 249
 250         res = listener_check(test, listener, 1, 1, 1, 0, 0, 0);
 251
 252 end:
 253         if (pool) {
 254                 ast_threadpool_shutdown(pool);
 255         }
 256         ao2_cleanup(listener);
 257         ast_free(std);
 258         return res;
 259 }
 260
 261 AST_TEST_DEFINE(threadpool_thread_creation)
 262 {
 263         struct ast_threadpool *pool = NULL;
 264         struct ast_threadpool_listener *listener = NULL;
 265         enum ast_test_result_state res = AST_TEST_FAIL;
 266         struct test_listener_data *tld;
 267
 268         switch (cmd) {
 269         case TEST_INIT:
 270                 info->name = "threadpool_thread_creation";
 271                 info->category = "/main/threadpool/";
 272                 info->summary = "Test threadpool thread creation";
 273                 info->description =
 274                         "Ensure that threads can be added to a threadpool";
 275                 return AST_TEST_NOT_RUN;
 276         case TEST_EXECUTE:
 277                 break;
 278         }
 279
 280         listener = ast_threadpool_listener_alloc(&test_callbacks);
 281         if (!listener) {
 282                 return AST_TEST_FAIL;
 283         }
 284         tld = listener->private_data;
 285
 286         pool = ast_threadpool_create(listener, 0);
 287         if (!pool) {
 288                 goto end;
 289         }
 290
 291         /* Now let's create a thread. It should start active, then go
 292          * idle immediately
 293          */
 294         ast_threadpool_set_size(pool, 1);
 295
 296         WAIT_WHILE(tld, tld->num_idle == 0);
 297
 298         res = listener_check(test, listener, 0, 0, 0, 0, 1, 0);
 299
 300 end:
 301         if (pool) {
 302                 ast_threadpool_shutdown(pool);
 303         }
 304         ao2_cleanup(listener);
 305         return res;
 306 }
 307
 308 static int unload_module(void)
 309 {
 310         ast_test_unregister(threadpool_push);
 311         ast_test_unregister(threadpool_thread_creation);
 312         return 0;
 313 }
 314
 315 static int load_module(void)
 316 {
 317         ast_test_register(threadpool_push);
 318         ast_test_register(threadpool_thread_creation);
 319         return AST_MODULE_LOAD_SUCCESS;
 320 }
 321
 322 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "threadpool test module");