Spinlock helper function.
[kopensolaris-gnu/glibc.git] / linuxthreads / spinlock.c
1 /* Linuxthreads - a simple clone()-based implementation of Posix        */
2 /* threads for Linux.                                                   */
3 /* Copyright (C) 1998 Xavier Leroy (Xavier.Leroy@inria.fr)              */
4 /*                                                                      */
5 /* This program is free software; you can redistribute it and/or        */
6 /* modify it under the terms of the GNU Library General Public License  */
7 /* as published by the Free Software Foundation; either version 2       */
8 /* of the License, or (at your option) any later version.               */
9 /*                                                                      */
10 /* This program is distributed in the hope that it will be useful,      */
11 /* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
12 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
13 /* GNU Library General Public License for more details.                 */
14
15 /* Spin locks */
16
17 #include <sched.h>
18 #include <time.h>
19 #include "pthread.h"
20 #include "internals.h"
21 #include "spinlock.h"
22
23 /* This function is called if the inlined test-and-set in acquire() failed */
24
25 /* The retry strategy is as follows:
26    - We test and set the spinlock MAX_SPIN_COUNT times, calling
27      sched_yield() each time.  This gives ample opportunity for other
28      threads with priority >= our priority to make progress and
29      release the spinlock.
30    - If a thread with priority < our priority owns the spinlock,
31      calling sched_yield() repeatedly is useless, since we're preventing
32      the owning thread from making progress and releasing the spinlock.
33      So, after MAX_SPIN_LOCK attemps, we suspend the calling thread
34      using nanosleep().  This again should give time to the owning thread
35      for releasing the spinlock.
36      Notice that the nanosleep() interval must not be too small,
37      since the kernel does busy-waiting for short intervals in a realtime
38      process (!).  The smallest duration that guarantees thread
39      suspension is currently 2ms.
40    - When nanosleep() returns, we try again, doing MAX_SPIN_COUNT
41      sched_yield(), then sleeping again if needed. */
42
43 void __pthread_acquire(int * spinlock)
44 {
45   int cnt = 0;
46   struct timespec tm;
47
48   while (testandset(spinlock)) {
49     if (cnt < MAX_SPIN_COUNT) {
50       sched_yield();
51       cnt++;
52     } else {
53       tm.tv_sec = 0;
54       tm.tv_nsec = SPIN_SLEEP_DURATION;
55       nanosleep(&tm, NULL);
56       cnt = 0;
57     }
58   }
59 }