1 #undef G_DISABLE_ASSERT
9 /* #define DEBUG_MSG(args) g_printerr args ; g_printerr ("\n"); */
11 #define WAIT 5 /* seconds */
12 #define MAX_THREADS 10
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
19 G_LOCK_DEFINE_STATIC (thread_counter_pools);
21 static gulong abs_thread_counter = 0;
22 static gulong running_thread_counter = 0;
23 static gulong leftover_task_counter = 0;
25 G_LOCK_DEFINE_STATIC (last_thread);
27 static guint last_thread_id = 0;
29 G_LOCK_DEFINE_STATIC (thread_counter_sort);
31 static gulong sort_thread_counter = 0;
33 static GThreadPool *idle_pool = NULL;
35 static GMainLoop *main_loop = NULL;
38 test_thread_functions (void)
40 gint max_unused_threads;
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.
48 max_unused_threads = 3;
50 DEBUG_MSG (("[funcs] Setting max unused threads to %d",
52 g_thread_pool_set_max_unused_threads (max_unused_threads);
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);
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);
62 DEBUG_MSG (("[funcs] Stopping unused threads"));
63 g_thread_pool_stop_unused_threads ();
65 max_idle_time = 10 * G_USEC_PER_SEC;
67 DEBUG_MSG (("[funcs] Setting max idle time to %d",
69 g_thread_pool_set_max_idle_time (max_idle_time);
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);
75 DEBUG_MSG (("[funcs] Setting max idle time to 0"));
76 g_thread_pool_set_max_idle_time (0);
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);
84 test_count_threads_foreach (GThread *thread,
91 test_count_threads (void)
95 g_thread_foreach ((GFunc) test_count_threads_foreach, &count);
97 /* Exclude main thread */
102 test_thread_stop_unused (void)
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);
112 for (i = 0; i < limit; i++)
113 g_thread_pool_push (pool, GUINT_TO_POINTER (1000), NULL);
115 DEBUG_MSG (("[unused] ===> pushed %d threads onto the idle pool",
118 /* Wait for the threads to migrate. */
119 g_usleep (G_USEC_PER_SEC);
121 DEBUG_MSG (("[unused] current threads %d",
122 test_count_threads()));
124 DEBUG_MSG (("[unused] stopping unused threads"));
125 g_thread_pool_stop_unused_threads ();
127 for (i = 0; i < 5; i++)
129 if (g_thread_pool_get_num_unused_threads () == 0 &&
130 test_count_threads () == 0)
133 DEBUG_MSG (("[unused] waiting ONE second for threads to die"));
135 /* Some time for threads to die. */
136 g_usleep (G_USEC_PER_SEC);
139 DEBUG_MSG (("[unused] stopped idle threads, %d remain, %d threads still exist",
140 g_thread_pool_get_num_unused_threads (),
141 test_count_threads ()));
143 g_assert (g_thread_pool_get_num_unused_threads () == test_count_threads ());
144 g_assert (g_thread_pool_get_num_unused_threads () == 0);
146 g_thread_pool_set_max_unused_threads (MAX_THREADS);
148 DEBUG_MSG (("[unused] cleaning up thread pool"));
149 g_thread_pool_free (pool, FALSE, TRUE);
153 test_thread_pools_entry_func (gpointer data, gpointer user_data)
157 id = GPOINTER_TO_UINT (data);
159 DEBUG_MSG (("[pool] ---> [%3.3d] entered thread.", id));
161 G_LOCK (thread_counter_pools);
162 abs_thread_counter++;
163 running_thread_counter++;
164 G_UNLOCK (thread_counter_pools);
166 g_usleep (g_random_int_range (0, 4000));
168 G_LOCK (thread_counter_pools);
169 running_thread_counter--;
170 leftover_task_counter--;
172 DEBUG_MSG (("[pool] ---> [%3.3d] exiting thread (abs count:%ld, "
173 "running count:%ld, left over:%ld)",
174 id, abs_thread_counter,
175 running_thread_counter, leftover_task_counter));
176 G_UNLOCK (thread_counter_pools);
180 test_thread_pools (void)
182 GThreadPool *pool1, *pool2, *pool3;
186 pool1 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 3, FALSE, NULL);
187 pool2 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 5, TRUE, NULL);
188 pool3 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 7, TRUE, NULL);
191 for (i = 0; i < runs; i++)
193 g_thread_pool_push (pool1, GUINT_TO_POINTER (i + 1), NULL);
194 g_thread_pool_push (pool2, GUINT_TO_POINTER (i + 1), NULL);
195 g_thread_pool_push (pool3, GUINT_TO_POINTER (i + 1), NULL);
197 G_LOCK (thread_counter_pools);
198 leftover_task_counter += 3;
199 G_UNLOCK (thread_counter_pools);
202 g_thread_pool_free (pool1, TRUE, TRUE);
203 g_thread_pool_free (pool2, FALSE, TRUE);
204 g_thread_pool_free (pool3, FALSE, TRUE);
206 g_assert (runs * 3 == abs_thread_counter + leftover_task_counter);
207 g_assert (running_thread_counter == 0);
211 test_thread_sort_compare_func (gconstpointer a, gconstpointer b, gpointer user_data)
215 id1 = GPOINTER_TO_UINT (a);
216 id2 = GPOINTER_TO_UINT (b);
218 return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1);
222 test_thread_sort_entry_func (gpointer data, gpointer user_data)
227 G_LOCK (last_thread);
229 thread_id = GPOINTER_TO_UINT (data);
230 is_sorted = GPOINTER_TO_INT (user_data);
232 DEBUG_MSG (("%s ---> entered thread:%2.2d, last thread:%2.2d",
233 is_sorted ? "[ sorted]" : "[unsorted]",
234 thread_id, last_thread_id));
237 static gboolean last_failed = FALSE;
239 if (last_thread_id > thread_id) {
241 g_assert (last_thread_id <= thread_id);
244 /* Here we remember one fail and if it concurrently fails, it
245 * can not be sorted. the last thread id might be < this thread
246 * id if something is added to the queue since threads were
254 last_thread_id = thread_id;
257 G_UNLOCK (last_thread);
259 g_usleep (WAIT * 1000);
263 test_thread_sort (gboolean sort)
270 limit = MAX_THREADS * 10;
275 max_threads = MAX_THREADS;
278 /* It is important that we only have a maximum of 1 thread for this
279 * test since the results can not be guranteed to be sorted if > 1.
281 * Threads are scheduled by the operating system and are executed at
282 * random. It cannot be assumed that threads are executed in the
283 * order they are created. This was discussed in bug #334943.
286 pool = g_thread_pool_new (test_thread_sort_entry_func,
287 GINT_TO_POINTER (sort),
292 g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);
295 g_thread_pool_set_sort_function (pool,
296 test_thread_sort_compare_func,
297 GUINT_TO_POINTER (69));
300 for (i = 0; i < limit; i++) {
303 id = g_random_int_range (1, limit) + 1;
304 g_thread_pool_push (pool, GUINT_TO_POINTER (id), NULL);
305 DEBUG_MSG (("%s ===> pushed new thread with id:%d, number "
306 "of threads:%d, unprocessed:%d",
307 sort ? "[ sorted]" : "[unsorted]",
309 g_thread_pool_get_num_threads (pool),
310 g_thread_pool_unprocessed (pool)));
313 g_assert (g_thread_pool_get_max_threads (pool) == max_threads);
314 g_assert (g_thread_pool_get_num_threads (pool) == g_thread_pool_get_max_threads (pool));
318 test_thread_idle_time_entry_func (gpointer data, gpointer user_data)
322 thread_id = GPOINTER_TO_UINT (data);
324 DEBUG_MSG (("[idle] ---> entered thread:%2.2d", thread_id));
326 g_usleep (WAIT * 1000);
328 DEBUG_MSG (("[idle] <--- exiting thread:%2.2d", thread_id));
332 test_thread_idle_timeout (gpointer data)
337 interval = GPOINTER_TO_UINT (data);
339 for (i = 0; i < 2; i++) {
340 g_thread_pool_push (idle_pool, GUINT_TO_POINTER (100 + i), NULL);
341 DEBUG_MSG (("[idle] ===> pushed new thread with id:%d, number "
342 "of threads:%d, unprocessed:%d",
344 g_thread_pool_get_num_threads (idle_pool),
345 g_thread_pool_unprocessed (idle_pool)));
353 test_thread_idle_time ()
356 guint interval = 10000;
359 idle_pool = g_thread_pool_new (test_thread_idle_time_entry_func,
365 g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);
366 g_thread_pool_set_max_idle_time (interval);
368 g_assert (g_thread_pool_get_max_unused_threads () == MAX_UNUSED_THREADS);
369 g_assert (g_thread_pool_get_max_idle_time () == interval);
371 for (i = 0; i < limit; i++) {
372 g_thread_pool_push (idle_pool, GUINT_TO_POINTER (i + 1), NULL);
373 DEBUG_MSG (("[idle] ===> pushed new thread with id:%d, "
374 "number of threads:%d, unprocessed:%d",
376 g_thread_pool_get_num_threads (idle_pool),
377 g_thread_pool_unprocessed (idle_pool)));
380 g_timeout_add ((interval - 1000),
381 test_thread_idle_timeout,
382 GUINT_TO_POINTER (interval));
386 test_check_start_and_stop (gpointer user_data)
388 static guint test_number = 0;
389 static gboolean run_next = FALSE;
390 gboolean continue_timeout = TRUE;
391 gboolean quit = TRUE;
393 if (test_number == 0) {
395 DEBUG_MSG (("***** RUNNING TEST %2.2d *****", test_number));
401 switch (test_number) {
403 test_thread_functions ();
406 test_thread_stop_unused ();
409 test_thread_pools ();
412 test_thread_sort (FALSE);
415 test_thread_sort (TRUE);
418 test_thread_stop_unused ();
421 test_thread_idle_time ();
424 DEBUG_MSG (("***** END OF TESTS *****"));
425 g_main_loop_quit (main_loop);
426 continue_timeout = FALSE;
434 if (test_number == 3) {
435 G_LOCK (thread_counter_pools);
436 quit &= running_thread_counter <= 0;
437 DEBUG_MSG (("***** POOL RUNNING THREAD COUNT:%ld",
438 running_thread_counter));
439 G_UNLOCK (thread_counter_pools);
442 if (test_number == 4 || test_number == 5) {
443 G_LOCK (thread_counter_sort);
444 quit &= sort_thread_counter <= 0;
445 DEBUG_MSG (("***** POOL SORT THREAD COUNT:%ld",
446 sort_thread_counter));
447 G_UNLOCK (thread_counter_sort);
450 if (test_number == 7) {
453 idle = g_thread_pool_get_num_unused_threads ();
455 DEBUG_MSG (("***** POOL IDLE THREAD COUNT:%d, UNPROCESSED JOBS:%d",
456 idle, g_thread_pool_unprocessed (idle_pool)));
463 return continue_timeout;
467 main (int argc, char *argv[])
469 /* Only run the test, if threads are enabled and a default thread
470 implementation is available */
472 #if defined(G_THREADS_ENABLED) && ! defined(G_THREADS_IMPL_NONE)
473 g_thread_init (NULL);
475 DEBUG_MSG (("Starting... (in one second)"));
476 g_timeout_add (1000, test_check_start_and_stop, NULL);
478 main_loop = g_main_loop_new (NULL, FALSE);
479 g_main_loop_run (main_loop);