|
|
@@ -29,6 +29,7 @@
|
|
|
#include <vector>
|
|
|
|
|
|
#include "gtest/gtest.h"
|
|
|
+#include "absl/base/attributes.h"
|
|
|
#include "absl/base/internal/raw_logging.h"
|
|
|
#include "absl/base/internal/sysinfo.h"
|
|
|
#include "absl/memory/memory.h"
|
|
|
@@ -54,8 +55,8 @@ CreateDefaultPool() {
|
|
|
// Hack to schedule a function to run on a thread pool thread after a
|
|
|
// duration has elapsed.
|
|
|
static void ScheduleAfter(absl::synchronization_internal::ThreadPool *tp,
|
|
|
- const std::function<void()> &func,
|
|
|
- absl::Duration after) {
|
|
|
+ absl::Duration after,
|
|
|
+ const std::function<void()> &func) {
|
|
|
tp->Schedule([func, after] {
|
|
|
absl::SleepFor(after);
|
|
|
func();
|
|
|
@@ -1150,249 +1151,369 @@ TEST(Mutex, DeadlockIdBug) NO_THREAD_SAFETY_ANALYSIS {
|
|
|
// and so never expires/passes, and one that will expire/pass in the near
|
|
|
// future.
|
|
|
|
|
|
-// Encapsulate a Mutex-protected bool with its associated Condition/CondVar.
|
|
|
-class Cond {
|
|
|
- public:
|
|
|
- explicit Cond(bool use_deadline) : use_deadline_(use_deadline), c_(&b_) {}
|
|
|
-
|
|
|
- void Set(bool v) {
|
|
|
- absl::MutexLock lock(&mu_);
|
|
|
- b_ = v;
|
|
|
+static absl::Duration TimeoutTestAllowedSchedulingDelay() {
|
|
|
+ // Note: we use a function here because Microsoft Visual Studio fails to
|
|
|
+ // properly initialize constexpr static absl::Duration variables.
|
|
|
+ return absl::Milliseconds(150);
|
|
|
+}
|
|
|
+
|
|
|
+// Returns true if `actual_delay` is close enough to `expected_delay` to pass
|
|
|
+// the timeouts/deadlines test. Otherwise, logs warnings and returns false.
|
|
|
+ABSL_MUST_USE_RESULT
|
|
|
+static bool DelayIsWithinBounds(absl::Duration expected_delay,
|
|
|
+ absl::Duration actual_delay) {
|
|
|
+ bool pass = true;
|
|
|
+ // Do not allow the observed delay to be less than expected. This may occur
|
|
|
+ // in practice due to clock skew or when the synchronization primitives use a
|
|
|
+ // different clock than absl::Now(), but these cases should be handled by the
|
|
|
+ // the retry mechanism in each TimeoutTest.
|
|
|
+ if (actual_delay < expected_delay) {
|
|
|
+ ABSL_RAW_LOG(WARNING,
|
|
|
+ "Actual delay %s was too short, expected %s (difference %s)",
|
|
|
+ absl::FormatDuration(actual_delay).c_str(),
|
|
|
+ absl::FormatDuration(expected_delay).c_str(),
|
|
|
+ absl::FormatDuration(actual_delay - expected_delay).c_str());
|
|
|
+ pass = false;
|
|
|
}
|
|
|
-
|
|
|
- bool AwaitWithTimeout(absl::Duration timeout) {
|
|
|
- absl::MutexLock lock(&mu_);
|
|
|
- return use_deadline_ ? mu_.AwaitWithDeadline(c_, absl::Now() + timeout)
|
|
|
- : mu_.AwaitWithTimeout(c_, timeout);
|
|
|
+ // If the expected delay is <= zero then allow a small error tolerance, since
|
|
|
+ // we do not expect context switches to occur during test execution.
|
|
|
+ // Otherwise, thread scheduling delays may be substantial in rare cases, so
|
|
|
+ // tolerate up to kTimeoutTestAllowedSchedulingDelay of error.
|
|
|
+ absl::Duration tolerance = expected_delay <= absl::ZeroDuration()
|
|
|
+ ? absl::Milliseconds(10)
|
|
|
+ : TimeoutTestAllowedSchedulingDelay();
|
|
|
+ if (actual_delay > expected_delay + tolerance) {
|
|
|
+ ABSL_RAW_LOG(WARNING,
|
|
|
+ "Actual delay %s was too long, expected %s (difference %s)",
|
|
|
+ absl::FormatDuration(actual_delay).c_str(),
|
|
|
+ absl::FormatDuration(expected_delay).c_str(),
|
|
|
+ absl::FormatDuration(actual_delay - expected_delay).c_str());
|
|
|
+ pass = false;
|
|
|
}
|
|
|
+ return pass;
|
|
|
+}
|
|
|
+
|
|
|
+// Parameters for TimeoutTest, below.
|
|
|
+struct TimeoutTestParam {
|
|
|
+ // The file and line number (used for logging purposes only).
|
|
|
+ const char *from_file;
|
|
|
+ int from_line;
|
|
|
+
|
|
|
+ // Should the absolute deadline API based on absl::Time be tested? If false,
|
|
|
+ // the relative deadline API based on absl::Duration is tested.
|
|
|
+ bool use_absolute_deadline;
|
|
|
+
|
|
|
+ // The deadline/timeout used when calling the API being tested
|
|
|
+ // (e.g. Mutex::LockWhenWithDeadline).
|
|
|
+ absl::Duration wait_timeout;
|
|
|
+
|
|
|
+ // The delay before the condition will be set true by the test code. If zero
|
|
|
+ // or negative, the condition is set true immediately (before calling the API
|
|
|
+ // being tested). Otherwise, if infinite, the condition is never set true.
|
|
|
+ // Otherwise a closure is scheduled for the future that sets the condition
|
|
|
+ // true.
|
|
|
+ absl::Duration satisfy_condition_delay;
|
|
|
+
|
|
|
+ // The expected result of the condition after the call to the API being
|
|
|
+ // tested. Generally `true` means the condition was true when the API returns,
|
|
|
+ // `false` indicates an expected timeout.
|
|
|
+ bool expected_result;
|
|
|
+
|
|
|
+ // The expected delay before the API under test returns. This is inherently
|
|
|
+ // flaky, so some slop is allowed (see `DelayIsWithinBounds` above), and the
|
|
|
+ // test keeps trying indefinitely until this constraint passes.
|
|
|
+ absl::Duration expected_delay;
|
|
|
+};
|
|
|
|
|
|
- bool LockWhenWithTimeout(absl::Duration timeout) {
|
|
|
- bool b = use_deadline_ ? mu_.LockWhenWithDeadline(c_, absl::Now() + timeout)
|
|
|
- : mu_.LockWhenWithTimeout(c_, timeout);
|
|
|
- mu_.Unlock();
|
|
|
- return b;
|
|
|
+// Print a `TimeoutTestParam` to a debug log.
|
|
|
+std::ostream &operator<<(std::ostream &os, const TimeoutTestParam ¶m) {
|
|
|
+ return os << "from: " << param.from_file << ":" << param.from_line
|
|
|
+ << " use_absolute_deadline: "
|
|
|
+ << (param.use_absolute_deadline ? "true" : "false")
|
|
|
+ << " wait_timeout: " << param.wait_timeout
|
|
|
+ << " satisfy_condition_delay: " << param.satisfy_condition_delay
|
|
|
+ << " expected_result: "
|
|
|
+ << (param.expected_result ? "true" : "false")
|
|
|
+ << " expected_delay: " << param.expected_delay;
|
|
|
+}
|
|
|
+
|
|
|
+std::string FormatString(const TimeoutTestParam ¶m) {
|
|
|
+ std::ostringstream os;
|
|
|
+ os << param;
|
|
|
+ return os.str();
|
|
|
+}
|
|
|
+
|
|
|
+// Like `thread::Executor::ScheduleAt` except:
|
|
|
+// a) Delays zero or negative are executed immediately in the current thread.
|
|
|
+// b) Infinite delays are never scheduled.
|
|
|
+// c) Calls this test's `ScheduleAt` helper instead of using `pool` directly.
|
|
|
+static void RunAfterDelay(absl::Duration delay,
|
|
|
+ absl::synchronization_internal::ThreadPool *pool,
|
|
|
+ const std::function<void()> &callback) {
|
|
|
+ if (delay <= absl::ZeroDuration()) {
|
|
|
+ callback(); // immediate
|
|
|
+ } else if (delay != absl::InfiniteDuration()) {
|
|
|
+ ScheduleAfter(pool, delay, callback);
|
|
|
}
|
|
|
+}
|
|
|
|
|
|
- bool ReaderLockWhenWithTimeout(absl::Duration timeout) {
|
|
|
- bool b = use_deadline_
|
|
|
- ? mu_.ReaderLockWhenWithDeadline(c_, absl::Now() + timeout)
|
|
|
- : mu_.ReaderLockWhenWithTimeout(c_, timeout);
|
|
|
- mu_.ReaderUnlock();
|
|
|
- return b;
|
|
|
- }
|
|
|
+class TimeoutTest : public ::testing::Test,
|
|
|
+ public ::testing::WithParamInterface<TimeoutTestParam> {};
|
|
|
|
|
|
- void Await() {
|
|
|
- absl::MutexLock lock(&mu_);
|
|
|
- mu_.Await(c_);
|
|
|
- }
|
|
|
+std::vector<TimeoutTestParam> MakeTimeoutTestParamValues() {
|
|
|
+ // The `finite` delay is a finite, relatively short, delay. We make it larger
|
|
|
+ // than our allowed scheduling delay (slop factor) to avoid confusion when
|
|
|
+ // diagnosing test failures. The other constants here have clear meanings.
|
|
|
+ const absl::Duration finite = 3 * TimeoutTestAllowedSchedulingDelay();
|
|
|
+ const absl::Duration never = absl::InfiniteDuration();
|
|
|
+ const absl::Duration negative = -absl::InfiniteDuration();
|
|
|
+ const absl::Duration immediate = absl::ZeroDuration();
|
|
|
|
|
|
- void Signal(bool v) {
|
|
|
- absl::MutexLock lock(&mu_);
|
|
|
- b_ = v;
|
|
|
- cv_.Signal();
|
|
|
+ // Every test case is run twice; once using the absolute deadline API and once
|
|
|
+ // using the relative timeout API.
|
|
|
+ std::vector<TimeoutTestParam> values;
|
|
|
+ for (bool use_absolute_deadline : {false, true}) {
|
|
|
+ // Tests with a negative timeout (deadline in the past), which should
|
|
|
+ // immediately return current state of the condition.
|
|
|
+
|
|
|
+ // The condition is already true:
|
|
|
+ values.push_back(TimeoutTestParam{
|
|
|
+ __FILE__, __LINE__, use_absolute_deadline,
|
|
|
+ negative, // wait_timeout
|
|
|
+ immediate, // satisfy_condition_delay
|
|
|
+ true, // expected_result
|
|
|
+ immediate, // expected_delay
|
|
|
+ });
|
|
|
+
|
|
|
+ // The condition becomes true, but the timeout has already expired:
|
|
|
+ values.push_back(TimeoutTestParam{
|
|
|
+ __FILE__, __LINE__, use_absolute_deadline,
|
|
|
+ negative, // wait_timeout
|
|
|
+ finite, // satisfy_condition_delay
|
|
|
+ false, // expected_result
|
|
|
+ immediate // expected_delay
|
|
|
+ });
|
|
|
+
|
|
|
+ // The condition never becomes true:
|
|
|
+ values.push_back(TimeoutTestParam{
|
|
|
+ __FILE__, __LINE__, use_absolute_deadline,
|
|
|
+ negative, // wait_timeout
|
|
|
+ never, // satisfy_condition_delay
|
|
|
+ false, // expected_result
|
|
|
+ immediate // expected_delay
|
|
|
+ });
|
|
|
+
|
|
|
+ // Tests with an infinite timeout (deadline in the infinite future), which
|
|
|
+ // should only return when the condition becomes true.
|
|
|
+
|
|
|
+ // The condition is already true:
|
|
|
+ values.push_back(TimeoutTestParam{
|
|
|
+ __FILE__, __LINE__, use_absolute_deadline,
|
|
|
+ never, // wait_timeout
|
|
|
+ immediate, // satisfy_condition_delay
|
|
|
+ true, // expected_result
|
|
|
+ immediate // expected_delay
|
|
|
+ });
|
|
|
+
|
|
|
+ // The condition becomes true before the (infinite) expiry:
|
|
|
+ values.push_back(TimeoutTestParam{
|
|
|
+ __FILE__, __LINE__, use_absolute_deadline,
|
|
|
+ never, // wait_timeout
|
|
|
+ finite, // satisfy_condition_delay
|
|
|
+ true, // expected_result
|
|
|
+ finite, // expected_delay
|
|
|
+ });
|
|
|
+
|
|
|
+ // Tests with a (small) finite timeout (deadline soon), with the condition
|
|
|
+ // becoming true both before and after its expiry.
|
|
|
+
|
|
|
+ // The condition is already true:
|
|
|
+ values.push_back(TimeoutTestParam{
|
|
|
+ __FILE__, __LINE__, use_absolute_deadline,
|
|
|
+ never, // wait_timeout
|
|
|
+ immediate, // satisfy_condition_delay
|
|
|
+ true, // expected_result
|
|
|
+ immediate // expected_delay
|
|
|
+ });
|
|
|
+
|
|
|
+ // The condition becomes true before the expiry:
|
|
|
+ values.push_back(TimeoutTestParam{
|
|
|
+ __FILE__, __LINE__, use_absolute_deadline,
|
|
|
+ finite * 2, // wait_timeout
|
|
|
+ finite, // satisfy_condition_delay
|
|
|
+ true, // expected_result
|
|
|
+ finite // expected_delay
|
|
|
+ });
|
|
|
+
|
|
|
+ // The condition becomes true, but the timeout has already expired:
|
|
|
+ values.push_back(TimeoutTestParam{
|
|
|
+ __FILE__, __LINE__, use_absolute_deadline,
|
|
|
+ finite, // wait_timeout
|
|
|
+ finite * 2, // satisfy_condition_delay
|
|
|
+ false, // expected_result
|
|
|
+ finite // expected_delay
|
|
|
+ });
|
|
|
+
|
|
|
+ // The condition never becomes true:
|
|
|
+ values.push_back(TimeoutTestParam{
|
|
|
+ __FILE__, __LINE__, use_absolute_deadline,
|
|
|
+ finite, // wait_timeout
|
|
|
+ never, // satisfy_condition_delay
|
|
|
+ false, // expected_result
|
|
|
+ finite // expected_delay
|
|
|
+ });
|
|
|
}
|
|
|
-
|
|
|
- bool WaitWithTimeout(absl::Duration timeout) {
|
|
|
- absl::MutexLock lock(&mu_);
|
|
|
- absl::Time deadline = absl::Now() + timeout;
|
|
|
- if (use_deadline_) {
|
|
|
- while (!b_ && !cv_.WaitWithDeadline(&mu_, deadline)) {
|
|
|
- }
|
|
|
- } else {
|
|
|
- while (!b_ && !cv_.WaitWithTimeout(&mu_, timeout)) {
|
|
|
- timeout = deadline - absl::Now(); // recompute timeout
|
|
|
- }
|
|
|
+ return values;
|
|
|
+}
|
|
|
+
|
|
|
+// Instantiate `TimeoutTest` with `MakeTimeoutTestParamValues()`.
|
|
|
+INSTANTIATE_TEST_CASE_P(All, TimeoutTest,
|
|
|
+ testing::ValuesIn(MakeTimeoutTestParamValues()));
|
|
|
+
|
|
|
+TEST_P(TimeoutTest, Await) {
|
|
|
+ const TimeoutTestParam params = GetParam();
|
|
|
+ ABSL_RAW_LOG(INFO, "Params: %s", FormatString(params).c_str());
|
|
|
+
|
|
|
+ // Because this test asserts bounds on scheduling delays it is flaky. To
|
|
|
+ // compensate it loops forever until it passes. Failures express as test
|
|
|
+ // timeouts, in which case the test log can be used to diagnose the issue.
|
|
|
+ for (int attempt = 1;; ++attempt) {
|
|
|
+ ABSL_RAW_LOG(INFO, "Attempt %d", attempt);
|
|
|
+
|
|
|
+ absl::Mutex mu;
|
|
|
+ bool value = false; // condition value (under mu)
|
|
|
+
|
|
|
+ std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
|
|
|
+ CreateDefaultPool();
|
|
|
+ RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
|
|
|
+ absl::MutexLock l(&mu);
|
|
|
+ value = true;
|
|
|
+ });
|
|
|
+
|
|
|
+ absl::MutexLock lock(&mu);
|
|
|
+ absl::Time start_time = absl::Now();
|
|
|
+ absl::Condition cond(&value);
|
|
|
+ bool result =
|
|
|
+ params.use_absolute_deadline
|
|
|
+ ? mu.AwaitWithDeadline(cond, start_time + params.wait_timeout)
|
|
|
+ : mu.AwaitWithTimeout(cond, params.wait_timeout);
|
|
|
+ if (DelayIsWithinBounds(params.expected_delay, absl::Now() - start_time)) {
|
|
|
+ EXPECT_EQ(params.expected_result, result);
|
|
|
+ break;
|
|
|
}
|
|
|
- return b_;
|
|
|
- }
|
|
|
-
|
|
|
- void Wait() {
|
|
|
- absl::MutexLock lock(&mu_);
|
|
|
- while (!b_) cv_.Wait(&mu_);
|
|
|
- }
|
|
|
-
|
|
|
- private:
|
|
|
- const bool use_deadline_;
|
|
|
-
|
|
|
- bool b_;
|
|
|
- absl::Condition c_;
|
|
|
- absl::CondVar cv_;
|
|
|
- absl::Mutex mu_;
|
|
|
-};
|
|
|
-
|
|
|
-class OperationTimer {
|
|
|
- public:
|
|
|
- OperationTimer() : start_(absl::Now()) {}
|
|
|
- absl::Duration Get() const { return absl::Now() - start_; }
|
|
|
-
|
|
|
- private:
|
|
|
- const absl::Time start_;
|
|
|
-};
|
|
|
-
|
|
|
-static void CheckResults(bool exp_result, bool act_result,
|
|
|
- absl::Duration exp_duration,
|
|
|
- absl::Duration act_duration) {
|
|
|
- ABSL_RAW_CHECK(exp_result == act_result, "CheckResults failed");
|
|
|
- // Allow for some worse-case scheduling delay and clock skew.
|
|
|
- if ((exp_duration - absl::Milliseconds(40) > act_duration) ||
|
|
|
- (exp_duration + absl::Milliseconds(150) < act_duration)) {
|
|
|
- ABSL_RAW_LOG(FATAL, "CheckResults failed: operation took %s, expected %s",
|
|
|
- absl::FormatDuration(act_duration).c_str(),
|
|
|
- absl::FormatDuration(exp_duration).c_str());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-static void TestAwaitTimeout(Cond *cp, absl::Duration timeout, bool exp_result,
|
|
|
- absl::Duration exp_duration) {
|
|
|
- OperationTimer t;
|
|
|
- bool act_result = cp->AwaitWithTimeout(timeout);
|
|
|
- CheckResults(exp_result, act_result, exp_duration, t.Get());
|
|
|
-}
|
|
|
-
|
|
|
-static void TestLockWhenTimeout(Cond *cp, absl::Duration timeout,
|
|
|
- bool exp_result, absl::Duration exp_duration) {
|
|
|
- OperationTimer t;
|
|
|
- bool act_result = cp->LockWhenWithTimeout(timeout);
|
|
|
- CheckResults(exp_result, act_result, exp_duration, t.Get());
|
|
|
-}
|
|
|
+TEST_P(TimeoutTest, LockWhen) {
|
|
|
+ const TimeoutTestParam params = GetParam();
|
|
|
+ ABSL_RAW_LOG(INFO, "Params: %s", FormatString(params).c_str());
|
|
|
+
|
|
|
+ // Because this test asserts bounds on scheduling delays it is flaky. To
|
|
|
+ // compensate it loops forever until it passes. Failures express as test
|
|
|
+ // timeouts, in which case the test log can be used to diagnose the issue.
|
|
|
+ for (int attempt = 1;; ++attempt) {
|
|
|
+ ABSL_RAW_LOG(INFO, "Attempt %d", attempt);
|
|
|
+
|
|
|
+ absl::Mutex mu;
|
|
|
+ bool value = false; // condition value (under mu)
|
|
|
+
|
|
|
+ std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
|
|
|
+ CreateDefaultPool();
|
|
|
+ RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
|
|
|
+ absl::MutexLock l(&mu);
|
|
|
+ value = true;
|
|
|
+ });
|
|
|
+
|
|
|
+ absl::Time start_time = absl::Now();
|
|
|
+ absl::Condition cond(&value);
|
|
|
+ bool result =
|
|
|
+ params.use_absolute_deadline
|
|
|
+ ? mu.LockWhenWithDeadline(cond, start_time + params.wait_timeout)
|
|
|
+ : mu.LockWhenWithTimeout(cond, params.wait_timeout);
|
|
|
+ mu.Unlock();
|
|
|
|
|
|
-static void TestReaderLockWhenTimeout(Cond *cp, absl::Duration timeout,
|
|
|
- bool exp_result,
|
|
|
- absl::Duration exp_duration) {
|
|
|
- OperationTimer t;
|
|
|
- bool act_result = cp->ReaderLockWhenWithTimeout(timeout);
|
|
|
- CheckResults(exp_result, act_result, exp_duration, t.Get());
|
|
|
+ if (DelayIsWithinBounds(params.expected_delay, absl::Now() - start_time)) {
|
|
|
+ EXPECT_EQ(params.expected_result, result);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-static void TestWaitTimeout(Cond *cp, absl::Duration timeout, bool exp_result,
|
|
|
- absl::Duration exp_duration) {
|
|
|
- OperationTimer t;
|
|
|
- bool act_result = cp->WaitWithTimeout(timeout);
|
|
|
- CheckResults(exp_result, act_result, exp_duration, t.Get());
|
|
|
+TEST_P(TimeoutTest, ReaderLockWhen) {
|
|
|
+ const TimeoutTestParam params = GetParam();
|
|
|
+ ABSL_RAW_LOG(INFO, "Params: %s", FormatString(params).c_str());
|
|
|
+
|
|
|
+ // Because this test asserts bounds on scheduling delays it is flaky. To
|
|
|
+ // compensate it loops forever until it passes. Failures express as test
|
|
|
+ // timeouts, in which case the test log can be used to diagnose the issue.
|
|
|
+ for (int attempt = 0;; ++attempt) {
|
|
|
+ ABSL_RAW_LOG(INFO, "Attempt %d", attempt);
|
|
|
+
|
|
|
+ absl::Mutex mu;
|
|
|
+ bool value = false; // condition value (under mu)
|
|
|
+
|
|
|
+ std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
|
|
|
+ CreateDefaultPool();
|
|
|
+ RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
|
|
|
+ absl::MutexLock l(&mu);
|
|
|
+ value = true;
|
|
|
+ });
|
|
|
+
|
|
|
+ absl::Time start_time = absl::Now();
|
|
|
+ bool result =
|
|
|
+ params.use_absolute_deadline
|
|
|
+ ? mu.ReaderLockWhenWithDeadline(absl::Condition(&value),
|
|
|
+ start_time + params.wait_timeout)
|
|
|
+ : mu.ReaderLockWhenWithTimeout(absl::Condition(&value),
|
|
|
+ params.wait_timeout);
|
|
|
+ mu.ReaderUnlock();
|
|
|
+
|
|
|
+ if (DelayIsWithinBounds(params.expected_delay, absl::Now() - start_time)) {
|
|
|
+ EXPECT_EQ(params.expected_result, result);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-// Tests with a negative timeout (deadline in the past), which should
|
|
|
-// immediately return the current state of the condition.
|
|
|
-static void TestNegativeTimeouts(absl::synchronization_internal::ThreadPool *tp,
|
|
|
- Cond *cp) {
|
|
|
- const absl::Duration negative = -absl::InfiniteDuration();
|
|
|
- const absl::Duration immediate = absl::ZeroDuration();
|
|
|
-
|
|
|
- // The condition is already true:
|
|
|
- cp->Set(true);
|
|
|
- TestAwaitTimeout(cp, negative, true, immediate);
|
|
|
- TestLockWhenTimeout(cp, negative, true, immediate);
|
|
|
- TestReaderLockWhenTimeout(cp, negative, true, immediate);
|
|
|
- TestWaitTimeout(cp, negative, true, immediate);
|
|
|
-
|
|
|
- // The condition becomes true, but the timeout has already expired:
|
|
|
- const absl::Duration delay = absl::Milliseconds(200);
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), 3 * delay);
|
|
|
- TestAwaitTimeout(cp, negative, false, immediate);
|
|
|
- TestLockWhenTimeout(cp, negative, false, immediate);
|
|
|
- TestReaderLockWhenTimeout(cp, negative, false, immediate);
|
|
|
- cp->Await(); // wait for the scheduled Set() to complete
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay);
|
|
|
- TestWaitTimeout(cp, negative, false, immediate);
|
|
|
- cp->Wait(); // wait for the scheduled Signal() to complete
|
|
|
-
|
|
|
- // The condition never becomes true:
|
|
|
- cp->Set(false);
|
|
|
- TestAwaitTimeout(cp, negative, false, immediate);
|
|
|
- TestLockWhenTimeout(cp, negative, false, immediate);
|
|
|
- TestReaderLockWhenTimeout(cp, negative, false, immediate);
|
|
|
- TestWaitTimeout(cp, negative, false, immediate);
|
|
|
-}
|
|
|
-
|
|
|
-// Tests with an infinite timeout (deadline in the infinite future), which
|
|
|
-// should only return when the condition becomes true.
|
|
|
-static void TestInfiniteTimeouts(absl::synchronization_internal::ThreadPool *tp,
|
|
|
- Cond *cp) {
|
|
|
- const absl::Duration infinite = absl::InfiniteDuration();
|
|
|
- const absl::Duration immediate = absl::ZeroDuration();
|
|
|
-
|
|
|
- // The condition is already true:
|
|
|
- cp->Set(true);
|
|
|
- TestAwaitTimeout(cp, infinite, true, immediate);
|
|
|
- TestLockWhenTimeout(cp, infinite, true, immediate);
|
|
|
- TestReaderLockWhenTimeout(cp, infinite, true, immediate);
|
|
|
- TestWaitTimeout(cp, infinite, true, immediate);
|
|
|
-
|
|
|
- // The condition becomes true before the (infinite) expiry:
|
|
|
- const absl::Duration delay = absl::Milliseconds(200);
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay);
|
|
|
- TestAwaitTimeout(cp, infinite, true, delay);
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay);
|
|
|
- TestLockWhenTimeout(cp, infinite, true, delay);
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay);
|
|
|
- TestReaderLockWhenTimeout(cp, infinite, true, delay);
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay);
|
|
|
- TestWaitTimeout(cp, infinite, true, delay);
|
|
|
-}
|
|
|
-
|
|
|
-// Tests with a (small) finite timeout (deadline soon), with the condition
|
|
|
-// becoming true both before and after its expiry.
|
|
|
-static void TestFiniteTimeouts(absl::synchronization_internal::ThreadPool *tp,
|
|
|
- Cond *cp) {
|
|
|
- const absl::Duration finite = absl::Milliseconds(400);
|
|
|
- const absl::Duration immediate = absl::ZeroDuration();
|
|
|
+TEST_P(TimeoutTest, Wait) {
|
|
|
+ const TimeoutTestParam params = GetParam();
|
|
|
+ ABSL_RAW_LOG(INFO, "Params: %s", FormatString(params).c_str());
|
|
|
+
|
|
|
+ // Because this test asserts bounds on scheduling delays it is flaky. To
|
|
|
+ // compensate it loops forever until it passes. Failures express as test
|
|
|
+ // timeouts, in which case the test log can be used to diagnose the issue.
|
|
|
+ for (int attempt = 0;; ++attempt) {
|
|
|
+ ABSL_RAW_LOG(INFO, "Attempt %d", attempt);
|
|
|
+
|
|
|
+ absl::Mutex mu;
|
|
|
+ bool value = false; // condition value (under mu)
|
|
|
+ absl::CondVar cv; // signals a change of `value`
|
|
|
+
|
|
|
+ std::unique_ptr<absl::synchronization_internal::ThreadPool> pool =
|
|
|
+ CreateDefaultPool();
|
|
|
+ RunAfterDelay(params.satisfy_condition_delay, pool.get(), [&] {
|
|
|
+ absl::MutexLock l(&mu);
|
|
|
+ value = true;
|
|
|
+ cv.Signal();
|
|
|
+ });
|
|
|
+
|
|
|
+ absl::MutexLock lock(&mu);
|
|
|
+ absl::Time start_time = absl::Now();
|
|
|
+ absl::Duration timeout = params.wait_timeout;
|
|
|
+ absl::Time deadline = start_time + timeout;
|
|
|
+ while (!value) {
|
|
|
+ if (params.use_absolute_deadline ? cv.WaitWithDeadline(&mu, deadline)
|
|
|
+ : cv.WaitWithTimeout(&mu, timeout)) {
|
|
|
+ break; // deadline/timeout exceeded
|
|
|
+ }
|
|
|
+ timeout = deadline - absl::Now(); // recompute
|
|
|
+ }
|
|
|
+ bool result = value; // note: `mu` is still held
|
|
|
|
|
|
- // The condition is already true:
|
|
|
- cp->Set(true);
|
|
|
- TestAwaitTimeout(cp, finite, true, immediate);
|
|
|
- TestLockWhenTimeout(cp, finite, true, immediate);
|
|
|
- TestReaderLockWhenTimeout(cp, finite, true, immediate);
|
|
|
- TestWaitTimeout(cp, finite, true, immediate);
|
|
|
-
|
|
|
- // The condition becomes true before the expiry:
|
|
|
- const absl::Duration delay1 = finite / 2;
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay1);
|
|
|
- TestAwaitTimeout(cp, finite, true, delay1);
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay1);
|
|
|
- TestLockWhenTimeout(cp, finite, true, delay1);
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay1);
|
|
|
- TestReaderLockWhenTimeout(cp, finite, true, delay1);
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay1);
|
|
|
- TestWaitTimeout(cp, finite, true, delay1);
|
|
|
-
|
|
|
- // The condition becomes true, but the timeout has already expired:
|
|
|
- const absl::Duration delay2 = finite * 2;
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), 3 * delay2);
|
|
|
- TestAwaitTimeout(cp, finite, false, finite);
|
|
|
- TestLockWhenTimeout(cp, finite, false, finite);
|
|
|
- TestReaderLockWhenTimeout(cp, finite, false, finite);
|
|
|
- cp->Await(); // wait for the scheduled Set() to complete
|
|
|
- cp->Set(false);
|
|
|
- ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay2);
|
|
|
- TestWaitTimeout(cp, finite, false, finite);
|
|
|
- cp->Wait(); // wait for the scheduled Signal() to complete
|
|
|
-
|
|
|
- // The condition never becomes true:
|
|
|
- cp->Set(false);
|
|
|
- TestAwaitTimeout(cp, finite, false, finite);
|
|
|
- TestLockWhenTimeout(cp, finite, false, finite);
|
|
|
- TestReaderLockWhenTimeout(cp, finite, false, finite);
|
|
|
- TestWaitTimeout(cp, finite, false, finite);
|
|
|
-}
|
|
|
-
|
|
|
-TEST(Mutex, Timeouts) {
|
|
|
- auto tp = CreateDefaultPool();
|
|
|
- for (bool use_deadline : {false, true}) {
|
|
|
- Cond cond(use_deadline);
|
|
|
- TestNegativeTimeouts(tp.get(), &cond);
|
|
|
- TestInfiniteTimeouts(tp.get(), &cond);
|
|
|
- TestFiniteTimeouts(tp.get(), &cond);
|
|
|
+ if (DelayIsWithinBounds(params.expected_delay, absl::Now() - start_time)) {
|
|
|
+ EXPECT_EQ(params.expected_result, result);
|
|
|
+ break;
|
|
|
+ }
|
|
|
}
|
|
|
}
|
|
|
|
Abseil Team