threadpool-test.c 11.4 KB
Newer Older
1 2 3
#undef G_DISABLE_ASSERT
#undef G_LOG_DOMAIN

4
#include "config.h"
5

6 7
#include <glib.h>

Dan Winship's avatar
Dan Winship committed
8 9 10 11 12 13 14
/* #define DEBUG 1 */

#ifdef DEBUG
# define DEBUG_MSG(args) g_printerr args ; g_printerr ("\n");
#else
# define DEBUG_MSG(x)
#endif
15 16 17

#define WAIT                5    /* seconds */
#define MAX_THREADS         10
18

Matthias Clasen's avatar
Matthias Clasen committed
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 25 26 27 28 29 30 31 32 33 34 35 36 37

G_LOCK_DEFINE_STATIC (thread_counter_pools);

static gulong abs_thread_counter = 0;
static gulong running_thread_counter = 0;
static gulong leftover_task_counter = 0;

G_LOCK_DEFINE_STATIC (last_thread);

static guint last_thread_id = 0;

G_LOCK_DEFINE_STATIC (thread_counter_sort);

static gulong sort_thread_counter = 0;

38
static GThreadPool *idle_pool = NULL;
39

40 41
static GMainLoop *main_loop = NULL;

42 43 44 45 46 47 48 49 50 51 52 53 54
static void
test_thread_functions (void)
{
  gint max_unused_threads;
  guint max_idle_time;

  /* This function attempts to call functions which don't need a
   * threadpool to operate to make sure no uninitialised pointers
   * accessed and no errors occur.
   */

  max_unused_threads = 3;

55
  DEBUG_MSG (("[funcs] Setting max unused threads to %d",
56 57 58
	      max_unused_threads));
  g_thread_pool_set_max_unused_threads (max_unused_threads);

59
  DEBUG_MSG (("[funcs] Getting max unused threads = %d",
60 61 62
	     g_thread_pool_get_max_unused_threads ()));
  g_assert (g_thread_pool_get_max_unused_threads() == max_unused_threads);

63
  DEBUG_MSG (("[funcs] Getting num unused threads = %d",
64 65 66 67 68 69 70 71
	     g_thread_pool_get_num_unused_threads ()));
  g_assert (g_thread_pool_get_num_unused_threads () == 0);

  DEBUG_MSG (("[funcs] Stopping unused threads"));
  g_thread_pool_stop_unused_threads ();

  max_idle_time = 10 * G_USEC_PER_SEC;

72
  DEBUG_MSG (("[funcs] Setting max idle time to %d",
73 74 75
	      max_idle_time));
  g_thread_pool_set_max_idle_time (max_idle_time);

76
  DEBUG_MSG (("[funcs] Getting max idle time = %d",
77 78 79 80 81 82
	     g_thread_pool_get_max_idle_time ()));
  g_assert (g_thread_pool_get_max_idle_time () == max_idle_time);

  DEBUG_MSG (("[funcs] Setting max idle time to 0"));
  g_thread_pool_set_max_idle_time (0);

83
  DEBUG_MSG (("[funcs] Getting max idle time = %d",
84 85 86 87 88 89
	     g_thread_pool_get_max_idle_time ()));
  g_assert (g_thread_pool_get_max_idle_time () == 0);
}

