Merge remote branch 'gvdb/master'
[platform/upstream/glib.git] / 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 }