X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2Fstress-test%2Fstress-sequential-folly-sync.cpp;fp=folly%2Fstress-test%2Fstress-sequential-folly-sync.cpp;h=8a7a1d1fce2843996ed0c7fcde8de61459534157;hb=bd5752012b2732027df7c0d13f5738029c606810;hp=775252c15b6194f7826f2830e4ed301dbc80109c;hpb=aa07c23de77d0f7a6c34ee6c12ed9c644d1059b5;p=folly.git

diff --git a/folly/stress-test/stress-sequential-folly-sync.cpp b/folly/stress-test/stress-sequential-folly-sync.cpp
index 775252c1..8a7a1d1f 100644
--- a/folly/stress-test/stress-sequential-folly-sync.cpp
+++ b/folly/stress-test/stress-sequential-folly-sync.cpp
@@ -1,157 +1,158 @@
-#include <folly/SmallLocks.h>
-#include <folly/RWSpinLock.h>
-#include <folly/SharedMutex.h>
-#include <folly/synchronization/Rcu.h>
-
-#include <gtest/gtest.h>
-
-#include <memory>
-
-namespace {
-
-// MicroLock
-const size_t kMicroLockPassCount = 2000000000;
-typedef folly::MicroLock MicroLock;
-
-// MicroSpinLock
-const size_t kMicroSpinLockPassCount = 1500000000;
-typedef folly::MicroSpinLock MicroSpinLock;
-
-// PicoSpinLock
-const size_t kPicoSpinLockPassCount = 2700000000;
-typedef folly::PicoSpinLock<size_t> PicoSpinLock;
-
-// SharedMutex
-const size_t kSharedMutexPassCount = 5000000;
-typedef folly::SharedMutexReadPriority SharedMutexReadPriority;
-typedef folly::SharedMutexWritePriority SharedMutexWritePriority;
-
-// RWSpinLock
-const size_t kRWSpinLockPassCount = 5000000;
-typedef folly::RWSpinLock RWSpinLock;
-
-// RWTicketSpinLock
-const size_t kRWTicketSpinLockPassCount = 5000000;
-typedef folly::RWTicketSpinLock32 RWTicketSpinLock32;
-typedef folly::RWTicketSpinLock64 RWTicketSpinLock64;
-
-// RCU
-const size_t kRcuSyncPassCount = 180000;
-const size_t kRcuNoSyncPassCount = 3500000;
-// Represent the RCU-protected data.
-struct RcuFoo {
-  size_t f1;
-  size_t f2;
-};
-
-}
+#include "sync_test.h"
+
+namespace folly_test {
+
+class FollySyncTest_Sequential: public cds_test::stress_fixture {
+protected:
+  // Simulate as the data protected by the lock.
+  static size_t locked_data;
+  // MicroLock
+  static size_t s_nMicroLockPassCount;
+  // MicroSpinLock
+  static size_t s_nMicroSpinLockPassCount;
+  // PicoSpinLock
+  static size_t s_nPicoSpinLockPassCount;
+  // SharedMutex
+  static size_t s_nSharedMutexPassCount;
+  // RWSpinLock
+  static size_t s_nRWSpinLockPassCount;
+  // RWTicketSpinLock
+  static size_t s_nRWTicketSpinLockPassCount;
+  // RCU
+  static size_t s_nRcuSyncPassCount;
+  static size_t s_nRcuNoSyncPassCount;
+
+  static void SetUpTestCase() {
+    const cds_test::config& cfg = get_config("SequentialFollySync");
+    GetConfigNonZeroExpected(MicroLockPassCount, 2000000000);
+    GetConfigNonZeroExpected(MicroSpinLockPassCount, 1500000000);
+    GetConfigNonZeroExpected(PicoSpinLockPassCount, 2700000000);
+    GetConfigNonZeroExpected(SharedMutexPassCount, 5000000);
+    GetConfigNonZeroExpected(RWSpinLockPassCount, 5000000);
+    GetConfigNonZeroExpected(RWTicketSpinLockPassCount, 5000000);
+    GetConfigNonZeroExpected(RcuSyncPassCount, 180000);
+    GetConfigNonZeroExpected(RcuNoSyncPassCount, 3500000);
+  }
 
-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) {
-        if (i < write_percentage) {
-          RcuFoo* f = new RcuFoo();
-          folly::rcu_retire(f);
-          folly::synchronize_rcu();
-        } else {
-          folly::rcu_reader g;
+  static 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) {
+          if (i < write_percentage) {
+            RcuData* data = new RcuData();
+            folly::rcu_retire(data);
+            folly::synchronize_rcu();
+          } else {
+            folly::rcu_reader g;
+          }
         }
       }
     }
   }
-}
 
-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) {
-        if (i < write_percentage) {
-          RcuFoo* f = new RcuFoo();
-          folly::rcu_retire(f);
-        } else {
-          folly::rcu_reader g;
+  static 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) {
+          if (i < write_percentage) {
+            RcuData* data = new RcuData();
+            folly::rcu_retire(data);
+          } else {
+            folly::rcu_reader g;
+          }
         }
       }
     }
   }
-}
 
