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