folly/synchronization/AtomicStruct.h

   1 /*
   2  * Copyright 2013-present Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #pragma once
  18
  19 #include <atomic>
  20 #include <cstddef>
  21 #include <cstdint>
  22 #include <cstring>
  23 #include <type_traits>
  24
  25 #include <folly/ConstexprMath.h>
  26 #include <folly/Traits.h>
  27 #include <folly/synchronization/detail/AtomicUtils.h>
  28
  29 namespace folly {
  30
  31 namespace detail {
  32 template <size_t>
  33 struct AtomicStructRaw;
  34 template <>
  35 struct AtomicStructRaw<0> {
  36   using type = uint8_t;
  37 };
  38 template <>
  39 struct AtomicStructRaw<1> {
  40   using type = uint16_t;
  41 };
  42 template <>
  43 struct AtomicStructRaw<2> {
  44   using type = uint32_t;
  45 };
  46 template <>
  47 struct AtomicStructRaw<3> {
  48   using type = uint64_t;
  49 };
  50 } // namespace detail
  51
  52 /// AtomicStruct<T> work like C++ atomics, but can be used on any POD
  53 /// type <= 8 bytes.
  54 template <typename T, template <typename> class Atom = std::atomic>
  55 class AtomicStruct {
  56  private:
  57   using Raw = _t<detail::AtomicStructRaw<constexpr_log2_ceil(sizeof(T))>>;
  58
  59   static_assert(alignof(T) <= alignof(Raw), "underlying type is under-aligned");
  60   static_assert(sizeof(T) <= sizeof(Raw), "underlying type is under-sized");
  61   static_assert(
  62       std::is_trivial<T>::value || folly::IsTriviallyCopyable<T>::value,
  63       "target type must be trivially copyable");
  64
  65   Atom<Raw> data;
  66
  67   static Raw encode(T v) noexcept {
  68     // we expect the compiler to optimize away the memcpy, but without
  69     // it we would violate strict aliasing rules
  70     Raw d = 0;
  71     memcpy(&d, &v, sizeof(T));
  72     return d;
  73   }
  74
  75   static T decode(Raw d) noexcept {
  76     T v;
  77     memcpy(&v, &d, sizeof(T));
  78     return v;
  79   }
  80
  81  public:
  82   AtomicStruct() = default;
  83   ~AtomicStruct() = default;
  84   AtomicStruct(AtomicStruct<T> const &) = delete;
  85   AtomicStruct<T>& operator= (AtomicStruct<T> const &) = delete;
  86
  87   constexpr /* implicit */ AtomicStruct(T v) noexcept : data(encode(v)) {}
  88
  89   bool is_lock_free() const noexcept {
  90     return data.is_lock_free();
  91   }
  92
  93   bool compare_exchange_strong(
  94       T& v0,
  95       T v1,
  96       std::memory_order mo = std::memory_order_seq_cst) noexcept {
  97     return compare_exchange_strong(
  98         v0, v1, mo, detail::default_failure_memory_order(mo));
  99   }
 100   bool compare_exchange_strong(
 101       T& v0,
 102       T v1,
 103       std::memory_order success,
 104       std::memory_order failure) noexcept {
 105     Raw d0 = encode(v0);
 106     bool rv = data.compare_exchange_strong(d0, encode(v1), success, failure);
 107     if (!rv) {
 108       v0 = decode(d0);
 109     }
 110     return rv;
 111   }
 112
 113   bool compare_exchange_weak(
 114       T& v0,
 115       T v1,
 116       std::memory_order mo = std::memory_order_seq_cst) noexcept {
 117     return compare_exchange_weak(
 118         v0, v1, mo, detail::default_failure_memory_order(mo));
 119   }
 120   bool compare_exchange_weak(
 121       T& v0,
 122       T v1,
 123       std::memory_order success,
 124       std::memory_order failure) noexcept {
 125     Raw d0 = encode(v0);
 126     bool rv = data.compare_exchange_weak(d0, encode(v1), success, failure);
 127     if (!rv) {
 128       v0 = decode(d0);
 129     }
 130     return rv;
 131   }
 132
 133   T exchange(T v, std::memory_order mo = std::memory_order_seq_cst) noexcept {
 134     return decode(data.exchange(encode(v), mo));
 135   }
 136
 137   /* implicit */ operator T () const noexcept {
 138     return decode(data);
 139   }
 140
 141   T load(std::memory_order mo = std::memory_order_seq_cst) const noexcept {
 142     return decode(data.load(mo));
 143   }
 144
 145   T operator= (T v) noexcept {
 146     return decode(data = encode(v));
 147   }
 148
 149   void store(T v, std::memory_order mo = std::memory_order_seq_cst) noexcept {
 150     data.store(encode(v), mo);
 151   }
 152
 153   // std::atomic also provides volatile versions of all of the access
 154   // methods.  These are callable on volatile objects, and also can
 155   // theoretically have different implementations than their non-volatile
 156   // counterpart.  If someone wants them here they can easily be added
 157   // by duplicating the above code and the corresponding unit tests.
 158 };
 159
 160 } // namespace folly