Refactors folly test cases to use gtest

[folly.git] / folly / stress-test / stress-sequential-folly-sync.cpp

diff --git a/folly/stress-test/stress-sequential-folly-sync.cpp b/folly/stress-test/stress-sequential-folly-sync.cpp
index dbedef056312569483becf42445c344aaeaef8b3..775252c15b6194f7826f2830e4ed301dbc80109c 100644 (file)
--- a/folly/stress-test/stress-sequential-folly-sync.cpp
+++ b/folly/stress-test/stress-sequential-folly-sync.cpp
@@ -3,56 +3,41 @@
 #include <folly/SharedMutex.h>
 #include <folly/synchronization/Rcu.h>
 
-#include <chrono>
-#include <cassert>
-#include <iostream>
+#include <gtest/gtest.h>
+
 #include <memory>
 
 namespace {
 
-const char* kTestName = "LockUnlock";
-
 // MicroLock
 const size_t kMicroLockPassCount = 2000000000;
-const char* kMicroLockBenchmarkName = "FollyMicroLock";
 typedef folly::MicroLock MicroLock;
 
 // MicroSpinLock
 const size_t kMicroSpinLockPassCount = 1500000000;
-const char* kMicroSpinLockBenchmarkName = "FollyMicroSpinLock";
 typedef folly::MicroSpinLock MicroSpinLock;
 
 // PicoSpinLock
 const size_t kPicoSpinLockPassCount = 2700000000;
-const char* kPicoSpinLockBenchmarkName = "FollyPicoSpinLock";
 typedef folly::PicoSpinLock<size_t> PicoSpinLock;
 
 // SharedMutex
 const size_t kSharedMutexPassCount = 5000000;
-const char* kSharedMutexReadPriorityBenchmarkName =
-    "FollySharedMutex_ReadPriority";
-const char* kSharedMutexWritePriorityBenchmarkName =
-    "FollySharedMutex_WritePriority";
 typedef folly::SharedMutexReadPriority SharedMutexReadPriority;
 typedef folly::SharedMutexWritePriority SharedMutexWritePriority;
 
 // RWSpinLock
 const size_t kRWSpinLockPassCount = 5000000;
-const char* kRWSpinLockBenchmarkName = "FollyRWSpinLock";
 typedef folly::RWSpinLock RWSpinLock;
 
 // RWTicketSpinLock
 const size_t kRWTicketSpinLockPassCount = 5000000;
-const char* kRWTicketSpinLock32BenchmarkName = "FollyRWTicketSpinLock_32";
-const char* kRWTicketSpinLock64BenchmarkName = "FollyRWTicketSpinLock_64";
 typedef folly::RWTicketSpinLock32 RWTicketSpinLock32;
 typedef folly::RWTicketSpinLock64 RWTicketSpinLock64;
 
 // RCU
 const size_t kRcuSyncPassCount = 180000;
 const size_t kRcuNoSyncPassCount = 3500000;
-const char* kRcuSyncBenchmarkName = "FollyRCU_Sync";
-const char* kRcuNoSyncBenchmarkName = "FollyRCU_NoSync";
 // Represent the RCU-protected data.
 struct RcuFoo {
   size_t f1;
@@ -61,10 +46,7 @@ struct RcuFoo {
 
 }
 
-void run_rcu_sync(size_t pass_count, const char* bench_name) {
-  std::cout << "[ RUN      ] " << kTestName << "." << bench_name << std::endl;
-  auto start_time = std::chrono::system_clock::now();
-
+void run_rcu_sync(size_t pass_count) {
   for (int write_percentage = 1; write_percentage <= 5; write_percentage += 1) {
     for (size_t count = 0; count < pass_count; count++) {
       for (int i = 0; i < 100; ++i) {
@@ -78,18 +60,9 @@ void run_rcu_sync(size_t pass_count, const char* bench_name) {
       }
     }
   }
-
-  auto finish_time = std::chrono::system_clock::now();
-  auto dur = finish_time - start_time;
-  auto milisecs = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
-  std::cout << "[       OK ] " << kTestName << "." << bench_name
-            << " (" << milisecs.count() << " ms)" << std::endl;
 }
 
-void run_rcu_no_sync(size_t pass_count, const char* bench_name) {
-  std::cout << "[ RUN      ] " << kTestName << "." << bench_name << std::endl;
-  auto start_time = std::chrono::system_clock::now();
-
+void run_rcu_no_sync(size_t pass_count) {
   for (int write_percentage = 1; write_percentage <= 5; write_percentage += 1) {
     for (size_t count = 0; count < pass_count; count++) {
       for (int i = 0; i < 100; ++i) {
@@ -102,19 +75,10 @@ void run_rcu_no_sync(size_t pass_count, const char* bench_name) {
       }
     }
   }
-
-  auto finish_time = std::chrono::system_clock::now();
-  auto dur = finish_time - start_time;
-  auto milisecs = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
-  std::cout << "[       OK ] " << kTestName << "." << bench_name
-            << " (" << milisecs.count() << " ms)" << std::endl;
 }
 
 template <typename Lock>
-void run_rw_lock(size_t pass_count, const char* bench_name) {
-  std::cout << "[ RUN      ] " << kTestName << "." << bench_name << std::endl;
-  auto start_time = std::chrono::system_clock::now();
-
+void run_rw_lock(size_t pass_count) {
   std::unique_ptr<Lock> l(new Lock());
   for (int write_percentage = 5; write_percentage < 20; write_percentage += 5) {
     for (size_t count = 0; count < pass_count; count++) {
@@ -129,57 +93,65 @@ void run_rw_lock(size_t pass_count, const char* bench_name) {
       }
     }
   }
-
-  auto finish_time = std::chrono::system_clock::now();
-  auto dur = finish_time - start_time;
-  auto milisecs = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
-  std::cout << "[       OK ] " << kTestName << "." << bench_name
-            << " (" << milisecs.count() << " ms)" << std::endl;
 }
 
 template <typename Lock>
-void run_small_lock(Lock* l, size_t pass_count, const char* bench_name) {
-    std::cout << "[ RUN      ] " << kTestName << "." << bench_name << std::endl;
-    auto start_time = std::chrono::system_clock::now();
+void run_small_lock(size_t pass_count) {
+  std::unique_ptr<Lock> l(new Lock());
+  l->init();
+  for (size_t count = 0; count < pass_count; count++) {
+    l->lock();
+    l->unlock();
+  }
+}
 
-    for (size_t count = 0; count < pass_count; count++) {
-      l->lock();
-      l->unlock();
-    }
-    auto finish_time = std::chrono::system_clock::now();
-    auto dur = finish_time - start_time;
-    auto milisecs = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
-    std::cout << "[       OK ] " << kTestName << "." << bench_name
-              << " (" << milisecs.count() << " ms)" << std::endl;
+class FollySyncTest: public ::testing::Test {
+
+};
+
+TEST_F(FollySyncTest, FollyRCU_Sync) {
+  run_rcu_sync(kRcuSyncPassCount);
 }
 
-template <typename Lock>
-void init_run_lock(size_t pass_count, const char* bench_name) {
-  std::unique_ptr<Lock> l(new Lock());
-  l->init();
-  run_small_lock<Lock>(l.get(), pass_count, bench_name);
+TEST_F(FollySyncTest, FollyRCU_NoSync) {
+  run_rcu_no_sync(kRcuNoSyncPassCount);
+}
+
+TEST_F(FollySyncTest, FollyRWTicketSpinLock_32) {
+  run_rw_lock<RWTicketSpinLock32>(kRWTicketSpinLockPassCount);
+}
+
+TEST_F(FollySyncTest, FollyRWTicketSpinLock_64) {
+  run_rw_lock<RWTicketSpinLock64>(kRWTicketSpinLockPassCount);
 }
 
-int main() {
-  run_rcu_sync(kRcuSyncPassCount, kRcuSyncBenchmarkName);
-  run_rcu_no_sync(kRcuNoSyncPassCount, kRcuNoSyncBenchmarkName);
+TEST_F(FollySyncTest, FollyRWSpinLock) {
+  run_rw_lock<RWSpinLock>(kRWSpinLockPassCount);
+}
+
+TEST_F(FollySyncTest, FollySharedMutex_ReadPriority) {
+  run_rw_lock<SharedMutexReadPriority>(kSharedMutexPassCount);
+}
+
+TEST_F(FollySyncTest, FollySharedMutex_WritePriority) {
+  run_rw_lock<SharedMutexWritePriority>(kSharedMutexPassCount);
+}
 
-  run_rw_lock<RWTicketSpinLock32>(kRWTicketSpinLockPassCount,
-                                  kRWTicketSpinLock32BenchmarkName);
-  run_rw_lock<RWTicketSpinLock64>(kRWTicketSpinLockPassCount,
-                                  kRWTicketSpinLock64BenchmarkName);
+TEST_F(FollySyncTest, FollyMicroSpinLock) {
+  run_small_lock<MicroSpinLock>(kMicroSpinLockPassCount);
+}
 
-  run_rw_lock<RWSpinLock>(kRWSpinLockPassCount, kRWSpinLockBenchmarkName);
+TEST_F(FollySyncTest, FollyPicoSpinLock) {
+  run_small_lock<PicoSpinLock>(kPicoSpinLockPassCount);
+}
 
-  run_rw_lock<SharedMutexReadPriority>(
-      kSharedMutexPassCount, kSharedMutexReadPriorityBenchmarkName);
-  run_rw_lock<SharedMutexWritePriority>(
-      kSharedMutexPassCount, kSharedMutexWritePriorityBenchmarkName);
+TEST_F(FollySyncTest, FollyMicroLock) {
+  run_small_lock<MicroLock>(kMicroLockPassCount);
+}
 
-  init_run_lock<MicroSpinLock>(kMicroSpinLockPassCount,
-                               kMicroSpinLockBenchmarkName);
-  init_run_lock<PicoSpinLock>(kPicoSpinLockPassCount,
-                              kPicoSpinLockBenchmarkName);
-  init_run_lock<MicroLock>(kMicroLockPassCount, kMicroLockBenchmarkName);
-  return 0;
+int main(int argc, char** argv) {
+  // Init Google test
+  ::testing::InitGoogleTest(&argc, argv);
+  int result = RUN_ALL_TESTS();
+  return result;
 }