Introduce WTF::releaseStore and WTF::acquireLoad.

Source/wtf/Atomics.h

 /*
  * Copyright (C) 2007, 2008, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 13 matching lines @@
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef Atomics_h
 #define Atomics_h
 
 #include "wtf/Assertions.h"
+#include "wtf/CPU.h"
 
 #include <stdint.h>
 
 #if COMPILER(MSVC)
 #include <windows.h>
 #endif
 
+#if defined(THREAD_SANITIZER)
+#include <sanitizer/tsan_interface_atomic.h>
+#endif
+
 namespace WTF {
 
 #if COMPILER(MSVC)
 
 // atomicAdd returns the result of the addition.
 ALWAYS_INLINE int atomicAdd(int volatile* addend, int increment)
 {
     return InterlockedExchangeAdd(reinterpret_cast<long volatile*>(addend), static_cast<long>(increment)) + increment;
 }
 
@@ skipping 40 matching lines @@
     int ret = __sync_lock_test_and_set(ptr, 1);
     ASSERT(!ret || ret == 1);
     return ret;
 }
 
 ALWAYS_INLINE void atomicSetOneToZero(int volatile* ptr)
 {
     ASSERT(*ptr == 1);
     __sync_lock_release(ptr);
 }
+#endif
+
+#if defined(THREAD_SANITIZER)
+ALWAYS_INLINE void releaseStore(volatile int* ptr, int value)
+{
+    __tsan_atomic32_store(ptr, value, __tsan_memory_order_release);
+}
+
+ALWAYS_INLINE int acquireLoad(volatile const int* ptr)
+{
+    return __tsan_atomic32_load(ptr, __tsan_memory_order_acquire);
+}
+#else
+
+#if CPU(X86) || CPU(X86_64)
+// Only compiler barrier is needed.
+#if COMPILER(MSVC)
+// Starting from Visual Studio 2005 compiler guarantees acquire and release
+// semantics for operations on volatile variables. See MSDN entry for
+// MemoryBarrier macro.
+#define MEMORY_BARRIER()
+#else
+#define MEMORY_BARRIER() __asm__ __volatile__("" : : : "memory")
+#endif
+#elif CPU(ARM) && (OS(LINUX) || OS(ANDROID))
+// On ARM __sync_synchronize generates dmb which is very expensive on single
+// core devices which don't actually need it. Avoid the cost by calling into
+// kuser_memory_barrier helper.
+inline void memoryBarrier()
+{
+    // Note: This is a function call, which is also an implicit compiler barrier.
+    typedef void (*KernelMemoryBarrierFunc)();
+    ((KernelMemoryBarrierFunc)0xffff0fa0)();
+}
+#define MEMORY_BARRIER() memoryBarrier()
+#else
+// Fallback to the compiler intrinsic on all other platforms.
+#define MEMORY_BARRIER() __sync_synchronize()
+#endif
+
+ALWAYS_INLINE void releaseStore(volatile int* ptr, int value)
+{
+    MEMORY_BARRIER();

[wibling-chromium, 2014/03/20 08:05:31]

I don't quite understand this. Wouldn't you normally put the barrier after the
write and before the read? 

As it is now can't you have

Thread0:
MB
store value

Thread1:
read value (but no barrier so reading local thread cached version)
MB

[Dmitry Vyukov, 2014/03/20 09:27:49]

No
There are no per-thread caches for variables.

+    *ptr = value;
+}
+
+ALWAYS_INLINE int acquireLoad(volatile const int* ptr)
+{
+    int value = *ptr;
+    MEMORY_BARRIER();
+    return value;
+}
+
+#undef MEMORY_BARRIER
 
 #endif
 
 } // namespace WTF
 
 using WTF::atomicAdd;
 using WTF::atomicSubtract;
 using WTF::atomicDecrement;
 using WTF::atomicIncrement;
 using WTF::atomicTestAndSetToOne;
 using WTF::atomicSetOneToZero;
+using WTF::acquireLoad;
+using WTF::releaseStore;
 
 #endif // Atomics_h