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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
/* Atomic integers. Useful for testing multithreaded locking primitives.
Copyright (C) 2005, 2008-2020 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>. */
/* Whether to use 'volatile' on some variables that communicate information
between threads. If set to 0, a semaphore or a lock is used to protect
these variables. If set to 1, 'volatile' is used; this is theoretically
equivalent but can lead to much slower execution (e.g. 30x slower total
run time on a 40-core machine), because 'volatile' does not imply any
synchronization/communication between different CPUs. */
#define USE_VOLATILE 0
#if USE_POSIX_THREADS && HAVE_SEMAPHORE_H
/* Whether to use a semaphore to communicate information between threads.
If set to 0, a lock is used. If set to 1, a semaphore is used.
Uncomment this to reduce the dependencies of this test. */
# define USE_SEMAPHORE 1
/* Mac OS X provides only named semaphores (sem_open); its facility for
unnamed semaphores (sem_init) does not work. */
# if defined __APPLE__ && defined __MACH__
# define USE_NAMED_SEMAPHORE 1
# else
# define USE_UNNAMED_SEMAPHORE 1
# endif
#endif
#if USE_SEMAPHORE
# include <errno.h>
# include <fcntl.h>
# include <semaphore.h>
# include <unistd.h>
#endif
#if USE_VOLATILE
struct atomic_int {
volatile int value;
};
static void
init_atomic_int (struct atomic_int *ai)
{
}
static int
get_atomic_int_value (struct atomic_int *ai)
{
return ai->value;
}
static void
set_atomic_int_value (struct atomic_int *ai, int new_value)
{
ai->value = new_value;
}
#elif USE_SEMAPHORE
/* This atomic_int implementation can only support the values 0 and 1.
It is initially 0 and can be set to 1 only once. */
# if USE_UNNAMED_SEMAPHORE
struct atomic_int {
sem_t semaphore;
};
#define atomic_int_semaphore(ai) (&(ai)->semaphore)
static void
init_atomic_int (struct atomic_int *ai)
{
sem_init (&ai->semaphore, 0, 0);
}
# endif
# if USE_NAMED_SEMAPHORE
struct atomic_int {
sem_t *semaphore;
};
#define atomic_int_semaphore(ai) ((ai)->semaphore)
static void
init_atomic_int (struct atomic_int *ai)
{
sem_t *s;
unsigned int count;
for (count = 0; ; count++)
{
char name[80];
/* Use getpid() in the name, so that different processes running at the
same time will not interfere. Use ai in the name, so that different
atomic_int in the same process will not interfere. Use a count in
the name, so that even in the (unlikely) case that a semaphore with
the specified name already exists, we can try a different name. */
sprintf (name, "test-lock-%lu-%p-%u",
(unsigned long) getpid (), ai, count);
s = sem_open (name, O_CREAT | O_EXCL, 0600, 0);
if (s == SEM_FAILED)
{
if (errno == EEXIST)
/* Retry with a different name. */
continue;
else
{
perror ("sem_open failed");
abort ();
}
}
else
{
/* Try not to leave a semaphore hanging around on the file system
eternally, if we can avoid it. */
sem_unlink (name);
break;
}
}
ai->semaphore = s;
}
# endif
static int
get_atomic_int_value (struct atomic_int *ai)
{
if (sem_trywait (atomic_int_semaphore (ai)) == 0)
{
if (sem_post (atomic_int_semaphore (ai)))
abort ();
return 1;
}
else if (errno == EAGAIN)
return 0;
else
abort ();
}
static void
set_atomic_int_value (struct atomic_int *ai, int new_value)
{
if (new_value == 0)
/* It's already initialized with 0. */
return;
/* To set the value 1: */
if (sem_post (atomic_int_semaphore (ai)))
abort ();
}
#else
struct atomic_int {
pthread_mutex_t lock;
int value;
};
static void
init_atomic_int (struct atomic_int *ai)
{
pthread_mutexattr_t attr;
ASSERT (pthread_mutexattr_init (&attr) == 0);
ASSERT (pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_NORMAL) == 0);
ASSERT (pthread_mutex_init (&ai->lock, &attr) == 0);
ASSERT (pthread_mutexattr_destroy (&attr) == 0);
}
static int
get_atomic_int_value (struct atomic_int *ai)
{
ASSERT (pthread_mutex_lock (&ai->lock) == 0);
int ret = ai->value;
ASSERT (pthread_mutex_unlock (&ai->lock) == 0);
return ret;
}
static void
set_atomic_int_value (struct atomic_int *ai, int new_value)
{
ASSERT (pthread_mutex_lock (&ai->lock) == 0);
ai->value = new_value;
ASSERT (pthread_mutex_unlock (&ai->lock) == 0);
}
#endif
|
