Source/WTF/wtf/Atomics.h

   1 /*
   2  * Copyright (C) 2007-2008, 2010, 2012-2015 Apple Inc. All rights reserved.
   3  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  21  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  23  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef Atomics_h
  27 #define Atomics_h
  28
  29 #include <atomic>
  30 #include <wtf/StdLibExtras.h>
  31
  32 #if OS(WINDOWS)
  33 #if !COMPILER(GCC_OR_CLANG)
  34 extern "C" void _ReadWriteBarrier(void);
  35 #pragma intrinsic(_ReadWriteBarrier)
  36 #endif
  37 #include <windows.h>
  38 #endif
  39
  40 namespace WTF {
  41
  42 // Atomic wraps around std::atomic with the sole purpose of making the compare_exchange
  43 // operations not alter the expected value. This is more in line with how we typically
  44 // use CAS in our code.
  45 //
  46 // Atomic is a struct without explicitly defined constructors so that it can be
  47 // initialized at compile time.
  48
  49 template<typename T>
  50 struct Atomic {
  51     // Don't pass a non-default value for the order parameter unless you really know
  52     // what you are doing and have thought about it very hard. The cost of seq_cst
  53     // is usually not high enough to justify the risk.
  54
  55     T load(std::memory_order order = std::memory_order_seq_cst) const { return value.load(order); }
  56
  57     void store(T desired, std::memory_order order = std::memory_order_seq_cst) { value.store(desired, order); }
  58
  59     bool compareExchangeWeak(T expected, T desired, std::memory_order order = std::memory_order_seq_cst)
  60     {
  61 #if OS(WINDOWS)
  62         // Windows makes strange assertions about the argument to compare_exchange_weak, and anyway,
  63         // Windows is X86 so seq_cst is cheap.
  64         order = std::memory_order_seq_cst;
  65 #endif
  66         T expectedOrActual = expected;
  67         return value.compare_exchange_weak(expectedOrActual, desired, order);
  68     }
  69
  70     bool compareExchangeStrong(T expected, T desired, std::memory_order order = std::memory_order_seq_cst)
  71     {
  72 #if OS(WINDOWS)
  73         // See above.
  74         order = std::memory_order_seq_cst;
  75 #endif
  76         T expectedOrActual = expected;
  77         return value.compare_exchange_strong(expectedOrActual, desired, order);
  78     }
  79
  80     template<typename U>
  81     T exchangeAndAdd(U addend, std::memory_order order = std::memory_order_seq_cst)
  82     {
  83 #if OS(WINDOWS)
  84         // See above.
  85         order = std::memory_order_seq_cst;
  86 #endif
  87         return value.fetch_add(addend, order);
  88     }
  89
  90     T exchange(T newValue, std::memory_order order = std::memory_order_seq_cst)
  91     {
  92 #if OS(WINDOWS)
  93         // See above.
  94         order = std::memory_order_seq_cst;
  95 #endif
  96         return value.exchange(newValue, order);
  97     }
  98
  99     std::atomic<T> value;
 100 };
 101
 102 // This is a weak CAS function that takes a direct pointer and has no portable fencing guarantees.
 103 template<typename T>
 104 inline bool weakCompareAndSwap(volatile T* location, T expected, T newValue)
 105 {
 106     return bitwise_cast<Atomic<T>*>(location)->compareExchangeWeak(expected, newValue, std::memory_order_relaxed);
 107 }
 108
 109 // Just a compiler fence. Has no effect on the hardware, but tells the compiler
 110 // not to move things around this call. Should not affect the compiler's ability
 111 // to do things like register allocation and code motion over pure operations.
 112 inline void compilerFence()
 113 {
 114 #if OS(WINDOWS) && !COMPILER(GCC_OR_CLANG)
 115     _ReadWriteBarrier();
 116 #else
 117     asm volatile("" ::: "memory");
 118 #endif
 119 }
 120
 121 #if CPU(ARM_THUMB2) || CPU(ARM64)
 122
 123 // Full memory fence. No accesses will float above this, and no accesses will sink
 124 // below it.
 125 inline void armV7_dmb()
 126 {
 127     asm volatile("dmb sy" ::: "memory");
 128 }
 129
 130 // Like the above, but only affects stores.
 131 inline void armV7_dmb_st()
 132 {
 133     asm volatile("dmb st" ::: "memory");
 134 }
 135
 136 inline void loadLoadFence() { armV7_dmb(); }
 137 inline void loadStoreFence() { armV7_dmb(); }
 138 inline void storeLoadFence() { armV7_dmb(); }
 139 inline void storeStoreFence() { armV7_dmb_st(); }
 140 inline void memoryBarrierAfterLock() { armV7_dmb(); }
 141 inline void memoryBarrierBeforeUnlock() { armV7_dmb(); }
 142
 143 #elif CPU(X86) || CPU(X86_64)
 144
 145 inline void x86_mfence()
 146 {
 147 #if OS(WINDOWS)
 148     // I think that this does the equivalent of a dummy interlocked instruction,
 149     // instead of using the 'mfence' instruction, at least according to MSDN. I
 150     // know that it is equivalent for our purposes, but it would be good to
 151     // investigate if that is actually better.
 152     MemoryBarrier();
 153 #else
 154     asm volatile("mfence" ::: "memory");
 155 #endif
 156 }
 157
 158 inline void loadLoadFence() { compilerFence(); }
 159 inline void loadStoreFence() { compilerFence(); }
 160 inline void storeLoadFence() { x86_mfence(); }
 161 inline void storeStoreFence() { compilerFence(); }
 162 inline void memoryBarrierAfterLock() { compilerFence(); }
 163 inline void memoryBarrierBeforeUnlock() { compilerFence(); }
 164
 165 #else
 166
 167 inline void loadLoadFence() { compilerFence(); }
 168 inline void loadStoreFence() { compilerFence(); }
 169 inline void storeLoadFence() { compilerFence(); }
 170 inline void storeStoreFence() { compilerFence(); }
 171 inline void memoryBarrierAfterLock() { compilerFence(); }
 172 inline void memoryBarrierBeforeUnlock() { compilerFence(); }
 173
 174 #endif
 175
 176 } // namespace WTF
 177
 178 using WTF::Atomic;
 179
 180 #endif // Atomics_h