base/atomicops_internals_portable.h

   1 // Copyright (c) 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file is an internal atomic implementation, use atomicops.h instead.
   6 //
   7 // This implementation uses C++11 atomics' member functions. The code base is
   8 // currently written assuming atomicity revolves around accesses instead of
   9 // C++11's memory locations. The burden is on the programmer to ensure that all
  10 // memory locations accessed atomically are never accessed non-atomically (tsan
  11 // should help with this).
  12 //
  13 // TODO(jfb) Modify the atomicops.h API and user code to declare atomic
  14 //           locations as truly atomic. See the static_assert below.
  15 //
  16 // Of note in this implementation:
  17 //  * All NoBarrier variants are implemented as relaxed.
  18 //  * All Barrier variants are implemented as sequentially-consistent.
  19 //  * Compare exchange's failure ordering is always the same as the success one
  20 //    (except for release, which fails as relaxed): using a weaker ordering is
  21 //    only valid under certain uses of compare exchange.
  22 //  * Acquire store doesn't exist in the C11 memory model, it is instead
  23 //    implemented as a relaxed store followed by a sequentially consistent
  24 //    fence.
  25 //  * Release load doesn't exist in the C11 memory model, it is instead
  26 //    implemented as sequentially consistent fence followed by a relaxed load.
  27 //  * Atomic increment is expected to return the post-incremented value, whereas
  28 //    C11 fetch add returns the previous value. The implementation therefore
  29 //    needs to increment twice (which the compiler should be able to detect and
  30 //    optimize).
  31
  32 #ifndef BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
  33 #define BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
  34
  35 #include <atomic>
  36
  37 #include "build/build_config.h"
  38
  39 namespace base {
  40 namespace subtle {
  41
  42 // This implementation is transitional and maintains the original API for
  43 // atomicops.h. This requires casting memory locations to the atomic types, and
  44 // assumes that the API and the C++11 implementation are layout-compatible,
  45 // which isn't true for all implementations or hardware platforms. The static
  46 // assertion should detect this issue, were it to fire then this header
  47 // shouldn't be used.
  48 //
  49 // TODO(jfb) If this header manages to stay committed then the API should be
  50 //           modified, and all call sites updated.
  51 typedef volatile std::atomic<Atomic32>* AtomicLocation32;
  52 static_assert(sizeof(*(AtomicLocation32) nullptr) == sizeof(Atomic32),
  53               "incompatible 32-bit atomic layout");
  54
  55 inline void MemoryBarrier() {
  56 #if defined(__GLIBCXX__)
  57   // Work around libstdc++ bug 51038 where atomic_thread_fence was declared but
  58   // not defined, leading to the linker complaining about undefined references.
  59   __atomic_thread_fence(std::memory_order_seq_cst);
  60 #else
  61   std::atomic_thread_fence(std::memory_order_seq_cst);
  62 #endif
  63 }
  64
  65 inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
  66                                          Atomic32 old_value,
  67                                          Atomic32 new_value) {
  68   ((AtomicLocation32)ptr)
  69       ->compare_exchange_strong(old_value,
  70                                 new_value,
  71                                 std::memory_order_relaxed,
  72                                 std::memory_order_relaxed);
  73   return old_value;
  74 }
  75
  76 inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
  77                                          Atomic32 new_value) {
  78   return ((AtomicLocation32)ptr)
  79       ->exchange(new_value, std::memory_order_relaxed);
  80 }
  81
  82 inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
  83                                           Atomic32 increment) {
  84   return increment +
  85          ((AtomicLocation32)ptr)
  86              ->fetch_add(increment, std::memory_order_relaxed);
  87 }
  88
  89 inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
  90                                         Atomic32 increment) {
  91   return increment + ((AtomicLocation32)ptr)->fetch_add(increment);
  92 }
  93
  94 inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
  95                                        Atomic32 old_value,
  96                                        Atomic32 new_value) {
  97   ((AtomicLocation32)ptr)
  98       ->compare_exchange_strong(old_value,
  99                                 new_value,
 100                                 std::memory_order_acquire,
 101                                 std::memory_order_acquire);
 102   return old_value;
 103 }
 104
 105 inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
 106                                        Atomic32 old_value,
 107                                        Atomic32 new_value) {
 108   ((AtomicLocation32)ptr)
 109       ->compare_exchange_strong(old_value,
 110                                 new_value,
 111                                 std::memory_order_release,
 112                                 std::memory_order_relaxed);
 113   return old_value;
 114 }
 115
 116 inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
 117   ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
 118 }
 119
 120 inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
 121   ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
 122   MemoryBarrier();
 123 }
 124
 125 inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
 126   ((AtomicLocation32)ptr)->store(value, std::memory_order_release);
 127 }
 128
 129 inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
 130   return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
 131 }
 132
 133 inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
 134   return ((AtomicLocation32)ptr)->load(std::memory_order_acquire);
 135 }
 136
 137 inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
 138   MemoryBarrier();
 139   return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
 140 }
 141
 142 #if defined(ARCH_CPU_64_BITS)
 143
 144 typedef volatile std::atomic<Atomic64>* AtomicLocation64;
 145 static_assert(sizeof(*(AtomicLocation64) nullptr) == sizeof(Atomic64),
 146               "incompatible 64-bit atomic layout");
 147
 148 inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
 149                                          Atomic64 old_value,
 150                                          Atomic64 new_value) {
 151   ((AtomicLocation64)ptr)
 152       ->compare_exchange_strong(old_value,
 153                                 new_value,
 154                                 std::memory_order_relaxed,
 155                                 std::memory_order_relaxed);
 156   return old_value;
 157 }
 158
 159 inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
 160                                          Atomic64 new_value) {
 161   return ((AtomicLocation64)ptr)
 162       ->exchange(new_value, std::memory_order_relaxed);
 163 }
 164
 165 inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
 166                                           Atomic64 increment) {
 167   return increment +
 168          ((AtomicLocation64)ptr)
 169              ->fetch_add(increment, std::memory_order_relaxed);
 170 }
 171
 172 inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
 173                                         Atomic64 increment) {
 174   return increment + ((AtomicLocation64)ptr)->fetch_add(increment);
 175 }
 176
 177 inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
 178                                        Atomic64 old_value,
 179                                        Atomic64 new_value) {
 180   ((AtomicLocation64)ptr)
 181       ->compare_exchange_strong(old_value,
 182                                 new_value,
 183                                 std::memory_order_acquire,
 184                                 std::memory_order_acquire);
 185   return old_value;
 186 }
 187
 188 inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
 189                                        Atomic64 old_value,
 190                                        Atomic64 new_value) {
 191   ((AtomicLocation64)ptr)
 192       ->compare_exchange_strong(old_value,
 193                                 new_value,
 194                                 std::memory_order_release,
 195                                 std::memory_order_relaxed);
 196   return old_value;
 197 }
 198
 199 inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
 200   ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
 201 }
 202
 203 inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
 204   ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
 205   MemoryBarrier();
 206 }
 207
 208 inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
 209   ((AtomicLocation64)ptr)->store(value, std::memory_order_release);
 210 }
 211
 212 inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
 213   return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
 214 }
 215
 216 inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
 217   return ((AtomicLocation64)ptr)->load(std::memory_order_acquire);
 218 }
 219
 220 inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
 221   MemoryBarrier();
 222   return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
 223 }
 224
 225 #endif  // defined(ARCH_CPU_64_BITS)
 226 }  // namespace subtle
 227 }  // namespace base
 228
 229 #endif  // BASE_ATOMICOPS_INTERNALS_PORTABLE_H_