WIP Transactional hash_map

Author: polytypic

internals/include/testing/hash_map.hpp

@@ -0,0 +1,91 @@
+#pragma once
+
+#include "testing/config.hpp"
+
+#include "trade_v1/trade.hpp"
+
+#include "polyfill_v1/memory.hpp"
+#include <functional>
+#include <utility>
+
+namespace testing {
+
+template <class Key,
+          class Mapped,
+          class Hash = std::hash<Key>,
+          class Equal = std::equal_to<Key>>
+struct hash_map;
+
+class hash_map_private {
+  template <class, class, class, class> friend struct hash_map;
+
+  static size_t next_capacity(size_t capacity);
+};
+
+template <class Key, class Mapped, class Hash, class Equal> struct hash_map {
+  using size_type = size_t;
+
+  using key_type = Key;
+  using mapped_type = Mapped;
+  using value_type = std::pair<const Key, Mapped>;
+
+  hash_map();
+
+  size_t size() const;
+
+  bool empty() const;
+
+  void clear();
+
+  void swap(hash_map &that);
+
+private:
+  struct node {
+    template <class ForwardableKey, class ForwardableMapped>
+    node(ForwardableKey &&key, ForwardableMapped &&value)
+        : m_next(nullptr), m_value(std::forward<ForwardableKey>(key),
+                                   std::forward<ForwardableMapped>(value)) {}
+    trade::atom<std::shared_ptr<node>> m_next;
+    std::pair<const Key, Mapped> m_value;
+  };
+
+  trade::atom<size_t> m_item_count;
+  trade::atom<size_t> m_buckets_count;
+  trade::atom<std::shared_ptr<node[]>> m_buckets;
+};
+
+// -----------------------------------------------------------------------------
+
+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([&]() { 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([&]() { 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());
+  });
+}
+
+} // 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,23 @@
+#include "testing/hash_map.hpp"
+
+#include "polyfill_v1/memory.hpp"
+
+#include "testing_v1/test.hpp"
+
+#include <string>
+
+using namespace testing_v1;
+
+using namespace testing;
+using namespace trade;
+
+auto hash_map_test = test([]() {
+  hash_map<std::string, int> map1;
+  hash_map<std::string, int> map2;
+
+  map1.clear();
+
+  map1.swap(map2);
+
+  verify(map1.size() == 0);
+});