xref: /llvm-project/libcxx/test/std/thread/thread.condition/thread.condition.condvar/wait_until.pass.cpp (revision ac88ad3c805f0cc0ea85975d52b2037940b2d040)
1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 // UNSUPPORTED: no-threads, c++03
10 
11 // <condition_variable>
12 
13 // class condition_variable;
14 
15 // template <class Clock, class Duration>
16 //   cv_status
17 //   wait_until(unique_lock<mutex>& lock,
18 //              const chrono::time_point<Clock, Duration>& abs_time);
19 
20 #include <condition_variable>
21 #include <atomic>
22 #include <cassert>
23 #include <chrono>
24 #include <mutex>
25 #include <thread>
26 
27 #include "make_test_thread.h"
28 #include "test_macros.h"
29 
30 struct TestClock {
31   typedef std::chrono::milliseconds duration;
32   typedef duration::rep rep;
33   typedef duration::period period;
34   typedef std::chrono::time_point<TestClock> time_point;
35   static const bool is_steady = true;
36 
nowTestClock37   static time_point now() {
38     using namespace std::chrono;
39     return time_point(duration_cast<duration>(steady_clock::now().time_since_epoch()));
40   }
41 };
42 
43 template <class Clock>
test()44 void test() {
45   // Test unblocking via a call to notify_one() in another thread.
46   //
47   // To test this, we set a very long timeout in wait_until() and we wait
48   // again in case we get awoken spuriously. Note that it can actually
49   // happen that we get awoken spuriously and fail to recognize it
50   // (making this test useless), but the likelihood should be small.
51   {
52     std::atomic<bool> ready(false);
53     std::atomic<bool> likely_spurious(true);
54     auto timeout = Clock::now() + std::chrono::seconds(3600);
55     std::condition_variable cv;
56     std::mutex mutex;
57 
58     std::thread t1 = support::make_test_thread([&] {
59       std::unique_lock<std::mutex> lock(mutex);
60       ready = true;
61       do {
62         std::cv_status result = cv.wait_until(lock, timeout);
63         assert(result == std::cv_status::no_timeout);
64       } while (likely_spurious);
65 
66       // This can technically fail if we have many spurious awakenings, but in practice the
67       // tolerance is so high that it shouldn't be a problem.
68       assert(Clock::now() < timeout);
69     });
70 
71     std::thread t2 = support::make_test_thread([&] {
72       while (!ready) {
73         // spin
74       }
75 
76       // Acquire the same mutex as t1. This blocks the condition variable inside its wait call
77       // so we can notify it while it is waiting.
78       std::unique_lock<std::mutex> lock(mutex);
79       cv.notify_one();
80       likely_spurious = false;
81       lock.unlock();
82     });
83 
84     t2.join();
85     t1.join();
86   }
87 
88   // Test unblocking via a timeout.
89   //
90   // To test this, we create a thread that waits on a condition variable
91   // with a certain timeout, and we never awaken it. To guard against
92   // spurious wakeups, we wait again whenever we are awoken for a reason
93   // other than a timeout.
94   {
95     auto timeout = Clock::now() + std::chrono::milliseconds(250);
96     std::condition_variable cv;
97     std::mutex mutex;
98 
99     std::thread t1 = support::make_test_thread([&] {
100       std::unique_lock<std::mutex> lock(mutex);
101       std::cv_status result;
102       do {
103         result = cv.wait_until(lock, timeout);
104         if (result == std::cv_status::timeout)
105           assert(Clock::now() >= timeout);
106       } while (result != std::cv_status::timeout);
107     });
108 
109     t1.join();
110   }
111 }
112 
main(int,char **)113 int main(int, char**) {
114   test<TestClock>();
115   test<std::chrono::steady_clock>();
116   return 0;
117 }
118