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 #ifndef _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
10 #define _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
11
12 #include <__chrono/steady_clock.h>
13 #include <__chrono/system_clock.h>
14 #include <__chrono/time_point.h>
15 #include <__config>
16 #include <__mutex/mutex.h>
17 #include <__mutex/unique_lock.h>
18 #include <__system_error/system_error.h>
19 #include <__threading_support>
20 #include <__type_traits/enable_if.h>
21 #include <__type_traits/is_floating_point.h>
22 #include <__utility/move.h>
23 #include <limits>
24 #include <ratio>
25
26 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
27 # pragma GCC system_header
28 #endif
29
30 _LIBCPP_PUSH_MACROS
31 #include <__undef_macros>
32
33 _LIBCPP_BEGIN_NAMESPACE_STD
34
35 #ifndef _LIBCPP_HAS_NO_THREADS
36
37 // enum class cv_status
_LIBCPP_DECLARE_STRONG_ENUM(cv_status)38 _LIBCPP_DECLARE_STRONG_ENUM(cv_status){no_timeout, timeout};
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(cv_status)39 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(cv_status)
40
41 class _LIBCPP_EXPORTED_FROM_ABI condition_variable {
42 __libcpp_condvar_t __cv_ = _LIBCPP_CONDVAR_INITIALIZER;
43
44 public:
45 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR condition_variable() _NOEXCEPT = default;
46
47 # ifdef _LIBCPP_HAS_TRIVIAL_CONDVAR_DESTRUCTION
48 ~condition_variable() = default;
49 # else
50 ~condition_variable();
51 # endif
52
53 condition_variable(const condition_variable&) = delete;
54 condition_variable& operator=(const condition_variable&) = delete;
55
56 void notify_one() _NOEXCEPT;
57 void notify_all() _NOEXCEPT;
58
59 void wait(unique_lock<mutex>& __lk) _NOEXCEPT;
60 template <class _Predicate>
61 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS void wait(unique_lock<mutex>& __lk, _Predicate __pred);
62
63 template <class _Clock, class _Duration>
64 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS cv_status
65 wait_until(unique_lock<mutex>& __lk, const chrono::time_point<_Clock, _Duration>& __t);
66
67 template <class _Clock, class _Duration, class _Predicate>
68 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool
69 wait_until(unique_lock<mutex>& __lk, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred);
70
71 template <class _Rep, class _Period>
72 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS cv_status
73 wait_for(unique_lock<mutex>& __lk, const chrono::duration<_Rep, _Period>& __d);
74
75 template <class _Rep, class _Period, class _Predicate>
76 bool _LIBCPP_HIDE_FROM_ABI
77 wait_for(unique_lock<mutex>& __lk, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred);
78
79 typedef __libcpp_condvar_t* native_handle_type;
80 _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__cv_; }
81
82 private:
83 void
84 __do_timed_wait(unique_lock<mutex>& __lk, chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT;
85 # if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
86 _LIBCPP_HIDE_FROM_ABI void
87 __do_timed_wait(unique_lock<mutex>& __lk, chrono::time_point<chrono::steady_clock, chrono::nanoseconds>) _NOEXCEPT;
88 # endif
89 template <class _Clock>
90 _LIBCPP_HIDE_FROM_ABI void
91 __do_timed_wait(unique_lock<mutex>& __lk, chrono::time_point<_Clock, chrono::nanoseconds>) _NOEXCEPT;
92 };
93 #endif // !_LIBCPP_HAS_NO_THREADS
94
95 template <class _Rep, class _Period, __enable_if_t<is_floating_point<_Rep>::value, int> = 0>
__safe_nanosecond_cast(chrono::duration<_Rep,_Period> __d)96 inline _LIBCPP_HIDE_FROM_ABI chrono::nanoseconds __safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d) {
97 using namespace chrono;
98 using __ratio = ratio_divide<_Period, nano>;
99 using __ns_rep = nanoseconds::rep;
100 _Rep __result_float = __d.count() * __ratio::num / __ratio::den;
101
102 _Rep __result_max = numeric_limits<__ns_rep>::max();
103 if (__result_float >= __result_max) {
104 return nanoseconds::max();
105 }
106
107 _Rep __result_min = numeric_limits<__ns_rep>::min();
108 if (__result_float <= __result_min) {
109 return nanoseconds::min();
110 }
111
112 return nanoseconds(static_cast<__ns_rep>(__result_float));
113 }
114
115 template <class _Rep, class _Period, __enable_if_t<!is_floating_point<_Rep>::value, int> = 0>
__safe_nanosecond_cast(chrono::duration<_Rep,_Period> __d)116 inline _LIBCPP_HIDE_FROM_ABI chrono::nanoseconds __safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d) {
117 using namespace chrono;
118 if (__d.count() == 0) {
119 return nanoseconds(0);
120 }
121
122 using __ratio = ratio_divide<_Period, nano>;
123 using __ns_rep = nanoseconds::rep;
124 __ns_rep __result_max = numeric_limits<__ns_rep>::max();
125 if (__d.count() > 0 && __d.count() > __result_max / __ratio::num) {
126 return nanoseconds::max();
127 }
128
129 __ns_rep __result_min = numeric_limits<__ns_rep>::min();
130 if (__d.count() < 0 && __d.count() < __result_min / __ratio::num) {
131 return nanoseconds::min();
132 }
133
134 __ns_rep __result = __d.count() * __ratio::num / __ratio::den;
135 if (__result == 0) {
136 return nanoseconds(1);
137 }
138
139 return nanoseconds(__result);
140 }
141
142 #ifndef _LIBCPP_HAS_NO_THREADS
143 template <class _Predicate>
wait(unique_lock<mutex> & __lk,_Predicate __pred)144 void condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred) {
145 while (!__pred())
146 wait(__lk);
147 }
148
149 template <class _Clock, class _Duration>
wait_until(unique_lock<mutex> & __lk,const chrono::time_point<_Clock,_Duration> & __t)150 cv_status condition_variable::wait_until(unique_lock<mutex>& __lk, const chrono::time_point<_Clock, _Duration>& __t) {
151 using namespace chrono;
152 using __clock_tp_ns = time_point<_Clock, nanoseconds>;
153
154 typename _Clock::time_point __now = _Clock::now();
155 if (__t <= __now)
156 return cv_status::timeout;
157
158 __clock_tp_ns __t_ns = __clock_tp_ns(std::__safe_nanosecond_cast(__t.time_since_epoch()));
159
160 __do_timed_wait(__lk, __t_ns);
161 return _Clock::now() < __t ? cv_status::no_timeout : cv_status::timeout;
162 }
163
164 template <class _Clock, class _Duration, class _Predicate>
wait_until(unique_lock<mutex> & __lk,const chrono::time_point<_Clock,_Duration> & __t,_Predicate __pred)165 bool condition_variable::wait_until(
166 unique_lock<mutex>& __lk, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred) {
167 while (!__pred()) {
168 if (wait_until(__lk, __t) == cv_status::timeout)
169 return __pred();
170 }
171 return true;
172 }
173
174 template <class _Rep, class _Period>
wait_for(unique_lock<mutex> & __lk,const chrono::duration<_Rep,_Period> & __d)175 cv_status condition_variable::wait_for(unique_lock<mutex>& __lk, const chrono::duration<_Rep, _Period>& __d) {
176 using namespace chrono;
177 if (__d <= __d.zero())
178 return cv_status::timeout;
179 using __ns_rep = nanoseconds::rep;
180 steady_clock::time_point __c_now = steady_clock::now();
181
182 # if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
183 using __clock_tp_ns = time_point<steady_clock, nanoseconds>;
184 __ns_rep __now_count_ns = std::__safe_nanosecond_cast(__c_now.time_since_epoch()).count();
185 # else
186 using __clock_tp_ns = time_point<system_clock, nanoseconds>;
187 __ns_rep __now_count_ns = std::__safe_nanosecond_cast(system_clock::now().time_since_epoch()).count();
188 # endif
189
190 __ns_rep __d_ns_count = std::__safe_nanosecond_cast(__d).count();
191
192 if (__now_count_ns > numeric_limits<__ns_rep>::max() - __d_ns_count) {
193 __do_timed_wait(__lk, __clock_tp_ns::max());
194 } else {
195 __do_timed_wait(__lk, __clock_tp_ns(nanoseconds(__now_count_ns + __d_ns_count)));
196 }
197
198 return steady_clock::now() - __c_now < __d ? cv_status::no_timeout : cv_status::timeout;
199 }
200
201 template <class _Rep, class _Period, class _Predicate>
202 inline bool
wait_for(unique_lock<mutex> & __lk,const chrono::duration<_Rep,_Period> & __d,_Predicate __pred)203 condition_variable::wait_for(unique_lock<mutex>& __lk, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred) {
204 return wait_until(__lk, chrono::steady_clock::now() + __d, std::move(__pred));
205 }
206
207 # if defined(_LIBCPP_HAS_COND_CLOCKWAIT)
__do_timed_wait(unique_lock<mutex> & __lk,chrono::time_point<chrono::steady_clock,chrono::nanoseconds> __tp)208 inline void condition_variable::__do_timed_wait(
209 unique_lock<mutex>& __lk, chrono::time_point<chrono::steady_clock, chrono::nanoseconds> __tp) _NOEXCEPT {
210 using namespace chrono;
211 if (!__lk.owns_lock())
212 __throw_system_error(EPERM, "condition_variable::timed wait: mutex not locked");
213 nanoseconds __d = __tp.time_since_epoch();
214 timespec __ts;
215 seconds __s = duration_cast<seconds>(__d);
216 using __ts_sec = decltype(__ts.tv_sec);
217 const __ts_sec __ts_sec_max = numeric_limits<__ts_sec>::max();
218 if (__s.count() < __ts_sec_max) {
219 __ts.tv_sec = static_cast<__ts_sec>(__s.count());
220 __ts.tv_nsec = (__d - __s).count();
221 } else {
222 __ts.tv_sec = __ts_sec_max;
223 __ts.tv_nsec = giga::num - 1;
224 }
225 int __ec = pthread_cond_clockwait(&__cv_, __lk.mutex()->native_handle(), CLOCK_MONOTONIC, &__ts);
226 if (__ec != 0 && __ec != ETIMEDOUT)
227 __throw_system_error(__ec, "condition_variable timed_wait failed");
228 }
229 # endif // _LIBCPP_HAS_COND_CLOCKWAIT
230
231 template <class _Clock>
__do_timed_wait(unique_lock<mutex> & __lk,chrono::time_point<_Clock,chrono::nanoseconds> __tp)232 inline void condition_variable::__do_timed_wait(unique_lock<mutex>& __lk,
233 chrono::time_point<_Clock, chrono::nanoseconds> __tp) _NOEXCEPT {
234 wait_for(__lk, __tp - _Clock::now());
235 }
236
237 #endif // _LIBCPP_HAS_NO_THREADS
238
239 _LIBCPP_END_NAMESPACE_STD
240
241 _LIBCPP_POP_MACROS
242
243 #endif // _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
244