folly/synchronization/test/BatonTest.cpp

   1 /*
   2  * Copyright 2014-present Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <folly/synchronization/Baton.h>
  18
  19 #include <thread>
  20
  21 #include <folly/portability/GTest.h>
  22 #include <folly/synchronization/test/BatonTestHelpers.h>
  23 #include <folly/test/DeterministicSchedule.h>
  24
  25 using namespace folly;
  26 using namespace folly::test;
  27 using folly::detail::EmulatedFutexAtomic;
  28 using std::chrono::steady_clock;
  29 using std::chrono::system_clock;
  30
  31 /// Basic test
  32
  33 TEST(Baton, basic_blocking) {
  34   run_basic_test<true, std::atomic>();
  35   run_basic_test<true, EmulatedFutexAtomic>();
  36   run_basic_test<true, DeterministicAtomic>();
  37 }
  38
  39 TEST(Baton, basic_nonblocking) {
  40   run_basic_test<false, std::atomic>();
  41   run_basic_test<false, EmulatedFutexAtomic>();
  42   run_basic_test<false, DeterministicAtomic>();
  43 }
  44
  45 /// Ping pong tests
  46
  47 TEST(Baton, pingpong_blocking) {
  48   DSched sched(DSched::uniform(0));
  49
  50   run_pingpong_test<true, DeterministicAtomic>(1000);
  51 }
  52
  53 TEST(Baton, pingpong_nonblocking) {
  54   DSched sched(DSched::uniform(0));
  55
  56   run_pingpong_test<false, DeterministicAtomic>(1000);
  57 }
  58
  59 // Timed wait basic system clock tests
  60
  61 TEST(Baton, timed_wait_basic_system_clock_blocking) {
  62   run_basic_timed_wait_tests<true, std::atomic, system_clock>();
  63   run_basic_timed_wait_tests<true, EmulatedFutexAtomic, system_clock>();
  64   run_basic_timed_wait_tests<true, DeterministicAtomic, system_clock>();
  65 }
  66
  67 TEST(Baton, timed_wait_basic_system_clock_nonblocking) {
  68   run_basic_timed_wait_tests<false, std::atomic, system_clock>();
  69   run_basic_timed_wait_tests<false, EmulatedFutexAtomic, system_clock>();
  70   run_basic_timed_wait_tests<false, DeterministicAtomic, system_clock>();
  71 }
  72
  73 // Timed wait timeout system clock tests
  74
  75 TEST(Baton, timed_wait_timeout_system_clock_blocking) {
  76   run_timed_wait_tmo_tests<true, std::atomic, system_clock>();
  77   run_timed_wait_tmo_tests<true, EmulatedFutexAtomic, system_clock>();
  78   run_timed_wait_tmo_tests<true, DeterministicAtomic, system_clock>();
  79 }
  80
  81 TEST(Baton, timed_wait_timeout_system_clock_nonblocking) {
  82   run_timed_wait_tmo_tests<false, std::atomic, system_clock>();
  83   run_timed_wait_tmo_tests<false, EmulatedFutexAtomic, system_clock>();
  84   run_timed_wait_tmo_tests<false, DeterministicAtomic, system_clock>();
  85 }
  86
  87 // Timed wait regular system clock tests
  88
  89 TEST(Baton, timed_wait_system_clock_blocking) {
  90   run_timed_wait_regular_test<true, std::atomic, system_clock>();
  91   run_timed_wait_regular_test<true, EmulatedFutexAtomic, system_clock>();
  92   run_timed_wait_regular_test<true, DeterministicAtomic, system_clock>();
  93 }
  94
  95 TEST(Baton, timed_wait_system_clock_nonblocking) {
  96   run_timed_wait_regular_test<false, std::atomic, system_clock>();
  97   run_timed_wait_regular_test<false, EmulatedFutexAtomic, system_clock>();
  98   run_timed_wait_regular_test<false, DeterministicAtomic, system_clock>();
  99 }
 100
 101 // Timed wait basic steady clock tests
 102
 103 TEST(Baton, timed_wait_basic_steady_clock_blocking) {
 104   run_basic_timed_wait_tests<true, std::atomic, steady_clock>();
 105   run_basic_timed_wait_tests<true, EmulatedFutexAtomic, steady_clock>();
 106   run_basic_timed_wait_tests<true, DeterministicAtomic, steady_clock>();
 107 }
 108
 109 TEST(Baton, timed_wait_basic_steady_clock_nonblocking) {
 110   run_basic_timed_wait_tests<false, std::atomic, steady_clock>();
 111   run_basic_timed_wait_tests<false, EmulatedFutexAtomic, steady_clock>();
 112   run_basic_timed_wait_tests<false, DeterministicAtomic, steady_clock>();
 113 }
 114
 115 // Timed wait timeout steady clock tests
 116
 117 TEST(Baton, timed_wait_timeout_steady_clock_blocking) {
 118   run_timed_wait_tmo_tests<true, std::atomic, steady_clock>();
 119   run_timed_wait_tmo_tests<true, EmulatedFutexAtomic, steady_clock>();
 120   run_timed_wait_tmo_tests<true, DeterministicAtomic, steady_clock>();
 121 }
 122
 123 TEST(Baton, timed_wait_timeout_steady_clock_nonblocking) {
 124   run_timed_wait_tmo_tests<false, std::atomic, steady_clock>();
 125   run_timed_wait_tmo_tests<false, EmulatedFutexAtomic, steady_clock>();
 126   run_timed_wait_tmo_tests<false, DeterministicAtomic, steady_clock>();
 127 }
 128
 129 // Timed wait regular steady clock tests
 130
 131 TEST(Baton, timed_wait_steady_clock_blocking) {
 132   run_timed_wait_regular_test<true, std::atomic, steady_clock>();
 133   run_timed_wait_regular_test<true, EmulatedFutexAtomic, steady_clock>();
 134   run_timed_wait_regular_test<true, DeterministicAtomic, steady_clock>();
 135 }
 136
 137 TEST(Baton, timed_wait_steady_clock_nonblocking) {
 138   run_timed_wait_regular_test<false, std::atomic, steady_clock>();
 139   run_timed_wait_regular_test<false, EmulatedFutexAtomic, steady_clock>();
 140   run_timed_wait_regular_test<false, DeterministicAtomic, steady_clock>();
 141 }
 142
 143 /// Try wait tests
 144
 145 TEST(Baton, try_wait_blocking) {
 146   run_try_wait_tests<true, std::atomic>();
 147   run_try_wait_tests<true, EmulatedFutexAtomic>();
 148   run_try_wait_tests<true, DeterministicAtomic>();
 149 }
 150
 151 TEST(Baton, try_wait_nonblocking) {
 152   run_try_wait_tests<false, std::atomic>();
 153   run_try_wait_tests<false, EmulatedFutexAtomic>();
 154   run_try_wait_tests<false, DeterministicAtomic>();
 155 }