tests/threadpool-test.c

   1 #undef G_DISABLE_ASSERT
   2 #undef G_LOG_DOMAIN
   3
   4 #include "config.h"
   5
   6 #include <glib.h>
   7
   8 /* #define DEBUG 1 */
   9
  10 #ifdef DEBUG
  11 # define DEBUG_MSG(args) g_printerr args ; g_printerr ("\n");
  12 #else
  13 # define DEBUG_MSG(x)
  14 #endif
  15
  16 #define WAIT                5    /* seconds */
  17 #define MAX_THREADS         10
  18
  19 /* if > 0 the test will run continuously (since the test ends when
  20  * thread count is 0), if -1 it means no limit to unused threads
  21  * if 0 then no unused threads are possible */
  22 #define MAX_UNUSED_THREADS -1
  23
  24 G_LOCK_DEFINE_STATIC (thread_counter_pools);
  25
  26 static gulong abs_thread_counter = 0;
  27 static gulong running_thread_counter = 0;
  28 static gulong leftover_task_counter = 0;
  29
  30 G_LOCK_DEFINE_STATIC (last_thread);
  31
  32 static guint last_thread_id = 0;
  33
  34 G_LOCK_DEFINE_STATIC (thread_counter_sort);
  35
  36 static gulong sort_thread_counter = 0;
  37
  38 static GThreadPool *idle_pool = NULL;
  39
  40 static GMainLoop *main_loop = NULL;
  41
  42 static void
  43 test_thread_functions (void)
  44 {
  45   gint max_unused_threads;
  46   guint max_idle_time;
  47
  48   /* This function attempts to call functions which don't need a
  49    * threadpool to operate to make sure no uninitialised pointers
  50    * accessed and no errors occur.
  51    */
  52
  53   max_unused_threads = 3;
  54
  55   DEBUG_MSG (("[funcs] Setting max unused threads to %d",
  56               max_unused_threads));
  57   g_thread_pool_set_max_unused_threads (max_unused_threads);
  58
  59   DEBUG_MSG (("[funcs] Getting max unused threads = %d",
  60              g_thread_pool_get_max_unused_threads ()));
  61   g_assert (g_thread_pool_get_max_unused_threads() == max_unused_threads);
  62
  63   DEBUG_MSG (("[funcs] Getting num unused threads = %d",
  64              g_thread_pool_get_num_unused_threads ()));
  65   g_assert (g_thread_pool_get_num_unused_threads () == 0);
  66
  67   DEBUG_MSG (("[funcs] Stopping unused threads"));
  68   g_thread_pool_stop_unused_threads ();
  69
  70   max_idle_time = 10 * G_USEC_PER_SEC;
  71
  72   DEBUG_MSG (("[funcs] Setting max idle time to %d",
  73               max_idle_time));
  74   g_thread_pool_set_max_idle_time (max_idle_time);
  75
  76   DEBUG_MSG (("[funcs] Getting max idle time = %d",
  77              g_thread_pool_get_max_idle_time ()));
  78   g_assert (g_thread_pool_get_max_idle_time () == max_idle_time);
  79
  80   DEBUG_MSG (("[funcs] Setting max idle time to 0"));
  81   g_thread_pool_set_max_idle_time (0);
  82
  83   DEBUG_MSG (("[funcs] Getting max idle time = %d",
  84              g_thread_pool_get_max_idle_time ()));
  85   g_assert (g_thread_pool_get_max_idle_time () == 0);
  86 }
  87
  88 static void
  89 test_thread_stop_unused (void)
  90 {
  91    GThreadPool *pool;
  92    guint i;
  93    guint limit = 100;
  94
  95    /* Spawn a few threads. */
  96    g_thread_pool_set_max_unused_threads (-1);
  97    pool = g_thread_pool_new ((GFunc) g_usleep, NULL, -1, FALSE, NULL);
  98
  99    for (i = 0; i < limit; i++)
 100      g_thread_pool_push (pool, GUINT_TO_POINTER (1000), NULL);
 101
 102    DEBUG_MSG (("[unused] ===> pushed %d threads onto the idle pool",
 103                limit));
 104
 105    /* Wait for the threads to migrate. */
 106    g_usleep (G_USEC_PER_SEC);
 107
 108    DEBUG_MSG (("[unused] stopping unused threads"));
 109    g_thread_pool_stop_unused_threads ();
 110
 111    for (i = 0; i < 5; i++)
 112      {
 113        if (g_thread_pool_get_num_unused_threads () == 0)
 114          break;
 115
 116        DEBUG_MSG (("[unused] waiting ONE second for threads to die"));
 117
 118        /* Some time for threads to die. */
 119        g_usleep (G_USEC_PER_SEC);
 120      }
 121
 122    DEBUG_MSG (("[unused] stopped idle threads, %d remain",
 123                g_thread_pool_get_num_unused_threads ()));
 124
 125    g_assert (g_thread_pool_get_num_unused_threads () == 0);
 126
 127    g_thread_pool_set_max_unused_threads (MAX_THREADS);
 128
 129    DEBUG_MSG (("[unused] cleaning up thread pool"));
 130    g_thread_pool_free (pool, FALSE, TRUE);
 131 }
 132
 133 static void
 134 test_thread_pools_entry_func (gpointer data, gpointer user_data)
 135 {
 136 #ifdef DEBUG
 137   guint id = 0;
 138
 139   id = GPOINTER_TO_UINT (data);
 140 #endif
 141
 142   DEBUG_MSG (("[pool] ---> [%3.3d] entered thread.", id));
 143
 144   G_LOCK (thread_counter_pools);
 145   abs_thread_counter++;
 146   running_thread_counter++;
 147   G_UNLOCK (thread_counter_pools);
 148
 149   g_usleep (g_random_int_range (0, 4000));
 150
 151   G_LOCK (thread_counter_pools);
 152   running_thread_counter--;
 153   leftover_task_counter--;
 154
 155   DEBUG_MSG (("[pool] ---> [%3.3d] exiting thread (abs count:%ld, "
 156               "running count:%ld, left over:%ld)",
 157               id, abs_thread_counter,
 158               running_thread_counter, leftover_task_counter));
 159   G_UNLOCK (thread_counter_pools);
 160 }
 161
 162 static void
 163 test_thread_pools (void)
 164 {
 165   GThreadPool *pool1, *pool2, *pool3;
 166   guint runs;
 167   guint i;
 168
 169   pool1 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 3, FALSE, NULL);
 170   pool2 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 5, TRUE, NULL);
 171   pool3 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 7, TRUE, NULL);
 172
 173   runs = 300;
 174   for (i = 0; i < runs; i++)
 175     {
 176       g_thread_pool_push (pool1, GUINT_TO_POINTER (i + 1), NULL);
 177       g_thread_pool_push (pool2, GUINT_TO_POINTER (i + 1), NULL);
 178       g_thread_pool_push (pool3, GUINT_TO_POINTER (i + 1), NULL);
 179
 180       G_LOCK (thread_counter_pools);
 181       leftover_task_counter += 3;
 182       G_UNLOCK (thread_counter_pools);
 183     }
 184
 185   g_thread_pool_free (pool1, TRUE, TRUE);
 186   g_thread_pool_free (pool2, FALSE, TRUE);
 187   g_thread_pool_free (pool3, FALSE, TRUE);
 188
 189   g_assert (runs * 3 == abs_thread_counter + leftover_task_counter);
 190   g_assert (running_thread_counter == 0);
 191 }
 192
 193 static gint
 194 test_thread_sort_compare_func (gconstpointer a, gconstpointer b, gpointer user_data)
 195 {
 196   guint32 id1, id2;
 197
 198   id1 = GPOINTER_TO_UINT (a);
 199   id2 = GPOINTER_TO_UINT (b);
 200
 201   return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1);
 202 }
 203
 204 static void
 205 test_thread_sort_entry_func (gpointer data, gpointer user_data)
 206 {
 207   guint thread_id;
 208   gboolean is_sorted;
 209
 210   G_LOCK (last_thread);
 211
 212   thread_id = GPOINTER_TO_UINT (data);
 213   is_sorted = GPOINTER_TO_INT (user_data);
 214
 215   DEBUG_MSG (("%s ---> entered thread:%2.2d, last thread:%2.2d",
 216               is_sorted ? "[  sorted]" : "[unsorted]",
 217               thread_id, last_thread_id));
 218
 219   if (is_sorted) {
 220     static gboolean last_failed = FALSE;
 221
 222     if (last_thread_id > thread_id) {
 223       if (last_failed) {
 224         g_assert (last_thread_id <= thread_id);
 225       }
 226
 227       /* Here we remember one fail and if it concurrently fails, it
 228        * can not be sorted. the last thread id might be < this thread
 229        * id if something is added to the queue since threads were
 230        * created
 231        */
 232       last_failed = TRUE;
 233     } else {
 234       last_failed = FALSE;
 235     }
 236
 237     last_thread_id = thread_id;
 238   }
 239
 240   G_UNLOCK (last_thread);
 241
 242   g_usleep (WAIT * 1000);
 243 }
 244
 245 static void
 246 test_thread_sort (gboolean sort)
 247 {
 248   GThreadPool *pool;
 249   guint limit;
 250   guint max_threads;
 251   gint i;
 252
 253   limit = MAX_THREADS * 10;
 254
 255   if (sort) {
 256     max_threads = 1;
 257   } else {
 258     max_threads = MAX_THREADS;
 259   }
 260
 261   /* It is important that we only have a maximum of 1 thread for this
 262    * test since the results can not be guaranteed to be sorted if > 1.
 263    *
 264    * Threads are scheduled by the operating system and are executed at
 265    * random. It cannot be assumed that threads are executed in the
 266    * order they are created. This was discussed in bug #334943.
 267    */
 268
 269   pool = g_thread_pool_new (test_thread_sort_entry_func,
 270                             GINT_TO_POINTER (sort),
 271                             max_threads,
 272                             FALSE,
 273                             NULL);
 274
 275   g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);
 276
 277   if (sort) {
 278     g_thread_pool_set_sort_function (pool,
 279                                      test_thread_sort_compare_func,
 280                                      GUINT_TO_POINTER (69));
 281   }
 282
 283   for (i = 0; i < limit; i++) {
 284     guint id;
 285
 286     id = g_random_int_range (1, limit) + 1;
 287     g_thread_pool_push (pool, GUINT_TO_POINTER (id), NULL);
 288     DEBUG_MSG (("%s ===> pushed new thread with id:%d, number "
 289                 "of threads:%d, unprocessed:%d",
 290                 sort ? "[  sorted]" : "[unsorted]",
 291                 id,
 292                 g_thread_pool_get_num_threads (pool),
 293                 g_thread_pool_unprocessed (pool)));
 294   }
 295
 296   g_assert (g_thread_pool_get_max_threads (pool) == max_threads);
 297   g_assert (g_thread_pool_get_num_threads (pool) == g_thread_pool_get_max_threads (pool));
 298 }
 299
 300 static void
 301 test_thread_idle_time_entry_func (gpointer data, gpointer user_data)
 302 {
 303 #ifdef DEBUG
 304   guint thread_id;
 305
 306   thread_id = GPOINTER_TO_UINT (data);
 307 #endif
 308
 309   DEBUG_MSG (("[idle] ---> entered thread:%2.2d", thread_id));
 310
 311   g_usleep (WAIT * 1000);
 312
 313   DEBUG_MSG (("[idle] <--- exiting thread:%2.2d", thread_id));
 314 }
 315
 316 static gboolean
 317 test_thread_idle_timeout (gpointer data)
 318 {
 319   gint i;
 320
 321   for (i = 0; i < 2; i++) {
 322     g_thread_pool_push (idle_pool, GUINT_TO_POINTER (100 + i), NULL);
 323     DEBUG_MSG (("[idle] ===> pushed new thread with id:%d, number "
 324                 "of threads:%d, unprocessed:%d",
 325                 100 + i,
 326                 g_thread_pool_get_num_threads (idle_pool),
 327                 g_thread_pool_unprocessed (idle_pool)));
 328   }
 329
 330
 331   return FALSE;
 332 }
 333
 334 static void
 335 test_thread_idle_time (void)
 336 {
 337   guint limit = 50;
 338   guint interval = 10000;
 339   gint i;
 340
 341   idle_pool = g_thread_pool_new (test_thread_idle_time_entry_func,
 342                                  NULL,
 343                                  0,
 344                                  FALSE,
 345                                  NULL);
 346
 347   g_thread_pool_set_max_threads (idle_pool, MAX_THREADS, NULL);
 348   g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);
 349   g_thread_pool_set_max_idle_time (interval);
 350
 351   g_assert (g_thread_pool_get_max_threads (idle_pool) == MAX_THREADS);
 352   g_assert (g_thread_pool_get_max_unused_threads () == MAX_UNUSED_THREADS);
 353   g_assert (g_thread_pool_get_max_idle_time () == interval);
 354
 355   for (i = 0; i < limit; i++) {
 356     g_thread_pool_push (idle_pool, GUINT_TO_POINTER (i + 1), NULL);
 357     DEBUG_MSG (("[idle] ===> pushed new thread with id:%d, "
 358                 "number of threads:%d, unprocessed:%d",
 359                 i,
 360                 g_thread_pool_get_num_threads (idle_pool),
 361                 g_thread_pool_unprocessed (idle_pool)));
 362   }
 363
 364   g_assert_cmpint (g_thread_pool_unprocessed (idle_pool), <=, limit);
 365
 366   g_timeout_add ((interval - 1000),
 367                  test_thread_idle_timeout,
 368                  GUINT_TO_POINTER (interval));
 369 }
 370
 371 static gboolean
 372 test_check_start_and_stop (gpointer user_data)
 373 {
 374   static guint test_number = 0;
 375   static gboolean run_next = FALSE;
 376   gboolean continue_timeout = TRUE;
 377   gboolean quit = TRUE;
 378
 379   if (test_number == 0) {
 380     run_next = TRUE;
 381     DEBUG_MSG (("***** RUNNING TEST %2.2d *****", test_number));
 382   }
 383
 384   if (run_next) {
 385     test_number++;
 386
 387     switch (test_number) {
 388     case 1:
 389       test_thread_functions ();
 390       break;
 391     case 2:
 392       test_thread_stop_unused ();
 393       break;
 394     case 3:
 395       test_thread_pools ();
 396       break;
 397     case 4:
 398       test_thread_sort (FALSE);
 399       break;
 400     case 5:
 401       test_thread_sort (TRUE);
 402       break;
 403     case 6:
 404       test_thread_stop_unused ();
 405       break;
 406     case 7:
 407       test_thread_idle_time ();
 408       break;
 409     default:
 410       DEBUG_MSG (("***** END OF TESTS *****"));
 411       g_main_loop_quit (main_loop);
 412       continue_timeout = FALSE;
 413       break;
 414     }
 415
 416     run_next = FALSE;
 417     return TRUE;
 418   }
 419
 420   if (test_number == 3) {
 421     G_LOCK (thread_counter_pools);
 422     quit &= running_thread_counter <= 0;
 423     DEBUG_MSG (("***** POOL RUNNING THREAD COUNT:%ld",
 424                 running_thread_counter));
 425     G_UNLOCK (thread_counter_pools);
 426   }
 427
 428   if (test_number == 4 || test_number == 5) {
 429     G_LOCK (thread_counter_sort);
 430     quit &= sort_thread_counter <= 0;
 431     DEBUG_MSG (("***** POOL SORT THREAD COUNT:%ld",
 432                 sort_thread_counter));
 433     G_UNLOCK (thread_counter_sort);
 434   }
 435
 436   if (test_number == 7) {
 437     guint idle;
 438
 439     idle = g_thread_pool_get_num_unused_threads ();
 440     quit &= idle < 1;
 441     DEBUG_MSG (("***** POOL IDLE THREAD COUNT:%d, UNPROCESSED JOBS:%d",
 442                 idle, g_thread_pool_unprocessed (idle_pool)));
 443   }
 444
 445   if (quit) {
 446     run_next = TRUE;
 447   }
 448
 449   return continue_timeout;
 450 }
 451
 452 int
 453 main (int argc, char *argv[])
 454 {
 455   DEBUG_MSG (("Starting... (in one second)"));
 456   g_timeout_add (1000, test_check_start_and_stop, NULL);
 457
 458   main_loop = g_main_loop_new (NULL, FALSE);
 459   g_main_loop_run (main_loop);
 460   g_main_loop_unref (main_loop);
 461
 462   g_thread_pool_free (idle_pool, FALSE, TRUE);
 463   return 0;
 464 }