contrib/libc++/include/condition_variable

   1 // -*- C++ -*-
   2 //===---------------------- condition_variable ----------------------------===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is dual licensed under the MIT and the University of Illinois Open
   7 // Source Licenses. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef _LIBCPP_CONDITION_VARIABLE
  12 #define _LIBCPP_CONDITION_VARIABLE
  13
  14 /*
  15     condition_variable synopsis
  16
  17 namespace std
  18 {
  19
  20 enum class cv_status { no_timeout, timeout };
  21
  22 class condition_variable
  23 {
  24 public:
  25     condition_variable();
  26     ~condition_variable();
  27
  28     condition_variable(const condition_variable&) = delete;
  29     condition_variable& operator=(const condition_variable&) = delete;
  30
  31     void notify_one() noexcept;
  32     void notify_all() noexcept;
  33
  34     void wait(unique_lock<mutex>& lock);
  35     template <class Predicate>
  36         void wait(unique_lock<mutex>& lock, Predicate pred);
  37
  38     template <class Clock, class Duration>
  39         cv_status
  40         wait_until(unique_lock<mutex>& lock,
  41                    const chrono::time_point<Clock, Duration>& abs_time);
  42
  43     template <class Clock, class Duration, class Predicate>
  44         bool
  45         wait_until(unique_lock<mutex>& lock,
  46                    const chrono::time_point<Clock, Duration>& abs_time,
  47                    Predicate pred);
  48
  49     template <class Rep, class Period>
  50         cv_status
  51         wait_for(unique_lock<mutex>& lock,
  52                  const chrono::duration<Rep, Period>& rel_time);
  53
  54     template <class Rep, class Period, class Predicate>
  55         bool
  56         wait_for(unique_lock<mutex>& lock,
  57                  const chrono::duration<Rep, Period>& rel_time,
  58                  Predicate pred);
  59
  60     typedef pthread_cond_t* native_handle_type;
  61     native_handle_type native_handle();
  62 };
  63
  64 void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
  65
  66 class condition_variable_any
  67 {
  68 public:
  69     condition_variable_any();
  70     ~condition_variable_any();
  71
  72     condition_variable_any(const condition_variable_any&) = delete;
  73     condition_variable_any& operator=(const condition_variable_any&) = delete;
  74
  75     void notify_one() noexcept;
  76     void notify_all() noexcept;
  77
  78     template <class Lock>
  79         void wait(Lock& lock);
  80     template <class Lock, class Predicate>
  81         void wait(Lock& lock, Predicate pred);
  82
  83     template <class Lock, class Clock, class Duration>
  84         cv_status
  85         wait_until(Lock& lock,
  86                    const chrono::time_point<Clock, Duration>& abs_time);
  87
  88     template <class Lock, class Clock, class Duration, class Predicate>
  89         bool
  90         wait_until(Lock& lock,
  91                    const chrono::time_point<Clock, Duration>& abs_time,
  92                    Predicate pred);
  93
  94     template <class Lock, class Rep, class Period>
  95         cv_status
  96         wait_for(Lock& lock,
  97                  const chrono::duration<Rep, Period>& rel_time);
  98
  99     template <class Lock, class Rep, class Period, class Predicate>
 100         bool
 101         wait_for(Lock& lock,
 102                  const chrono::duration<Rep, Period>& rel_time,
 103                  Predicate pred);
 104 };
 105
 106 }  // std
 107
 108 */
 109
 110 #include <__config>
 111 #include <__mutex_base>
 112 #include <memory>
 113
 114 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 115 #pragma GCC system_header
 116 #endif
 117
 118 #ifndef _LIBCPP_HAS_NO_THREADS
 119
 120 _LIBCPP_BEGIN_NAMESPACE_STD
 121
 122 class _LIBCPP_TYPE_VIS condition_variable_any
 123 {
 124     condition_variable __cv_;
 125     shared_ptr<mutex>  __mut_;
 126 public:
 127     _LIBCPP_INLINE_VISIBILITY
 128     condition_variable_any();
 129
 130     _LIBCPP_INLINE_VISIBILITY
 131     void notify_one() _NOEXCEPT;
 132     _LIBCPP_INLINE_VISIBILITY
 133     void notify_all() _NOEXCEPT;
 134
 135     template <class _Lock>
 136         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 137         void wait(_Lock& __lock);
 138     template <class _Lock, class _Predicate>
 139         _LIBCPP_INLINE_VISIBILITY
 140         void wait(_Lock& __lock, _Predicate __pred);
 141
 142     template <class _Lock, class _Clock, class _Duration>
 143         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 144         cv_status
 145         wait_until(_Lock& __lock,
 146                    const chrono::time_point<_Clock, _Duration>& __t);
 147
 148     template <class _Lock, class _Clock, class _Duration, class _Predicate>
 149         bool
 150         _LIBCPP_INLINE_VISIBILITY
 151         wait_until(_Lock& __lock,
 152                    const chrono::time_point<_Clock, _Duration>& __t,
 153                    _Predicate __pred);
 154
 155     template <class _Lock, class _Rep, class _Period>
 156         cv_status
 157         _LIBCPP_INLINE_VISIBILITY
 158         wait_for(_Lock& __lock,
 159                  const chrono::duration<_Rep, _Period>& __d);
 160
 161     template <class _Lock, class _Rep, class _Period, class _Predicate>
 162         bool
 163         _LIBCPP_INLINE_VISIBILITY
 164         wait_for(_Lock& __lock,
 165                  const chrono::duration<_Rep, _Period>& __d,
 166                  _Predicate __pred);
 167 };
 168
 169 inline
 170 condition_variable_any::condition_variable_any()
 171     : __mut_(make_shared<mutex>()) {}
 172
 173 inline
 174 void
 175 condition_variable_any::notify_one() _NOEXCEPT
 176 {
 177     {lock_guard<mutex> __lx(*__mut_);}
 178     __cv_.notify_one();
 179 }
 180
 181 inline
 182 void
 183 condition_variable_any::notify_all() _NOEXCEPT
 184 {
 185     {lock_guard<mutex> __lx(*__mut_);}
 186     __cv_.notify_all();
 187 }
 188
 189 struct __lock_external
 190 {
 191     template <class _Lock>
 192     void operator()(_Lock* __m) {__m->lock();}
 193 };
 194
 195 template <class _Lock>
 196 void
 197 condition_variable_any::wait(_Lock& __lock)
 198 {
 199     shared_ptr<mutex> __mut = __mut_;
 200     unique_lock<mutex> __lk(*__mut);
 201     __lock.unlock();
 202     unique_ptr<_Lock, __lock_external> __lxx(&__lock);
 203     lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
 204     __cv_.wait(__lk);
 205 }  // __mut_.unlock(), __lock.lock()
 206
 207 template <class _Lock, class _Predicate>
 208 inline
 209 void
 210 condition_variable_any::wait(_Lock& __lock, _Predicate __pred)
 211 {
 212     while (!__pred())
 213         wait(__lock);
 214 }
 215
 216 template <class _Lock, class _Clock, class _Duration>
 217 cv_status
 218 condition_variable_any::wait_until(_Lock& __lock,
 219                                    const chrono::time_point<_Clock, _Duration>& __t)
 220 {
 221     shared_ptr<mutex> __mut = __mut_;
 222     unique_lock<mutex> __lk(*__mut);
 223     __lock.unlock();
 224     unique_ptr<_Lock, __lock_external> __lxx(&__lock);
 225     lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
 226     return __cv_.wait_until(__lk, __t);
 227 }  // __mut_.unlock(), __lock.lock()
 228
 229 template <class _Lock, class _Clock, class _Duration, class _Predicate>
 230 inline
 231 bool
 232 condition_variable_any::wait_until(_Lock& __lock,
 233                                    const chrono::time_point<_Clock, _Duration>& __t,
 234                                    _Predicate __pred)
 235 {
 236     while (!__pred())
 237         if (wait_until(__lock, __t) == cv_status::timeout)
 238             return __pred();
 239     return true;
 240 }
 241
 242 template <class _Lock, class _Rep, class _Period>
 243 inline
 244 cv_status
 245 condition_variable_any::wait_for(_Lock& __lock,
 246                                  const chrono::duration<_Rep, _Period>& __d)
 247 {
 248     return wait_until(__lock, chrono::steady_clock::now() + __d);
 249 }
 250
 251 template <class _Lock, class _Rep, class _Period, class _Predicate>
 252 inline
 253 bool
 254 condition_variable_any::wait_for(_Lock& __lock,
 255                                  const chrono::duration<_Rep, _Period>& __d,
 256                                  _Predicate __pred)
 257 {
 258     return wait_until(__lock, chrono::steady_clock::now() + __d,
 259                       _VSTD::move(__pred));
 260 }
 261
 262 _LIBCPP_FUNC_VIS
 263 void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
 264
 265 _LIBCPP_END_NAMESPACE_STD
 266
 267 #endif // !_LIBCPP_HAS_NO_THREADS
 268
 269 #endif  // _LIBCPP_CONDITION_VARIABLE