1 /* Locking in multithreaded situations.
2 Copyright (C) 2005-2006 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify it
5 under the terms of the GNU Library General Public License as published
6 by the Free Software Foundation; either version 2, or (at your option)
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 GNU
12 Library General Public License for more details.
14 You should have received a copy of the GNU Library General Public
15 License along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19 /* Written by Bruno Haible <bruno@clisp.org>, 2005.
20 Based on GCC's gthr-posix.h, gthr-posix95.h, gthr-solaris.h,
23 /* This file contains locking primitives for use with a given thread library.
24 It does not contain primitives for creating threads or for other
25 synchronization primitives.
27 Normal (non-recursive) locks:
29 Declaration: gl_lock_define(extern, name)
30 Initializer: gl_lock_define_initialized(, name)
31 Initialization: gl_lock_init (name);
32 Taking the lock: gl_lock_lock (name);
33 Releasing the lock: gl_lock_unlock (name);
34 De-initialization: gl_lock_destroy (name);
36 Read-Write (non-recursive) locks:
38 Declaration: gl_rwlock_define(extern, name)
39 Initializer: gl_rwlock_define_initialized(, name)
40 Initialization: gl_rwlock_init (name);
41 Taking the lock: gl_rwlock_rdlock (name);
42 gl_rwlock_wrlock (name);
43 Releasing the lock: gl_rwlock_unlock (name);
44 De-initialization: gl_rwlock_destroy (name);
47 Type: gl_recursive_lock_t
48 Declaration: gl_recursive_lock_define(extern, name)
49 Initializer: gl_recursive_lock_define_initialized(, name)
50 Initialization: gl_recursive_lock_init (name);
51 Taking the lock: gl_recursive_lock_lock (name);
52 Releasing the lock: gl_recursive_lock_unlock (name);
53 De-initialization: gl_recursive_lock_destroy (name);
57 Initializer: gl_once_define(extern, name)
58 Execution: gl_once (name, initfunction);
65 /* ========================================================================= */
69 /* Use the POSIX threads library. */
78 # if PTHREAD_IN_USE_DETECTION_HARD
80 /* The pthread_in_use() detection needs to be done at runtime. */
81 # define pthread_in_use() \
83 extern int glthread_in_use (void);
87 # if USE_POSIX_THREADS_WEAK
89 /* Use weak references to the POSIX threads library. */
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. */
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. */
106 # pragma weak pthread_mutex_init
107 # pragma weak pthread_mutex_lock
108 # pragma weak pthread_mutex_unlock
109 # pragma weak pthread_mutex_destroy
110 # pragma weak pthread_rwlock_init
111 # pragma weak pthread_rwlock_rdlock
112 # pragma weak pthread_rwlock_wrlock
113 # pragma weak pthread_rwlock_unlock
114 # pragma weak pthread_rwlock_destroy
115 # pragma weak pthread_once
116 # pragma weak pthread_cond_init
117 # pragma weak pthread_cond_wait
118 # pragma weak pthread_cond_signal
119 # pragma weak pthread_cond_broadcast
120 # pragma weak pthread_cond_destroy
121 # pragma weak pthread_mutexattr_init
122 # pragma weak pthread_mutexattr_settype
123 # pragma weak pthread_mutexattr_destroy
124 # ifndef pthread_self
125 # pragma weak pthread_self
128 # if !PTHREAD_IN_USE_DETECTION_HARD
129 # pragma weak pthread_cancel
130 # define pthread_in_use() (pthread_cancel != NULL)
135 # if !PTHREAD_IN_USE_DETECTION_HARD
136 # define pthread_in_use() 1
141 /* -------------------------- gl_lock_t datatype -------------------------- */
143 typedef pthread_mutex_t gl_lock_t;
144 # define gl_lock_define(STORAGECLASS, NAME) \
145 STORAGECLASS pthread_mutex_t NAME;
146 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
147 STORAGECLASS pthread_mutex_t NAME = gl_lock_initializer;
148 # define gl_lock_initializer \
149 PTHREAD_MUTEX_INITIALIZER
150 # define gl_lock_init(NAME) \
151 if (pthread_in_use () && pthread_mutex_init (&NAME, NULL) != 0) abort ()
152 # define gl_lock_lock(NAME) \
153 if (pthread_in_use () && pthread_mutex_lock (&NAME) != 0) abort ()
154 # define gl_lock_unlock(NAME) \
155 if (pthread_in_use () && pthread_mutex_unlock (&NAME) != 0) abort ()
156 # define gl_lock_destroy(NAME) \
157 if (pthread_in_use () && pthread_mutex_destroy (&NAME) != 0) abort ()
159 /* ------------------------- gl_rwlock_t datatype ------------------------- */
161 # if HAVE_PTHREAD_RWLOCK
163 # ifdef PTHREAD_RWLOCK_INITIALIZER
165 typedef pthread_rwlock_t gl_rwlock_t;
166 # define gl_rwlock_define(STORAGECLASS, NAME) \
167 STORAGECLASS pthread_rwlock_t NAME;
168 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
169 STORAGECLASS pthread_rwlock_t NAME = gl_rwlock_initializer;
170 # define gl_rwlock_initializer \
171 PTHREAD_RWLOCK_INITIALIZER
172 # define gl_rwlock_init(NAME) \
173 if (pthread_in_use () && pthread_rwlock_init (&NAME, NULL) != 0) abort ()
174 # define gl_rwlock_rdlock(NAME) \
175 if (pthread_in_use () && pthread_rwlock_rdlock (&NAME) != 0) abort ()
176 # define gl_rwlock_wrlock(NAME) \
177 if (pthread_in_use () && pthread_rwlock_wrlock (&NAME) != 0) abort ()
178 # define gl_rwlock_unlock(NAME) \
179 if (pthread_in_use () && pthread_rwlock_unlock (&NAME) != 0) abort ()
180 # define gl_rwlock_destroy(NAME) \
181 if (pthread_in_use () && pthread_rwlock_destroy (&NAME) != 0) abort ()
188 pthread_mutex_t guard; /* protects the initialization */
189 pthread_rwlock_t rwlock; /* read-write lock */
192 # define gl_rwlock_define(STORAGECLASS, NAME) \
193 STORAGECLASS gl_rwlock_t NAME;
194 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
195 STORAGECLASS gl_rwlock_t NAME = gl_rwlock_initializer;
196 # define gl_rwlock_initializer \
197 { 0, PTHREAD_MUTEX_INITIALIZER }
198 # define gl_rwlock_init(NAME) \
199 if (pthread_in_use ()) glthread_rwlock_init (&NAME)
200 # define gl_rwlock_rdlock(NAME) \
201 if (pthread_in_use ()) glthread_rwlock_rdlock (&NAME)
202 # define gl_rwlock_wrlock(NAME) \
203 if (pthread_in_use ()) glthread_rwlock_wrlock (&NAME)
204 # define gl_rwlock_unlock(NAME) \
205 if (pthread_in_use ()) glthread_rwlock_unlock (&NAME)
206 # define gl_rwlock_destroy(NAME) \
207 if (pthread_in_use ()) glthread_rwlock_destroy (&NAME)
208 extern void glthread_rwlock_init (gl_rwlock_t *lock);
209 extern void glthread_rwlock_rdlock (gl_rwlock_t *lock);
210 extern void glthread_rwlock_wrlock (gl_rwlock_t *lock);
211 extern void glthread_rwlock_unlock (gl_rwlock_t *lock);
212 extern void glthread_rwlock_destroy (gl_rwlock_t *lock);
220 pthread_mutex_t lock; /* protects the remaining fields */
221 pthread_cond_t waiting_readers; /* waiting readers */
222 pthread_cond_t waiting_writers; /* waiting writers */
223 unsigned int waiting_writers_count; /* number of waiting writers */
224 int runcount; /* number of readers running, or -1 when a writer runs */
227 # define gl_rwlock_define(STORAGECLASS, NAME) \
228 STORAGECLASS gl_rwlock_t NAME;
229 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
230 STORAGECLASS gl_rwlock_t NAME = gl_rwlock_initializer;
231 # define gl_rwlock_initializer \
232 { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER, 0, 0 }
233 # define gl_rwlock_init(NAME) \
234 if (pthread_in_use ()) glthread_rwlock_init (&NAME)
235 # define gl_rwlock_rdlock(NAME) \
236 if (pthread_in_use ()) glthread_rwlock_rdlock (&NAME)
237 # define gl_rwlock_wrlock(NAME) \
238 if (pthread_in_use ()) glthread_rwlock_wrlock (&NAME)
239 # define gl_rwlock_unlock(NAME) \
240 if (pthread_in_use ()) glthread_rwlock_unlock (&NAME)
241 # define gl_rwlock_destroy(NAME) \
242 if (pthread_in_use ()) glthread_rwlock_destroy (&NAME)
243 extern void glthread_rwlock_init (gl_rwlock_t *lock);
244 extern void glthread_rwlock_rdlock (gl_rwlock_t *lock);
245 extern void glthread_rwlock_wrlock (gl_rwlock_t *lock);
246 extern void glthread_rwlock_unlock (gl_rwlock_t *lock);
247 extern void glthread_rwlock_destroy (gl_rwlock_t *lock);
251 /* --------------------- gl_recursive_lock_t datatype --------------------- */
253 # if HAVE_PTHREAD_MUTEX_RECURSIVE
255 # if defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER || defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
257 typedef pthread_mutex_t gl_recursive_lock_t;
258 # define gl_recursive_lock_define(STORAGECLASS, NAME) \
259 STORAGECLASS pthread_mutex_t NAME;
260 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
261 STORAGECLASS pthread_mutex_t NAME = gl_recursive_lock_initializer;
262 # ifdef PTHREAD_RECURSIVE_MUTEX_INITIALIZER
263 # define gl_recursive_lock_initializer \
264 PTHREAD_RECURSIVE_MUTEX_INITIALIZER
266 # define gl_recursive_lock_initializer \
267 PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
269 # define gl_recursive_lock_init(NAME) \
270 if (pthread_in_use () && pthread_mutex_init (&NAME, NULL) != 0) abort ()
271 # define gl_recursive_lock_lock(NAME) \
272 if (pthread_in_use () && pthread_mutex_lock (&NAME) != 0) abort ()
273 # define gl_recursive_lock_unlock(NAME) \
274 if (pthread_in_use () && pthread_mutex_unlock (&NAME) != 0) abort ()
275 # define gl_recursive_lock_destroy(NAME) \
276 if (pthread_in_use () && pthread_mutex_destroy (&NAME) != 0) abort ()
282 pthread_mutex_t recmutex; /* recursive mutex */
283 pthread_mutex_t guard; /* protects the initialization */
287 # define gl_recursive_lock_define(STORAGECLASS, NAME) \
288 STORAGECLASS gl_recursive_lock_t NAME;
289 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
290 STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
291 # define gl_recursive_lock_initializer \
292 { PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, 0 }
293 # define gl_recursive_lock_init(NAME) \
294 if (pthread_in_use ()) glthread_recursive_lock_init (&NAME)
295 # define gl_recursive_lock_lock(NAME) \
296 if (pthread_in_use ()) glthread_recursive_lock_lock (&NAME)
297 # define gl_recursive_lock_unlock(NAME) \
298 if (pthread_in_use ()) glthread_recursive_lock_unlock (&NAME)
299 # define gl_recursive_lock_destroy(NAME) \
300 if (pthread_in_use ()) glthread_recursive_lock_destroy (&NAME)
301 extern void glthread_recursive_lock_init (gl_recursive_lock_t *lock);
302 extern void glthread_recursive_lock_lock (gl_recursive_lock_t *lock);
303 extern void glthread_recursive_lock_unlock (gl_recursive_lock_t *lock);
304 extern void glthread_recursive_lock_destroy (gl_recursive_lock_t *lock);
310 /* Old versions of POSIX threads on Solaris did not have recursive locks.
311 We have to implement them ourselves. */
315 pthread_mutex_t mutex;
320 # define gl_recursive_lock_define(STORAGECLASS, NAME) \
321 STORAGECLASS gl_recursive_lock_t NAME;
322 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
323 STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
324 # define gl_recursive_lock_initializer \
325 { PTHREAD_MUTEX_INITIALIZER, (pthread_t) 0, 0 }
326 # define gl_recursive_lock_init(NAME) \
327 if (pthread_in_use ()) glthread_recursive_lock_init (&NAME)
328 # define gl_recursive_lock_lock(NAME) \
329 if (pthread_in_use ()) glthread_recursive_lock_lock (&NAME)
330 # define gl_recursive_lock_unlock(NAME) \
331 if (pthread_in_use ()) glthread_recursive_lock_unlock (&NAME)
332 # define gl_recursive_lock_destroy(NAME) \
333 if (pthread_in_use ()) glthread_recursive_lock_destroy (&NAME)
334 extern void glthread_recursive_lock_init (gl_recursive_lock_t *lock);
335 extern void glthread_recursive_lock_lock (gl_recursive_lock_t *lock);
336 extern void glthread_recursive_lock_unlock (gl_recursive_lock_t *lock);
337 extern void glthread_recursive_lock_destroy (gl_recursive_lock_t *lock);
341 /* -------------------------- gl_once_t datatype -------------------------- */
343 typedef pthread_once_t gl_once_t;
344 # define gl_once_define(STORAGECLASS, NAME) \
345 STORAGECLASS pthread_once_t NAME = PTHREAD_ONCE_INIT;
346 # define gl_once(NAME, INITFUNCTION) \
349 if (pthread_in_use ()) \
351 if (pthread_once (&NAME, INITFUNCTION) != 0) \
356 if (glthread_once_singlethreaded (&NAME)) \
361 extern int glthread_once_singlethreaded (pthread_once_t *once_control);
369 /* ========================================================================= */
373 /* Use the GNU Pth threads library. */
382 # if USE_PTH_THREADS_WEAK
384 /* Use weak references to the GNU Pth threads library. */
386 # pragma weak pth_mutex_init
387 # pragma weak pth_mutex_acquire
388 # pragma weak pth_mutex_release
389 # pragma weak pth_rwlock_init
390 # pragma weak pth_rwlock_acquire
391 # pragma weak pth_rwlock_release
392 # pragma weak pth_once
394 # pragma weak pth_cancel
395 # define pth_in_use() (pth_cancel != NULL)
399 # define pth_in_use() 1
403 /* -------------------------- gl_lock_t datatype -------------------------- */
405 typedef pth_mutex_t gl_lock_t;
406 # define gl_lock_define(STORAGECLASS, NAME) \
407 STORAGECLASS pth_mutex_t NAME;
408 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
409 STORAGECLASS pth_mutex_t NAME = gl_lock_initializer;
410 # define gl_lock_initializer \
412 # define gl_lock_init(NAME) \
413 if (pth_in_use() && !pth_mutex_init (&NAME)) abort ()
414 # define gl_lock_lock(NAME) \
415 if (pth_in_use() && !pth_mutex_acquire (&NAME, 0, NULL)) abort ()
416 # define gl_lock_unlock(NAME) \
417 if (pth_in_use() && !pth_mutex_release (&NAME)) abort ()
418 # define gl_lock_destroy(NAME) \
421 /* ------------------------- gl_rwlock_t datatype ------------------------- */
423 typedef pth_rwlock_t gl_rwlock_t;
424 # define gl_rwlock_define(STORAGECLASS, NAME) \
425 STORAGECLASS pth_rwlock_t NAME;
426 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
427 STORAGECLASS pth_rwlock_t NAME = gl_rwlock_initializer;
428 # define gl_rwlock_initializer \
430 # define gl_rwlock_init(NAME) \
431 if (pth_in_use() && !pth_rwlock_init (&NAME)) abort ()
432 # define gl_rwlock_rdlock(NAME) \
433 if (pth_in_use() && !pth_rwlock_acquire (&NAME, PTH_RWLOCK_RD, 0, NULL)) abort ()
434 # define gl_rwlock_wrlock(NAME) \
435 if (pth_in_use() && !pth_rwlock_acquire (&NAME, PTH_RWLOCK_RW, 0, NULL)) abort ()
436 # define gl_rwlock_unlock(NAME) \
437 if (pth_in_use() && !pth_rwlock_release (&NAME)) abort ()
438 # define gl_rwlock_destroy(NAME) \
441 /* --------------------- gl_recursive_lock_t datatype --------------------- */
443 /* In Pth, mutexes are recursive by default. */
444 typedef pth_mutex_t gl_recursive_lock_t;
445 # define gl_recursive_lock_define(STORAGECLASS, NAME) \
446 STORAGECLASS pth_mutex_t NAME;
447 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
448 STORAGECLASS pth_mutex_t NAME = gl_recursive_lock_initializer;
449 # define gl_recursive_lock_initializer \
451 # define gl_recursive_lock_init(NAME) \
452 if (pth_in_use() && !pth_mutex_init (&NAME)) abort ()
453 # define gl_recursive_lock_lock(NAME) \
454 if (pth_in_use() && !pth_mutex_acquire (&NAME, 0, NULL)) abort ()
455 # define gl_recursive_lock_unlock(NAME) \
456 if (pth_in_use() && !pth_mutex_release (&NAME)) abort ()
457 # define gl_recursive_lock_destroy(NAME) \
460 /* -------------------------- gl_once_t datatype -------------------------- */
462 typedef pth_once_t gl_once_t;
463 # define gl_once_define(STORAGECLASS, NAME) \
464 STORAGECLASS pth_once_t NAME = PTH_ONCE_INIT;
465 # define gl_once(NAME, INITFUNCTION) \
470 void (*gl_once_temp) (void) = INITFUNCTION; \
471 if (!pth_once (&NAME, glthread_once_call, &gl_once_temp)) \
476 if (glthread_once_singlethreaded (&NAME)) \
481 extern void glthread_once_call (void *arg);
482 extern int glthread_once_singlethreaded (pth_once_t *once_control);
490 /* ========================================================================= */
492 #if USE_SOLARIS_THREADS
494 /* Use the old Solaris threads library. */
504 # if USE_SOLARIS_THREADS_WEAK
506 /* Use weak references to the old Solaris threads library. */
508 # pragma weak mutex_init
509 # pragma weak mutex_lock
510 # pragma weak mutex_unlock
511 # pragma weak mutex_destroy
512 # pragma weak rwlock_init
513 # pragma weak rw_rdlock
514 # pragma weak rw_wrlock
515 # pragma weak rw_unlock
516 # pragma weak rwlock_destroy
517 # pragma weak thr_self
519 # pragma weak thr_suspend
520 # define thread_in_use() (thr_suspend != NULL)
524 # define thread_in_use() 1
528 /* -------------------------- gl_lock_t datatype -------------------------- */
530 typedef mutex_t gl_lock_t;
531 # define gl_lock_define(STORAGECLASS, NAME) \
532 STORAGECLASS mutex_t NAME;
533 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
534 STORAGECLASS mutex_t NAME = gl_lock_initializer;
535 # define gl_lock_initializer \
537 # define gl_lock_init(NAME) \
538 if (thread_in_use () && mutex_init (&NAME, USYNC_THREAD, NULL) != 0) abort ()
539 # define gl_lock_lock(NAME) \
540 if (thread_in_use () && mutex_lock (&NAME) != 0) abort ()
541 # define gl_lock_unlock(NAME) \
542 if (thread_in_use () && mutex_unlock (&NAME) != 0) abort ()
543 # define gl_lock_destroy(NAME) \
544 if (thread_in_use () && mutex_destroy (&NAME) != 0) abort ()
546 /* ------------------------- gl_rwlock_t datatype ------------------------- */
548 typedef rwlock_t gl_rwlock_t;
549 # define gl_rwlock_define(STORAGECLASS, NAME) \
550 STORAGECLASS rwlock_t NAME;
551 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
552 STORAGECLASS rwlock_t NAME = gl_rwlock_initializer;
553 # define gl_rwlock_initializer \
555 # define gl_rwlock_init(NAME) \
556 if (thread_in_use () && rwlock_init (&NAME, USYNC_THREAD, NULL) != 0) abort ()
557 # define gl_rwlock_rdlock(NAME) \
558 if (thread_in_use () && rw_rdlock (&NAME) != 0) abort ()
559 # define gl_rwlock_wrlock(NAME) \
560 if (thread_in_use () && rw_wrlock (&NAME) != 0) abort ()
561 # define gl_rwlock_unlock(NAME) \
562 if (thread_in_use () && rw_unlock (&NAME) != 0) abort ()
563 # define gl_rwlock_destroy(NAME) \
564 if (thread_in_use () && rwlock_destroy (&NAME) != 0) abort ()
566 /* --------------------- gl_recursive_lock_t datatype --------------------- */
568 /* Old Solaris threads did not have recursive locks.
569 We have to implement them ourselves. */
578 # define gl_recursive_lock_define(STORAGECLASS, NAME) \
579 STORAGECLASS gl_recursive_lock_t NAME;
580 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
581 STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
582 # define gl_recursive_lock_initializer \
583 { DEFAULTMUTEX, (thread_t) 0, 0 }
584 # define gl_recursive_lock_init(NAME) \
585 if (thread_in_use ()) glthread_recursive_lock_init (&NAME)
586 # define gl_recursive_lock_lock(NAME) \
587 if (thread_in_use ()) glthread_recursive_lock_lock (&NAME)
588 # define gl_recursive_lock_unlock(NAME) \
589 if (thread_in_use ()) glthread_recursive_lock_unlock (&NAME)
590 # define gl_recursive_lock_destroy(NAME) \
591 if (thread_in_use ()) glthread_recursive_lock_destroy (&NAME)
592 extern void glthread_recursive_lock_init (gl_recursive_lock_t *lock);
593 extern void glthread_recursive_lock_lock (gl_recursive_lock_t *lock);
594 extern void glthread_recursive_lock_unlock (gl_recursive_lock_t *lock);
595 extern void glthread_recursive_lock_destroy (gl_recursive_lock_t *lock);
597 /* -------------------------- gl_once_t datatype -------------------------- */
605 # define gl_once_define(STORAGECLASS, NAME) \
606 STORAGECLASS gl_once_t NAME = { 0, DEFAULTMUTEX };
607 # define gl_once(NAME, INITFUNCTION) \
610 if (thread_in_use ()) \
612 glthread_once (&NAME, INITFUNCTION); \
616 if (glthread_once_singlethreaded (&NAME)) \
621 extern void glthread_once (gl_once_t *once_control, void (*initfunction) (void));
622 extern int glthread_once_singlethreaded (gl_once_t *once_control);
630 /* ========================================================================= */
632 #if USE_WIN32_THREADS
634 # include <windows.h>
640 /* We can use CRITICAL_SECTION directly, rather than the Win32 Event, Mutex,
641 Semaphore types, because
642 - we need only to synchronize inside a single process (address space),
643 not inter-process locking,
644 - we don't need to support trylock operations. (TryEnterCriticalSection
645 does not work on Windows 95/98/ME. Packages that need trylock usually
646 define their own mutex type.) */
648 /* There is no way to statically initialize a CRITICAL_SECTION. It needs
649 to be done lazily, once only. For this we need spinlocks. */
651 typedef struct { volatile int done; volatile long started; } gl_spinlock_t;
653 /* -------------------------- gl_lock_t datatype -------------------------- */
657 gl_spinlock_t guard; /* protects the initialization */
658 CRITICAL_SECTION lock;
661 # define gl_lock_define(STORAGECLASS, NAME) \
662 STORAGECLASS gl_lock_t NAME;
663 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
664 STORAGECLASS gl_lock_t NAME = gl_lock_initializer;
665 # define gl_lock_initializer \
667 # define gl_lock_init(NAME) \
668 glthread_lock_init (&NAME)
669 # define gl_lock_lock(NAME) \
670 glthread_lock_lock (&NAME)
671 # define gl_lock_unlock(NAME) \
672 glthread_lock_unlock (&NAME)
673 # define gl_lock_destroy(NAME) \
674 glthread_lock_destroy (&NAME)
675 extern void glthread_lock_init (gl_lock_t *lock);
676 extern void glthread_lock_lock (gl_lock_t *lock);
677 extern void glthread_lock_unlock (gl_lock_t *lock);
678 extern void glthread_lock_destroy (gl_lock_t *lock);
680 /* ------------------------- gl_rwlock_t datatype ------------------------- */
682 /* It is impossible to implement read-write locks using plain locks, without
683 introducing an extra thread dedicated to managing read-write locks.
684 Therefore here we need to use the low-level Event type. */
688 HANDLE *array; /* array of waiting threads, each represented by an event */
689 unsigned int count; /* number of waiting threads */
690 unsigned int alloc; /* length of allocated array */
691 unsigned int offset; /* index of first waiting thread in array */
696 gl_spinlock_t guard; /* protects the initialization */
697 CRITICAL_SECTION lock; /* protects the remaining fields */
698 gl_waitqueue_t waiting_readers; /* waiting readers */
699 gl_waitqueue_t waiting_writers; /* waiting writers */
700 int runcount; /* number of readers running, or -1 when a writer runs */
703 # define gl_rwlock_define(STORAGECLASS, NAME) \
704 STORAGECLASS gl_rwlock_t NAME;
705 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
706 STORAGECLASS gl_rwlock_t NAME = gl_rwlock_initializer;
707 # define gl_rwlock_initializer \
709 # define gl_rwlock_init(NAME) \
710 glthread_rwlock_init (&NAME)
711 # define gl_rwlock_rdlock(NAME) \
712 glthread_rwlock_rdlock (&NAME)
713 # define gl_rwlock_wrlock(NAME) \
714 glthread_rwlock_wrlock (&NAME)
715 # define gl_rwlock_unlock(NAME) \
716 glthread_rwlock_unlock (&NAME)
717 # define gl_rwlock_destroy(NAME) \
718 glthread_rwlock_destroy (&NAME)
719 extern void glthread_rwlock_init (gl_rwlock_t *lock);
720 extern void glthread_rwlock_rdlock (gl_rwlock_t *lock);
721 extern void glthread_rwlock_wrlock (gl_rwlock_t *lock);
722 extern void glthread_rwlock_unlock (gl_rwlock_t *lock);
723 extern void glthread_rwlock_destroy (gl_rwlock_t *lock);
725 /* --------------------- gl_recursive_lock_t datatype --------------------- */
727 /* The Win32 documentation says that CRITICAL_SECTION already implements a
728 recursive lock. But we need not rely on it: It's easy to implement a
729 recursive lock without this assumption. */
733 gl_spinlock_t guard; /* protects the initialization */
736 CRITICAL_SECTION lock;
739 # define gl_recursive_lock_define(STORAGECLASS, NAME) \
740 STORAGECLASS gl_recursive_lock_t NAME;
741 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
742 STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
743 # define gl_recursive_lock_initializer \
745 # define gl_recursive_lock_init(NAME) \
746 glthread_recursive_lock_init (&NAME)
747 # define gl_recursive_lock_lock(NAME) \
748 glthread_recursive_lock_lock (&NAME)
749 # define gl_recursive_lock_unlock(NAME) \
750 glthread_recursive_lock_unlock (&NAME)
751 # define gl_recursive_lock_destroy(NAME) \
752 glthread_recursive_lock_destroy (&NAME)
753 extern void glthread_recursive_lock_init (gl_recursive_lock_t *lock);
754 extern void glthread_recursive_lock_lock (gl_recursive_lock_t *lock);
755 extern void glthread_recursive_lock_unlock (gl_recursive_lock_t *lock);
756 extern void glthread_recursive_lock_destroy (gl_recursive_lock_t *lock);
758 /* -------------------------- gl_once_t datatype -------------------------- */
763 volatile long started;
764 CRITICAL_SECTION lock;
767 # define gl_once_define(STORAGECLASS, NAME) \
768 STORAGECLASS gl_once_t NAME = { -1, -1 };
769 # define gl_once(NAME, INITFUNCTION) \
770 glthread_once (&NAME, INITFUNCTION)
771 extern void glthread_once (gl_once_t *once_control, void (*initfunction) (void));
779 /* ========================================================================= */
781 #if !(USE_POSIX_THREADS || USE_PTH_THREADS || USE_SOLARIS_THREADS || USE_WIN32_THREADS)
783 /* Provide dummy implementation if threads are not supported. */
785 /* -------------------------- gl_lock_t datatype -------------------------- */
787 typedef int gl_lock_t;
788 # define gl_lock_define(STORAGECLASS, NAME)
789 # define gl_lock_define_initialized(STORAGECLASS, NAME)
790 # define gl_lock_init(NAME)
791 # define gl_lock_lock(NAME)
792 # define gl_lock_unlock(NAME)
794 /* ------------------------- gl_rwlock_t datatype ------------------------- */
796 typedef int gl_rwlock_t;
797 # define gl_rwlock_define(STORAGECLASS, NAME)
798 # define gl_rwlock_define_initialized(STORAGECLASS, NAME)
799 # define gl_rwlock_init(NAME)
800 # define gl_rwlock_rdlock(NAME)
801 # define gl_rwlock_wrlock(NAME)
802 # define gl_rwlock_unlock(NAME)
804 /* --------------------- gl_recursive_lock_t datatype --------------------- */
806 typedef int gl_recursive_lock_t;
807 # define gl_recursive_lock_define(STORAGECLASS, NAME)
808 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME)
809 # define gl_recursive_lock_init(NAME)
810 # define gl_recursive_lock_lock(NAME)
811 # define gl_recursive_lock_unlock(NAME)
813 /* -------------------------- gl_once_t datatype -------------------------- */
815 typedef int gl_once_t;
816 # define gl_once_define(STORAGECLASS, NAME) \
817 STORAGECLASS gl_once_t NAME = 0;
818 # define gl_once(NAME, INITFUNCTION) \
831 /* ========================================================================= */