instance_copy_.reset();
if (destroy_baton_) {
constexpr std::chrono::seconds kDestroyWaitTime{5};
- auto last_reference_released = destroy_baton_->timed_wait(
- std::chrono::steady_clock::now() + kDestroyWaitTime);
+ auto last_reference_released =
+ destroy_baton_->try_wait_for(kDestroyWaitTime);
if (last_reference_released) {
teardown_(instance_ptr_);
} else {
* folly::IOThreadPoolExecutor executor(max_concurrency_level);
* folly::Baton<> done;
* doEagerInitVia(executor, &done);
- * done.wait(); // or 'timed_wait', or spin with 'try_wait'
+ * done.wait(); // or 'try_wait_for', etc.
*
*/
void doEagerInitVia(Executor& exe, folly::Baton<>* done = nullptr);
observable.setValue(24);
- EXPECT_TRUE(baton.timed_wait(std::chrono::seconds{1}));
+ EXPECT_TRUE(baton.try_wait_for(std::chrono::seconds{1}));
EXPECT_EQ(24, **observer);
}
observable.setValue(24);
- EXPECT_TRUE(baton.timed_wait(std::chrono::seconds{1}));
+ EXPECT_TRUE(baton.try_wait_for(std::chrono::seconds{1}));
EXPECT_EQ(25, **observer);
}
observable.setValue(24);
- EXPECT_TRUE(baton.timed_wait(std::chrono::seconds{1}));
+ EXPECT_TRUE(baton.try_wait_for(std::chrono::seconds{1}));
EXPECT_EQ(25 * 26, **observer);
}
observable.setValue(2);
// Waiting observer shouldn't be updated
- EXPECT_FALSE(baton.timed_wait(std::chrono::seconds{1}));
+ EXPECT_FALSE(baton.try_wait_for(std::chrono::seconds{1}));
baton.reset();
EXPECT_EQ(82, **oddObserver);
observable.setValue(23);
- EXPECT_TRUE(baton.timed_wait(std::chrono::seconds{1}));
+ EXPECT_TRUE(baton.try_wait_for(std::chrono::seconds{1}));
EXPECT_EQ(46, **oddObserver);
}
for (size_t i = 1; i <= 3; ++i) {
observable.setValue(i);
- EXPECT_TRUE(baton.timed_wait(std::chrono::seconds{1}));
+ EXPECT_TRUE(baton.try_wait_for(std::chrono::seconds{1}));
baton.reset();
EXPECT_EQ(i, **collectObserver);
baton.post();
});
- ASSERT_TRUE(baton.timed_wait(testInterval(15)));
+ ASSERT_TRUE(baton.try_wait_for(testInterval(15)));
th.join();
}
baton.post();
});
- ASSERT_TRUE(baton.timed_wait(testInterval(15)));
+ ASSERT_TRUE(baton.try_wait_for(testInterval(15)));
th.join();
}
baton.post();
});
- ASSERT_TRUE(baton.timed_wait(testInterval(15)));
+ ASSERT_TRUE(baton.try_wait_for(testInterval(15)));
th.join();
}
});
doBoost(f);
f = std::move(ret);
- if (baton->timed_wait(dur)) {
+ if (baton->try_wait_for(dur)) {
assert(f.isReady());
}
}
p.setInterruptHandler([&](const exception_wrapper& /* e */) { done.post(); });
p.getFuture().within(std::chrono::milliseconds(1));
// Give it 100ms to time out and call the interrupt handler
- auto t = std::chrono::steady_clock::now() + std::chrono::milliseconds(100);
- EXPECT_TRUE(done.timed_wait(t));
+ EXPECT_TRUE(done.try_wait_for(std::chrono::milliseconds(100)));
}
EXPECT_EQ(getCurrentThreadName().value(), "monkey");
done.post();
});
- ASSERT_TRUE(done.timed_wait(seconds(1)));
+ ASSERT_TRUE(done.try_wait_for(seconds(1)));
}
TEST_F(EventBaseThreadTest, start_stop) {
Baton<> done;
ebt.getEventBase()->runInEventBaseThread([&] { done.post(); });
- ASSERT_TRUE(done.timed_wait(seconds(1)));
+ ASSERT_TRUE(done.try_wait_for(seconds(1)));
EXPECT_NE(nullptr, ebt.getEventBase());
ebt.stop();
Baton<> done;
ebt2.getEventBase()->runInEventBaseThread([&] { done.post(); });
- ASSERT_TRUE(done.timed_wait(seconds(1)));
+ ASSERT_TRUE(done.try_wait_for(seconds(1)));
}
TEST_F(EventBaseThreadTest, self_move) {
Baton<> done;
ebt.getEventBase()->runInEventBaseThread([&] { done.post(); });
- ASSERT_TRUE(done.timed_wait(seconds(1)));
+ ASSERT_TRUE(done.try_wait_for(seconds(1)));
}
TEST_F(EventBaseThreadTest, default_manager) {
Baton<> done;
sebt.getEventBase()->runInEventBaseThread([&] { done.post(); });
- ASSERT_TRUE(done.timed_wait(seconds(1)));
+ ASSERT_TRUE(done.try_wait_for(seconds(1)));
}
TEST_F(ScopedEventBaseThreadTest, named_example) {
done.post();
});
- ASSERT_TRUE(done.timed_wait(seconds(1)));
+ ASSERT_TRUE(done.try_wait_for(seconds(1)));
if (createdThreadName) {
ASSERT_EQ(kThreadName.toString(), createdThreadName.value());
}
run_pingpong_test<DeterministicAtomic, false>(1000);
}
-/// Timed wait tests - Nonblocking Baton does not support timed_wait()
+/// Timed wait tests - Nonblocking Baton does not support try_wait_until()
// Timed wait basic system clock tests
Baton<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>
Baton<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);
});
// 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