← Back to branch summary

~vcs-imports/tuxtype/trunk

« back to all changes in this revision

Viewing changes to intl/lock.c

  • Committer: dbruce-guest
  • Date: 2008-11-24 13:42:10 UTC
  • Revision ID: vcs-imports@canonical.com-20081124134210-owbqr2ral094y8to
Re-ran gettextize to add in-tree libintl (needed for Windows cross-build).
Got crossbuild working again, cleaned up configure.ac and Makefile.am's.
Fixed crashing bug in new word list editing feature that segfaulted if word list not user-writable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
intl/lock.c
 
1
/* Locking in multithreaded situations.
 
2
   Copyright (C) 2005-2006 Free Software Foundation, Inc.
 
3
 
 
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)
 
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 GNU
 
12
   Library General Public License for more details.
 
13
 
 
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,
 
17
   USA.  */
 
18
 
 
19
/* Written by Bruno Haible <bruno@clisp.org>, 2005.
 
20
   Based on GCC's gthr-posix.h, gthr-posix95.h, gthr-solaris.h,
 
21
   gthr-win32.h.  */
 
22
 
 
23
#include <config.h>
 
24
 
 
25
#include "lock.h"
 
26
 
 
27
/* ========================================================================= */
 
28
 
 
29
#if USE_POSIX_THREADS
 
30
 
 
31
/* Use the POSIX threads library.  */
 
32
 
 
33
# if PTHREAD_IN_USE_DETECTION_HARD
 
34
 
 
35
/* The function to be executed by a dummy thread.  */
 
36
static void *
 
37
dummy_thread_func (void *arg)
 
38
{
 
39
  return arg;
 
40
}
 
41
 
 
42
int
 
43
glthread_in_use (void)
 
44
{
 
45
  static int tested;
 
46
  static int result; /* 1: linked with -lpthread, 0: only with libc */
 
47
 
 
48
  if (!tested)
 
49
    {
 
50
      pthread_t thread;
 
51
 
 
52
      if (pthread_create (&thread, NULL, dummy_thread_func, NULL) != 0)
 
53
        /* Thread creation failed.  */
 
54
        result = 0;
 
55
      else
 
56
        {
 
57
          /* Thread creation works.  */
 
58
          void *retval;
 
59
          if (pthread_join (thread, &retval) != 0)
 
60
            abort ();
 
61
          result = 1;
 
62
        }
 
63
      tested = 1;
 
64
    }
 
65
  return result;
 
66
}
 
67
 
 
68
# endif
 
69
 
 
70
/* -------------------------- gl_lock_t datatype -------------------------- */
 
71
 
 
72
/* ------------------------- gl_rwlock_t datatype ------------------------- */
 
73
 
 
74
# if HAVE_PTHREAD_RWLOCK
 
75
 
 
76
#  if !defined PTHREAD_RWLOCK_INITIALIZER
 
77
 
 
78
void
 
79
glthread_rwlock_init (gl_rwlock_t *lock)
 
80
{
 
81
  if (pthread_rwlock_init (&lock->rwlock, NULL) != 0)
 
82
    abort ();
 
83
  lock->initialized = 1;
 
84
}
 
85
 
 
86
void
 
87
glthread_rwlock_rdlock (gl_rwlock_t *lock)
 
88
{
 
89
  if (!lock->initialized)
 
90
    {
 
91
      if (pthread_mutex_lock (&lock->guard) != 0)
 
92
        abort ();
 
93
      if (!lock->initialized)
 
94
        glthread_rwlock_init (lock);
 
95
      if (pthread_mutex_unlock (&lock->guard) != 0)
 
96
        abort ();
 
97
    }
 
98
  if (pthread_rwlock_rdlock (&lock->rwlock) != 0)
 
99
    abort ();
 
100
}
 
101
 
 
102
void
 
103
glthread_rwlock_wrlock (gl_rwlock_t *lock)
 
104
{
 
105
  if (!lock->initialized)
 
106
    {
 
107
      if (pthread_mutex_lock (&lock->guard) != 0)
 
108
        abort ();
 
109
      if (!lock->initialized)
 
110
        glthread_rwlock_init (lock);
 
111
      if (pthread_mutex_unlock (&lock->guard) != 0)
 
112
        abort ();
 
113
    }
 
114
  if (pthread_rwlock_wrlock (&lock->rwlock) != 0)
 
115
    abort ();
 
116
}
 
