nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 #undef G_DISABLE_ASSERT
2 #undef G_LOG_DOMAIN
3  
4 #include <errno.h>
5 #include <glib.h>
6 #ifdef G_OS_UNIX
7 #include <unistd.h>
8 #endif
9 #include <stdio.h>
10 #include <stdlib.h>
11  
12 #ifdef G_OS_WIN32
13 #include <fcntl.h> /* For _O_BINARY used by pipe() macro */
14 #include <io.h> /* for _pipe() */
15 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
16 #endif
17  
18 #define ITERS 10000
19 #define INCREMENT 10
20 #define NTHREADS 4
21 #define NCRAWLERS 4
22 #define CRAWLER_TIMEOUT_RANGE 40
23 #define RECURSER_TIMEOUT 50
24  
25 /* The partial ordering between the context array mutex and
26 * crawler array mutex is that the crawler array mutex cannot
27 * be locked while the context array mutex is locked
28 */
29 GPtrArray *context_array;
30 GMutex context_array_mutex;
31 GCond context_array_cond;
32  
33 GMainLoop *main_loop;
34  
35 G_LOCK_DEFINE_STATIC (crawler_array_lock);
36 GPtrArray *crawler_array;
37  
38 typedef struct _AddrData AddrData;
39 typedef struct _TestData TestData;
40  
41 struct _AddrData
42 {
43 GMainLoop *loop;
44 GIOChannel *dest;
45 gint count;
46 };
47  
48 struct _TestData
49 {
50 gint current_val;
51 gint iters;
52 GIOChannel *in;
53 };
54  
55 static void cleanup_crawlers (GMainContext *context);
56  
57 static gboolean
58 read_all (GIOChannel *channel, char *buf, gsize len)
59 {
60 gsize bytes_read = 0;
61 gsize count;
62 GIOError err;
63  
64 while (bytes_read < len)
65 {
66 err = g_io_channel_read (channel, buf + bytes_read, len - bytes_read, &count);
67 if (err)
68 {
69 if (err != G_IO_ERROR_AGAIN)
70 return FALSE;
71 }
72 else if (count == 0)
73 return FALSE;
74  
75 bytes_read += count;
76 }
77  
78 return TRUE;
79 }
80  
81 static gboolean
82 write_all (GIOChannel *channel, char *buf, gsize len)
83 {
84 gsize bytes_written = 0;
85 gsize count;
86 GIOError err;
87  
88 while (bytes_written < len)
89 {
90 err = g_io_channel_write (channel, buf + bytes_written, len - bytes_written, &count);
91 if (err && err != G_IO_ERROR_AGAIN)
92 return FALSE;
93  
94 bytes_written += count;
95 }
96  
97 return TRUE;
98 }
99  
100 static gboolean
101 adder_callback (GIOChannel *source,
102 GIOCondition condition,
103 gpointer data)
104 {
105 char buf1[32];
106 char buf2[32];
107  
108 char result[32] = { 0, };
109  
110 AddrData *addr_data = data;
111  
112 if (!read_all (source, buf1, 32) ||
113 !read_all (source, buf2, 32))
114 {
115 g_main_loop_quit (addr_data->loop);
116 return FALSE;
117 }
118  
119 sprintf (result, "%d", atoi(buf1) + atoi(buf2));
120 write_all (addr_data->dest, result, 32);
121  
122 return TRUE;
123 }
124  
125 static gboolean
126 timeout_callback (gpointer data)
127 {
128 AddrData *addr_data = data;
129  
130 addr_data->count++;
131  
132 return TRUE;
133 }
134  
135 static gpointer
136 adder_thread (gpointer data)
137 {
138 GMainContext *context;
139 GSource *adder_source;
140 GSource *timeout_source;
141  
142 GIOChannel **channels = data;
143 AddrData addr_data;
144  
145 context = g_main_context_new ();
146  
147 g_mutex_lock (&context_array_mutex);
148  
149 g_ptr_array_add (context_array, context);
150  
151 if (context_array->len == NTHREADS)
152 g_cond_broadcast (&context_array_cond);
153  
154 g_mutex_unlock (&context_array_mutex);
155  
156 addr_data.dest = channels[1];
157 addr_data.loop = g_main_loop_new (context, FALSE);
158 addr_data.count = 0;
159  
160 adder_source = g_io_create_watch (channels[0], G_IO_IN | G_IO_HUP);
161 g_source_set_name (adder_source, "Adder I/O");
162 g_source_set_callback (adder_source, (GSourceFunc)adder_callback, &addr_data, NULL);
163 g_source_attach (adder_source, context);
164 g_source_unref (adder_source);
165  
166 timeout_source = g_timeout_source_new (10);
167 g_source_set_name (timeout_source, "Adder timeout");
168 g_source_set_callback (timeout_source, (GSourceFunc)timeout_callback, &addr_data, NULL);
169 g_source_set_priority (timeout_source, G_PRIORITY_HIGH);
170 g_source_attach (timeout_source, context);
171 g_source_unref (timeout_source);
172  
173 g_main_loop_run (addr_data.loop);
174  
175 g_io_channel_unref (channels[0]);
176 g_io_channel_unref (channels[1]);
177  
178 g_free (channels);
179  
180 g_main_loop_unref (addr_data.loop);
181  
182 #ifdef VERBOSE
183 g_print ("Timeout run %d times\n", addr_data.count);
184 #endif
185  
186 g_mutex_lock (&context_array_mutex);
187 g_ptr_array_remove (context_array, context);
188 if (context_array->len == 0)
189 g_main_loop_quit (main_loop);
190 g_mutex_unlock (&context_array_mutex);
191  
192 cleanup_crawlers (context);
193 g_main_context_unref (context);
194  
195 return NULL;
196 }
197  
198 static void
199 io_pipe (GIOChannel **channels)
200 {
201 gint fds[2];
202  
203 if (pipe(fds) < 0)
204 {
205 g_warning ("Cannot create pipe %s\n", g_strerror (errno));
206 exit (1);
207 }
208  
209 channels[0] = g_io_channel_unix_new (fds[0]);
210 channels[1] = g_io_channel_unix_new (fds[1]);
211  
212 g_io_channel_set_close_on_unref (channels[0], TRUE);
213 g_io_channel_set_close_on_unref (channels[1], TRUE);
214 }
215  
216 static void
217 do_add (GIOChannel *in, gint a, gint b)
218 {
219 char buf1[32] = { 0, };
220 char buf2[32] = { 0, };
221  
222 sprintf (buf1, "%d", a);
223 sprintf (buf2, "%d", b);
224  
225 write_all (in, buf1, 32);
226 write_all (in, buf2, 32);
227 }
228  
229 static gboolean
230 adder_response (GIOChannel *source,
231 GIOCondition condition,
232 gpointer data)
233 {
234 char result[32];
235 TestData *test_data = data;
236  
237 if (!read_all (source, result, 32))
238 return FALSE;
239  
240 test_data->current_val = atoi (result);
241 test_data->iters--;
242  
243 if (test_data->iters == 0)
244 {
245 if (test_data->current_val != ITERS * INCREMENT)
246 {
247 g_print ("Addition failed: %d != %d\n",
248 test_data->current_val, ITERS * INCREMENT);
249 exit (1);
250 }
251  
252 g_io_channel_unref (source);
253 g_io_channel_unref (test_data->in);
254  
255 g_free (test_data);
256  
257 return FALSE;
258 }
259  
260 do_add (test_data->in, test_data->current_val, INCREMENT);
261  
262 return TRUE;
263 }
264  
265 static void
266 create_adder_thread (void)
267 {
268 GError *err = NULL;
269 TestData *test_data;
270  
271 GIOChannel *in_channels[2];
272 GIOChannel *out_channels[2];
273  
274 GIOChannel **sub_channels;
275  
276 sub_channels = g_new (GIOChannel *, 2);
277  
278 io_pipe (in_channels);
279 io_pipe (out_channels);
280  
281 sub_channels[0] = in_channels[0];
282 sub_channels[1] = out_channels[1];
283  
284 g_thread_create (adder_thread, sub_channels, FALSE, &err);
285  
286 if (err)
287 {
288 g_warning ("Cannot create thread: %s", err->message);
289 exit (1);
290 }
291  
292 test_data = g_new (TestData, 1);
293 test_data->in = in_channels[1];
294 test_data->current_val = 0;
295 test_data->iters = ITERS;
296  
297 g_io_add_watch (out_channels[0], G_IO_IN | G_IO_HUP,
298 adder_response, test_data);
299  
300 do_add (test_data->in, test_data->current_val, INCREMENT);
301 }
302  
303 static void create_crawler (void);
304  
305 static void
306 remove_crawler (void)
307 {
308 GSource *other_source;
309  
310 if (crawler_array->len > 0)
311 {
312 other_source = crawler_array->pdata[g_random_int_range (0, crawler_array->len)];
313 g_source_destroy (other_source);
314 g_assert (g_ptr_array_remove_fast (crawler_array, other_source));
315 }
316 }
317  
318 static gint
319 crawler_callback (gpointer data)
320 {
321 GSource *source = data;
322  
323 G_LOCK (crawler_array_lock);
324  
325 if (!g_ptr_array_remove_fast (crawler_array, source))
326 remove_crawler();
327  
328 remove_crawler();
329 G_UNLOCK (crawler_array_lock);
330  
331 create_crawler();
332 create_crawler();
333  
334 return FALSE;
335 }
336  
337 static void
338 create_crawler (void)
339 {
340 GSource *source = g_timeout_source_new (g_random_int_range (0, CRAWLER_TIMEOUT_RANGE));
341 g_source_set_name (source, "Crawler timeout");
342 g_source_set_callback (source, (GSourceFunc)crawler_callback, source, NULL);
343  
344 G_LOCK (crawler_array_lock);
345 g_ptr_array_add (crawler_array, source);
346  
347 g_mutex_lock (&context_array_mutex);
348 g_source_attach (source, context_array->pdata[g_random_int_range (0, context_array->len)]);
349 g_source_unref (source);
350 g_mutex_unlock (&context_array_mutex);
351  
352 G_UNLOCK (crawler_array_lock);
353 }
354  
355 static void
356 cleanup_crawlers (GMainContext *context)
357 {
358 gint i;
359  
360 G_LOCK (crawler_array_lock);
361 for (i=0; i < crawler_array->len; i++)
362 {
363 if (g_source_get_context (crawler_array->pdata[i]) == context)
364 {
365 g_source_destroy (g_ptr_array_remove_index (crawler_array, i));
366 i--;
367 }
368 }
369 G_UNLOCK (crawler_array_lock);
370 }
371  
372 static gboolean
373 recurser_idle (gpointer data)
374 {
375 GMainContext *context = data;
376 gint i;
377  
378 for (i = 0; i < 10; i++)
379 g_main_context_iteration (context, FALSE);
380  
381 return FALSE;
382 }
383  
384 static gboolean
385 recurser_start (gpointer data)
386 {
387 GMainContext *context;
388 GSource *source;
389  
390 g_mutex_lock (&context_array_mutex);
391 context = context_array->pdata[g_random_int_range (0, context_array->len)];
392 source = g_idle_source_new ();
393 g_source_set_name (source, "Recursing idle source");
394 g_source_set_callback (source, recurser_idle, context, NULL);
395 g_source_attach (source, context);
396 g_source_unref (source);
397 g_mutex_unlock (&context_array_mutex);
398  
399 return TRUE;
400 }
401  
402 int
403 main (int argc,
404 char *argv[])
405 {
406 gint i;
407  
408 context_array = g_ptr_array_new ();
409  
410 crawler_array = g_ptr_array_new ();
411  
412 main_loop = g_main_loop_new (NULL, FALSE);
413  
414 for (i = 0; i < NTHREADS; i++)
415 create_adder_thread ();
416  
417 /* Wait for all threads to start
418 */
419 g_mutex_lock (&context_array_mutex);
420  
421 if (context_array->len < NTHREADS)
422 g_cond_wait (&context_array_cond, &context_array_mutex);
423  
424 g_mutex_unlock (&context_array_mutex);
425  
426 for (i = 0; i < NCRAWLERS; i++)
427 create_crawler ();
428  
429 g_timeout_add (RECURSER_TIMEOUT, recurser_start, NULL);
430  
431 g_main_loop_run (main_loop);
432 g_main_loop_unref (main_loop);
433  
434 g_ptr_array_unref (crawler_array);
435 g_ptr_array_unref (context_array);
436  
437 return 0;
438 }