WIP Transactional hash_map

Author: polytypic

internals/CMakeLists.txt

@@ -1,2 +1,4 @@
-add_conventional_library(testing PUBLIC trade_v1)
+add_conventional_library(testing)
+target_link_libraries(testing PUBLIC trade_v1)
+
 add_conventional_executable_tests(PRIVATE testing trade_v1 testing_v1 std_thread)

internals/include/testing/hash_map.hpp

@@ -0,0 +1,232 @@
+#pragma once
+
+#include "testing/config.hpp"
+
+#include "trade_v1/trade.hpp"
+
+#include "polyfill_v1/memory.hpp"
+#include <functional>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace testing {
+
+template <class Key,
+          class Mapped,
+          class Hash = std::hash<Key>,
+          class Equal = std::equal_to<Key>>
+class hash_map;
+
+class hash_map_private {
+  template <class, class, class, class> friend class hash_map;
+
+  static size_t next_capacity(size_t capacity);
+
+  // This hack is a workaround for not having std::shared_ptr<T[]> support
+  // in AppleClang.
+  template <class T> struct array_hack {
+    void operator delete(void *self) { delete[] reinterpret_cast<T *>(self); }
+    T &at(size_t i) { return reinterpret_cast<T *>(this)[i]; }
+  };
+};
+
+template <class Key, class Mapped, class Hash, class Equal>
+class hash_map : hash_map_private {
+  struct node_t;
+
+  using link = trade::atom<std::shared_ptr<node_t>>;
+
+  trade::atom<size_t> m_item_count;
+  trade::atom<size_t> m_buckets_count;
+  trade::atom<std::shared_ptr<array_hack<link>>> m_buckets;
+
+public:
+  using size_type = size_t;
+
+  using key_type = Key;
+  using mapped_type = Mapped;
+
+  hash_map();
+
+  size_t size() const;
+
+  bool empty() const;
+
+  void clear();
+
+  void swap(hash_map &that);
+
+  template <class ForwardableMapped, class Config = trade::stack_t<1024>>
+  bool add_or_set(const Key &key,
+                  ForwardableMapped &&mapped,
+                  Config config = trade::stack<1024>);
+
+  std::optional<Mapped> try_get(const Key &key) const;
+
+  bool remove(const Key &key);
+
+  std::string to_debug_string() const;
+};
+
+// -----------------------------------------------------------------------------
+
+template <class Key, class Mapped, class Hash, class Equal>
+struct hash_map<Key, Mapped, Hash, Equal>::node_t {
+  template <class ForwardableKey, class ForwardableMapped>
+  node_t(ForwardableKey &&key, ForwardableMapped &&value)
+      : m_next(nullptr), m_key(std::forward<ForwardableKey>(key)),
+        m_mapped(std::forward<ForwardableMapped>(value)) {}
+  link m_next;
+  const Key m_key;
+  trade::atom<Mapped> m_mapped;
+};
+
+//
+
+template <class Key, class Mapped, class Hash, class Equal>
+hash_map<Key, Mapped, Hash, Equal>::hash_map()
+    : m_item_count(0), m_buckets_count(0), m_buckets(nullptr) {}
+
+template <class Key, class Mapped, class Hash, class Equal>
+size_t hash_map<Key, Mapped, Hash, Equal>::size() const {
+  return trade::atomically(trade::assume_readonly,
+                           [&]() { return m_item_count.load(); });
+}
+
+template <class Key, class Mapped, class Hash, class Equal>
+bool hash_map<Key, Mapped, Hash, Equal>::empty() const {
+  return trade::atomically(trade::assume_readonly,
+                           [&]() { return m_item_count == 0; });
+}
+
+template <class Key, class Mapped, class Hash, class Equal>
+void hash_map<Key, Mapped, Hash, Equal>::clear() {
+  trade::atomically([&]() {
+    m_item_count = 0;
+    m_buckets_count = 0;
+    m_buckets = nullptr;
+  });
+}
+
+template <class Key, class Mapped, class Hash, class Equal>
+void hash_map<Key, Mapped, Hash, Equal>::swap(hash_map &that) {
+  trade::atomically([&]() {
+    std::swap(m_item_count.ref(), that.m_item_count.ref());
+    std::swap(m_buckets_count.ref(), that.m_buckets_count.ref());
+    std::swap(m_buckets.ref(), that.m_buckets.ref());
+  });
+}
+
+template <class Key, class Mapped, class Hash, class Equal>
+template <class ForwardableMapped, class Config>
+bool hash_map<Key, Mapped, Hash, Equal>::add_or_set(const Key &key,
+                                                    ForwardableMapped &&mapped,
+                                                    Config config) {
+  auto key_hash = Hash()(key);
+
+  return trade::atomically(config, [&]() {
+    auto item_count = m_item_count.load();
+    auto buckets_count = m_buckets_count.load();
+    auto buckets = m_buckets.load();
+
+    if (buckets_count <= item_count) {
+      auto old_buckets = std::move(buckets);
+      auto old_buckets_count = buckets_count;
+
+      m_buckets_count = buckets_count = next_capacity(old_buckets_count);
+      m_buckets = buckets = std::shared_ptr<array_hack<link>>(
+          reinterpret_cast<array_hack<link> *>(new link[buckets_count]));
+
+      for (size_t i = 0; i < old_buckets_count; ++i) {
+        auto work = old_buckets->at(i).load();
+        while (work) {
+          auto &ref_next = work->m_next.ref();
+          auto &ref_bucket =
+              buckets->at(Hash()(work->m_key) % buckets_count).ref();
+          auto next = std::move(ref_next);
+          ref_next = std::move(ref_bucket);
+          ref_bucket = std::move(work);
+          work = std::move(next);
+        }
+      }
+    }
+
+    auto prev = &buckets->at(key_hash % buckets_count);
+    while (true) {
+      if (auto node = prev->load()) {
+        if (Equal()(node->m_key, key)) {
+          node->m_mapped = std::forward<ForwardableMapped>(mapped);
+          return false;
+        } else {
+          prev = &node->m_next;
+        }
+      } else {
+        prev->ref().reset(
+            new node_t(key, std::forward<ForwardableMapped>(mapped)));
+        m_item_count = item_count + 1;
+        return true;
+      }
+    }
+  });
+}
+
+template <class Key, class Mapped, class Hash, class Equal>
+std::optional<Mapped>
+hash_map<Key, Mapped, Hash, Equal>::try_get(const Key &key) const {
+  auto key_hash = Hash()(key);
+  return trade::atomically(
+      trade::assume_readonly, [&]() -> std::optional<Mapped> {
+        if (auto buckets_count = m_buckets_count.load())
+          for (auto node =
+                   m_buckets.load()->at(key_hash % buckets_count).load();
+               node;
+               node = node->m_next)
+            if (Equal()(node->m_key, key))
+              return node->m_mapped.load();
+        return std::nullopt;
+      });
+}
+
+template <class Key, class Mapped, class Hash, class Equal>
+bool hash_map<Key, Mapped, Hash, Equal>::remove(const Key &key) {
+  auto key_hash = Hash()(key);
+  return trade::atomically([&]() {
+    if (auto buckets_count = m_buckets_count.load()) {
+      auto prev = &m_buckets.load()->at(key_hash % buckets_count);
+      while (true) {
+        auto node = prev->load();
+        if (!node)
+          break;
+        if (Equal()(node->m_key, key)) {
+          *prev = node->m_next;
+          return true;
+        }
+        prev = &node->m_next;
+      }
+    }
+    return false;
+  });
+}
+
+template <class Key, class Mapped, class Hash, class Equal>
+std::string hash_map<Key, Mapped, Hash, Equal>::to_debug_string() const {
+  std::string result;
+  trade::atomically(trade::assume_readonly, [&]() {
+    result.clear();
+    for (size_t i = 0, n = m_buckets_count; i < n; ++i) {
+      result += "bucket[" + std::to_string(i) + "]";
+      auto node = m_buckets.load()->at(i).load();
+      while (node) {
+        result += " -> [" + std::to_string(node->m_key) + ", " +
+                  std::to_string(node->m_mapped) + "]";
+
+        node = node->m_next;
+      }
+      result += " -> null\n";
+    }
+  });
+  return result;
+}
+
+} // namespace testing