117
 
 
118
void
 
119
glthread_rwlock_unlock (gl_rwlock_t *lock)
 
120
{
 
121
  if (!lock->initialized)
 
122
    abort ();
 
123
  if (pthread_rwlock_unlock (&lock->rwlock) != 0)
 
124
    abort ();
 
125
}
 
126
 
 
127
void
 
128
glthread_rwlock_destroy (gl_rwlock_t *lock)
 
129
{
 
130
  if (!lock->initialized)
 
131
    abort ();
 
132
  if (pthread_rwlock_destroy (&lock->rwlock) != 0)
 
133
    abort ();
 
134
  lock->initialized = 0;
 
135
}
 
136
 
 
137
#  endif
 
138
 
 
139
# else
 
140
 
 
141
void
 
142
glthread_rwlock_init (gl_rwlock_t *lock)
 
143
{
 
144
  if (pthread_mutex_init (&lock->lock, NULL) != 0)
 
145
    abort ();
 
146
  if (pthread_cond_init (&lock->waiting_readers, NULL) != 0)
 
147
    abort ();
 
148
  if (pthread_cond_init (&lock->waiting_writers, NULL) != 0)
 
149
    abort ();
 
150
  lock->waiting_writers_count = 0;
 
151
  lock->runcount = 0;
 
152
}
 
153
 
 
154
void
 
155
glthread_rwlock_rdlock (gl_rwlock_t *lock)
 
156
{
 
157
  if (pthread_mutex_lock (&lock->lock) != 0)
 
158
    abort ();
 
159
  /* Test whether only readers are currently running, and whether the runcount
 
160
     field will not overflow.  */
 
161
  /* POSIX says: "It is implementation-defined whether the calling thread
 
162
     acquires the lock when a writer does not hold the lock and there are
 
163
     writers blocked on the lock."  Let's say, no: give the writers a higher
 
164
     priority.  */
 
165
  while (!(lock->runcount + 1 > 0 && lock->waiting_writers_count == 0))
 
166
    {
 
167
      /* This thread has to wait for a while.  Enqueue it among the
 
168
         waiting_readers.  */
 
169
      if (pthread_cond_wait (&lock->waiting_readers, &lock->lock) != 0)
 
170
        abort ();
 
171
    }
 
172
  lock->runcount++;
 
173
  if (pthread_mutex_unlock (&lock->lock) != 0)
 
174
    abort ();
 
175
}
 
176
 
 
177
void
 
178
glthread_rwlock_wrlock (gl_rwlock_t *lock)
 
179
{
 
180
  if (pthread_mutex_lock (&lock->lock) != 0)
 
181
    abort ();
 
182
  /* Test whether no readers or writers are currently running.  */
 
183
  while (!(lock->runcount == 0))
 
184
    {
 
185
      /* This thread has to wait for a while.  Enqueue it among the
 
186
         waiting_writers.  */
 
187
      lock->waiting_writers_count++;
 
188
      if (pthread_cond_wait (&lock->waiting_writers, &lock->lock) != 0)
 
189
        abort ();
 
190
      lock->waiting_writers_count--;
 
191
    }
 
192
  lock->runcount--; /* runcount becomes -1 */
 
193
  if (pthread_mutex_unlock (&lock->lock) != 0)
 
194
    abort ();
 
195
}
 
196
 
 
197
void
 
198
glthread_rwlock_unlock (gl_rwlock_t *lock)
 
199
{
 
200
  if (pthread_mutex_lock (&lock->lock) != 0)
 
201
    abort ();
 
202
  if (lock->runcount < 0)
 
203
    {
 
204
      /* Drop a writer lock.  */
 
205
      if (!(lock->runcount == -1))
 
206
        abort ();
 
207
      lock->runcount = 0;
 
208
    }
 
209
  else
 
210
    {
 
211
      /* Drop a reader lock.  */
 
212
      if (!(lock->runcount > 0))
 
213
        abort ();
 
214
      lock->runcount--;
 
215
    }
 
216
  if (lock->runcount == 0)
 
217
    {
 
218
      /* POSIX recommends that "write locks shall take precedence over read
 
219
         locks", to avoid "writer starvation".  */
 
220
      if (lock->waiting_writers_count > 0)
 
221
        {
 
222
          /* Wake up one of the waiting writers.  */
 
223
          if (pthread_cond_signal (&lock->waiting_writers) != 0)
 
224
            abort ();
 
225
        }
 
226
      else
 
227
        {
 
228
          /* Wake up all waiting readers.  */
 
229
          if (pthread_cond_broadcast (&lock->waiting_readers) != 0)
 
230
            abort ();
 
231
        }
 
232
    }
 
233
  if (pthread_mutex_unlock (&lock->lock) != 0)
 
234
    abort ();
 
235
}
 
