Switch to a Win32 critical section implementation of spinlocks
[WebKit-https.git] / JavaScriptCore / wtf / TCSpinLock.h
1 // Copyright (c) 2005, Google Inc.
2 // All rights reserved.
3 // 
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 // 
8 //     * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 //     * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 //     * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 // 
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30 // ---
31 // Author: Sanjay Ghemawat <opensource@google.com>
32
33 #ifndef TCMALLOC_INTERNAL_SPINLOCK_H__
34 #define TCMALLOC_INTERNAL_SPINLOCK_H__
35
36 #if (PLATFORM(X86) || PLATFORM(PPC)) && COMPILER(GCC)
37
38 #include <time.h>       /* For nanosleep() */
39
40 #include <sched.h>      /* For sched_yield() */
41
42 #if HAVE(STDINT_H)
43 #include <stdint.h>
44 #elif HAVE(INTTYPES_H)
45 #include <inttypes.h>
46 #else
47 #include <sys/types.h>
48 #endif
49 #include <stdlib.h>     /* for abort() */
50
51 static void TCMalloc_SlowLock(volatile unsigned int* lockword);
52
53 // The following is a struct so that it can be initialized at compile time
54 struct TCMalloc_SpinLock {
55   volatile unsigned int private_lockword_;
56
57   inline void Init() { private_lockword_ = 0; }
58   inline void Finalize() { }
59     
60   inline void Lock() {
61     int r;
62 #if PLATFORM(X86)
63     __asm__ __volatile__
64       ("xchgl %0, %1"
65        : "=r"(r), "=m"(private_lockword_)
66        : "0"(1), "m"(private_lockword_)
67        : "memory");
68 #else
69     volatile unsigned int *lockword_ptr = &private_lockword_;
70     __asm__ __volatile__
71         ("1: lwarx %0, 0, %1\n\t"
72          "stwcx. %2, 0, %1\n\t"
73          "bne- 1b\n\t"
74          "isync"
75          : "=&r" (r), "=r" (lockword_ptr)
76          : "r" (1), "1" (lockword_ptr)
77          : "memory");
78 #endif
79     if (r) TCMalloc_SlowLock(&private_lockword_);
80   }
81
82   inline void Unlock() {
83 #if PLATFORM(X86)
84     __asm__ __volatile__
85       ("movl $0, %0"
86        : "=m"(private_lockword_)
87        : "m" (private_lockword_)
88        : "memory");
89 #else
90     __asm__ __volatile__
91       ("isync\n\t"
92        "eieio\n\t"
93        "stw %1, %0"
94        : "=o" (private_lockword_) 
95        : "r" (0)
96        : "memory");
97 #endif
98   }
99
100 #ifdef WTF_CHANGES  
101   inline bool IsLocked() {
102     return private_lockword_ != 0;
103   }
104 #endif
105 };
106
107 #define SPINLOCK_INITIALIZER { 0 }
108
109 static void TCMalloc_SlowLock(volatile unsigned int* lockword) {
110   sched_yield();        // Yield immediately since fast path failed
111   while (true) {
112     int r;
113 #if PLATFORM(X86)
114     __asm__ __volatile__
115       ("xchgl %0, %1"
116        : "=r"(r), "=m"(*lockword)
117        : "0"(1), "m"(*lockword)
118        : "memory");
119
120 #else
121     int tmp = 1;
122     __asm__ __volatile__
123         ("1: lwarx %0, 0, %1\n\t"
124          "stwcx. %2, 0, %1\n\t"
125          "bne- 1b\n\t"
126          "isync"
127          : "=&r" (r), "=r" (lockword)
128          : "r" (tmp), "1" (lockword)
129          : "memory");
130 #endif
131     if (!r) {
132       return;
133     }
134
135     // This code was adapted from the ptmalloc2 implementation of
136     // spinlocks which would sched_yield() upto 50 times before
137     // sleeping once for a few milliseconds.  Mike Burrows suggested
138     // just doing one sched_yield() outside the loop and always
139     // sleeping after that.  This change helped a great deal on the
140     // performance of spinlocks under high contention.  A test program
141     // with 10 threads on a dual Xeon (four virtual processors) went
142     // from taking 30 seconds to 16 seconds.
143
144     // Sleep for a few milliseconds
145     struct timespec tm;
146     tm.tv_sec = 0;
147     tm.tv_nsec = 2000001;
148     nanosleep(&tm, NULL);
149   }
150 }
151
152 #elif COMPILER(MSVC)
153
154 #define WIN32_LEAN_AND_MEAN
155 #include <windows.h>
156
157 struct TCMalloc_SpinLock {
158   CRITICAL_SECTION private_lock_;
159
160   inline TCMalloc_SpinLock() {
161     Init();
162   }
163
164   inline void Init() {
165     InitializeCriticalSection(&private_lock_);
166   }
167   inline void Finalize() {
168     DeleteCriticalSection(&private_lock_);
169   }
170   inline void Lock() {
171     EnterCriticalSection(&private_lock_);
172   }
173   inline void Unlock() {
174     LeaveCriticalSection(&private_lock_);
175   }
176 };
177
178 #else
179
180 #include <pthread.h>
181
182 // Portable version
183 struct TCMalloc_SpinLock {
184   pthread_mutex_t private_lock_;
185
186   inline void Init() {
187     if (pthread_mutex_init(&private_lock_, NULL) != 0) abort();
188   }
189   inline void Finalize() {
190     if (pthread_mutex_destroy(&private_lock_) != 0) abort();
191   }
192   inline void Lock() {
193     if (pthread_mutex_lock(&private_lock_) != 0) abort();
194   }
195   inline void Unlock() {
196     if (pthread_mutex_unlock(&private_lock_) != 0) abort();
197   }
198 };
199
200 #define SPINLOCK_INITIALIZER { PTHREAD_MUTEX_INITIALIZER }
201
202 #endif
203
204 // Corresponding locker object that arranges to acquire a spinlock for
205 // the duration of a C++ scope.
206 class TCMalloc_SpinLockHolder {
207  private:
208   TCMalloc_SpinLock* lock_;
209  public:
210   inline explicit TCMalloc_SpinLockHolder(TCMalloc_SpinLock* l)
211     : lock_(l) { l->Lock(); }
212   inline ~TCMalloc_SpinLockHolder() { lock_->Unlock(); }
213 };
214
215 // Short-hands for convenient use by tcmalloc.cc
216 typedef TCMalloc_SpinLock SpinLock;
217 typedef TCMalloc_SpinLockHolder SpinLockHolder;
218
219 #endif  // TCMALLOC_INTERNAL_SPINLOCK_H__