1 /* Condition variables for multithreading.
2 Copyright (C) 2005-2017 Free Software Foundation, Inc.
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 3, or (at your option)
7 any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, see <http://www.gnu.org/licenses/>. */
16
17 /* Written by Yoann Vandoorselaere <yoann@prelude-ids.org>, 2008.
18 Based on Bruno Haible <bruno@clisp.org> lock.h */
19
20 /*
21 Condition variables can be used for waiting until a condition
22 becomes true. In this respect, they are similar to wait queues. But
23 contrary to wait queues, condition variables have different
24 semantics that allows events to be lost when there is no thread
25 waiting for them.
26
27 Condition variable:
28 Type: gl_cond_t
29 Declaration: gl_cond_define(extern, name)
30 Initializer: gl_cond_define_initialized(, name)
31 Initialization: gl_cond_init (name);
32 Waiting: gl_cond_wait (name, lock);
33 Timed wait: bool timedout = gl_cond_timedwait (name, lock, abstime);
34 where lock is a gl_lock_t variable (cf. <glthread/lock.h>)
35 Signaling: gl_cond_signal (name);
36 Broadcasting: gl_cond_broadcast (name);
37 De-initialization: gl_cond_destroy (name);
38 Equivalent functions with control of error handling:
39 Initialization: err = glthread_cond_init (&name);
40 Waiting: err = glthread_cond_wait (&name);
41 Timed wait: err = glthread_cond_timedwait (&name, &lock, abstime);
42 Signaling: err = glthread_cond_signal (&name);
43 Broadcasting: err = glthread_cond_broadcast (&name);
44 De-initialization: err = glthread_cond_destroy (&name);
45 */
46
47
48 #ifndef _GLTHREAD_COND_H
49 #define _GLTHREAD_COND_H
50
51 #include <errno.h>
52 #include <stdbool.h>
53 #include <stdlib.h>
54 #include <time.h>
55
56 #include "glthread/lock.h"
57 #ifndef _GL_INLINE_HEADER_BEGIN
58 #error "Please include config.h first."
59 #endif
60
61 _GL_INLINE_HEADER_BEGIN
62 #ifndef _GLTHREAD_COND_INLINE
63 # define _GLTHREAD_COND_INLINE _GL_INLINE
64 #endif
65
66 /* ========================================================================= */
67
68 #if USE_POSIX_THREADS
69
70 /* Use the POSIX threads library. */
71
72 # include <pthread.h>
73
74 # ifdef __cplusplus
75 extern "C" {
76 # endif
77
78 # if PTHREAD_IN_USE_DETECTION_HARD
79
80 /* The pthread_in_use() detection needs to be done at runtime. */
81 # define pthread_in_use() \
82 glthread_in_use ()
83 extern int glthread_in_use (void);
84
85 # endif
86
87 # if USE_POSIX_THREADS_WEAK
88
89 /* Use weak references to the POSIX threads library. */
90
91 /* Weak references avoid dragging in external libraries if the other parts
92 of the program don't use them. Here we use them, because we don't want
93 every program that uses libintl to depend on libpthread. This assumes
94 that libpthread would not be loaded after libintl; i.e. if libintl is
95 loaded first, by an executable that does not depend on libpthread, and
96 then a module is dynamically loaded that depends on libpthread, libintl
97 will not be multithread-safe. */
98
99 /* The way to test at runtime whether libpthread is present is to test
100 whether a function pointer's value, such as &pthread_mutex_init, is
101 non-NULL. However, some versions of GCC have a bug through which, in
102 PIC mode, &foo != NULL always evaluates to true if there is a direct
103 call to foo(...) in the same function. To avoid this, we test the
104 address of a function in libpthread that we don't use. */
105
106 # pragma weak pthread_cond_init
107 # pragma weak pthread_cond_wait
108 # pragma weak pthread_cond_timedwait
109 # pragma weak pthread_cond_signal
110 # pragma weak pthread_cond_broadcast
111 # pragma weak pthread_cond_destroy
112 # ifndef pthread_self
113 # pragma weak pthread_self
114 # endif
115
116 # if !PTHREAD_IN_USE_DETECTION_HARD
117 # pragma weak pthread_cancel
118 # define pthread_in_use() (pthread_cancel != NULL)
119 # endif
120
121 # else
122
123 # if !PTHREAD_IN_USE_DETECTION_HARD
124 # define pthread_in_use() 1
125 # endif
126
127 # endif
128
129 /* -------------------------- gl_cond_t datatype -------------------------- */
130
131 typedef pthread_cond_t gl_cond_t;
132 # define gl_cond_define(STORAGECLASS, NAME) \
133 STORAGECLASS gl_cond_t NAME;
134 # define gl_cond_define_initialized(STORAGECLASS, NAME) \
135 STORAGECLASS gl_cond_t NAME = gl_cond_initializer;
136 # define gl_cond_initializer \
137 PTHREAD_COND_INITIALIZER
138 # define glthread_cond_init(COND) \
139 (pthread_in_use () ? pthread_cond_init (COND, NULL) : 0)
140 # define glthread_cond_wait(COND, LOCK) \
141 (pthread_in_use () ? pthread_cond_wait (COND, LOCK) : 0)
142 # define glthread_cond_timedwait(COND, LOCK, ABSTIME) \
143 (pthread_in_use () ? pthread_cond_timedwait (COND, LOCK, ABSTIME) : 0)
144 # define glthread_cond_signal(COND) \
145 (pthread_in_use () ? pthread_cond_signal (COND) : 0)
146 # define glthread_cond_broadcast(COND) \
147 (pthread_in_use () ? pthread_cond_broadcast (COND) : 0)
148 # define glthread_cond_destroy(COND) \
149 (pthread_in_use () ? pthread_cond_destroy (COND) : 0)
150
151 # ifdef __cplusplus
152 }
153 # endif
154
155 #endif
156
157 /* ========================================================================= */
158
159 #if USE_PTH_THREADS
160
161 /* Use the GNU Pth threads library. */
162
163 # include <pth.h>
164
165 # ifdef __cplusplus
166 extern "C" {
167 # endif
168
169 # if USE_PTH_THREADS_WEAK
170
171 /* Use weak references to the GNU Pth threads library. */
172
173 # pragma weak pth_cond_init
174 # pragma weak pth_cond_await
175 # pragma weak pth_cond_notify
176 # pragma weak pth_event
177 # pragma weak pth_timeout
178
179 # pragma weak pth_cancel
180 # define pth_in_use() (pth_cancel != NULL)
181
182 # else
183
184 # define pth_in_use() 1
185
186 # endif
187
188 /* -------------------------- gl_cond_t datatype -------------------------- */
189
190 typedef pth_cond_t gl_cond_t;
191 # define gl_cond_define(STORAGECLASS, NAME) \
192 STORAGECLASS gl_cond_t NAME;
193 # define gl_cond_define_initialized(STORAGECLASS, NAME) \
194 STORAGECLASS gl_cond_t NAME = gl_cond_initializer;
195 # define gl_cond_initializer \
196 PTH_COND_INIT
197 # define glthread_cond_init(COND) \
198 (pth_in_use () && !pth_cond_init (COND) ? errno : 0)
199 # define glthread_cond_wait(COND, LOCK) \
200 (pth_in_use () && !pth_cond_await (COND, LOCK, NULL) ? errno : 0)
201 # define glthread_cond_timedwait(COND, LOCK, ABSTIME) \
202 (pth_in_use () ? glthread_cond_timedwait_multithreaded (COND, LOCK, ABSTIME) : 0)
203 # define glthread_cond_signal(COND) \
204 (pth_in_use () && !pth_cond_notify (COND, FALSE) ? errno : 0)
205 # define glthread_cond_broadcast(COND) \
206 (pth_in_use () && !pth_cond_notify (COND, TRUE) ? errno : 0)
207 # define glthread_cond_destroy(COND) 0
208 extern int glthread_cond_timedwait_multithreaded (gl_cond_t *cond, gl_lock_t *lock, struct timespec *abstime);
209
210 # ifdef __cplusplus
211 }
212 # endif
213
214 #endif
215
216 /* ========================================================================= */
217
218 #if USE_SOLARIS_THREADS
219
220 /* Use the old Solaris threads library. */
221
222 # include <thread.h>
223 # include <synch.h>
224
225 # ifdef __cplusplus
226 extern "C" {
227 # endif
228
229 # if USE_SOLARIS_THREADS_WEAK
230
231 /* Use weak references to the old Solaris threads library. */
232
233 # pragma weak cond_init
234 # pragma weak cond_wait
235 # pragma weak cond_timedwait
236 # pragma weak cond_signal
237 # pragma weak cond_broadcast
238 # pragma weak cond_destroy
239 # pragma weak thr_suspend
240 # define thread_in_use() (thr_suspend != NULL)
241
242 # else
243
244 # define thread_in_use() 1
245
246 # endif
247
248 /* -------------------------- gl_cond_t datatype -------------------------- */
249
250 typedef cond_t gl_cond_t;
251 # define gl_cond_define(STORAGECLASS, NAME) \
252 STORAGECLASS gl_cond_t NAME;
253 # define gl_cond_define_initialized(STORAGECLASS, NAME) \
254 STORAGECLASS gl_cond_t NAME = gl_cond_initializer;
255 # define gl_cond_initializer \
256 DEFAULTCV
257 # define glthread_cond_init(COND) \
258 (pthread_in_use () ? cond_init (COND, USYNC_THREAD, NULL) : 0)
259 # define glthread_cond_wait(COND, LOCK) \
260 (pthread_in_use () ? cond_wait (COND, LOCK) : 0)
261 # define glthread_cond_timedwait(COND, LOCK, ABSTIME) \
262 (pthread_in_use () ? glthread_cond_timedwait_multithreaded (COND, LOCK, ABSTIME) : 0)
263 # define glthread_cond_signal(COND) \
264 (pthread_in_use () ? cond_signal (COND) : 0)
265 # define glthread_cond_broadcast(COND) \
266 (pthread_in_use () ? cond_broadcast (COND) : 0)
267 # define glthread_cond_destroy(COND) \
268 (pthread_in_use () ? cond_destroy (COND) : 0)
269 extern int glthread_cond_timedwait_multithreaded (gl_cond_t *cond, gl_lock_t *lock, struct timespec *abstime);
270
271 # ifdef __cplusplus
272 }
273 # endif
274
275 #endif
276
277 /* ========================================================================= */
278
279 #if USE_WINDOWS_THREADS
280
281 # define WIN32_LEAN_AND_MEAN /* avoid including junk */
282 # include <windows.h>
283
284 # ifdef __cplusplus
285 extern "C" {
286 # endif
287
288 /* -------------------------- gl_cond_t datatype -------------------------- */
289
290 struct gl_waitqueue_link
291 {
292 struct gl_waitqueue_link *wql_next;
293 struct gl_waitqueue_link *wql_prev;
294 };
295 typedef struct
296 {
297 struct gl_waitqueue_link wq_list; /* circular list of waiting threads */
298 }
299 gl_linked_waitqueue_t;
300 typedef struct
301 {
302 gl_spinlock_t guard; /* protects the initialization */
303 CRITICAL_SECTION lock; /* protects the remaining fields */
304 gl_linked_waitqueue_t waiters; /* waiting threads */
305 }
306 gl_cond_t;
307 # define gl_cond_define(STORAGECLASS, NAME) \
308 STORAGECLASS gl_cond_t NAME;
309 # define gl_cond_define_initialized(STORAGECLASS, NAME) \
310 STORAGECLASS gl_cond_t NAME = gl_cond_initializer;
311 # define gl_cond_initializer \
312 { { 0, -1 } }
313 # define glthread_cond_init(COND) \
314 glthread_cond_init_func (COND)
315 # define glthread_cond_wait(COND, LOCK) \
316 glthread_cond_wait_func (COND, LOCK)
317 # define glthread_cond_timedwait(COND, LOCK, ABSTIME) \
318 glthread_cond_timedwait_func (COND, LOCK, ABSTIME)
319 # define glthread_cond_signal(COND) \
320 glthread_cond_signal_func (COND)
321 # define glthread_cond_broadcast(COND) \
322 glthread_cond_broadcast_func (COND)
323 # define glthread_cond_destroy(COND) \
324 glthread_cond_destroy_func (COND)
325 extern int glthread_cond_init_func (gl_cond_t *cond);
326 extern int glthread_cond_wait_func (gl_cond_t *cond, gl_lock_t *lock);
327 extern int glthread_cond_timedwait_func (gl_cond_t *cond, gl_lock_t *lock, struct timespec *abstime);
328 extern int glthread_cond_signal_func (gl_cond_t *cond);
329 extern int glthread_cond_broadcast_func (gl_cond_t *cond);
330 extern int glthread_cond_destroy_func (gl_cond_t *cond);
331
332 # ifdef __cplusplus
333 }
334 # endif
335
336 #endif
337
338 /* ========================================================================= */
339
340 #if !(USE_POSIX_THREADS || USE_PTH_THREADS || USE_SOLARIS_THREADS || USE_WINDOWS_THREADS)
341
342 /* Provide dummy implementation if threads are not supported. */
343
344 typedef int gl_cond_t;
345 # define gl_cond_define(STORAGECLASS, NAME)
346 # define gl_cond_define_initialized(STORAGECLASS, NAME)
347 # define glthread_cond_init(COND) 0
348 # define glthread_cond_wait(COND, LOCK) 0
349 # define glthread_cond_timedwait(COND, LOCK, ABSTIME) 0
350 # define glthread_cond_signal(COND) 0
351 # define glthread_cond_broadcast(COND) 0
352 # define glthread_cond_destroy(COND) 0
353
354 #endif
355
356 /* ========================================================================= */
357
358 /* Macros with built-in error handling. */
359
360 #ifdef __cplusplus
361 extern "C" {
362 #endif
363
364 #define gl_cond_init(COND) \
365 do \
366 { \
367 if (glthread_cond_init (&COND)) \
368 abort (); \
369 } \
370 while (0)
371 #define gl_cond_wait(COND, LOCK) \
372 do \
373 { \
374 if (glthread_cond_wait (&COND, &LOCK)) \
375 abort (); \
376 } \
377 while (0)
378 #define gl_cond_timedwait(COND, LOCK, ABSTIME) \
379 gl_cond_timedwait_func (&COND, &LOCK, ABSTIME)
380 _GLTHREAD_COND_INLINE bool
gl_cond_timedwait_func(gl_cond_t * cond,gl_lock_t * lock,struct timespec * abstime)381 gl_cond_timedwait_func (gl_cond_t *cond, gl_lock_t *lock, struct timespec *abstime)
382 {
383 int err = glthread_cond_timedwait (cond, lock, abstime);
384 if (err == ETIMEDOUT)
385 return true;
386 if (err != 0)
387 abort ();
388 return false;
389 }
390 #define gl_cond_signal(COND) \
391 do \
392 { \
393 if (glthread_cond_signal (&COND)) \
394 abort (); \
395 } \
396 while (0)
397 #define gl_cond_broadcast(COND) \
398 do \
399 { \
400 if (glthread_cond_broadcast (&COND)) \
401 abort (); \
402 } \
403 while (0)
404 #define gl_cond_destroy(COND) \
405 do \
406 { \
407 if (glthread_cond_destroy (&COND)) \
408 abort (); \
409 } \
410 while (0)
411
412 #ifdef __cplusplus
413 }
414 #endif
415
416 _GL_INLINE_HEADER_END
417
418 #endif /* _GLTHREAD_COND_H */
419