static void
test_thread_stop_unused (void)
90
{
91 92 93
   GThreadPool *pool;
   guint i;
   guint limit = 100;
94

95 96 97
   /* Spawn a few threads. */
   g_thread_pool_set_max_unused_threads (-1);
   pool = g_thread_pool_new ((GFunc) g_usleep, NULL, -1, FALSE, NULL);
98

99 100 101 102 103
   for (i = 0; i < limit; i++)
     g_thread_pool_push (pool, GUINT_TO_POINTER (1000), NULL);

   DEBUG_MSG (("[unused] ===> pushed %d threads onto the idle pool",
	       limit));
104

105
   /* Wait for the threads to migrate. */
106
   g_usleep (G_USEC_PER_SEC);
107 108 109 110

   DEBUG_MSG (("[unused] stopping unused threads"));
   g_thread_pool_stop_unused_threads ();

111 112
   for (i = 0; i < 5; i++)
     {
113
       if (g_thread_pool_get_num_unused_threads () == 0)
114
         break;
115

116 117 118 119 120
       DEBUG_MSG (("[unused] waiting ONE second for threads to die"));

       /* Some time for threads to die. */
       g_usleep (G_USEC_PER_SEC);
     }
121

122 123
   DEBUG_MSG (("[unused] stopped idle threads, %d remain",
	       g_thread_pool_get_num_unused_threads ()));
124

125
   g_assert (g_thread_pool_get_num_unused_threads () == 0);
126

127 128 129 130 131
   g_thread_pool_set_max_unused_threads (MAX_THREADS);

   DEBUG_MSG (("[unused] cleaning up thread pool"));
   g_thread_pool_free (pool, FALSE, TRUE);
}
132 133 134

static void
test_thread_pools_entry_func (gpointer data, gpointer user_data)
135
{
Dan Winship's avatar
Dan Winship committed
136
#ifdef DEBUG
137 138 139
  guint id = 0;

  id = GPOINTER_TO_UINT (data);
Dan Winship's avatar
Dan Winship committed
140
#endif
141

142
  DEBUG_MSG (("[pool] ---> [%3.3d] entered thread.", id));
143 144

  G_LOCK (thread_counter_pools);
145 146
  abs_thread_counter++;
  running_thread_counter++;
147
  G_UNLOCK (thread_counter_pools);
148 149 150

  g_usleep (g_random_int_range (0, 4000));

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 157 158
	      "running count:%ld, left over:%ld)",
	      id, abs_thread_counter,
	      running_thread_counter, leftover_task_counter));
159
  G_UNLOCK (thread_counter_pools);
160 161
}

162 163
static void
test_thread_pools (void)
164
{
165
  GThreadPool *pool1, *pool2, *pool3;
166
  guint runs;
167
  guint i;
168

169 170 171
  pool1 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 3, FALSE, NULL);
  pool2 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 5, TRUE, NULL);
  pool3 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 7, TRUE, NULL);
172

173 174
  runs = 300;
  for (i = 0; i < runs; i++)
175
    {
176 177 178
      g_thread_pool_push (pool1, GUINT_TO_POINTER (i + 1), NULL);
      g_thread_pool_push (pool2, GUINT_TO_POINTER (i + 1), NULL);
      g_thread_pool_push (pool3, GUINT_TO_POINTER (i + 1), NULL);
179 180

      G_LOCK (thread_counter_pools);
181
      leftover_task_counter += 3;
182 183 184
      G_UNLOCK (thread_counter_pools);
    }

185
  g_thread_pool_free (pool1, TRUE, TRUE);
186 187 188
  g_thread_pool_free (pool2, FALSE, TRUE);
  g_thread_pool_free (pool3, FALSE, TRUE);

189
  g_assert (runs * 3 == abs_thread_counter + leftover_task_counter);
190
  g_assert (running_thread_counter == 0);
191 192 193 194 195 196 197 198 199 200
}

static gint
test_thread_sort_compare_func (gconstpointer a, gconstpointer b, gpointer user_data)
{
  guint32 id1, id2;

  id1 = GPOINTER_TO_UINT (a);
  id2 = GPOINTER_TO_UINT (b);

201
  return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1);
202 203 204 205 206 207 208 209 210 211 212 213 214
}

