drd/tests/pth_broadcast.c

   1 /** Broadcast a (POSIX threads) signal to all running threads, where the
   2  *  number of threads can be specified on the command line. This test program
   3  *  is intended not only to test the correctness of drd but also to test
   4  *  whether performance does not degrade too much when the number of threads
   5  *  increases.
   6  */
   7
   8
   9 #include <assert.h>
  10 #include <pthread.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <unistd.h>
  15
  16
  17 // Counting semaphore.
  18
  19 struct csema
  20 {
  21   pthread_mutex_t  m_mutex;
  22   pthread_cond_t   m_cond;
  23   int              m_count;
  24 };
  25
  26 void csema_ctr(struct csema* p)
  27 {
  28   memset(p, 0, sizeof(*p));
  29   pthread_mutex_init(&p->m_mutex, 0);
  30   pthread_cond_init(&p->m_cond, 0);
  31 }
  32
  33 void csema_dtr(struct csema* p)
  34 {
  35   pthread_cond_destroy(&p->m_cond);
  36   pthread_mutex_destroy(&p->m_mutex);
  37 }
  38
  39 void csema_p(struct csema* p, const int n)
  40 {
  41   pthread_mutex_lock(&p->m_mutex);
  42   while (p->m_count < n)
  43     pthread_cond_wait(&p->m_cond, &p->m_mutex);
  44   p->m_count -= n;
  45   pthread_cond_signal(&p->m_cond);
  46   pthread_mutex_unlock(&p->m_mutex);
  47 }
  48
  49 void csema_v(struct csema* p)
  50 {
  51   pthread_mutex_lock(&p->m_mutex);
  52   p->m_count++;
  53   pthread_cond_signal(&p->m_cond);
  54   pthread_mutex_unlock(&p->m_mutex);
  55 }
  56
  57
  58 struct cthread
  59 {
  60   pthread_t     m_thread;
  61   int           m_threadnum;
  62   struct csema* m_sema;
  63 };
  64
  65 void cthread_ctr(struct cthread* p)
  66 {
  67   p->m_thread = 0;
  68   p->m_sema   = 0;
  69 }
  70
  71 void cthread_dtr(struct cthread* p)
  72 { }
  73
  74
  75 // Local variables.
  76
  77 static int s_debug = 0;
  78 static int s_trace = 0;
  79 static int s_signal_count;
  80 static pthread_mutex_t s_mutex;
  81 static pthread_cond_t  s_cond;
  82
  83
  84 // Function definitions.
  85
  86 static void *thread_func(void *arg)
  87 {
  88   struct cthread* thread_info = arg;
  89   int i;
  90
  91   pthread_mutex_lock(&s_mutex);
  92
  93   for (i = 0; i < s_signal_count; i++)
  94   {
  95     if (s_trace)
  96     {
  97       printf("thread %d [%d] (1)\n", thread_info->m_threadnum, i);
  98     }
  99     csema_v(thread_info->m_sema);
 100
 101     // Wait until the main thread signals us via pthread_cond_broadcast().
 102     pthread_cond_wait(&s_cond, &s_mutex);
 103     if (s_trace)
 104     {
 105       printf("thread %d [%d] (2)\n", thread_info->m_threadnum, i);
 106     }
 107   }
 108
 109   pthread_mutex_unlock(&s_mutex);
 110
 111   return NULL;
 112 }
 113
 114 int main(int argc, char** argv)
 115 {
 116   int optchar;
 117   int thread_count;
 118
 119   while ((optchar = getopt(argc, argv, "d")) != EOF)
 120   {
 121     switch (optchar)
 122     {
 123     case 'd':
 124       s_debug = 1;
 125       break;
 126     default:
 127       assert(0);
 128       break;
 129     }
 130   }
 131
 132   /* This test should complete in 15s or less. If the test does not complete */
 133   /* within that time, abort the test via the signal SIGALRM.                */
 134   alarm(100);
 135
 136   s_signal_count = argc > optind ? atoi(argv[optind]) : 10;
 137   thread_count = argc > optind + 1 ? atoi(argv[optind + 1]) : 10;
 138
 139   if (s_debug)
 140     printf("&s_cond = %p\n", &s_cond);
 141
 142   pthread_mutex_init(&s_mutex, 0);
 143   pthread_cond_init(&s_cond, 0);
 144   {
 145     int i;
 146     struct csema sema;
 147     struct cthread* p;
 148     struct cthread* thread_vec;
 149
 150     csema_ctr(&sema);
 151     thread_vec = malloc(sizeof(struct cthread) * thread_count);
 152     for (p = thread_vec; p != thread_vec + thread_count; p++)
 153     {
 154       cthread_ctr(p);
 155       p->m_threadnum = p - thread_vec;
 156       p->m_sema = &sema;
 157       pthread_create(&p->m_thread, 0, thread_func, &*p);
 158     }
 159     for (i = 0; i < s_signal_count; i++)
 160     {
 161       if (s_trace)
 162         printf("main [%d] (1)\n", i);
 163       csema_p(&sema, thread_count);
 164       if (s_trace)
 165         printf("main [%d] (2)\n", i);
 166       pthread_mutex_lock(&s_mutex);
 167       pthread_cond_broadcast(&s_cond);
 168       pthread_mutex_unlock(&s_mutex);
 169       if (s_trace)
 170         printf("main [%d] (3)\n", i);
 171     }
 172     for (i = 0; i < thread_count; i++)
 173     {
 174       pthread_join(thread_vec[i].m_thread, 0);
 175       cthread_dtr(&thread_vec[i]);
 176     }
 177     free(thread_vec);
 178     csema_dtr(&sema);
 179   }
 180   pthread_cond_destroy(&s_cond);
 181   pthread_mutex_destroy(&s_mutex);
 182
 183   fprintf(stderr, "Done.\n");
 184
 185   return 0;
 186 }