internals/library/hash_map.cpp

@@ -0,0 +1,16 @@
+#include "testing/hash_map.hpp"
+
+static const size_t s_capacities[] = {
+    3,        7,         13,        31,        61,        127,
+    251,      509,       1021,      2039,      4093,      8191,
+    16381,    32749,     65521,     131071,    262139,    524287,
+    1048573,  2097143,   4194301,   8388593,   16777213,  33554393,
+    67108859, 134217689, 268435399, 536870909, 1073741789};
+
+size_t testing::hash_map_private::next_capacity(size_t capacity) {
+  size_t n = sizeof(s_capacities) / sizeof(*s_capacities);
+  for (size_t i = 0; i < n; ++i)
+    if (capacity < s_capacities[i])
+      return s_capacities[i];
+  return capacity;
+}

internals/testing/hash_map_test.cpp

@@ -0,0 +1,50 @@
+#include "testing/hash_map.hpp"
+
+#include "testing_v1/test.hpp"
+
+#include "dumpster_v1/ranqd1.hpp"
+
+#include "polyfill_v1/memory.hpp"
+#include <thread>
+
+using namespace testing_v1;
+
+using namespace testing;
+using namespace trade;
+
+auto hash_map_test = test([]() {
+  const size_t n_threads = std::thread::hardware_concurrency();
+  const size_t n_ops = 100000;
+  const uint32_t max_keys = 31;
+
+  hash_map<uint32_t, size_t> map;
+
+  atom<size_t> done(0);
+
+  for (size_t t = 0; t < n_threads; ++t)
+    std::thread([&, t]() {
+      auto s = static_cast<uint32_t>(t);
+
+      for (size_t i = 0; i < n_ops; ++i) {
+        uint32_t key = (s = dumpster::ranqd1(s)) % max_keys;
+        map.add_or_set(key, t, trade::stack<8192>);
+      }
+
+      atomically([&]() { done.ref() += 1; });
+    }).detach();
+
+  atomically(assume_readonly, [&]() {
+    if (done != n_threads)
+      retry();
+  });
+
+  verify(map.size() == max_keys);
+
+  {
+    hash_map<uint32_t, size_t> other;
+    map.swap(other);
+    verify(other.size() == max_keys);
+    verify(map.size() == 0);
+    other.clear();
+  }
+});

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

@@ -25,8 +25,9 @@ void trade_v1::Private::destroy(clock_t t, access_base_t *access_base) {
         signal(first);
       lock.m_clock.store(t, std::memory_order_release);
     }
+  } else {
+    access->destroy();
   }
-  access->destroy();
 }
 
 template <class Value>

provides/library/trade.cpp

@@ -411,5 +411,8 @@ bool trade_v1::Private::try_commit(transaction_base_t *transaction) {
   for (auto it = writes.m_children[1]; it; it = it->m_children[1])
     it->m_destroy(u, it);
 
+  for (auto it = writes.m_children[1]; it; it = it->m_children[1])
+    it->m_destroy(0, it);
+
   return true;
 }