Split implementation over multiple headers

Author: polytypic

internals/testing/smoke_test.cpp

@@ -24,9 +24,9 @@ auto smoke_test = test([]() {
   {
     atomically([&]() {
       int x = xA;
-      int z = zA;
+      int z = zA.load();
       xA = z;
-      zA = x;
+      zA.store(x);
     });
 
     verify(3 == xA.unsafe_load());
@@ -35,7 +35,7 @@ auto smoke_test = test([]() {
   }
 
   {
-    auto r = atomically([&]() { return xA + 1; });
+    auto r = atomically([&]() { return xA.ref() + 1; });
 
     verify(r == 4);
     verify(3 == xA.unsafe_load());

provides/include/trade_v1/private/access-methods.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "trade_v1/private/access.hpp"
+
+template <class Value>
+void trade_v1::Private::access_t<Value, false>::retain() {
+  new (&m_original) Value(std::move(m_current));
+}
+
+template <class Value>
+void trade_v1::Private::access_t<Value, false>::destroy() {
+  if (INITIAL != m_state) {
+    m_current.~Value();
+    if (READ + WRITTEN == m_state)
+      m_original.~Value();
+  }
+}
+
+template <class Value>
+void trade_v1::Private::access_t<Value, true>::retain() {}
+
+template <class Value>
+void trade_v1::Private::access_t<Value, true>::destroy() {}

provides/include/trade_v1/private/access.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "trade_v1/private/private.hpp"
+
+struct trade_v1::Private::access_base_t {
+  access_base_t *m_children[2];
+  atom_mono_t *m_atom;
+  state_t m_state;
+  lock_ix_t m_lock_ix;
+  destroy_t m_destroy;
+};
+
+template <class Value>
+struct trade_v1::Private::access_t<Value, false> : access_base_t {
+  ~access_t() = delete;
+
+  Value m_current;
+  Value m_original;
+
+  void retain();
+  void destroy();
+};
+
+template <class Value>
+struct trade_v1::Private::access_t<Value, true> : access_base_t {
+  ~access_t() = delete;
+
+  Value m_current;
+
+  void retain();
+  void destroy();
+};

provides/include/trade_v1/private/atom-methods.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "trade_v1/private/atom.hpp"
+
+template <class Value> trade_v1::Private::atom_t<Value>::atom_t() {}
+
+template <class Value>
+trade_v1::Private::atom_t<Value>::atom_t(const Value &value) : m_value(value) {}

provides/include/trade_v1/private/atom.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "trade_v1/private/non_atomic.hpp"
+
+class trade_v1::Private::atom_mono_t {
+  friend class Private;
+};
+
+template <class Value> class trade_v1::Private::atom_t : Private::atom_mono_t {
+  friend class Private;
+  template <class> friend struct trade_v1::atom;
+
+  static constexpr bool is_atomic = !std::is_trivially_copyable_v<Value> ||
+                                    std::atomic<Value>::is_always_lock_free;
+
+  std::conditional_t<is_atomic, std::atomic<Value>, non_atomic_t<Value>>
+      m_value;
+
+  atom_t();
+  atom_t(const Value &value);
+};

provides/include/trade_v1/private/backoff-methods.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "trade_v1/private/backoff.hpp"
+
+#include "trade_v1/config.hpp"
+
+#include "intrinsics_v1/pause.hpp"
+
+#include "dumpster_v1/ranqd1.hpp"
+
+inline trade_v1::Private::backoff_t::backoff_t() : m_count(0) {}
+
+inline void trade_v1::Private::backoff_t::operator()() {
+#if defined(__clang__)
+#pragma unroll 1
+#endif
+  for (auto n = 1 + ((s_seed = dumpster::ranqd1(s_seed)) &
+                     (m_count = 2 * m_count + 1));
+       n;
+       --n)
+    intrinsics::pause();
+}

provides/include/trade_v1/private/backoff.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "trade_v1/private/private.hpp"
+
+struct trade_v1::Private::backoff_t {
+  backoff_t();
+  void operator()();
+  static thread_local uint32_t s_seed;
+  uint8_t m_count;
+};

provides/include/trade_v1/private/lock.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "trade_v1/private/private.hpp"
+
+struct trade_v1::Private::lock_t {
+  std::atomic<clock_t> m_clock;
+  waiter_t *m_first;
+};

provides/include/trade_v1/private/non_atomic-methods.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "trade_v1/private/private.hpp"
+
+template <class Value> trade_v1::Private::non_atomic_t<Value>::non_atomic_t() {}
+
+template <class Value>
+trade_v1::Private::non_atomic_t<Value>::non_atomic_t(const Value &value)
+    : m_value(value) {}
+
+template <class Value>
+void trade_v1::Private::non_atomic_t<Value>::store(const Value &value,
+                                                   std::memory_order) {
+  m_value = value;
+}
+
+template <class Value>
+const Value &
+trade_v1::Private::non_atomic_t<Value>::load(std::memory_order) const {
+  return m_value;
+}

provides/include/trade_v1/private/non_atomic.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "trade_v1/private/private.hpp"
+
+template <class Value> class trade_v1::Private::non_atomic_t {
+  friend class Private;
+
+  non_atomic_t();
+  non_atomic_t(const Value &value);
+
+  void store(const Value &value, std::memory_order = std::memory_order_relaxed);
+  const Value &load(std::memory_order = std::memory_order_relaxed) const;
+
+  Value m_value;
+};