236
 
 
237
void
 
238
glthread_rwlock_destroy (gl_rwlock_t *lock)
 
239
{
 
240
  if (pthread_mutex_destroy (&lock->lock) != 0)
 
241
    abort ();
 
242
  if (pthread_cond_destroy (&lock->waiting_readers) != 0)
 
243
    abort ();
 
244
  if (pthread_cond_destroy (&lock->waiting_writers) != 0)
 
245
    abort ();
 
246
}
 
247
 
 
248
# endif
 
249
 
 
250
/* --------------------- gl_recursive_lock_t datatype --------------------- */
 
251
 
 
252
# if HAVE_PTHREAD_MUTEX_RECURSIVE
 
253
 
 
254
#  if !(defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER || defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
 
255
 
 
256
void
 
257
glthread_recursive_lock_init (gl_recursive_lock_t *lock)
 
258
{
 
259
  pthread_mutexattr_t attributes;
 
260
 
 
261
  if (pthread_mutexattr_init (&attributes) != 0)
 
262
    abort ();
 
263
  if (pthread_mutexattr_settype (&attributes, PTHREAD_MUTEX_RECURSIVE) != 0)
 
264
    abort ();
 
265
  if (pthread_mutex_init (&lock->recmutex, &attributes) != 0)
 
266
    abort ();
 
267
  if (pthread_mutexattr_destroy (&attributes) != 0)
 
268
    abort ();
 
269
  lock->initialized = 1;
 
270
}
 
271
 
 
272
void
 
273
glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
 
274
{
 
275
  if (!lock->initialized)
 
276
    {
 
277
      if (pthread_mutex_lock (&lock->guard) != 0)
 
278
        abort ();
 
279
      if (!lock->initialized)
 
280
        glthread_recursive_lock_init (lock);
 
281
      if (pthread_mutex_unlock (&lock->guard) != 0)
 
282
        abort ();
 
283
    }
 
284
  if (pthread_mutex_lock (&lock->recmutex) != 0)
 
285
    abort ();
 
286
}
 
287
 
 
288
void
 
289
glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
 
290
{
 
291
  if (!lock->initialized)
 
292
    abort ();
 
293
  if (pthread_mutex_unlock (&lock->recmutex) != 0)
 
294
    abort ();
 
295
}
 
296
 
 
297
void
 
298
glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
 
299
{
 
300
  if (!lock->initialized)
 
301
    abort ();
 
302
  if (pthread_mutex_destroy (&lock->recmutex) != 0)
 
303
    abort ();
 
304
  lock->initialized = 0;
 
305
}
 
306
 
 
307
#  endif
 
308
 
 
309
# else
 
310
 
 
311
void
 
312
glthread_recursive_lock_init (gl_recursive_lock_t *lock)
 
313
{
 
314
  if (pthread_mutex_init (&lock->mutex, NULL) != 0)
 
315
    abort ();
 
316
  lock->owner = (pthread_t) 0;
 
317
  lock->depth = 0;
 
318
}
 
319
 
 
320
void
 
321
glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
 
322
{
 
323
  pthread_t self = pthread_self ();
 
324
  if (lock->owner != self)
 
325
    {
 
326
      if (pthread_mutex_lock (&lock->mutex) != 0)
 
327
        abort ();
 
328
      lock->owner = self;
 
329
    }
 
330
  if (++(lock->depth) == 0) /* wraparound? */
 
331
    abort ();
 
332
}
 
333
 
 
334
void
 
335
glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
 
336
{
 
337
  if (lock->owner != pthread_self ())
 
338
    abort ();
 
339
  if (lock->depth == 0)
 
340
    abort ();
 
341
  if (--(lock->depth) == 0)
 
342
    {
 
343
      lock->owner = (pthread_t) 0;
 
344
      if (pthread_mutex_unlock (&lock->mutex) != 0)
 
345
        abort ();
 
346
    }
 
347
}
 
348
 
 
349
void
 
350
glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
 
