X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=folly%2Fsynchronization%2Ftest%2FBatonTestHelpers.h;h=0884927a79b2ab7113cc2b2f53be19d4df55f0d0;hb=3579ddb46bf91312e7c1d24389ad60fd96fad776;hp=6e242e2a6817d361b3fa60f4c44e03b9f07d3040;hpb=b3dc093ef094d6d97c10755e60392124828c5103;p=folly.git

diff --git a/folly/synchronization/test/BatonTestHelpers.h b/folly/synchronization/test/BatonTestHelpers.h
index 6e242e2a..0884927a 100644
--- a/folly/synchronization/test/BatonTestHelpers.h
+++ b/folly/synchronization/test/BatonTestHelpers.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 Facebook, Inc.
+ * Copyright 2016-present Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,16 +25,16 @@ namespace test {
 
 typedef DeterministicSchedule DSched;
 
-template <template <typename> class Atom, bool SinglePoster, bool Blocking>
+template <bool MayBlock, template <typename> class Atom>
 void run_basic_test() {
-  Baton<Atom, SinglePoster, Blocking> b;
+  Baton<MayBlock, Atom> b;
   b.post();
   b.wait();
 }
 
-template <template <typename> class Atom, bool SinglePoster, bool Blocking>
+template <bool MayBlock, template <typename> class Atom>
 void run_pingpong_test(int numRounds) {
-  using B = Baton<Atom, SinglePoster, Blocking>;
+  using B = Baton<MayBlock, Atom>;
   B batons[17];
   B& a = batons[0];
   B& b = batons[16]; // to get it on a different cache line
@@ -53,36 +53,36 @@ void run_pingpong_test(int numRounds) {
   DSched::join(thr);
 }
 
-template <template <typename> class Atom, typename Clock, bool SinglePoster>
+template <bool MayBlock, template <typename> class Atom, typename Clock>
 void run_basic_timed_wait_tests() {
-  Baton<Atom, SinglePoster> b;
+  Baton<MayBlock, Atom> b;
   b.post();
   // tests if early delivery works fine
-  EXPECT_TRUE(b.timed_wait(Clock::now()));
+  EXPECT_TRUE(b.try_wait_until(Clock::now()));
 }
 
-template <template <typename> class Atom, typename Clock, bool SinglePoster>
+template <bool MayBlock, template <typename> class Atom, typename Clock>
 void run_timed_wait_tmo_tests() {
-  Baton<Atom, SinglePoster> b;
+  Baton<MayBlock, Atom> b;
 
   auto thr = DSched::thread([&] {
-    bool rv = b.timed_wait(Clock::now() + std::chrono::milliseconds(1));
+    bool rv = b.try_wait_until(Clock::now() + std::chrono::milliseconds(1));
     // main thread is guaranteed to not post until timeout occurs
     EXPECT_FALSE(rv);
   });
   DSched::join(thr);
 }
 
-template <template <typename> class Atom, typename Clock, bool SinglePoster>
+template <bool MayBlock, template <typename> class Atom, typename Clock>
 void run_timed_wait_regular_test() {
-  Baton<Atom, SinglePoster> b;
+  Baton<MayBlock, Atom> b;
 
   auto thr = DSched::thread([&] {
     // To wait forever we'd like to use time_point<Clock>::max, but
     // std::condition_variable does math to convert the timeout to
     // system_clock without handling overflow.
     auto farFuture = Clock::now() + std::chrono::hours(1000);
-    bool rv = b.timed_wait(farFuture);
+    bool rv = b.try_wait_until(farFuture);
     if (!std::is_same<Atom<int>, DeterministicAtomic<int>>::value) {
       // DeterministicAtomic ignores actual times, so doesn't guarantee
       // a lack of timeout
@@ -104,68 +104,15 @@ void run_timed_wait_regular_test() {
   DSched::join(thr);
 }
 
-template <template <typename> class Atom, bool SinglePoster, bool Blocking>
+template <bool MayBlock, template <typename> class Atom>
 void run_try_wait_tests() {
-  Baton<Atom, SinglePoster, Blocking> b;
+  Baton<MayBlock, Atom> b;
+  EXPECT_FALSE(b.ready());
   EXPECT_FALSE(b.try_wait());
   b.post();
+  EXPECT_TRUE(b.ready());
   EXPECT_TRUE(b.try_wait());
 }
 
-template <template <typename> class Atom, bool SinglePoster, bool Blocking>
-void run_multi_producer_tests() {
-  constexpr int NPROD = 5;
-  Baton<Atom, SinglePoster, Blocking> local_ping[NPROD];
-  Baton<Atom, SinglePoster, Blocking> local_pong[NPROD];
-  Baton<Atom, /* SingleProducer = */ false, Blocking> global;
-  Baton<Atom, SinglePoster, Blocking> shutdown;
-
-  std::thread prod[NPROD];
-  for (int i = 0; i < NPROD; ++i) {
-    prod[i] = DSched::thread([&, i] {
-      if (!std::is_same<Atom<int>, DeterministicAtomic<int>>::value) {
-        // If we are using std::atomic (or EmulatedFutexAtomic) then
-        // a variable sleep here will make it more likely that
-        // global.post()-s will span more than one global.wait() by
-        // the consumer thread and for the latter to block (if the
-        // global baton is blocking). For DeterministicAtomic, we just
-        // rely on DeterministicSchedule to do the scheduling.  The
-        // test won't fail if we lose the race, we just don't get
-        // coverage.
-        for (int j = 0; j < i; ++j) {
-          std::this_thread::sleep_for(std::chrono::microseconds(1));
-        }
-      }
-      local_ping[i].post();
-      global.post();
-      local_pong[i].wait();
-    });
-  }
-
-  auto cons = DSched::thread([&] {
-    while (true) {
-      global.wait();
-      global.reset();
-      if (shutdown.try_wait()) {
-        return;
-      }
-      for (int i = 0; i < NPROD; ++i) {
-        if (local_ping.try_wait()) {
-          local_ping.reset();
-          local_pong.post();
-        }
-      }
-    }
-  });
-
-  for (auto& t : prod) {
-    DSched::join(t);
-  }
-
-  global.post();
-  shutdown.post();
-  DSched::join(cons);
-}
-
 } // namespace test
 } // namespace folly