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__