351
{
 
352
  if (lock->owner != (pthread_t) 0)
 
353
    abort ();
 
354
  if (pthread_mutex_destroy (&lock->mutex) != 0)
 
355
    abort ();
 
356
}
 
357
 
 
358
# endif
 
359
 
 
360
/* -------------------------- gl_once_t datatype -------------------------- */
 
361
 
 
362
static const pthread_once_t fresh_once = PTHREAD_ONCE_INIT;
 
363
 
 
364
int
 
365
glthread_once_singlethreaded (pthread_once_t *once_control)
 
366
{
 
367
  /* We don't know whether pthread_once_t is an integer type, a floating-point
 
368
     type, a pointer type, or a structure type.  */
 
369
  char *firstbyte = (char *)once_control;
 
370
  if (*firstbyte == *(const char *)&fresh_once)
 
371
    {
 
372
      /* First time use of once_control.  Invert the first byte.  */
 
373
      *firstbyte = ~ *(const char *)&fresh_once;
 
374
      return 1;
 
375
    }
 
376
  else
 
377
    return 0;
 
378
}
 
379
 
 
380
#endif
 
381
 
 
382
/* ========================================================================= */
 
383
 
 
384
#if USE_PTH_THREADS
 
385
 
 
386
/* Use the GNU Pth threads library.  */
 
387
 
 
388
/* -------------------------- gl_lock_t datatype -------------------------- */
 
389
 
 
390
/* ------------------------- gl_rwlock_t datatype ------------------------- */
 
391
 
 
392
/* --------------------- gl_recursive_lock_t datatype --------------------- */
 
393
 
 
394
/* -------------------------- gl_once_t datatype -------------------------- */
 
395
 
 
396
void
 
397
glthread_once_call (void *arg)
 
398
{
 
399
  void (**gl_once_temp_addr) (void) = (void (**) (void)) arg;
 
400
  void (*initfunction) (void) = *gl_once_temp_addr;
 
401
  initfunction ();
 
402
}
 
403
 
 
404
int
 
405
glthread_once_singlethreaded (pth_once_t *once_control)
 
406
{
 
407
  /* We know that pth_once_t is an integer type.  */
 
408
  if (*once_control == PTH_ONCE_INIT)
 
409
    {
 
410
      /* First time use of once_control.  Invert the marker.  */
 
411
      *once_control = ~ PTH_ONCE_INIT;
 
412
      return 1;
 
413
    }
 
414
  else
 
415
    return 0;
 
416
}
 
417
 
 
418
#endif
 
419
 
 
420
/* ========================================================================= */
 
421
 
 
422
#if USE_SOLARIS_THREADS
 
423
 
 
424
/* Use the old Solaris threads library.  */
 
425
 
 
426
/* -------------------------- gl_lock_t datatype -------------------------- */
 
427
 
 
428
/* ------------------------- gl_rwlock_t datatype ------------------------- */
 
429
 
 
430
/* --------------------- gl_recursive_lock_t datatype --------------------- */
 
431
 
 
432
void
 
433
glthread_recursive_lock_init (gl_recursive_lock_t *lock)
 
434
{
 
435
  if (mutex_init (&lock->mutex, USYNC_THREAD, NULL) != 0)
 
436
    abort ();
 
437
  lock->owner = (thread_t) 0;
 
438
  lock->depth = 0;
 
439
}
 
440
 
 
441
void
 
442
glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
 
443
{
 
444
  thread_t self = thr_self ();
 
445
  if (lock->owner != self)
 
446
    {
 
447
      if (mutex_lock (&lock->mutex) != 0)
 
448
        abort ();
 
449
      lock->owner = self;
 
450
    }
 
451
  if (++(lock->depth) == 0) /* wraparound? */
 
452
    abort ();
 
453
}
 
454
 
 
455
void
 
456
glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
 
457
{
 
458
  if (lock->owner != thr_self ())
 
459
    abort ();
 
460
  if (lock->depth == 0)
 
461
    abort ();
 
462
  if (--(lock->depth) == 0)
 
463
    {
 
464
      lock->owner = (thread_t) 0;
 
465
      if (mutex_unlock (&lock->mutex) != 0)
 
466
        abort ();
 
467
    }
 
468
}
 
469
 
 
470
void
 
471
glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
 
472
{
 
473
  if (lock->owner != (thread_t) 0)
 
474
    abort ();
 
475
  if (mutex_destroy (&lock->mutex) != 0)
 
476
    abort ();
 
477
}
 
