Initial commit

tests/common/folly/TestConcurrentHashMap.cc

@@ -0,0 +1,58 @@
+#include <atomic>
+#include <chrono>
+#include <folly/Random.h>
+#include <folly/concurrency/ConcurrentHashMap.h>
+#include <folly/portability/GTest.h>
+#include <functional>
+#include <thread>
+
+namespace hf3fs::test {
+namespace {
+
+struct Dummy {
+  std::array<uint8_t, 64u> x;
+};
+
+TEST(TestConcurrentHashMap, Normal) {
+  constexpr auto N = 1000000;
+
+  std::atomic<bool> stop = false;
+  std::atomic<uint64_t> readTimes = 0;
+  std::atomic<uint64_t> writeTimes = 0;
+
+  folly::ConcurrentHashMap<uint64_t, Dummy> map;
+  for (auto i = 0; i < N; ++i) {
+    map.insert_or_assign(i, Dummy{});
+  }
+
+  auto start = std::chrono::steady_clock::now();
+  std::jthread writer([&] {
+    while (!stop) {
+      map.insert_or_assign(folly::Random::rand32() % N, Dummy{});
+      ++writeTimes;
+    }
+  });
+
+  std::vector<std::jthread> readers(4);
+  for (auto &reader : readers) {
+    reader = std::jthread([&] {
+      while (!stop) {
+        auto it = map.find(folly::Random::rand32() % N);
+        ++readTimes;
+      }
+    });
+  }
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+  stop = true;
+  writer.join();
+  for (auto &reader : readers) {
+    reader.join();
+  }
+  auto elapsed = std::chrono::steady_clock::now() - start;
+  auto ratio = std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count();
+  fmt::print("OPS: {} read, {} write\n", readTimes.load() * 1000 / ratio, writeTimes.load() * 1000 / ratio);
+}
+
+}  // namespace
+}  // namespace hf3fs::test