static void
test_thread_sort_entry_func (gpointer data, gpointer user_data)
{
  guint thread_id;
  gboolean is_sorted;

  G_LOCK (last_thread);

  thread_id = GPOINTER_TO_UINT (data);
  is_sorted = GPOINTER_TO_INT (user_data);

215 216
  DEBUG_MSG (("%s ---> entered thread:%2.2d, last thread:%2.2d",
	      is_sorted ? "[  sorted]" : "[unsorted]",
217
	      thread_id, last_thread_id));
218 219 220 221 222 223

  if (is_sorted) {
    static gboolean last_failed = FALSE;

    if (last_thread_id > thread_id) {
      if (last_failed) {
224
	g_assert (last_thread_id <= thread_id);
225 226
      }

227 228 229
      /* Here we remember one fail and if it concurrently fails, it
       * can not be sorted. the last thread id might be < this thread
       * id if something is added to the queue since threads were
230
       * created
231
       */
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
      last_failed = TRUE;
    } else {
      last_failed = FALSE;
    }

    last_thread_id = thread_id;
  }

  G_UNLOCK (last_thread);

  g_usleep (WAIT * 1000);
}

static void
test_thread_sort (gboolean sort)
{
  GThreadPool *pool;
249 250
  guint limit;
  guint max_threads;
251 252
  gint i;

253 254 255 256 257 258 259 260 261
  limit = MAX_THREADS * 10;

  if (sort) {
    max_threads = 1;
  } else {
    max_threads = MAX_THREADS;
  }

  /* It is important that we only have a maximum of 1 thread for this
Matthias Clasen's avatar
Matthias Clasen committed
262
   * test since the results can not be guaranteed to be sorted if > 1.
263
   *
264 265 266 267
   * Threads are scheduled by the operating system and are executed at
   * random. It cannot be assumed that threads are executed in the
   * order they are created. This was discussed in bug #334943.
   */
268 269 270 271

  pool = g_thread_pool_new (test_thread_sort_entry_func,
			    GINT_TO_POINTER (sort),
			    max_threads,
272 273 274
			    FALSE,
			    NULL);

275
  g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);
276 277

  if (sort) {
278
    g_thread_pool_set_sort_function (pool,
279 280 281
				     test_thread_sort_compare_func,
				     GUINT_TO_POINTER (69));
  }
282

283 284 285
  for (i = 0; i < limit; i++) {
    guint id;

286 287 288 289
    id = g_random_int_range (1, limit) + 1;
    g_thread_pool_push (pool, GUINT_TO_POINTER (id), NULL);
    DEBUG_MSG (("%s ===> pushed new thread with id:%d, number "
		"of threads:%d, unprocessed:%d",
290 291
		sort ? "[  sorted]" : "[unsorted]",
		id,
292 293
		g_thread_pool_get_num_threads (pool),
		g_thread_pool_unprocessed (pool)));
294 295
  }

296
  g_assert (g_thread_pool_get_max_threads (pool) == max_threads);
297 298 299
  g_assert (g_thread_pool_get_num_threads (pool) == g_thread_pool_get_max_threads (pool));
}

300 301 302
static void
test_thread_idle_time_entry_func (gpointer data, gpointer user_data)
{
Dan Winship's avatar
Dan Winship committed
303
#ifdef DEBUG
304
  guint thread_id;
305

306
  thread_id = GPOINTER_TO_UINT (data);
Dan Winship's avatar
Dan Winship committed
307
#endif
308

309
  DEBUG_MSG (("[idle] ---> entered thread:%2.2d", thread_id));
310 311 312

  g_usleep (WAIT * 1000);

313
  DEBUG_MSG (("[idle] <--- exiting thread:%2.2d", thread_id));
314 315
}

316
static gboolean
317 318 319 320 321
test_thread_idle_timeout (gpointer data)
{
  gint i;

  for (i = 0; i < 2; i++) {
322
    g_thread_pool_push (idle_pool, GUINT_TO_POINTER (100 + i), NULL);
323 324
    DEBUG_MSG (("[idle] ===> pushed new thread with id:%d, number "
		"of threads:%d, unprocessed:%d",
325
		100 + i,
326 327
		g_thread_pool_get_num_threads (idle_pool),
		g_thread_pool_unprocessed (idle_pool)));
328
  }
329

330 331 332 333 334

  return FALSE;
}