478
 
 
479
/* -------------------------- gl_once_t datatype -------------------------- */
 
480
 
 
481
void
 
482
glthread_once (gl_once_t *once_control, void (*initfunction) (void))
 
483
{
 
484
  if (!once_control->inited)
 
485
    {
 
486
      /* Use the mutex to guarantee that if another thread is already calling
 
487
         the initfunction, this thread waits until it's finished.  */
 
488
      if (mutex_lock (&once_control->mutex) != 0)
 
489
        abort ();
 
490
      if (!once_control->inited)
 
491
        {
 
492
          once_control->inited = 1;
 
493
          initfunction ();
 
494
        }
 
495
      if (mutex_unlock (&once_control->mutex) != 0)
 
496
        abort ();
 
497
    }
 
498
}
 
499
 
 
500
int
 
501
glthread_once_singlethreaded (gl_once_t *once_control)
 
502
{
 
503
  /* We know that gl_once_t contains an integer type.  */
 
504
  if (!once_control->inited)
 
505
    {
 
506
      /* First time use of once_control.  Invert the marker.  */
 
507
      once_control->inited = ~ 0;
 
508
      return 1;
 
509
    }
 
510
  else
 
511
    return 0;
 
512
}
 
513
 
 
514
#endif
 
515
 
 
516
/* ========================================================================= */
 
517
 
 
518
#if USE_WIN32_THREADS
 
519
 
 
520
/* -------------------------- gl_lock_t datatype -------------------------- */
 
521
 
 
522
void
 
523
glthread_lock_init (gl_lock_t *lock)
 
524
{
 
525
  InitializeCriticalSection (&lock->lock);
 
526
  lock->guard.done = 1;
 
527
}
 
528
 
 
529
void
 
530
glthread_lock_lock (gl_lock_t *lock)
 
531
{
 
532
  if (!lock->guard.done)
 
533
    {
 
534
      if (InterlockedIncrement (&lock->guard.started) == 0)
 
535
        /* This thread is the first one to need this lock.  Initialize it.  */
 
536
        glthread_lock_init (lock);
 
537
      else
 
538
        /* Yield the CPU while waiting for another thread to finish
 
539
           initializing this lock.  */
 
540
        while (!lock->guard.done)
 
541
          Sleep (0);
 
542
    }
 
543
  EnterCriticalSection (&lock->lock);
 
544
}
 
545
 
 
546
void
 
547
glthread_lock_unlock (gl_lock_t *lock)
 
548
{
 
549
  if (!lock->guard.done)
 
550
    abort ();
 
551
  LeaveCriticalSection (&lock->lock);
 
552
}
 
553
 
 
554
void
 
555
glthread_lock_destroy (gl_lock_t *lock)
 
556
{
 
557
  if (!lock->guard.done)
 
558
    abort ();
 
559
  DeleteCriticalSection (&lock->lock);
 
560
  lock->guard.done = 0;
 
561
}
 
562
 
 
563
/* ------------------------- gl_rwlock_t datatype ------------------------- */
 
564
 
 
565
static inline void
 
566
gl_waitqueue_init (gl_waitqueue_t *wq)
 
567
{
 
568
  wq->array = NULL;
 
569
  wq->count = 0;
 
570
  wq->alloc = 0;
 
571
  wq->offset = 0;
 
572
}
 
573
 
 
574
/* Enqueues the current thread, represented by an event, in a wait queue.
 
575
   Returns INVALID_HANDLE_VALUE if an allocation failure occurs.  */
 
576
static HANDLE
 
577
gl_waitqueue_add (gl_waitqueue_t *wq)
 
