tests/mainloop-test.c

   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 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 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 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];
 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 gboolean
 126 timeout_callback (gpointer data)
 127 {
 128   AddrData *addr_data = data;
 129
 130   addr_data->count++;
 131
 132   return TRUE;
 133 }
 134
 135 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
 194   return NULL;
 195 }
 196
 197 void
 198 io_pipe (GIOChannel **channels)
 199 {
 200   gint fds[2];
 201
 202   if (pipe(fds) < 0)
 203     {
 204       g_warning ("Cannot create pipe %s\n", g_strerror (errno));
 205       exit (1);
 206     }
 207
 208   channels[0] = g_io_channel_unix_new (fds[0]);
 209   channels[1] = g_io_channel_unix_new (fds[1]);
 210
 211   g_io_channel_set_close_on_unref (channels[0], TRUE);
 212   g_io_channel_set_close_on_unref (channels[1], TRUE);
 213 }
 214
 215 void
 216 do_add (GIOChannel *in, gint a, gint b)
 217 {
 218   char buf1[32];
 219   char buf2[32];
 220
 221   sprintf (buf1, "%d", a);
 222   sprintf (buf2, "%d", b);
 223
 224   write_all (in, buf1, 32);
 225   write_all (in, buf2, 32);
 226 }
 227
 228 gboolean
 229 adder_response (GIOChannel   *source,
 230                 GIOCondition  condition,
 231                 gpointer      data)
 232 {
 233   char result[32];
 234   TestData *test_data = data;
 235
 236   if (!read_all (source, result, 32))
 237     return FALSE;
 238
 239   test_data->current_val = atoi (result);
 240   test_data->iters--;
 241
 242   if (test_data->iters == 0)
 243     {
 244       if (test_data->current_val != ITERS * INCREMENT)
 245         {
 246           g_print ("Addition failed: %d != %d\n",
 247                    test_data->current_val, ITERS * INCREMENT);
 248           exit (1);
 249         }
 250
 251       g_io_channel_unref (source);
 252       g_io_channel_unref (test_data->in);
 253
 254       g_free (test_data);
 255
 256       return FALSE;
 257     }
 258
 259   do_add (test_data->in, test_data->current_val, INCREMENT);
 260
 261   return TRUE;
 262 }
 263
 264 void
 265 create_adder_thread (void)
 266 {
 267   GError *err = NULL;
 268   TestData *test_data;
 269
 270   GIOChannel *in_channels[2];
 271   GIOChannel *out_channels[2];
 272
 273   GIOChannel **sub_channels;
 274
 275   sub_channels = g_new (GIOChannel *, 2);
 276
 277   io_pipe (in_channels);
 278   io_pipe (out_channels);
 279
 280   sub_channels[0] = in_channels[0];
 281   sub_channels[1] = out_channels[1];
 282
 283   g_thread_create (adder_thread, sub_channels, FALSE, &err);
 284
 285   if (err)
 286     {
 287       g_warning ("Cannot create thread: %s", err->message);
 288       exit (1);
 289     }
 290
 291   test_data = g_new (TestData, 1);
 292   test_data->in = in_channels[1];
 293   test_data->current_val = 0;
 294   test_data->iters = ITERS;
 295
 296   g_io_add_watch (out_channels[0], G_IO_IN | G_IO_HUP,
 297                   adder_response, test_data);
 298
 299   do_add (test_data->in, test_data->current_val, INCREMENT);
 300 }
 301
 302 static void create_crawler (void);
 303
 304 static void
 305 remove_crawler (void)
 306 {
 307   GSource *other_source;
 308
 309   if (crawler_array->len > 0)
 310     {
 311       other_source = crawler_array->pdata[g_random_int_range (0, crawler_array->len)];
 312       g_source_destroy (other_source);
 313       g_assert (g_ptr_array_remove_fast (crawler_array, other_source));
 314     }
 315 }
 316
 317 static gint
 318 crawler_callback (gpointer data)
 319 {
 320   GSource *source = data;
 321
 322   G_LOCK (crawler_array_lock);
 323
 324   if (!g_ptr_array_remove_fast (crawler_array, source))
 325     remove_crawler();
 326
 327   remove_crawler();
 328   G_UNLOCK (crawler_array_lock);
 329
 330   create_crawler();
 331   create_crawler();
 332
 333   return FALSE;
 334 }
 335
 336 static void
 337 create_crawler (void)
 338 {
 339   GSource *source = g_timeout_source_new (g_random_int_range (0, CRAWLER_TIMEOUT_RANGE));
 340   g_source_set_name (source, "Crawler timeout");
 341   g_source_set_callback (source, (GSourceFunc)crawler_callback, source, NULL);
 342
 343   G_LOCK (crawler_array_lock);
 344   g_ptr_array_add (crawler_array, source);
 345
 346   g_mutex_lock (context_array_mutex);
 347   g_source_attach (source, context_array->pdata[g_random_int_range (0, context_array->len)]);
 348   g_source_unref (source);
 349   g_mutex_unlock (context_array_mutex);
 350
 351   G_UNLOCK (crawler_array_lock);
 352 }
 353
 354 static void
 355 cleanup_crawlers (GMainContext *context)
 356 {
 357   gint i;
 358
 359   G_LOCK (crawler_array_lock);
 360   for (i=0; i < crawler_array->len; i++)
 361     {
 362       if (g_source_get_context (crawler_array->pdata[i]) == context)
 363         {
 364           g_source_destroy (g_ptr_array_remove_index (crawler_array, i));
 365           i--;
 366         }
 367     }
 368   G_UNLOCK (crawler_array_lock);
 369 }
 370
 371 static gboolean
 372 recurser_idle (gpointer data)
 373 {
 374   GMainContext *context = data;
 375   gint i;
 376
 377   for (i = 0; i < 10; i++)
 378     g_main_context_iteration (context, FALSE);
 379
 380   return FALSE;
 381 }
 382
 383 static gboolean
 384 recurser_start (gpointer data)
 385 {
 386   GMainContext *context;
 387   GSource *source;
 388
 389   g_mutex_lock (context_array_mutex);
 390   context = context_array->pdata[g_random_int_range (0, context_array->len)];
 391   source = g_idle_source_new ();
 392   g_source_set_name (source, "Recursing idle source");
 393   g_source_set_callback (source, recurser_idle, context, NULL);
 394   g_source_attach (source, context);
 395   g_source_unref (source);
 396   g_mutex_unlock (context_array_mutex);
 397
 398   return TRUE;
 399 }
 400
 401 int
 402 main (int   argc,
 403       char *argv[])
 404 {
 405   /* Only run the test, if threads are enabled and a default thread
 406      implementation is available */
 407 #if defined(G_THREADS_ENABLED) && ! defined(G_THREADS_IMPL_NONE)
 408   gint i;
 409
 410   g_thread_init (NULL);
 411
 412   context_array = g_ptr_array_new ();
 413   context_array_mutex = g_mutex_new ();
 414   context_array_cond = g_cond_new ();
 415
 416   crawler_array = g_ptr_array_new ();
 417
 418   main_loop = g_main_loop_new (NULL, FALSE);
 419
 420   for (i = 0; i < NTHREADS; i++)
 421     create_adder_thread ();
 422
 423   /* Wait for all threads to start
 424    */
 425   g_mutex_lock (context_array_mutex);
 426
 427   if (context_array->len < NTHREADS)
 428     g_cond_wait (context_array_cond, context_array_mutex);
 429
 430   g_mutex_unlock (context_array_mutex);
 431
 432   for (i = 0; i < NCRAWLERS; i++)
 433     create_crawler ();
 434
 435   g_timeout_add (RECURSER_TIMEOUT, recurser_start, NULL);
 436
 437   g_main_loop_run (main_loop);
 438   g_main_loop_unref (main_loop);
 439
 440 #endif
 441   return 0;
 442 }