Changeset 120356 in webkit

Timestamp:

Jun 14, 2012 1:18:23 PM (12 years ago)

Author:

ggaren@apple.com

Message:

ARMv7 should support spinlocks
​https://bugs.webkit.org/show_bug.cgi?id=88957

Reviewed by Darin Adler.

More info @ ​http://infocenter.arm.com/help/topic/
com.arm.doc.genc007826/Barrier_Litmus_Tests_and_Cookbook_A08.pdf

• wtf/Atomics.h:

(WTF::memoryBarrierAfterLock):
(WTF::memoryBarrierBeforeUnlock): Added memory barrier primitives since
ARMv7 has a weakly ordered memory model.

• wtf/Platform.h: Enabled compare-and-swap on Windows so our spinlock

implementation would continue working on Windows.

• wtf/TCSpinLock.h:

(TCMalloc_SpinLock::Lock):
(TCMalloc_SpinLock::Unlock):
(TCMalloc_SpinLock): Use our compare-and-swap helper function to avoid
rewriting it in assembly here.

Added memory barriers since ARMv7 needs them.

Removed PPC support because our helper function doesn't support PPC.

Location:

trunk/Source/WTF

Files:

• ChangeLog (modified) (1 diff)
• wtf/Atomics.h (modified) (1 diff)
• wtf/Platform.h (modified) (1 diff)
• wtf/TCSpinLock.h (modified) (2 diffs)

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2012-06-14  Geoffrey Garen  <ggaren@apple.com>
+
+        ARMv7 should support spinlocks
+        https://bugs.webkit.org/show_bug.cgi?id=88957
+
+        Reviewed by Darin Adler.
+
+        More info @ http://infocenter.arm.com/help/topic/
+        com.arm.doc.genc007826/Barrier_Litmus_Tests_and_Cookbook_A08.pdf
+
+        * wtf/Atomics.h:
+        (WTF::memoryBarrierAfterLock):
+        (WTF::memoryBarrierBeforeUnlock): Added memory barrier primitives since
+        ARMv7 has a weakly ordered memory model.
+
+        * wtf/Platform.h: Enabled compare-and-swap on Windows so our spinlock
+        implementation would continue working on Windows.
+
+        * wtf/TCSpinLock.h:
+        (TCMalloc_SpinLock::Lock):
+        (TCMalloc_SpinLock::Unlock):
+        (TCMalloc_SpinLock): Use our compare-and-swap helper function to avoid
+        rewriting it in assembly here.
+
+        Added memory barriers since ARMv7 needs them.
+
+        Removed PPC support because our helper function doesn't support PPC.
+
 2012-06-13  Arnaud Renevier  <arno@renevier.net>
 

trunk/Source/WTF/wtf/Atomics.h

@@ -207 +207 @@
 }
 
+#if CPU(ARM_THUMB2)
+
+inline void memoryBarrierAfterLock()
+{
+    asm volatile("dmb" ::: "memory");
+}
+
+inline void memoryBarrierBeforeUnlock()
+{
+    asm volatile("dmb" ::: "memory");
+}
+
+#else
+
+inline void memoryBarrierAfterLock() { }
+inline void memoryBarrierBeforeUnlock() { }
+
+#endif
+
 } // namespace WTF
 

trunk/Source/WTF/wtf/Platform.h

@@ -1069 +1069 @@
 #endif
 
-#if !defined(ENABLE_COMPARE_AND_SWAP) && COMPILER(GCC) && (CPU(X86) || CPU(X86_64) || CPU(ARM_THUMB2))
+#if !defined(ENABLE_COMPARE_AND_SWAP) && (OS(WINDOWS) || (COMPILER(GCC) && (CPU(X86) || CPU(X86_64) || CPU(ARM_THUMB2))))
 #define ENABLE_COMPARE_AND_SWAP 1
 #endif

trunk/Source/WTF/wtf/TCSpinLock.h

@@ -35 +35 @@
 #define TCMALLOC_INTERNAL_SPINLOCK_H__
 
-#if (CPU(X86) || CPU(X86_64) || CPU(PPC)) && (COMPILER(GCC) || COMPILER(MSVC))
-
-#include <stdint.h>
-#include <time.h>       /* For nanosleep() */
-
-#if OS(WINDOWS)
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#else
-#include <sched.h>      /* For sched_yield() */
+#include <wtf/Atomics.h>
+#if OS(UNIX)
+#include <sched.h>
 #endif
 