578
{
 
579
  HANDLE event;
 
580
  unsigned int index;
 
581
 
 
582
  if (wq->count == wq->alloc)
 
583
    {
 
584
      unsigned int new_alloc = 2 * wq->alloc + 1;
 
585
      HANDLE *new_array =
 
586
        (HANDLE *) realloc (wq->array, new_alloc * sizeof (HANDLE));
 
587
      if (new_array == NULL)
 
588
        /* No more memory.  */
 
589
        return INVALID_HANDLE_VALUE;
 
590
      /* Now is a good opportunity to rotate the array so that its contents
 
591
         starts at offset 0.  */
 
592
      if (wq->offset > 0)
 
593
        {
 
594
          unsigned int old_count = wq->count;
 
595
          unsigned int old_alloc = wq->alloc;
 
596
          unsigned int old_offset = wq->offset;
 
597
          unsigned int i;
 
598
          if (old_offset + old_count > old_alloc)
 
599
            {
 
600
              unsigned int limit = old_offset + old_count - old_alloc;
 
601
              for (i = 0; i < limit; i++)
 
602
                new_array[old_alloc + i] = new_array[i];
 
603
            }
 
604
          for (i = 0; i < old_count; i++)
 
605
            new_array[i] = new_array[old_offset + i];
 
606
          wq->offset = 0;
 
607
        }
 
608
      wq->array = new_array;
 
609
      wq->alloc = new_alloc;
 
610
    }
 
611
  event = CreateEvent (NULL, TRUE, FALSE, NULL);
 
612
  if (event == INVALID_HANDLE_VALUE)
 
613
    /* No way to allocate an event.  */
 
614
    return INVALID_HANDLE_VALUE;
 
615
  index = wq->offset + wq->count;
 
616
  if (index >= wq->alloc)
 
617
    index -= wq->alloc;
 
618
  wq->array[index] = event;
 
619
  wq->count++;
 
620
  return event;
 
621
}
 
622
 
 
623
/* Notifies the first thread from a wait queue and dequeues it.  */
 
624
static inline void
 
625
gl_waitqueue_notify_first (gl_waitqueue_t *wq)
 
626
{
 
627
  SetEvent (wq->array[wq->offset + 0]);
 
628
  wq->offset++;
 
629
  wq->count--;
 
630
  if (wq->count == 0 || wq->offset == wq->alloc)
 
631
    wq->offset = 0;
 
632
}
 
633
 
 
634
/* Notifies all threads from a wait queue and dequeues them all.  */
 
635
static inline void
 
636
gl_waitqueue_notify_all (gl_waitqueue_t *wq)
 
637
{
 
638
  unsigned int i;
 
639
 
 
640
  for (i = 0; i < wq->count; i++)
 
641
    {
 
642
      unsigned int index = wq->offset + i;
 
643
      if (index >= wq->alloc)
 
644
        index -= wq->alloc;
 
645
      SetEvent (wq->array[index]);
 
646
    }
 
647
  wq->count = 0;
 
648
  wq->offset = 0;
 
649
}
 
650
 
 
651
void
 
652
glthread_rwlock_init (gl_rwlock_t *lock)
 
653
{
 
654
  InitializeCriticalSection (&lock->lock);
 
655
  gl_waitqueue_init (&lock->waiting_readers);
 
656
  gl_waitqueue_init (&lock->waiting_writers);
 
657
  lock->runcount = 0;
 
658
  lock->guard.done = 1;
 
659
}
 
660
 
 
661
void
 
662
glthread_rwlock_rdlock (gl_rwlock_t *lock)
 
663
{
 
664
  if (!lock->guard.done)
 
665
    {
 
666
      if (InterlockedIncrement (&lock->guard.started) == 0)
 
667
        /* This thread is the first one to need this lock.  Initialize it.  */
 
668
        glthread_rwlock_init (lock);
 
669
      else
 
670
        /* Yield the CPU while waiting for another thread to finish
 
671
           initializing this lock.  */
 
672
        while (!lock->guard.done)
 
673
          Sleep (0);
 
674
    }
 
675
  EnterCriticalSection (&lock->lock);
 
676
  /* Test whether only readers are currently running, and whether the runcount
 
677
     field will not overflow.  */
 
678
  if (!(lock->runcount + 1 > 0))
 
679
    {
 
680
      /* This thread has to wait for a while.  Enqueue it among the
 
681
         waiting_readers.  */
 
682
      HANDLE event = gl_waitqueue_add (&lock->waiting_readers);
 
683
      if (event != INVALID_HANDLE_VALUE)
 
684
        {
 
685
          DWORD result;
 
686
          LeaveCriticalSection (&lock->lock);
 
687
          /* Wait until another thread signals this event.  */
 
688
          result = WaitForSingleObject (event, INFINITE);
 
689
          if (result == WAIT_FAILED || result == WAIT_TIMEOUT)
 
690
            abort ();
 
691
          CloseHandle (event);
 
692
          /* The thread which signalled the event already did the bookkeeping:
 
693
             removed us from the waiting_readers, incremented lock->runcount.  */
 
694
          if (!(lock->runcount > 0))
 
695
            abort ();
 
696
          return;
 
697
        }
 
698
      else
 
699
        {
 
700
          /* Allocation failure.  Weird.  */
 
701
          do
 
702
            {
 
703
              LeaveCriticalSection (&lock->lock);
 
704
              Sleep (1);
 
705
              EnterCriticalSection (&lock->lock);
 
706
            }
 
707
          while (!(lock->runcount + 1 > 0));
 
708
        }
 
709
    }
 
710
  lock->runcount++;
 
711
  LeaveCriticalSection (&lock->lock);
 
712
}
 
