1
/* Locking in multithreaded situations.
2
Copyright (C) 2005 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,
29
/* ========================================================================= */
33
/* Use the POSIX threads library. */
35
# if PTHREAD_IN_USE_DETECTION_HARD
37
/* The function to be executed by a dummy thread. */
39
dummy_thread_func (void *arg)
45
glthread_in_use (void)
48
static int result; /* 1: linked with -lpthread, 0: only with libc */
54
if (pthread_create (&thread, NULL, dummy_thread_func, NULL) != 0)
55
/* Thread creation failed. */
59
/* Thread creation works. */
61
if (pthread_join (thread, &retval) != 0)
72
/* -------------------------- gl_lock_t datatype -------------------------- */
74
/* ------------------------- gl_rwlock_t datatype ------------------------- */
76
# if HAVE_PTHREAD_RWLOCK
78
# if !defined PTHREAD_RWLOCK_INITIALIZER
81
glthread_rwlock_init (gl_rwlock_t *lock)
83
if (pthread_rwlock_init (&lock->rwlock, NULL) != 0)
85
lock->initialized = 1;
89
glthread_rwlock_rdlock (gl_rwlock_t *lock)
91
if (!lock->initialized)
93
if (pthread_mutex_lock (&lock->guard) != 0)
95
if (!lock->initialized)
96
glthread_rwlock_init (lock);
97
if (pthread_mutex_unlock (&lock->guard) != 0)
100
if (pthread_rwlock_rdlock (&lock->rwlock) != 0)
105
glthread_rwlock_wrlock (gl_rwlock_t *lock)
107
if (!lock->initialized)
109
if (pthread_mutex_lock (&lock->guard) != 0)
111
if (!lock->initialized)
112
glthread_rwlock_init (lock);
113
if (pthread_mutex_unlock (&lock->guard) != 0)
116
if (pthread_rwlock_wrlock (&lock->rwlock) != 0)
121
glthread_rwlock_unlock (gl_rwlock_t *lock)
123
if (!lock->initialized)
125
if (pthread_rwlock_unlock (&lock->rwlock) != 0)
130
glthread_rwlock_destroy (gl_rwlock_t *lock)
132
if (!lock->initialized)
134
if (pthread_rwlock_destroy (&lock->rwlock) != 0)
136
lock->initialized = 0;
144
glthread_rwlock_init (gl_rwlock_t *lock)
146
if (pthread_mutex_init (&lock->lock, NULL) != 0)
148
if (pthread_cond_init (&lock->waiting_readers, NULL) != 0)
150
if (pthread_cond_init (&lock->waiting_writers, NULL) != 0)
152
lock->waiting_writers_count = 0;
157
glthread_rwlock_rdlock (gl_rwlock_t *lock)
159
if (pthread_mutex_lock (&lock->lock) != 0)
161
/* Test whether only readers are currently running, and whether the runcount
162
field will not overflow. */
163
/* POSIX says: "It is implementation-defined whether the calling thread
164
acquires the lock when a writer does not hold the lock and there are
165
writers blocked on the lock." Let's say, no: give the writers a higher
167
while (!(lock->runcount + 1 > 0 && lock->waiting_writers_count == 0))
169
/* This thread has to wait for a while. Enqueue it among the
171
if (pthread_cond_wait (&lock->waiting_readers, &lock->lock) != 0)
175
if (pthread_mutex_unlock (&lock->lock) != 0)
180
glthread_rwlock_wrlock (gl_rwlock_t *lock)
182
if (pthread_mutex_lock (&lock->lock) != 0)
184
/* Test whether no readers or writers are currently running. */
185
while (!(lock->runcount == 0))
187
/* This thread has to wait for a while. Enqueue it among the
189
lock->waiting_writers_count++;
190
if (pthread_cond_wait (&lock->waiting_writers, &lock->lock) != 0)
192
lock->waiting_writers_count--;
194
lock->runcount--; /* runcount becomes -1 */
195
if (pthread_mutex_unlock (&lock->lock) != 0)
200
glthread_rwlock_unlock (gl_rwlock_t *lock)
202
if (pthread_mutex_lock (&lock->lock) != 0)
204
if (lock->runcount < 0)
206
/* Drop a writer lock. */
207
if (!(lock->runcount == -1))
213
/* Drop a reader lock. */
214
if (!(lock->runcount > 0))
218
if (lock->runcount == 0)
220
/* POSIX recommends that "write locks shall take precedence over read
221
locks", to avoid "writer starvation". */
222
if (lock->waiting_writers_count > 0)
224
/* Wake up one of the waiting writers. */
225
if (pthread_cond_signal (&lock->waiting_writers) != 0)
230
/* Wake up all waiting readers. */
231
if (pthread_cond_broadcast (&lock->waiting_readers) != 0)
235
if (pthread_mutex_unlock (&lock->lock) != 0)
240
glthread_rwlock_destroy (gl_rwlock_t *lock)
242
if (pthread_mutex_destroy (&lock->lock) != 0)
244
if (pthread_cond_destroy (&lock->waiting_readers) != 0)
246
if (pthread_cond_destroy (&lock->waiting_writers) != 0)
252
/* --------------------- gl_recursive_lock_t datatype --------------------- */
254
# if HAVE_PTHREAD_MUTEX_RECURSIVE
256
# if !(defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER || defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
259
glthread_recursive_lock_init (gl_recursive_lock_t *lock)
261
pthread_mutexattr_t attributes;
263
if (pthread_mutexattr_init (&attributes) != 0)
265
if (pthread_mutexattr_settype (&attributes, PTHREAD_MUTEX_RECURSIVE) != 0)
267
if (pthread_mutex_init (&lock->recmutex, &attributes) != 0)
269
if (pthread_mutexattr_destroy (&attributes) != 0)
271
lock->initialized = 1;
275
glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
277
if (!lock->initialized)
279
if (pthread_mutex_lock (&lock->guard) != 0)
281
if (!lock->initialized)
282
glthread_recursive_lock_init (lock);
283
if (pthread_mutex_unlock (&lock->guard) != 0)
286
if (pthread_mutex_lock (&lock->recmutex) != 0)
291
glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
293
if (!lock->initialized)
295
if (pthread_mutex_unlock (&lock->recmutex) != 0)
300
glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
302
if (!lock->initialized)
304
if (pthread_mutex_destroy (&lock->recmutex) != 0)
306
lock->initialized = 0;
314
glthread_recursive_lock_init (gl_recursive_lock_t *lock)
316
if (pthread_mutex_init (&lock->mutex, NULL) != 0)
318
lock->owner = (pthread_t) 0;
323
glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
325
pthread_t self = pthread_self ();
326
if (lock->owner != self)
328
if (pthread_mutex_lock (&lock->mutex) != 0)
332
if (++(lock->depth) == 0) /* wraparound? */
337
glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
339
if (lock->owner != pthread_self ())
341
if (lock->depth == 0)
343
if (--(lock->depth) == 0)
345
lock->owner = (pthread_t) 0;
346
if (pthread_mutex_unlock (&lock->mutex) != 0)
352
glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
354
if (lock->owner != (pthread_t) 0)
356
if (pthread_mutex_destroy (&lock->mutex) != 0)
362
/* -------------------------- gl_once_t datatype -------------------------- */
364
static const pthread_once_t fresh_once = PTHREAD_ONCE_INIT;
367
glthread_once_singlethreaded (pthread_once_t *once_control)
369
/* We don't know whether pthread_once_t is an integer type, a floating-point
370
type, a pointer type, or a structure type. */
371
char *firstbyte = (char *)once_control;
372
if (*firstbyte == *(const char *)&fresh_once)
374
/* First time use of once_control. Invert the first byte. */
375
*firstbyte = ~ *(const char *)&fresh_once;
384
/* ========================================================================= */
388
/* Use the GNU Pth threads library. */
390
/* -------------------------- gl_lock_t datatype -------------------------- */
392
/* ------------------------- gl_rwlock_t datatype ------------------------- */
394
/* --------------------- gl_recursive_lock_t datatype --------------------- */
396
/* -------------------------- gl_once_t datatype -------------------------- */
399
glthread_once_call (void *arg)
401
void (**gl_once_temp_addr) (void) = (void (**) (void)) arg;
402
void (*initfunction) (void) = *gl_once_temp_addr;
407
glthread_once_singlethreaded (pth_once_t *once_control)
409
/* We know that pth_once_t is an integer type. */
410
if (*once_control == PTH_ONCE_INIT)
412
/* First time use of once_control. Invert the marker. */
413
*once_control = ~ PTH_ONCE_INIT;
422
/* ========================================================================= */
424
#if USE_SOLARIS_THREADS
426
/* Use the old Solaris threads library. */
428
/* -------------------------- gl_lock_t datatype -------------------------- */
430
/* ------------------------- gl_rwlock_t datatype ------------------------- */
432
/* --------------------- gl_recursive_lock_t datatype --------------------- */
435
glthread_recursive_lock_init (gl_recursive_lock_t *lock)
437
if (mutex_init (&lock->mutex, USYNC_THREAD, NULL) != 0)
439
lock->owner = (thread_t) 0;
444
glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
446
thread_t self = thr_self ();
447
if (lock->owner != self)
449
if (mutex_lock (&lock->mutex) != 0)
453
if (++(lock->depth) == 0) /* wraparound? */
458
glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
460
if (lock->owner != thr_self ())
462
if (lock->depth == 0)
464
if (--(lock->depth) == 0)
466
lock->owner = (thread_t) 0;
467
if (mutex_unlock (&lock->mutex) != 0)
473
glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
475
if (lock->owner != (thread_t) 0)
477
if (mutex_destroy (&lock->mutex) != 0)
481
/* -------------------------- gl_once_t datatype -------------------------- */
484
glthread_once (gl_once_t *once_control, void (*initfunction) (void))
486
if (!once_control->inited)
488
/* Use the mutex to guarantee that if another thread is already calling
489
the initfunction, this thread waits until it's finished. */
490
if (mutex_lock (&once_control->mutex) != 0)
492
if (!once_control->inited)
494
once_control->inited = 1;
497
if (mutex_unlock (&once_control->mutex) != 0)
503
glthread_once_singlethreaded (gl_once_t *once_control)
505
/* We know that gl_once_t contains an integer type. */
506
if (!once_control->inited)
508
/* First time use of once_control. Invert the marker. */
509
once_control->inited = ~ 0;
518
/* ========================================================================= */
520
#if USE_WIN32_THREADS
522
/* -------------------------- gl_lock_t datatype -------------------------- */
525
glthread_lock_init (gl_lock_t *lock)
527
InitializeCriticalSection (&lock->lock);
528
lock->guard.done = 1;
532
glthread_lock_lock (gl_lock_t *lock)
534
if (!lock->guard.done)
536
if (InterlockedIncrement (&lock->guard.started) == 0)
537
/* This thread is the first one to need this lock. Initialize it. */
538
glthread_lock_init (lock);
540
/* Yield the CPU while waiting for another thread to finish
541
initializing this lock. */
542
while (!lock->guard.done)
545
EnterCriticalSection (&lock->lock);
549
glthread_lock_unlock (gl_lock_t *lock)
551
if (!lock->guard.done)
553
LeaveCriticalSection (&lock->lock);
557
glthread_lock_destroy (gl_lock_t *lock)
559
if (!lock->guard.done)
561
DeleteCriticalSection (&lock->lock);
562
lock->guard.done = 0;
565
/* ------------------------- gl_rwlock_t datatype ------------------------- */
568
gl_waitqueue_init (gl_waitqueue_t *wq)
576
/* Enqueues the current thread, represented by an event, in a wait queue.
577
Returns INVALID_HANDLE_VALUE if an allocation failure occurs. */
579
gl_waitqueue_add (gl_waitqueue_t *wq)
584
if (wq->count == wq->alloc)
586
unsigned int new_alloc = 2 * wq->alloc + 1;
588
(HANDLE *) realloc (wq->array, new_alloc * sizeof (HANDLE));
589
if (new_array == NULL)
590
/* No more memory. */
591
return INVALID_HANDLE_VALUE;
592
/* Now is a good opportunity to rotate the array so that its contents
593
starts at offset 0. */
596
unsigned int old_count = wq->count;
597
unsigned int old_alloc = wq->alloc;
598
unsigned int old_offset = wq->offset;
600
if (old_offset + old_count > old_alloc)
602
unsigned int limit = old_offset + old_count - old_alloc;
603
for (i = 0; i < limit; i++)
604
new_array[old_alloc + i] = new_array[i];
606
for (i = 0; i < old_count; i++)
607
new_array[i] = new_array[old_offset + i];
610
wq->array = new_array;
611
wq->alloc = new_alloc;
613
event = CreateEvent (NULL, TRUE, FALSE, NULL);
614
if (event == INVALID_HANDLE_VALUE)
615
/* No way to allocate an event. */
616
return INVALID_HANDLE_VALUE;
617
index = wq->offset + wq->count;
618
if (index >= wq->alloc)
620
wq->array[index] = event;
625
/* Notifies the first thread from a wait queue and dequeues it. */
627
gl_waitqueue_notify_first (gl_waitqueue_t *wq)
629
SetEvent (wq->array[wq->offset + 0]);
632
if (wq->count == 0 || wq->offset == wq->alloc)
636
/* Notifies all threads from a wait queue and dequeues them all. */
638
gl_waitqueue_notify_all (gl_waitqueue_t *wq)
642
for (i = 0; i < wq->count; i++)
644
unsigned int index = wq->offset + i;
645
if (index >= wq->alloc)
647
SetEvent (wq->array[index]);
654
glthread_rwlock_init (gl_rwlock_t *lock)
656
InitializeCriticalSection (&lock->lock);
657
gl_waitqueue_init (&lock->waiting_readers);
658
gl_waitqueue_init (&lock->waiting_writers);
660
lock->guard.done = 1;
664
glthread_rwlock_rdlock (gl_rwlock_t *lock)
666
if (!lock->guard.done)
668
if (InterlockedIncrement (&lock->guard.started) == 0)
669
/* This thread is the first one to need this lock. Initialize it. */
670
glthread_rwlock_init (lock);
672
/* Yield the CPU while waiting for another thread to finish
673
initializing this lock. */
674
while (!lock->guard.done)
677
EnterCriticalSection (&lock->lock);
678
/* Test whether only readers are currently running, and whether the runcount
679
field will not overflow. */
680
if (!(lock->runcount + 1 > 0))
682
/* This thread has to wait for a while. Enqueue it among the
684
HANDLE event = gl_waitqueue_add (&lock->waiting_readers);
685
if (event != INVALID_HANDLE_VALUE)
688
LeaveCriticalSection (&lock->lock);
689
/* Wait until another thread signals this event. */
690
result = WaitForSingleObject (event, INFINITE);
691
if (result == WAIT_FAILED || result == WAIT_TIMEOUT)
694
/* The thread which signalled the event already did the bookkeeping:
695
removed us from the waiting_readers, incremented lock->runcount. */
696
if (!(lock->runcount > 0))
702
/* Allocation failure. Weird. */
705
LeaveCriticalSection (&lock->lock);
707
EnterCriticalSection (&lock->lock);
709
while (!(lock->runcount + 1 > 0));
713
LeaveCriticalSection (&lock->lock);
717
glthread_rwlock_wrlock (gl_rwlock_t *lock)
719
if (!lock->guard.done)
721
if (InterlockedIncrement (&lock->guard.started) == 0)
722
/* This thread is the first one to need this lock. Initialize it. */
723
glthread_rwlock_init (lock);
725
/* Yield the CPU while waiting for another thread to finish
726
initializing this lock. */
727
while (!lock->guard.done)
730
EnterCriticalSection (&lock->lock);
731
/* Test whether no readers or writers are currently running. */
732
if (!(lock->runcount == 0))
734
/* This thread has to wait for a while. Enqueue it among the
736
HANDLE event = gl_waitqueue_add (&lock->waiting_writers);
737
if (event != INVALID_HANDLE_VALUE)
740
LeaveCriticalSection (&lock->lock);
741
/* Wait until another thread signals this event. */
742
result = WaitForSingleObject (event, INFINITE);
743
if (result == WAIT_FAILED || result == WAIT_TIMEOUT)
746
/* The thread which signalled the event already did the bookkeeping:
747
removed us from the waiting_writers, set lock->runcount = -1. */
748
if (!(lock->runcount == -1))
754
/* Allocation failure. Weird. */
757
LeaveCriticalSection (&lock->lock);
759
EnterCriticalSection (&lock->lock);
761
while (!(lock->runcount == 0));
764
lock->runcount--; /* runcount becomes -1 */
765
LeaveCriticalSection (&lock->lock);
769
glthread_rwlock_unlock (gl_rwlock_t *lock)
771
if (!lock->guard.done)
773
EnterCriticalSection (&lock->lock);
774
if (lock->runcount < 0)
776
/* Drop a writer lock. */
777
if (!(lock->runcount == -1))
783
/* Drop a reader lock. */
784
if (!(lock->runcount > 0))
788
if (lock->runcount == 0)
790
/* POSIX recommends that "write locks shall take precedence over read
791
locks", to avoid "writer starvation". */
792
if (lock->waiting_writers.count > 0)
794
/* Wake up one of the waiting writers. */
796
gl_waitqueue_notify_first (&lock->waiting_writers);
800
/* Wake up all waiting readers. */
801
lock->runcount += lock->waiting_readers.count;
802
gl_waitqueue_notify_all (&lock->waiting_readers);
805
LeaveCriticalSection (&lock->lock);
809
glthread_rwlock_destroy (gl_rwlock_t *lock)
811
if (!lock->guard.done)
813
if (lock->runcount != 0)
815
DeleteCriticalSection (&lock->lock);
816
if (lock->waiting_readers.array != NULL)
817
free (lock->waiting_readers.array);
818
if (lock->waiting_writers.array != NULL)
819
free (lock->waiting_writers.array);
820
lock->guard.done = 0;
823
/* --------------------- gl_recursive_lock_t datatype --------------------- */
826
glthread_recursive_lock_init (gl_recursive_lock_t *lock)
830
InitializeCriticalSection (&lock->lock);
831
lock->guard.done = 1;
835
glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
837
if (!lock->guard.done)
839
if (InterlockedIncrement (&lock->guard.started) == 0)
840
/* This thread is the first one to need this lock. Initialize it. */
841
glthread_recursive_lock_init (lock);
843
/* Yield the CPU while waiting for another thread to finish
844
initializing this lock. */
845
while (!lock->guard.done)
849
DWORD self = GetCurrentThreadId ();
850
if (lock->owner != self)
852
EnterCriticalSection (&lock->lock);
855
if (++(lock->depth) == 0) /* wraparound? */
861
glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
863
if (lock->owner != GetCurrentThreadId ())
865
if (lock->depth == 0)
867
if (--(lock->depth) == 0)
870
LeaveCriticalSection (&lock->lock);
875
glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
877
if (lock->owner != 0)
879
DeleteCriticalSection (&lock->lock);
880
lock->guard.done = 0;
883
/* -------------------------- gl_once_t datatype -------------------------- */
886
glthread_once (gl_once_t *once_control, void (*initfunction) (void))
888
if (once_control->inited <= 0)
890
if (InterlockedIncrement (&once_control->started) == 0)
892
/* This thread is the first one to come to this once_control. */
893
InitializeCriticalSection (&once_control->lock);
894
EnterCriticalSection (&once_control->lock);
895
once_control->inited = 0;
897
once_control->inited = 1;
898
LeaveCriticalSection (&once_control->lock);
902
/* Undo last operation. */
903
InterlockedDecrement (&once_control->started);
904
/* Some other thread has already started the initialization.
905
Yield the CPU while waiting for the other thread to finish
906
initializing and taking the lock. */
907
while (once_control->inited < 0)
909
if (once_control->inited <= 0)
911
/* Take the lock. This blocks until the other thread has
912
finished calling the initfunction. */
913
EnterCriticalSection (&once_control->lock);
914
LeaveCriticalSection (&once_control->lock);
915
if (!(once_control->inited > 0))
924
/* ========================================================================= */
added
removed
intl/lock.c
