527dfaec49cfd7c0a6b2b187f87275d5f4ea5077
[WebKit-https.git] / JavaScriptCore / wtf / TCSpinLock.h
1 // Copyright (c) 2005, 2006, 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) || COMPILER(MSVC))
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 #if COMPILER(MSVC)
52 #define WIN32_LEAN_AND_MEAN
53 #include <windows.h>
54 #endif
55
56 static void TCMalloc_SlowLock(volatile unsigned int* lockword);
57
58 // The following is a struct so that it can be initialized at compile time
59 struct TCMalloc_SpinLock {
60
61   inline void Lock() {
62     int r;
63 #if COMPILER(GCC)
64 #if PLATFORM(X86)
65     __asm__ __volatile__
66       ("xchgl %0, %1"
67        : "=r"(r), "=m"(lockword_)
68        : "0"(1), "m"(lockword_)
69        : "memory");
70 #else
71     volatile unsigned int *lockword_ptr = &lockword_;
72     __asm__ __volatile__
73         ("1: lwarx %0, 0, %1\n\t"
74          "stwcx. %2, 0, %1\n\t"
75          "bne- 1b\n\t"
76          "isync"
77          : "=&r" (r), "=r" (lockword_ptr)
78          : "r" (1), "1" (lockword_ptr)
79          : "memory");
80 #endif
81 #elif COMPILER(MSVC)
82     __asm {
83         mov eax, this    ; store &lockword_ (which is this+0) in eax
84         mov ebx, 1       ; store 1 in ebx
85         xchg [eax], ebx  ; exchange lockword_ and 1
86         mov r, ebx       ; store old value of lockword_ in r
87     }
88 #endif
89     if (r) TCMalloc_SlowLock(&lockword_);
90   }
91
92   inline void Unlock() {
93 #if COMPILER(GCC)
94 #if PLATFORM(X86)
95     __asm__ __volatile__
96       ("movl $0, %0"
97        : "=m"(lockword_)
98        : "m" (lockword_)
99        : "memory");
100 #else
101     __asm__ __volatile__
102       ("isync\n\t"
103        "eieio\n\t"
104        "stw %1, %0"
105 #if PLATFORM(DARWIN)
106        : "=o" (lockword_)
107 #else
108        : "=m" (lockword_) 
109 #endif
110        : "r" (0)
111        : "memory");
112 #endif
113 #elif COMPILER(MSVC)
114       __asm {
115           mov eax, this  ; store &lockword_ (which is this+0) in eax
116           mov [eax], 0   ; set lockword_ to 0
117       }
118 #endif
119   }
120     // Report if we think the lock can be held by this thread.
121     // When the lock is truly held by the invoking thread
122     // we will always return true.
123     // Indended to be used as CHECK(lock.IsHeld());
124     inline bool IsHeld() const {
125         return lockword_ != 0;
126     }
127
128     inline void Init() { lockword_ = 0; }
129
130     volatile unsigned int lockword_;
131 };
132
133 #define SPINLOCK_INITIALIZER { 0 }
134
135 static void TCMalloc_SlowLock(volatile unsigned int* lockword) {
136   sched_yield();        // Yield immediately since fast path failed
137   while (true) {
138     int r;
139 #if COMPILER(GCC)
140 #if PLATFORM(X86)
141     __asm__ __volatile__
142       ("xchgl %0, %1"
143        : "=r"(r), "=m"(*lockword)
144        : "0"(1), "m"(*lockword)
145        : "memory");
146
147 #else
148     int tmp = 1;
149     __asm__ __volatile__
150         ("1: lwarx %0, 0, %1\n\t"
151          "stwcx. %2, 0, %1\n\t"
152          "bne- 1b\n\t"
153          "isync"
154          : "=&r" (r), "=r" (lockword)
155          : "r" (tmp), "1" (lockword)
156          : "memory");
157 #endif
158 #elif COMPILER(MSVC)
159     __asm {
160         mov eax, lockword     ; assign lockword into eax
161         mov ebx, 1            ; assign 1 into ebx
162         xchg [eax], ebx       ; exchange *lockword and 1
163         mov r, ebx            ; store old value of *lockword in r
164     }
165 #endif
166     if (!r) {
167       return;
168     }
169
170     // This code was adapted from the ptmalloc2 implementation of
171     // spinlocks which would sched_yield() upto 50 times before
172     // sleeping once for a few milliseconds.  Mike Burrows suggested
173     // just doing one sched_yield() outside the loop and always
174     // sleeping after that.  This change helped a great deal on the
175     // performance of spinlocks under high contention.  A test program
176     // with 10 threads on a dual Xeon (four virtual processors) went
177     // from taking 30 seconds to 16 seconds.
178
179     // Sleep for a few milliseconds
180 #if COMPILER(MSVC)
181     Sleep(2);
182 #else
183     struct timespec tm;
184     tm.tv_sec = 0;
185     tm.tv_nsec = 2000001;
186     nanosleep(&tm, NULL);
187 #endif
188   }
189 }
190
191 #else
192
193 #include <pthread.h>
194
195 // Portable version
196 struct TCMalloc_SpinLock {
197   pthread_mutex_t private_lock_;
198
199   inline void Init() {
200     if (pthread_mutex_init(&private_lock_, NULL) != 0) abort();
201   }
202   inline void Finalize() {
203     if (pthread_mutex_destroy(&private_lock_) != 0) abort();
204   }
205   inline void Lock() {
206     if (pthread_mutex_lock(&private_lock_) != 0) abort();
207   }
208   inline void Unlock() {
209     if (pthread_mutex_unlock(&private_lock_) != 0) abort();
210   }
211 };
212
213 #define SPINLOCK_INITIALIZER { PTHREAD_MUTEX_INITIALIZER }
214
215 #endif
216
217 // Corresponding locker object that arranges to acquire a spinlock for
218 // the duration of a C++ scope.
219 class TCMalloc_SpinLockHolder {
220  private:
221   TCMalloc_SpinLock* lock_;
222  public:
223   inline explicit TCMalloc_SpinLockHolder(TCMalloc_SpinLock* l)
224     : lock_(l) { l->Lock(); }
225   inline ~TCMalloc_SpinLockHolder() { lock_->Unlock(); }
226 };
227
228 // Short-hands for convenient use by tcmalloc.cc
229 typedef TCMalloc_SpinLock SpinLock;
230 typedef TCMalloc_SpinLockHolder SpinLockHolder;
231
232 #endif  // TCMALLOC_INTERNAL_SPINLOCK_H__