713
 
 
714
void
 
715
glthread_rwlock_wrlock (gl_rwlock_t *lock)
 
716
{
 
717
  if (!lock->guard.done)
 
718
    {
 
719
      if (InterlockedIncrement (&lock->guard.started) == 0)
 
720
        /* This thread is the first one to need this lock.  Initialize it.  */
 
721
        glthread_rwlock_init (lock);
 
722
      else
 
723
        /* Yield the CPU while waiting for another thread to finish
 
724
           initializing this lock.  */
 
725
        while (!lock->guard.done)
 
726
          Sleep (0);
 
727
    }
 
728
  EnterCriticalSection (&lock->lock);
 
729
  /* Test whether no readers or writers are currently running.  */
 
730
  if (!(lock->runcount == 0))
 
731
    {
 
732
      /* This thread has to wait for a while.  Enqueue it among the
 
733
         waiting_writers.  */
 
734
      HANDLE event = gl_waitqueue_add (&lock->waiting_writers);
 
735
      if (event != INVALID_HANDLE_VALUE)
 
736
        {
 
737
          DWORD result;
 
738
          LeaveCriticalSection (&lock->lock);
 
739
          /* Wait until another thread signals this event.  */
 
740
          result = WaitForSingleObject (event, INFINITE);
 
741
          if (result == WAIT_FAILED || result == WAIT_TIMEOUT)
 
742
            abort ();
 
743
          CloseHandle (event);
 
744
          /* The thread which signalled the event already did the bookkeeping:
 
745
             removed us from the waiting_writers, set lock->runcount = -1.  */
 
746
          if (!(lock->runcount == -1))
 
747
            abort ();
 
748
          return;
 
749
        }
 
750
      else
 
751
        {
 
752
          /* Allocation failure.  Weird.  */
 
753
          do
 
754
            {
 
755
              LeaveCriticalSection (&lock->lock);
 
756
              Sleep (1);
 
757
              EnterCriticalSection (&lock->lock);
 
758
            }
 
759
          while (!(lock->runcount == 0));
 
760
        }
 
761
    }
 
762
  lock->runcount--; /* runcount becomes -1 */
 
763
  LeaveCriticalSection (&lock->lock);
 
764
}
 
765
 
 
766
void
 
767
glthread_rwlock_unlock (gl_rwlock_t *lock)
 
768
{
 
769
  if (!lock->guard.done)
 
770
    abort ();
 
771
  EnterCriticalSection (&lock->lock);
 
772
  if (lock->runcount < 0)
 
773
    {
 
774
      /* Drop a writer lock.  */
 
775
      if (!(lock->runcount == -1))
 
776
        abort ();
 
777
      lock->runcount = 0;
 
778
    }
 
779
  else
 
780
    {
 
781
      /* Drop a reader lock.  */
 
782
      if (!(lock->runcount > 0))
 
783
        abort ();
 
784
      lock->runcount--;
 
785
    }
 
786
  if (lock->runcount == 0)
 
787
    {
 
788
      /* POSIX recommends that "write locks shall take precedence over read
 
789
         locks", to avoid "writer starvation".  */
 
790
      if (lock->waiting_writers.count > 0)
 
791
        {
 
792
          /* Wake up one of the waiting writers.  */
 
793
          lock->runcount--;
 
794
          gl_waitqueue_notify_first (&lock->waiting_writers);
 
795
        }
 
796
      else
 
797
        {
 
798
          /* Wake up all waiting readers.  */
 
799
          lock->runcount += lock->waiting_readers.count;
 
800
          gl_waitqueue_notify_all (&lock->waiting_readers);
 
801
        }
 
802
    }
 
803
  LeaveCriticalSection (&lock->lock);
 
804
}
 
805
 
 
806
void
 
807
glthread_rwlock_destroy (gl_rwlock_t *lock)
 
