Cast int to long before casting to void *.
[kopensolaris-gnu/glibc.git] / linuxthreads / Examples / ex14.c
1 /* Test of POSIX barriers.  */
2
3 #include <pthread.h>
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7
8 #define NTHREADS 20
9
10 #define ROUNDS 20
11
12 static pthread_barrier_t barriers[NTHREADS];
13
14 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
15 static int counters[NTHREADS];
16 static int serial[NTHREADS];
17
18 static void *
19 worker (void *arg)
20 {
21   void *result = NULL;
22   int nr = (long int) arg;
23   int i;
24
25   for (i = 0; i < ROUNDS; ++i)
26     {
27       int j;
28       int retval;
29
30       if (nr == 0)
31         {
32           memset (counters, '\0', sizeof (counters));
33           memset (serial, '\0', sizeof (serial));
34         }
35
36       retval = pthread_barrier_wait (&barriers[NTHREADS - 1]);
37       if (retval != 0 && retval != PTHREAD_BARRIER_SERIAL_THREAD)
38         {
39           printf ("thread %d failed to wait for all the others\n", nr);
40           result = (void *) 1;
41         }
42
43       for (j = nr; j < NTHREADS; ++j)
44         {
45           /* Increment the counter for this round.  */
46           pthread_mutex_lock (&lock);
47           ++counters[j];
48           pthread_mutex_unlock (&lock);
49
50           /* Wait for the rest.  */
51           retval = pthread_barrier_wait (&barriers[j]);
52
53           /* Test the result.  */
54           if (nr == 0 && counters[j] != j + 1)
55             {
56               printf ("barrier in round %d released but count is %d\n",
57                       j, counters[j]);
58               result = (void *) 1;
59             }
60
61           if (retval != 0)
62             {
63               if (retval != PTHREAD_BARRIER_SERIAL_THREAD)
64                 {
65                   printf ("thread %d in round %d has nonzero return value != PTHREAD_BARRIER_SERIAL_THREAD\n",
66                           nr, j);
67                   result = (void *) 1;
68                 }
69               else
70                 {
71                   pthread_mutex_lock (&lock);
72                   ++serial[j];
73                   pthread_mutex_unlock (&lock);
74                 }
75             }
76
77           /* Wait for the rest again.  */
78           retval = pthread_barrier_wait (&barriers[j]);
79
80           /* Now we can check whether exactly one thread was serializing.  */
81           if (nr == 0 && serial[j] != 1)
82             {
83               printf ("not exactly one serial thread in round %d\n", j);
84               result = (void *) 1;
85             }
86         }
87     }
88
89   return result;
90 }
91
92
93 #define TEST_FUNCTION do_test ()
94 #define TIMEOUT 60
95 int
96 do_test (void)
97 {
98   pthread_t threads[NTHREADS];
99   int i;
100   void *res;
101   int result = 0;
102
103   /* Initialized the barrier variables.  */
104   for (i = 0; i < NTHREADS; ++i)
105     if (pthread_barrier_init (&barriers[i], NULL, i + 1) != 0)
106       {
107         printf ("Failed to initialize barrier %d\n", i);
108         exit (1);
109       }
110
111   /* Start the threads.  */
112   for (i = 0; i < NTHREADS; ++i)
113     if (pthread_create (&threads[i], NULL, worker, (void *) (long int) i) != 0)
114       {
115         printf ("Failed to start thread %d\n", i);
116         exit (1);
117       }
118
119   /* And wait for them.  */
120   for (i = 0; i < NTHREADS; ++i)
121     if (pthread_join (threads[i], &res) != 0 || res != NULL)
122       {
123         printf ("thread %d returned a failure\n", i);
124         result = 1;
125       }
126
127   if (result == 0)
128     puts ("all OK");
129
130   return result;
131 }
132
133 #include "../test-skeleton.c"