-static void TCMalloc_SlowLock(volatile unsigned int* lockword);
+#if ENABLE(COMPARE_AND_SWAP)
+
+static void TCMalloc_SlowLock(unsigned* lockword);
 
 // The following is a struct so that it can be initialized at compile time
 struct TCMalloc_SpinLock {
+    void Lock() {
+      if (!WTF::weakCompareAndSwap(&lockword_, 0, 1))
+        TCMalloc_SlowLock(&lockword_);
+      WTF::memoryBarrierAfterLock();
+    }
 
-  inline void Lock() {
-    int r;
-#if COMPILER(GCC)
-#if CPU(X86) || CPU(X86_64)
-    __asm__ __volatile__
-      ("xchgl %0, %1"
-       : "=r"(r), "=m"(lockword_)
-       : "0"(1), "m"(lockword_)
-       : "memory");
-#else
-    volatile unsigned int *lockword_ptr = &lockword_;
-    __asm__ __volatile__
-        ("1: lwarx %0, 0, %1\n\t"
-         "stwcx. %2, 0, %1\n\t"
-         "bne- 1b\n\t"
-         "isync"
-         : "=&r" (r), "=r" (lockword_ptr)
-         : "r" (1), "1" (lockword_ptr)
-         : "memory");
-#endif
-#elif COMPILER(MSVC)
-    __asm {
-        mov eax, this    ; store &lockword_ (which is this+0) in eax
-        mov ebx, 1       ; store 1 in ebx
-        xchg [eax], ebx  ; exchange lockword_ and 1
-        mov r, ebx       ; store old value of lockword_ in r
+    void Unlock() {
+      WTF::memoryBarrierBeforeUnlock();
+      lockword_ = 0;
     }
-#endif
-    if (r) TCMalloc_SlowLock(&lockword_);
-  }
 
-  inline void Unlock() {
-#if COMPILER(GCC)
-#if CPU(X86) || CPU(X86_64)
-    __asm__ __volatile__
-      ("movl $0, %0"
-       : "=m"(lockword_)
-       : "m" (lockword_)
-       : "memory");
-#else
-    __asm__ __volatile__
-      ("isync\n\t"
-       "eieio\n\t"
-       "stw %1, %0"
-#if OS(DARWIN) || CPU(PPC)
-       : "=o" (lockword_)
-#else
-       : "=m" (lockword_) 
-#endif
-       : "r" (0)
-       : "memory");
-#endif
-#elif COMPILER(MSVC)
-      __asm {
-          mov eax, this  ; store &lockword_ (which is this+0) in eax
-          mov [eax], 0   ; set lockword_ to 0
-      }
-#endif
-  }
     // Report if we think the lock can be held by this thread.
     // When the lock is truly held by the invoking thread
     // we will always return true.
     // Indended to be used as CHECK(lock.IsHeld());
-    inline bool IsHeld() const {
+    bool IsHeld() const {
         return lockword_ != 0;
     }
 
-    inline void Init() { lockword_ = 0; }
-    inline void Finalize() { }
+    void Init() { lockword_ = 0; }
+    void Finalize() { }
 
-    volatile unsigned int lockword_;
+    unsigned lockword_;
 };
 
 #define SPINLOCK_INITIALIZER { 0 }
 
-static void TCMalloc_SlowLock(volatile unsigned int* lockword) {
-  while (true) {
-    // Yield immediately since fast path failed
+static void TCMalloc_SlowLock(unsigned* lockword) {
+  do {
 #if OS(WINDOWS)
     Sleep(0);
@@ -137 +80 @@
     sched_yield();
 #endif
-
-    int r;
-#if COMPILER(GCC)
-#if CPU(X86) || CPU(X86_64)
-    __asm__ __volatile__
-      ("xchgl %0, %1"
-       : "=r"(r), "=m"(*lockword)
-       : "0"(1), "m"(*lockword)
-       : "memory");
-
-#else
-    int tmp = 1;
-    __asm__ __volatile__
-        ("1: lwarx %0, 0, %1\n\t"
-         "stwcx. %2, 0, %1\n\t"
-         "bne- 1b\n\t"
-         "isync"
-         : "=&r" (r), "=r" (lockword)
-         : "r" (tmp), "1" (lockword)
-         : "memory");
-#endif
-#elif COMPILER(MSVC)
-    __asm {
-        mov eax, lockword     ; assign lockword into eax
-        mov ebx, 1            ; assign 1 into ebx
-        xchg [eax], ebx       ; exchange *lockword and 1
-        mov r, ebx            ; store old value of *lockword in r
-    }
-#endif
-    if (!r) {
-      return;
-    }
-  }
-}
-
-#elif OS(WINDOWS)
-
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-
-static void TCMalloc_SlowLock(LPLONG lockword);
-
-// The following is a struct so that it can be initialized at compile time
-struct TCMalloc_SpinLock {
-
-    inline void Lock() {
-        if (InterlockedExchange(&m_lockword, 1))
-            TCMalloc_SlowLock(&m_lockword);
-    }
-
-    inline void Unlock() {
-        InterlockedExchange(&m_lockword, 0);
-    }
-
-    inline bool IsHeld() const {
-        return m_lockword != 0;
-    }
-
-    inline void Init() { m_lockword = 0; }
-    inline void Finalize() { }
-
-    LONG m_lockword;
-};
-
-#define SPINLOCK_INITIALIZER { 0 }
-
-static void TCMalloc_SlowLock(LPLONG lockword) {
-    Sleep(0);        // Yield immediately since fast path failed
-    while (InterlockedExchange(lockword, 1))
-        Sleep(2);
+  } while (!WTF::weakCompareAndSwap(lockword, 0, 1));
 }