808
{
 
809
  if (!lock->guard.done)
 
810
    abort ();
 
811
  if (lock->runcount != 0)
 
812
    abort ();
 
813
  DeleteCriticalSection (&lock->lock);
 
814
  if (lock->waiting_readers.array != NULL)
 
815
    free (lock->waiting_readers.array);
 
816
  if (lock->waiting_writers.array != NULL)
 
817
    free (lock->waiting_writers.array);
 
818
  lock->guard.done = 0;
 
819
}
 
820
 
 
821
/* --------------------- gl_recursive_lock_t datatype --------------------- */
 
822
 
 
823
void
 
824
glthread_recursive_lock_init (gl_recursive_lock_t *lock)
 
825
{
 
826
  lock->owner = 0;
 
827
  lock->depth = 0;
 
828
  InitializeCriticalSection (&lock->lock);
 
829
  lock->guard.done = 1;
 
830
}
 
831
 
 
832
void
 
833
glthread_recursive_lock_lock (gl_recursive_lock_t *lock)
 
834
{
 
835
  if (!lock->guard.done)
 
836
    {
 
837
      if (InterlockedIncrement (&lock->guard.started) == 0)
 
838
        /* This thread is the first one to need this lock.  Initialize it.  */
 
839
        glthread_recursive_lock_init (lock);
 
840
      else
 
841
        /* Yield the CPU while waiting for another thread to finish
 
842
           initializing this lock.  */
 
843
        while (!lock->guard.done)
 
844
          Sleep (0);
 
845
    }
 
846
  {
 
847
    DWORD self = GetCurrentThreadId ();
 
848
    if (lock->owner != self)
 
849
      {
 
850
        EnterCriticalSection (&lock->lock);
 
851
        lock->owner = self;
 
852
      }
 
853
    if (++(lock->depth) == 0) /* wraparound? */
 
854
      abort ();
 
855
  }
 
856
}
 
857
 
 
858
void
 
859
glthread_recursive_lock_unlock (gl_recursive_lock_t *lock)
 
860
{
 
861
  if (lock->owner != GetCurrentThreadId ())
 
862
    abort ();
 
863
  if (lock->depth == 0)
 
864
    abort ();
 
865
  if (--(lock->depth) == 0)
 
866
    {
 
867
      lock->owner = 0;
 
868
      LeaveCriticalSection (&lock->lock);
 
869
    }
 
870
}
 
871
 
 
872
void
 
873
glthread_recursive_lock_destroy (gl_recursive_lock_t *lock)
 
874
{
 
875
  if (lock->owner != 0)
 
876
    abort ();
 
877
  DeleteCriticalSection (&lock->lock);
 
878
  lock->guard.done = 0;
 
879
}
 
880
 
 
881
/* -------------------------- gl_once_t datatype -------------------------- */
 
882
 
 
883
void
 
884
glthread_once (gl_once_t *once_control, void (*initfunction) (void))
 
885
{
 
886
  if (once_control->inited <= 0)
 
887
    {
 
888
      if (InterlockedIncrement (&once_control->started) == 0)
 
889
        {
 
890
          /* This thread is the first one to come to this once_control.  */
 
891
          InitializeCriticalSection (&once_control->lock);
 
892
          EnterCriticalSection (&once_control->lock);
 
893
          once_control->inited = 0;
 
894
          initfunction ();
 
895
          once_control->inited = 1;
 
896
          LeaveCriticalSection (&once_control->lock);
 
897
        }
 
898
      else
 
899
        {
 
900
          /* Undo last operation.  */
 
901
          InterlockedDecrement (&once_control->started);
 
902
          /* Some other thread has already started the initialization.
 
903
             Yield the CPU while waiting for the other thread to finish
 
904
             initializing and taking the lock.  */
 
905
          while (once_control->inited < 0)
 
906
            Sleep (0);
 
907
          if (once_control->inited <= 0)
 
908
            {
 
909
              /* Take the lock.  This blocks until the other thread has
 
910
                 finished calling the initfunction.  */
 
911
              EnterCriticalSection (&once_control->lock);
 
912
              LeaveCriticalSection (&once_control->lock);
 
913
              if (!(once_control->inited > 0))
 
914
                abort ();
 
915
            }
 
916
        }
 
917
    }
 
918
}
 
919
 
 
920
#endif
 
921
 
 
922
/* ========================================================================= */