Initial commit

tests/common/utils/TestLockManager.cc

@@ -0,0 +1,136 @@
+#include <chrono>
+#include <folly/experimental/coro/BlockingWait.h>
+#include <folly/logging/xlog.h>
+#include <mutex>
+#include <thread>
+
+#include "common/utils/LockManager.h"
+#include "tests/GtestHelpers.h"
+
+namespace hf3fs::test {
+namespace {
+
+using namespace std::chrono_literals;
+
+TEST(TestLockManager, Normal) {
+  UniqueLockManager lockManager;
+
+  auto lock1 = lockManager.lock(123);
+  auto lock2 = lockManager.lock(std::string{"yes"});
+
+  auto lock3 = lockManager.try_lock(124);
+  ASSERT_TRUE(lock3.owns_lock());
+
+  auto lock4 = lockManager.try_lock(123);
+  ASSERT_FALSE(lock4.owns_lock());
+
+  lock1.unlock();
+
+  auto lock5 = lockManager.try_lock(123);
+  ASSERT_TRUE(lock5.owns_lock());
+
+  auto lock6 = lockManager.try_lock(std::string{"yes"});
+  ASSERT_FALSE(lock6.owns_lock());
+}
+
+TEST(TestLockManager, SharedLock) {
+  SharedLockManager lockManager;
+
+  auto lock = lockManager.lock_shared(123);
+  std::jthread([&] { auto anotherLock = lockManager.lock_shared(123); });
+}
+
+TEST(TestLockManager, FairSharedLock) {
+  SharedLockManager lockManager;
+
+  std::jthread read1([&] {
+    // 0ms
+    auto start = std::chrono::steady_clock::now();
+    auto lock = lockManager.lock_shared(1);
+    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start);
+    XLOGF(INFO, "read1 lock wait {}ms", elapsed.count());
+    std::this_thread::sleep_for(100ms);
+
+    // 100ms
+    std::this_thread::sleep_for(100ms);
+
+    // 200ms
+    std::this_thread::sleep_for(100ms);
+
+    // 300ms
+    lock.unlock();
+    std::this_thread::sleep_for(100ms);
+
+    // 400ms
+    lock.lock();
+    std::this_thread::sleep_for(100ms);
+
+    // 500ms
+    std::this_thread::sleep_for(100ms);
+
+    // 600ms
+  });
+
+  std::jthread read2([&] {
+    // 0ms
+    std::this_thread::sleep_for(100ms);
+
+    // 100ms
+    std::this_thread::sleep_for(100ms);
+
+    // 200ms
+    auto start = std::chrono::steady_clock::now();
+    auto lock = lockManager.lock_shared(1);
+    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start);
+    XLOGF(INFO, "read2 lock wait {}ms", elapsed.count());
+    std::this_thread::sleep_for(100ms);
+
+    // 300ms
+    std::this_thread::sleep_for(100ms);
+
+    // 400ms
+    std::this_thread::sleep_for(100ms);
+
+    // 500ms
+    lock.unlock();
+  });
+
+  std::jthread write([&] {
+    // 0ms
+    std::this_thread::sleep_for(100ms);
+
+    // 100ms
+    auto start = std::chrono::steady_clock::now();
+    auto lock = lockManager.lock(1);
+    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start);
+    XLOGF(INFO, "write lock wait {}ms", elapsed.count());
+
+    ASSERT_NEAR(elapsed.count(), 200, 50);
+  });
+}
+
+TEST(TestLockManager, CoMutex) {
+  CoUniqueLockManager lockManager;
+
+  folly::coro::blockingWait([&]() -> folly::coro::Task<void> {
+    auto lock1 = co_await lockManager.co_scoped_lock(123);
+    auto lock2 = co_await lockManager.co_scoped_lock(std::string{"yes"});
+
+    auto lock3 = lockManager.try_lock(124);
+    CO_ASSERT_TRUE(lock3.owns_lock());
+
+    auto lock4 = lockManager.try_lock(123);
+    CO_ASSERT_FALSE(lock4.owns_lock());
+
+    lock1.unlock();
+
+    auto lock5 = lockManager.try_lock(123);
+    CO_ASSERT_TRUE(lock5.owns_lock());
+
+    auto lock6 = lockManager.try_lock(std::string{"yes"});
+    CO_ASSERT_FALSE(lock6.owns_lock());
+  }());
+}
+
+}  // namespace
+}  // namespace hf3fs::test