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