From 614a2213b3d18c09b4fba87795fe5c9923acb085 Mon Sep 17 00:00:00 2001 From: Peizhao Ou Date: Fri, 9 Feb 2018 00:54:12 -0800 Subject: [PATCH] Refactors folly test cases to use gtest --- .../stress-sequential-folly-map.cpp | 103 +++--------- .../stress-sequential-folly-queue.cpp | 154 ++++++------------ .../stress-sequential-folly-sync.cpp | 136 ++++++---------- 3 files changed, 132 insertions(+), 261 deletions(-) diff --git a/folly/stress-test/stress-sequential-folly-map.cpp b/folly/stress-test/stress-sequential-folly-map.cpp index c9acaee9..53b95290 100644 --- a/folly/stress-test/stress-sequential-folly-map.cpp +++ b/folly/stress-test/stress-sequential-folly-map.cpp @@ -2,29 +2,22 @@ #include #include +#include -#include -#include -#include #include namespace { const unsigned s_nInsertPercentage = 10; -const char* kTestName = "InsDelFind"; const size_t kConcurrentHashMapSize = 10000; const size_t kConcurrentHashMapPassCount = 36000; -const char* kConcurrentHashMapBenchmarkName = "FollyConcurrentHashMap"; const size_t kAtomicHashMapSize = 10000; const size_t kAtomicHashMapPassCount = 250000; -const char* kAtomicHashMapBenchmarkName = "FollyAtomicHashMap"; const size_t kAtomicUnorderedInsertMapSize = 10000; const size_t kAtomicUnorderedInsertMapPassCount = 500000; -const char* kAtomicUnorderedInsertMapBenchmarkName = - "FollyAtomicUnorderedInsertMap"; typedef folly::ConcurrentHashMap ConcurrentHashMap; typedef folly::AtomicHashMap AtomicHashMap; @@ -48,11 +41,7 @@ bool map_contains(const Map* map, Key key) { } template -void run_atomic_unordered_insert_map(size_t map_size, 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_atomic_unordered_insert_map(size_t map_size, size_t pass_count) { size_t nInsertedNum = 0; size_t nFindSuccess = 0; std::unique_ptr map(new Map(map_size)); @@ -78,32 +67,15 @@ void run_atomic_unordered_insert_map(size_t map_size, size_t pass_count, { if (map_contains(map.get(), i)) { ++nFindSuccess; -// std::cout << "Found" << i << "\n"; } } } } - auto finish_time = std::chrono::system_clock::now(); - auto dur = finish_time - start_time; - auto milisecs = std::chrono::duration_cast(dur); - - if (nFindSuccess != nInsertedNum) { - std::cout << "nFindSuccess=" << nFindSuccess << ", nInsertedNum=" - << nInsertedNum << std::endl; - std::cout << "[ FAILED ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; - assert(false && "ConcurrentMap ERROR"); - } else { - std::cout << "[ OK ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; - } + EXPECT_EQ(nFindSuccess, nInsertedNum); } template -void run_atomic_hashmap(size_t map_size, 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_atomic_hashmap(size_t map_size, size_t pass_count) { size_t nInsertedNum = 0; size_t nFindSuccess = 0; std::unique_ptr map(new Map(map_size)); @@ -129,33 +101,15 @@ void run_atomic_hashmap(size_t map_size, size_t pass_count, const char* bench_na { if (map_contains(map.get(), i)) { ++nFindSuccess; -// std::cout << "Found" << i << "\n"; } } } } - auto finish_time = std::chrono::system_clock::now(); - auto dur = finish_time - start_time; - auto milisecs = std::chrono::duration_cast(dur); - - if (nFindSuccess != nInsertedNum) { - std::cout << "nFindSuccess=" << nFindSuccess << ", nInsertedNum=" - << nInsertedNum << std::endl; - std::cout << "[ FAILED ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; - assert(false && "ConcurrentMap ERROR"); - } else { - std::cout << "[ OK ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; - } + EXPECT_EQ(nFindSuccess, nInsertedNum); } template -void run_concurrent_hashmap(size_t map_size, 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_concurrent_hashmap(size_t map_size, size_t pass_count) { size_t nInsertedNum = 0; size_t nFindSuccess = 0; std::unique_ptr map(new Map(map_size)); @@ -167,53 +121,48 @@ void run_concurrent_hashmap(size_t map_size, size_t pass_count, if (i % s_nInsertPercentage == 1) { auto iter = map->insert({i, n}); nInsertedNum++; -// std::cout << "Inserted" << i << "\n"; } // Find { if (map_contains(map.get(), i)) { ++nFindSuccess; -// std::cout << "Found" << i << "\n"; } } // Delete if (i % s_nInsertPercentage == 1) { if (map_contains(map.get(), i)) { map->erase(i); -// std::cout << "Erased" << i << "\n"; } } } } - auto finish_time = std::chrono::system_clock::now(); - auto dur = finish_time - start_time; - auto milisecs = std::chrono::duration_cast(dur); - - if (nFindSuccess != nInsertedNum) { - std::cout << "nFindSuccess=" << nFindSuccess << ", nInsertedNum=" - << nInsertedNum << std::endl; - std::cout << "[ FAILED ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; - assert(false && "ConcurrentMap ERROR"); - } else { - std::cout << "[ OK ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; - } + EXPECT_EQ(nFindSuccess, nInsertedNum); } -int main() { +class FollyMapInsDelFindTest: public ::testing::Test { +}; + +TEST_F(FollyMapInsDelFindTest, FollyConcurrentHashMap) { run_concurrent_hashmap( kConcurrentHashMapSize, - kConcurrentHashMapPassCount, - kConcurrentHashMapBenchmarkName); + kConcurrentHashMapPassCount); +} + +TEST_F(FollyMapInsDelFindTest, FollyAtomicHashMap) { run_atomic_hashmap( kAtomicHashMapSize, - kAtomicHashMapPassCount, - kAtomicHashMapBenchmarkName); + kAtomicHashMapPassCount); +} + +TEST_F(FollyMapInsDelFindTest, FollyAtomicUnorderedInsertMap) { run_atomic_unordered_insert_map( kAtomicUnorderedInsertMapSize, - kAtomicUnorderedInsertMapPassCount, - kAtomicUnorderedInsertMapBenchmarkName); + kAtomicUnorderedInsertMapPassCount); +} - return 0; +int main(int argc, char** argv) { + // Init Google test + ::testing::InitGoogleTest(&argc, argv); + int result = RUN_ALL_TESTS(); + return result; } diff --git a/folly/stress-test/stress-sequential-folly-queue.cpp b/folly/stress-test/stress-sequential-folly-queue.cpp index d3c3906a..70bcb15d 100644 --- a/folly/stress-test/stress-sequential-folly-queue.cpp +++ b/folly/stress-test/stress-sequential-folly-queue.cpp @@ -3,25 +3,18 @@ #include #include -#include -#include -#include +#include + #include namespace { -const char* kTestName = "EnqueueDequeue"; - // Unbounded queue size_t kUnboundedQueueEnqueueStride = 10000; size_t kUSPSCQueueEnqueueCount = 1200000000; -const char* kUSPSCQueueBenchmarkName = "FollyUnboundedQueue_SPSC"; size_t kUMPSCQueueEnqueueCount = 320000000; -const char* kUMPSCQueueBenchmarkName = "FollyUnboundedQueue_MPSC"; size_t kUSPMCQueueEnqueueCount = 320000000; -const char* kUSPMCQueueBenchmarkName = "FollyUnboundedQueue_SPMC"; size_t kUMPMCQueueEnqueueCount = 320000000; -const char* kUMPMCQueueBenchmarkName = "FollyUnboundedQueue_MPMC"; typedef folly::USPSCQueue USPSCQueue; typedef folly::UMPSCQueue UMPSCQueue; @@ -32,13 +25,9 @@ typedef folly::UMPMCQueue UMPMCQueue; size_t kDynamicBoundedQueueEnqueueStride = 50000; size_t kDynamicBoundedQueueCapacity = 200000; size_t kDSPSCQueueEnqueueCount = 1200000000; -const char* kDSPSCQueueBenchmarkName = "FollyDynamicBoundedQueue_SPSC"; size_t kDMPSCQueueEnqueueCount = 320000000; -const char* kDMPSCQueueBenchmarkName = "FollyDynamicBoundedQueue_MPSC"; size_t kDSPMCQueueEnqueueCount = 320000000; -const char* kDSPMCQueueBenchmarkName = "FollyDynamicBoundedQueue_SPMC"; size_t kDMPMCQueueEnqueueCount = 320000000; -const char* kDMPMCQueueBenchmarkName = "FollyDynamicBoundedQueue_MPMC"; typedef folly::DSPSCQueue DSPSCQueue; typedef folly::DMPSCQueue DMPSCQueue; @@ -48,22 +37,17 @@ typedef folly::DMPMCQueue DMPMCQueue; // AtomicLinkedList size_t kAtomicLinkedListSize = 50000; size_t kAtomicLinkedListPassCount = 10000; -const char* kAtomicLinkedListBenchmarkName = "FollyAtomicLinkedList"; typedef folly::AtomicLinkedList AtomicLinkedList; // MPMC Queue (linearizable) size_t kMPMCQueueEnqueueStride = 10000; size_t kMPMCQueueCapacity = 50000; size_t kMPMCQueueEnqueueCount = 500000000; -const char* kMPMCQueueBenchmarkName = "FollyMPMCQueue"; typedef folly::MPMCQueue MPMCQueue; } void run_atomic_linkedlist() { - std::cout << "[ RUN ] " << kTestName << "." - << kAtomicLinkedListBenchmarkName << std::endl; - auto start_time = std::chrono::system_clock::now(); for (size_t pass = 0; pass < kAtomicLinkedListPassCount; pass++) { std::unique_ptr list(new AtomicLinkedList()); bool in_order = true; @@ -80,30 +64,12 @@ void run_atomic_linkedlist() { in_order = !in_order; size_t supposed_sum = kAtomicLinkedListSize * (kAtomicLinkedListSize - 1) / 2; - if (nSum != supposed_sum) { - std::cout << "Sequential linked list pop sum: " << nSum - << " != " << supposed_sum << "\n"; - auto finish_time = std::chrono::system_clock::now(); - auto dur = finish_time - start_time; - auto milisecs = std::chrono::duration_cast(dur); - std::cout << "[ FAILED ] " << kTestName << "." << kAtomicLinkedListBenchmarkName - << " (" << milisecs.count() << " ms)" << std::endl; - assert(false && "Folly AtomicLinkedList ERROR"); - } + EXPECT_EQ(nSum, supposed_sum); } - auto finish_time = std::chrono::system_clock::now(); - auto dur = finish_time - start_time; - auto milisecs = std::chrono::duration_cast(dur); - std::cout << "[ OK ] " << kTestName << "." << kAtomicLinkedListBenchmarkName - << " (" << milisecs.count() << " ms)" << std::endl; } template -void run_queue(Queue* q, size_t enqueue_count, const char* bench_name, - size_t enqueue_stride) { - std::cout << "[ RUN ] " << kTestName << "." << bench_name << std::endl; - auto start_time = std::chrono::system_clock::now(); - +void run_queue(Queue* q, size_t enqueue_count, size_t enqueue_stride) { size_t nNo = 0; size_t pop_sum = 0; while (nNo < enqueue_count) { @@ -118,31 +84,13 @@ void run_queue(Queue* q, size_t enqueue_count, const char* bench_name, pop_sum += res; } } - - auto finish_time = std::chrono::system_clock::now(); - auto dur = finish_time - start_time; - auto milisecs = std::chrono::duration_cast(dur); - size_t supposed_sum = enqueue_count * (enqueue_count - 1) / 2; - if (pop_sum != supposed_sum) { - std::cout << "Sequential queue pop sum: " << pop_sum - << " != " << supposed_sum << "\n"; - std::cout << "[ FAILED ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; - assert(false && "Folly concurrent queue ERROR"); - } else { - std::cout << "[ OK ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; - } + EXPECT_EQ (pop_sum, supposed_sum); } // MPMC Specialization. template <> -void run_queue(MPMCQueue* q, size_t enqueue_count, const char* bench_name, - size_t enqueue_stride) { - std::cout << "[ RUN ] " << kTestName << "." << bench_name << std::endl; - auto start_time = std::chrono::system_clock::now(); - +void run_queue(MPMCQueue* q, size_t enqueue_count, size_t enqueue_stride) { size_t nNo = 0; size_t push_sum = 0; size_t pop_sum = 0; @@ -161,86 +109,88 @@ void run_queue(MPMCQueue* q, size_t enqueue_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(dur); - size_t supposed_sum = enqueue_count * (enqueue_count - 1) / 2; - if (pop_sum != supposed_sum) { - std::cout << "Sequential queue pop sum: " << pop_sum - << " != " << supposed_sum << "\n"; - std::cout << "[ FAILED ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; - assert(false && "Folly concurrent queue ERROR"); - } else { - std::cout << "[ OK ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; - } + EXPECT_EQ(pop_sum, supposed_sum); } template -void run_without_initial_capacity(size_t enqueue_count, const char* bench_name, - size_t enqueue_stride) { +void run_without_initial_capacity(size_t enqueue_count, size_t enqueue_stride) { std::unique_ptr q(new Queue()); - run_queue(q.get(), enqueue_count, bench_name, enqueue_stride); + run_queue(q.get(), enqueue_count, enqueue_stride); } template void run_with_initial_capacity(size_t queue_capacity, size_t enqueue_count, - const char* bench_name, size_t enqueue_stride) { + size_t enqueue_stride) { std::unique_ptr q(new Queue(queue_capacity)); - run_queue(q.get(), enqueue_count, bench_name, enqueue_stride); + run_queue(q.get(), enqueue_count, enqueue_stride); } -int main() { - // MPMCQueue +class FollyQueueEnqueueDequeueTest : public ::testing::Test { + +}; + +TEST_F(FollyQueueEnqueueDequeueTest, FollyMPMCQueue) { run_with_initial_capacity( - kMPMCQueueCapacity , - kMPMCQueueEnqueueCount, - kMPMCQueueBenchmarkName, - kMPMCQueueEnqueueStride); + kMPMCQueueCapacity, kMPMCQueueEnqueueCount, kMPMCQueueEnqueueStride); +} - // AtomicLinkedList +TEST_F(FollyQueueEnqueueDequeueTest, FollyAtomicLinkedList) { run_atomic_linkedlist(); +} - // UnboundedQueue +TEST_F(FollyQueueEnqueueDequeueTest, FollyUnboundedQueue_SPSC) { run_without_initial_capacity( - kUSPSCQueueEnqueueCount, - kUSPSCQueueBenchmarkName, - kUnboundedQueueEnqueueStride); + kUSPSCQueueEnqueueCount, kUnboundedQueueEnqueueStride); +} + +TEST_F(FollyQueueEnqueueDequeueTest, FollyUnboundedQueue_MPSC) { run_without_initial_capacity( - kUMPSCQueueEnqueueCount, - kUMPSCQueueBenchmarkName, - kUnboundedQueueEnqueueStride); + kUMPSCQueueEnqueueCount, kUnboundedQueueEnqueueStride); +} + +TEST_F(FollyQueueEnqueueDequeueTest, FollyUnboundedQueue_SPMC) { run_without_initial_capacity( - kUSPMCQueueEnqueueCount, - kUSPMCQueueBenchmarkName, - kUnboundedQueueEnqueueStride); + kUSPMCQueueEnqueueCount, kUnboundedQueueEnqueueStride); +} + +TEST_F(FollyQueueEnqueueDequeueTest, FollyUnboundedQueue_MPMC) { run_without_initial_capacity( kUMPMCQueueEnqueueCount, - kUMPMCQueueBenchmarkName, kUnboundedQueueEnqueueStride); +} +TEST_F(FollyQueueEnqueueDequeueTest, FollyDynamicBoundedQueue_SPSC) { // DynamicBoundedQueue run_with_initial_capacity( - kDynamicBoundedQueueCapacity , - kDSPSCQueueEnqueueCount, kDSPSCQueueBenchmarkName, - kDynamicBoundedQueueEnqueueStride); + kDynamicBoundedQueueCapacity, + kDSPSCQueueEnqueueCount, kDynamicBoundedQueueEnqueueStride); +} + +TEST_F(FollyQueueEnqueueDequeueTest, FollyDynamicBoundedQueue_MPSC) { run_with_initial_capacity( kDynamicBoundedQueueCapacity, kDMPSCQueueEnqueueCount, - kDMPSCQueueBenchmarkName, kDynamicBoundedQueueEnqueueStride); +} + +TEST_F(FollyQueueEnqueueDequeueTest, FollyDynamicBoundedQueue_SPMC) { run_with_initial_capacity( kDynamicBoundedQueueCapacity, kDSPMCQueueEnqueueCount, - kDSPMCQueueBenchmarkName, kDynamicBoundedQueueEnqueueStride); +} + +TEST_F(FollyQueueEnqueueDequeueTest, FollyDynamicBoundedQueue_MPMC) { run_with_initial_capacity( kDynamicBoundedQueueCapacity, kDMPMCQueueEnqueueCount, - kDMPMCQueueBenchmarkName, kDynamicBoundedQueueEnqueueStride); +} - return 0; +int main(int argc, char** argv) { + // Init Google test + ::testing::InitGoogleTest(&argc, argv); + int result = RUN_ALL_TESTS(); + return result; } diff --git a/folly/stress-test/stress-sequential-folly-sync.cpp b/folly/stress-test/stress-sequential-folly-sync.cpp index dbedef05..775252c1 100644 --- a/folly/stress-test/stress-sequential-folly-sync.cpp +++ b/folly/stress-test/stress-sequential-folly-sync.cpp @@ -3,56 +3,41 @@ #include #include -#include -#include -#include +#include + #include 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 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(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(dur); - std::cout << "[ OK ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; } template -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 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(dur); - std::cout << "[ OK ] " << kTestName << "." << bench_name - << " (" << milisecs.count() << " ms)" << std::endl; } template -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 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(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 -void init_run_lock(size_t pass_count, const char* bench_name) { - std::unique_ptr l(new Lock()); - l->init(); - run_small_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(kRWTicketSpinLockPassCount); +} + +TEST_F(FollySyncTest, FollyRWTicketSpinLock_64) { + run_rw_lock(kRWTicketSpinLockPassCount); } -int main() { - run_rcu_sync(kRcuSyncPassCount, kRcuSyncBenchmarkName); - run_rcu_no_sync(kRcuNoSyncPassCount, kRcuNoSyncBenchmarkName); +TEST_F(FollySyncTest, FollyRWSpinLock) { + run_rw_lock(kRWSpinLockPassCount); +} + +TEST_F(FollySyncTest, FollySharedMutex_ReadPriority) { + run_rw_lock(kSharedMutexPassCount); +} + +TEST_F(FollySyncTest, FollySharedMutex_WritePriority) { + run_rw_lock(kSharedMutexPassCount); +} - run_rw_lock(kRWTicketSpinLockPassCount, - kRWTicketSpinLock32BenchmarkName); - run_rw_lock(kRWTicketSpinLockPassCount, - kRWTicketSpinLock64BenchmarkName); +TEST_F(FollySyncTest, FollyMicroSpinLock) { + run_small_lock(kMicroSpinLockPassCount); +} - run_rw_lock(kRWSpinLockPassCount, kRWSpinLockBenchmarkName); +TEST_F(FollySyncTest, FollyPicoSpinLock) { + run_small_lock(kPicoSpinLockPassCount); +} - run_rw_lock( - kSharedMutexPassCount, kSharedMutexReadPriorityBenchmarkName); - run_rw_lock( - kSharedMutexPassCount, kSharedMutexWritePriorityBenchmarkName); +TEST_F(FollySyncTest, FollyMicroLock) { + run_small_lock(kMicroLockPassCount); +} - init_run_lock(kMicroSpinLockPassCount, - kMicroSpinLockBenchmarkName); - init_run_lock(kPicoSpinLockPassCount, - kPicoSpinLockBenchmarkName); - init_run_lock(kMicroLockPassCount, kMicroLockBenchmarkName); - return 0; +int main(int argc, char** argv) { + // Init Google test + ::testing::InitGoogleTest(&argc, argv); + int result = RUN_ALL_TESTS(); + return result; } -- 2.34.1