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
38 _LIBCPP_DECLARE_STRONG_ENUM(cv_status){no_timeout, timeout};
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>
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>
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>
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>
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>
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>
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
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)
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>
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