folly/stress-test/stress-sequential-folly-sync.cpp

   1 #include <folly/SmallLocks.h>
   2 #include <folly/RWSpinLock.h>
   3 #include <folly/SharedMutex.h>
   4 #include <folly/synchronization/Rcu.h>
   5
   6 #include <gtest/gtest.h>
   7
   8 #include <memory>
   9
  10 namespace {
  11
  12 // MicroLock
  13 const size_t kMicroLockPassCount = 2000000000;
  14 typedef folly::MicroLock MicroLock;
  15
  16 // MicroSpinLock
  17 const size_t kMicroSpinLockPassCount = 1500000000;
  18 typedef folly::MicroSpinLock MicroSpinLock;
  19
  20 // PicoSpinLock
  21 const size_t kPicoSpinLockPassCount = 2700000000;
  22 typedef folly::PicoSpinLock<size_t> PicoSpinLock;
  23
  24 // SharedMutex
  25 const size_t kSharedMutexPassCount = 5000000;
  26 typedef folly::SharedMutexReadPriority SharedMutexReadPriority;
  27 typedef folly::SharedMutexWritePriority SharedMutexWritePriority;
  28
  29 // RWSpinLock
  30 const size_t kRWSpinLockPassCount = 5000000;
  31 typedef folly::RWSpinLock RWSpinLock;
  32
  33 // RWTicketSpinLock
  34 const size_t kRWTicketSpinLockPassCount = 5000000;
  35 typedef folly::RWTicketSpinLock32 RWTicketSpinLock32;
  36 typedef folly::RWTicketSpinLock64 RWTicketSpinLock64;
  37
  38 // RCU
  39 const size_t kRcuSyncPassCount = 180000;
  40 const size_t kRcuNoSyncPassCount = 3500000;
  41 // Represent the RCU-protected data.
  42 struct RcuFoo {
  43   size_t f1;
  44   size_t f2;
  45 };
  46
  47 }
  48
  49 void run_rcu_sync(size_t pass_count) {
  50   for (int write_percentage = 1; write_percentage <= 5; write_percentage += 1) {
  51     for (size_t count = 0; count < pass_count; count++) {
  52       for (int i = 0; i < 100; ++i) {
  53         if (i < write_percentage) {
  54           RcuFoo* f = new RcuFoo();
  55           folly::rcu_retire(f);
  56           folly::synchronize_rcu();
  57         } else {
  58           folly::rcu_reader g;
  59         }
  60       }
  61     }
  62   }
  63 }
  64
  65 void run_rcu_no_sync(size_t pass_count) {
  66   for (int write_percentage = 1; write_percentage <= 5; write_percentage += 1) {
  67     for (size_t count = 0; count < pass_count; count++) {
  68       for (int i = 0; i < 100; ++i) {
  69         if (i < write_percentage) {
  70           RcuFoo* f = new RcuFoo();
  71           folly::rcu_retire(f);
  72         } else {
  73           folly::rcu_reader g;
  74         }
  75       }
  76     }
  77   }
  78 }
  79
  80 template <typename Lock>
  81 void run_rw_lock(size_t pass_count) {
  82   std::unique_ptr<Lock> l(new Lock());
  83   for (int write_percentage = 5; write_percentage < 20; write_percentage += 5) {
  84     for (size_t count = 0; count < pass_count; count++) {
  85       for (int i = 0; i < 100; ++i) {
  86         if (i < write_percentage) {
  87           l->lock();
  88           l->unlock();
  89         } else {
  90           l->lock_shared();
  91           l->unlock_shared();
  92         }
  93       }
  94     }
  95   }
  96 }
  97
  98 template <typename Lock>
  99 void run_small_lock(size_t pass_count) {
 100   std::unique_ptr<Lock> l(new Lock());
 101   l->init();
 102   for (size_t count = 0; count < pass_count; count++) {
 103     l->lock();
 104     l->unlock();
 105   }
 106 }
 107
 108 class FollySyncTest: public ::testing::Test {
 109
 110 };
 111
 112 TEST_F(FollySyncTest, FollyRCU_Sync) {
 113   run_rcu_sync(kRcuSyncPassCount);
 114 }
 115
 116 TEST_F(FollySyncTest, FollyRCU_NoSync) {
 117   run_rcu_no_sync(kRcuNoSyncPassCount);
 118 }
 119
 120 TEST_F(FollySyncTest, FollyRWTicketSpinLock_32) {
 121   run_rw_lock<RWTicketSpinLock32>(kRWTicketSpinLockPassCount);
 122 }
 123
 124 TEST_F(FollySyncTest, FollyRWTicketSpinLock_64) {
 125   run_rw_lock<RWTicketSpinLock64>(kRWTicketSpinLockPassCount);
 126 }
 127
 128 TEST_F(FollySyncTest, FollyRWSpinLock) {
 129   run_rw_lock<RWSpinLock>(kRWSpinLockPassCount);
 130 }
 131
 132 TEST_F(FollySyncTest, FollySharedMutex_ReadPriority) {
 133   run_rw_lock<SharedMutexReadPriority>(kSharedMutexPassCount);
 134 }
 135
 136 TEST_F(FollySyncTest, FollySharedMutex_WritePriority) {
 137   run_rw_lock<SharedMutexWritePriority>(kSharedMutexPassCount);
 138 }
 139
 140 TEST_F(FollySyncTest, FollyMicroSpinLock) {
 141   run_small_lock<MicroSpinLock>(kMicroSpinLockPassCount);
 142 }
 143
 144 TEST_F(FollySyncTest, FollyPicoSpinLock) {
 145   run_small_lock<PicoSpinLock>(kPicoSpinLockPassCount);
 146 }
 147
 148 TEST_F(FollySyncTest, FollyMicroLock) {
 149   run_small_lock<MicroLock>(kMicroLockPassCount);
 150 }
 151
 152 int main(int argc, char** argv) {
 153   // Init Google test
 154   ::testing::InitGoogleTest(&argc, argv);
 155   int result = RUN_ALL_TESTS();
 156   return result;
 157 }