WIP Transactional hash_map

Author: polytypic

internals/include/testing/hash_map.hpp

@@ -0,0 +1,73 @@
+#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 KeyEqual = 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 KeyEqual> 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() : m_item_count(0), m_buckets_count(0), m_buckets(nullptr) {}
+
+  size_type size() const {
+    return trade::atomically([&]() { return m_item_count.load(); });
+  }
+
+  bool empty() const {
+    return trade::atomically([&]() { return m_item_count == 0; });
+  }
+
+  void clear() {
+    trade::atomically([&]() {
+      m_item_count = 0;
+      m_buckets_count = 0;
+      m_buckets = nullptr;
+    });
+  }
+
+  void 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());
+    });
+  }
+
+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_type> m_item_count;
+  trade::atom<size_type> m_buckets_count;
+  trade::atom<std::shared_ptr<node[]>> m_buckets;
+};
+
+} // 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);
+});