10 #include <fcntl.h> /* For _O_BINARY used by pipe() macro */
17 #define CRAWLER_TIMEOUT_RANGE 40
18 #define RECURSER_TIMEOUT 50
20 GPtrArray *context_array;
21 GMutex *context_array_mutex;
22 GCond *context_array_cond;
26 G_LOCK_DEFINE_STATIC (crawler_array_lock);
27 GPtrArray *crawler_array;
29 typedef struct _AddrData AddrData;
30 typedef struct _TestData TestData;
46 static void cleanup_crawlers (GMainContext *context);
49 read_all (GIOChannel *channel, char *buf, int len)
55 while (bytes_read < len)
57 err = g_io_channel_read (channel, buf + bytes_read, len - bytes_read, &count);
60 if (err != G_IO_ERROR_AGAIN)
73 write_all (GIOChannel *channel, char *buf, int len)
75 int bytes_written = 0;
79 while (bytes_written < len)
81 err = g_io_channel_write (channel, buf + bytes_written, len - bytes_written, &count);
82 if (err && err != G_IO_ERROR_AGAIN)
85 bytes_written += count;
92 adder_callback (GIOChannel *source,
93 GIOCondition condition,
101 AddrData *addr_data = data;
103 if (!read_all (source, buf1, 32) ||
104 !read_all (source, buf2, 32))
106 g_main_loop_quit (addr_data->loop);
110 sprintf (result, "%d", atoi(buf1) + atoi(buf2));
111 write_all (addr_data->dest, result, 32);
117 timeout_callback (gpointer data)
119 AddrData *addr_data = data;
127 adder_thread (gpointer data)
129 GMainContext *context;
130 GSource *adder_source;
131 GSource *timeout_source;
133 GIOChannel **channels = data;
136 context = g_main_context_get (g_thread_self());
138 g_mutex_lock (context_array_mutex);
140 g_ptr_array_add (context_array, context);
142 if (context_array->len == NTHREADS)
143 g_cond_broadcast (context_array_cond);
145 g_mutex_unlock (context_array_mutex);
147 addr_data.dest = channels[1];
148 addr_data.loop = g_main_loop_new (context, FALSE);
151 adder_source = g_io_create_watch (channels[0], G_IO_IN | G_IO_HUP);
152 g_source_set_callback (adder_source, (GSourceFunc)adder_callback, &addr_data, NULL);
153 g_source_attach (adder_source, context);
154 g_source_unref (adder_source);
156 timeout_source = g_timeout_source_new (10);
157 g_source_set_callback (timeout_source, (GSourceFunc)timeout_callback, &addr_data, NULL);
158 g_source_set_priority (timeout_source, G_PRIORITY_HIGH);
159 g_source_attach (timeout_source, context);
160 g_source_unref (timeout_source);
162 g_main_run (addr_data.loop);
164 g_io_channel_close (channels[0]);
165 g_io_channel_close (channels[1]);
166 g_io_channel_unref (channels[0]);
167 g_io_channel_unref (channels[1]);
171 g_main_loop_unref (addr_data.loop);
173 g_print ("Timeout run %d times\n", addr_data.count);
175 g_mutex_lock (context_array_mutex);
176 g_ptr_array_remove (context_array, context);
177 if (context_array->len == 0)
178 g_main_loop_quit (main_loop);
179 g_mutex_unlock (context_array_mutex);
181 cleanup_crawlers (context);
185 io_pipe (GIOChannel **channels)
191 g_warning ("Cannot create pipe %s\n", g_strerror (errno));
195 channels[0] = g_io_channel_unix_new (fds[0]);
196 channels[1] = g_io_channel_unix_new (fds[1]);
200 do_add (GIOChannel *in, gint a, gint b)
205 sprintf (buf1, "%d", a);
206 sprintf (buf2, "%d", b);
208 write_all (in, buf1, 32);
209 write_all (in, buf2, 32);
213 adder_response (GIOChannel *source,
214 GIOCondition condition,
218 TestData *test_data = data;
220 if (!read_all (source, result, 32))
223 test_data->current_val = atoi (result);
226 if (test_data->iters == 0)
228 if (test_data->current_val != ITERS * INCREMENT)
230 g_print ("Addition failed: %d != %d\n",
231 test_data->current_val, ITERS * INCREMENT);
235 g_io_channel_close (source);
236 g_io_channel_close (test_data->in);
238 g_io_channel_unref (source);
239 g_io_channel_unref (test_data->in);
244 do_add (test_data->in, test_data->current_val, INCREMENT);
250 create_adder_thread (void)
255 GIOChannel *in_channels[2];
256 GIOChannel *out_channels[2];
258 GIOChannel **sub_channels;
260 sub_channels = g_new (GIOChannel *, 2);
262 io_pipe (in_channels);
263 io_pipe (out_channels);
265 sub_channels[0] = in_channels[0];
266 sub_channels[1] = out_channels[1];
268 g_thread_create (adder_thread, sub_channels, 0,
269 FALSE, TRUE, G_THREAD_PRIORITY_NORMAL, &err);
273 g_warning ("Cannot create thread: %s", err->message);
277 test_data = g_new (TestData, 1);
278 test_data->in = in_channels[1];
279 test_data->current_val = 0;
280 test_data->iters = ITERS;
282 g_io_add_watch (out_channels[0], G_IO_IN | G_IO_HUP,
283 adder_response, test_data);
285 do_add (test_data->in, test_data->current_val, INCREMENT);
288 static void create_crawler (void);
291 remove_crawler (void)
293 GSource *other_source;
295 if (crawler_array->len > 0)
297 other_source = crawler_array->pdata[g_random_int_range (0, crawler_array->len)];
298 g_source_destroy (other_source);
299 g_assert (g_ptr_array_remove_fast (crawler_array, other_source));
304 crawler_callback (gpointer data)
306 GSource *source = data;
308 G_LOCK (crawler_array_lock);
310 if (!g_ptr_array_remove_fast (crawler_array, source))
314 G_UNLOCK (crawler_array_lock);
323 create_crawler (void)
325 GSource *source = g_timeout_source_new (g_random_int_range (0, CRAWLER_TIMEOUT_RANGE));
326 g_source_set_callback (source, (GSourceFunc)crawler_callback, source, NULL);
328 g_mutex_lock (context_array_mutex);
329 g_source_attach (source, context_array->pdata[g_random_int_range (0, context_array->len)]);
330 g_source_unref (source);
331 g_mutex_unlock (context_array_mutex);
333 G_LOCK (crawler_array_lock);
334 g_ptr_array_add (crawler_array, source);
335 G_UNLOCK (crawler_array_lock);
339 cleanup_crawlers (GMainContext *context)
343 G_LOCK (crawler_array_lock);
344 for (i=0; i < crawler_array->len; i++)
346 if (g_source_get_context (crawler_array->pdata[i]) == context)
348 g_source_destroy (g_ptr_array_remove_index (crawler_array, i));
352 G_UNLOCK (crawler_array_lock);
356 recurser_idle (gpointer data)
358 GMainContext *context = data;
361 for (i = 0; i < 10; i++)
362 g_main_context_iteration (context, TRUE);
368 recurser_start (gpointer data)
370 GMainContext *context;
373 g_mutex_lock (context_array_mutex);
374 context = context_array->pdata[g_random_int_range (0, context_array->len)];
375 source = g_idle_source_new ();
376 g_source_set_callback (source, recurser_idle, context, NULL);
377 g_source_attach (source, context);
378 g_source_unref (source);
379 g_mutex_unlock (context_array_mutex);
388 /* Only run the test, if threads are enabled and a default thread
389 implementation is available */
390 #if defined(G_THREADS_ENABLED) && ! defined(G_THREADS_IMPL_NONE)
393 g_thread_init (NULL);
395 context_array = g_ptr_array_new ();
396 context_array_mutex = g_mutex_new ();
397 context_array_cond = g_cond_new ();
399 crawler_array = g_ptr_array_new ();
401 main_loop = g_main_loop_new (NULL, FALSE);
403 for (i = 0; i < NTHREADS; i++)
404 create_adder_thread ();
406 /* Wait for all threads to start
408 g_mutex_lock (context_array_mutex);
410 if (context_array->len < NTHREADS)
411 g_cond_wait (context_array_cond, context_array_mutex);
413 g_mutex_unlock (context_array_mutex);
415 for (i = 0; i < NCRAWLERS; i++)
418 g_timeout_add (RECURSER_TIMEOUT, recurser_start, NULL);
420 g_main_loop_run (main_loop);
421 g_main_loop_unref (main_loop);