-#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;
+ static std::atomic<RcuData*> rcu_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 size_t s_nRcuReaderOnlyPassCount;
+
+ 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);
+ GetConfigNonZeroExpected(RcuReaderOnlyPassCount, 3000000);
+
+ // Initialize the RCU protected data.
+ rcu_data.store(new RcuData(), std::memory_order_relaxed);
+ }
-void run_rcu_sync(size_t pass_count) {
- for (int write_percentage = 1; write_percentage <= 5; write_percentage += 1) {
+ static void run_rcu_reader_only(size_t pass_count) {
+ size_t sum = 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;
+ folly::rcu_reader g;
+ auto *data = rcu_data.load(std::memory_order_consume);
+ sum += (data->d1 + data->d2);
+ }
+ EXPECT_EQ(sum, 1);
+ }
+
+ static void run_rcu_sync(size_t pass_count) {
+ for (int write_percentage = 1; write_percentage <= 5; write_percentage += 1) {
+ size_t sum = 0;
+ for (size_t count = 0; count < pass_count; count++) {
+ for (int i = 0; i < 100; ++i) {
+ if (i < write_percentage) {
+ auto* old_data = rcu_data.load(std::memory_order_consume);
+ auto* new_data = new RcuData(*old_data);
+ new_data->d1++;
+ new_data->d2++;
+ rcu_data.store(new_data, std::memory_order_release);
+ folly::synchronize_rcu();
+ delete old_data;
+ } else {
+ folly::rcu_reader g;
+ auto* data = rcu_data.load(std::memory_order_consume);
+ sum += (data->d1 + data->d2);
+ }
}
}
+ EXPECT_GT(sum, 0);
}
}
-}
-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) {
+ size_t sum = 0;
+ for (size_t count = 0; count < pass_count; count++) {
+ for (int i = 0; i < 100; ++i) {
+ if (i < write_percentage) {
+ auto* old_data = rcu_data.load(std::memory_order_consume);
+ auto* new_data = new RcuData(*old_data);
+ new_data->d1++;
+ new_data->d2++;
+ rcu_data.store(new_data, std::memory_order_release);
+ folly::rcu_retire(old_data);
+ } else {
+ folly::rcu_reader g;
+ auto* data = rcu_data.load(std::memory_order_consume);
+ sum += (data->d1 + data->d2);
+ }
}
}
+ EXPECT_GT(sum, 0);
}
}
-}
-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;
+std::atomic<RcuData*> FollySyncTest_Sequential::rcu_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;
+size_t FollySyncTest_Sequential::s_nRcuReaderOnlyPassCount;
+
+TEST_F(FollySyncTest_Sequential, FollyRCU_ReaderOnly) {
+ run_rcu_reader_only(s_nRcuReaderOnlyPassCount);
}
-TEST_F(FollySyncTest, FollyRCU_NoSync) {
- run_rcu_no_sync(kRcuNoSyncPassCount);
+TEST_F(FollySyncTest_Sequential, FollyRCU_Sync) {
+ run_rcu_sync(s_nRcuSyncPassCount);
}
-TEST_F(FollySyncTest, FollyRWTicketSpinLock_32) {
- run_rw_lock<RWTicketSpinLock32>(kRWTicketSpinLockPassCount);
+TEST_F(FollySyncTest_Sequential, FollyRCU_NoSync) {
+ run_rcu_no_sync(s_nRcuNoSyncPassCount);
}
-TEST_F(FollySyncTest, FollyRWTicketSpinLock_64) {
- run_rw_lock<RWTicketSpinLock64>(kRWTicketSpinLockPassCount);
+TEST_F(FollySyncTest_Sequential, FollyMicroSpinLock) {
+ run_small_lock<MicroSpinLock>(s_nMicroSpinLockPassCount);
}
-TEST_F(FollySyncTest, FollyRWSpinLock) {
- run_rw_lock<RWSpinLock>(kRWSpinLockPassCount);
+TEST_F(FollySyncTest_Sequential, FollyPicoSpinLock) {
+ run_small_lock<PicoSpinLock>(s_nPicoSpinLockPassCount);
}
-TEST_F(FollySyncTest, FollySharedMutex_ReadPriority) {
- run_rw_lock<SharedMutexReadPriority>(kSharedMutexPassCount);
+TEST_F(FollySyncTest_Sequential, FollyMicroLock) {
+ run_small_lock<MicroLock>(s_nMicroLockPassCount);
}
-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
projects / folly.git / blobdiff