-template <typename Lock>
-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++) {
-      for (int i = 0; i < 100; ++i) {
-        if (i < write_percentage) {
-          l->lock();
-          l->unlock();
-        } else {
-          l->lock_shared();
-          l->unlock_shared();
+  template <typename Lock>
+  static 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) {
+      locked_data = 0;
+      size_t read_sum = 0;
+      size_t write_lock_cnt = 0;
+      for (size_t count = 0; count < pass_count; count++) {
+        for (int i = 0; i < 100; ++i) {
+          if (i < write_percentage) {
+            write_lock_cnt++;
+            l->lock();
+            locked_data++;
+            l->unlock();
+          } else {
+            l->lock_shared();
+            read_sum = locked_data;
+            l->unlock_shared();
+          }
         }
       }
+      EXPECT_EQ(write_lock_cnt, locked_data);
+      EXPECT_EQ(locked_data, read_sum);
     }
   }
-}
 
-template <typename Lock>
-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();
+  template <typename Lock>
+  static void run_small_lock(size_t pass_count) {
+    std::unique_ptr<Lock> l(new Lock());
+    locked_data = 0;
+    l->init();
+    for (size_t count = 0; count < pass_count; count++) {
+      l->lock();
+      locked_data++;
+      l->unlock();
+    }
+    EXPECT_EQ(locked_data, pass_count);
   }
-}
-
-class FollySyncTest: public ::testing::Test {
-
 };
 
-TEST_F(FollySyncTest, FollyRCU_Sync) {
-  run_rcu_sync(kRcuSyncPassCount);
-}
+size_t FollySyncTest_Sequential::locked_data;
+size_t FollySyncTest_Sequential::s_nMicroLockPassCount;
+size_t FollySyncTest_Sequential::s_nMicroSpinLockPassCount;
+size_t FollySyncTest_Sequential::s_nPicoSpinLockPassCount;
+size_t FollySyncTest_Sequential::s_nSharedMutexPassCount;
+size_t FollySyncTest_Sequential::s_nRWSpinLockPassCount;
+size_t FollySyncTest_Sequential::s_nRWTicketSpinLockPassCount;
+size_t FollySyncTest_Sequential::s_nRcuSyncPassCount;
+size_t FollySyncTest_Sequential::s_nRcuNoSyncPassCount;
 
-TEST_F(FollySyncTest, FollyRCU_NoSync) {
-  run_rcu_no_sync(kRcuNoSyncPassCount);
+TEST_F(FollySyncTest_Sequential, FollyMicroSpinLock) {
+  run_small_lock<MicroSpinLock>(s_nMicroSpinLockPassCount);
 }
 
-TEST_F(FollySyncTest, FollyRWTicketSpinLock_32) {
-  run_rw_lock<RWTicketSpinLock32>(kRWTicketSpinLockPassCount);
+TEST_F(FollySyncTest_Sequential, FollyPicoSpinLock) {
+  run_small_lock<PicoSpinLock>(s_nPicoSpinLockPassCount);
 }
 
-TEST_F(FollySyncTest, FollyRWTicketSpinLock_64) {
-  run_rw_lock<RWTicketSpinLock64>(kRWTicketSpinLockPassCount);
+TEST_F(FollySyncTest_Sequential, FollyMicroLock) {
+  run_small_lock<MicroLock>(s_nMicroLockPassCount);
 }
 
-TEST_F(FollySyncTest, FollyRWSpinLock) {
-  run_rw_lock<RWSpinLock>(kRWSpinLockPassCount);
+TEST_F(FollySyncTest_Sequential, FollyRCU_Sync) {
+  run_rcu_sync(s_nRcuSyncPassCount);
 }
 
-TEST_F(FollySyncTest, FollySharedMutex_ReadPriority) {
-  run_rw_lock<SharedMutexReadPriority>(kSharedMutexPassCount);
+TEST_F(FollySyncTest_Sequential, FollyRCU_NoSync) {
+  run_rcu_no_sync(s_nRcuNoSyncPassCount);
 }
 
-TEST_F(FollySyncTest, FollySharedMutex_WritePriority) {
-  run_rw_lock<SharedMutexWritePriority>(kSharedMutexPassCount);
+TEST_F(FollySyncTest_Sequential, FollyRWTicketSpinLock_32) {
+  run_rw_lock<RWTicketSpinLock32>(s_nRWTicketSpinLockPassCount);
 }
 
-TEST_F(FollySyncTest, FollyMicroSpinLock) {
-  run_small_lock<MicroSpinLock>(kMicroSpinLockPassCount);
+TEST_F(FollySyncTest_Sequential, FollyRWTicketSpinLock_64) {
+  run_rw_lock<RWTicketSpinLock64>(s_nRWTicketSpinLockPassCount);
 }
 
-TEST_F(FollySyncTest, FollyPicoSpinLock) {
-  run_small_lock<PicoSpinLock>(kPicoSpinLockPassCount);
+TEST_F(FollySyncTest_Sequential, FollyRWSpinLock) {
+  run_rw_lock<RWSpinLock>(s_nRWSpinLockPassCount);
 }
 
-TEST_F(FollySyncTest, FollyMicroLock) {
-  run_small_lock<MicroLock>(kMicroLockPassCount);
+TEST_F(FollySyncTest_Sequential, FollySharedMutex_ReadPriority) {
+  run_rw_lock<SharedMutexReadPriority>(s_nSharedMutexPassCount);
 }
 
-int main(int argc, char** argv) {
-  // Init Google test
-  ::testing::InitGoogleTest(&argc, argv);
-  int result = RUN_ALL_TESTS();
-  return result;
+TEST_F(FollySyncTest_Sequential, FollySharedMutex_WritePriority) {
+  run_rw_lock<SharedMutexWritePriority>(s_nSharedMutexPassCount);
 }
+
+} // namespace folly_test