libcxx/include/__condition_variable/condition_variable.h

   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