static void
335
test_thread_idle_time (void)
336 337 338 339 340
{
  guint limit = 50;
  guint interval = 10000;
  gint i;

341 342
  idle_pool = g_thread_pool_new (test_thread_idle_time_entry_func,
				 NULL,
343
				 0,
344 345 346
				 FALSE,
				 NULL);

347
  g_thread_pool_set_max_threads (idle_pool, MAX_THREADS, NULL);
348 349
  g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);
  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 354 355
  g_assert (g_thread_pool_get_max_idle_time () == interval);

  for (i = 0; i < limit; i++) {
356
    g_thread_pool_push (idle_pool, GUINT_TO_POINTER (i + 1), NULL);
357 358 359 360 361
    DEBUG_MSG (("[idle] ===> pushed new thread with id:%d, "
		"number of threads:%d, unprocessed:%d",
		i,
		g_thread_pool_get_num_threads (idle_pool),
		g_thread_pool_unprocessed (idle_pool)));
362 363
  }

364 365
  g_assert_cmpint (g_thread_pool_unprocessed (idle_pool), <=, limit);

366
  g_timeout_add ((interval - 1000),
367
		 test_thread_idle_timeout,
368 369 370
		 GUINT_TO_POINTER (interval));
}

371 372 373 374 375 376 377 378 379 380
static gboolean
test_check_start_and_stop (gpointer user_data)
{
  static guint test_number = 0;
  static gboolean run_next = FALSE;
  gboolean continue_timeout = TRUE;
  gboolean quit = TRUE;

  if (test_number == 0) {
    run_next = TRUE;
381
    DEBUG_MSG (("***** RUNNING TEST %2.2d *****", test_number));
382
  }
383

384 385 386 387 388
  if (run_next) {
    test_number++;

    switch (test_number) {
    case 1:
389
      test_thread_functions ();
390 391
      break;
    case 2:
392
      test_thread_stop_unused ();
393 394
      break;
    case 3:
395
      test_thread_pools ();
396
      break;
397
    case 4:
398
      test_thread_sort (FALSE);
399 400
      break;
    case 5:
401
      test_thread_sort (TRUE);
402 403
      break;
    case 6:
404 405 406
      test_thread_stop_unused ();
      break;
    case 7:
407
      test_thread_idle_time ();
408
      break;
409
    default:
410
      DEBUG_MSG (("***** END OF TESTS *****"));
411 412 413 414 415 416 417 418 419
      g_main_loop_quit (main_loop);
      continue_timeout = FALSE;
      break;
    }

    run_next = FALSE;
    return TRUE;
  }

420
  if (test_number == 3) {
421
    G_LOCK (thread_counter_pools);
422
    quit &= running_thread_counter <= 0;
423 424 425
    DEBUG_MSG (("***** POOL RUNNING THREAD COUNT:%ld",
		running_thread_counter));
    G_UNLOCK (thread_counter_pools);
426 427
  }

428
  if (test_number == 4 || test_number == 5) {
429 430
    G_LOCK (thread_counter_sort);
    quit &= sort_thread_counter <= 0;
431 432 433
    DEBUG_MSG (("***** POOL SORT THREAD COUNT:%ld",
		sort_thread_counter));
    G_UNLOCK (thread_counter_sort);
434 435
  }

436
  if (test_number == 7) {
437 438
    guint idle;

439
    idle = g_thread_pool_get_num_unused_threads ();
440
    quit &= idle < 1;
441 442
    DEBUG_MSG (("***** POOL IDLE THREAD COUNT:%d, UNPROCESSED JOBS:%d",
		idle, g_thread_pool_unprocessed (idle_pool)));
443
  }
444

445 446 447 448 449 450 451
  if (quit) {
    run_next = TRUE;
  }

  return continue_timeout;
}

452
int
453 454
main (int argc, char *argv[])
{
455
  DEBUG_MSG (("Starting... (in one second)"));
456 457
  g_timeout_add (1000, test_check_start_and_stop, NULL);

458 459 460
  main_loop = g_main_loop_new (NULL, FALSE);
  g_main_loop_run (main_loop);

461 462
  return 0;
}