condition_variable revision 302408
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 17namespace std 18{ 19 20enum class cv_status { no_timeout, timeout }; 21 22class condition_variable 23{ 24public: 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 64void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); 65 66class condition_variable_any 67{ 68public: 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 122class _LIBCPP_TYPE_VIS condition_variable_any 123{ 124 condition_variable __cv_; 125 shared_ptr<mutex> __mut_; 126public: 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 void wait(_Lock& __lock); 137 template <class _Lock, class _Predicate> 138 _LIBCPP_INLINE_VISIBILITY 139 void wait(_Lock& __lock, _Predicate __pred); 140 141 template <class _Lock, class _Clock, class _Duration> 142 cv_status 143 wait_until(_Lock& __lock, 144 const chrono::time_point<_Clock, _Duration>& __t); 145 146 template <class _Lock, class _Clock, class _Duration, class _Predicate> 147 bool 148 _LIBCPP_INLINE_VISIBILITY 149 wait_until(_Lock& __lock, 150 const chrono::time_point<_Clock, _Duration>& __t, 151 _Predicate __pred); 152 153 template <class _Lock, class _Rep, class _Period> 154 cv_status 155 _LIBCPP_INLINE_VISIBILITY 156 wait_for(_Lock& __lock, 157 const chrono::duration<_Rep, _Period>& __d); 158 159 template <class _Lock, class _Rep, class _Period, class _Predicate> 160 bool 161 _LIBCPP_INLINE_VISIBILITY 162 wait_for(_Lock& __lock, 163 const chrono::duration<_Rep, _Period>& __d, 164 _Predicate __pred); 165}; 166 167inline 168condition_variable_any::condition_variable_any() 169 : __mut_(make_shared<mutex>()) {} 170 171inline 172void 173condition_variable_any::notify_one() _NOEXCEPT 174{ 175 {lock_guard<mutex> __lx(*__mut_);} 176 __cv_.notify_one(); 177} 178 179inline 180void 181condition_variable_any::notify_all() _NOEXCEPT 182{ 183 {lock_guard<mutex> __lx(*__mut_);} 184 __cv_.notify_all(); 185} 186 187struct __lock_external 188{ 189 template <class _Lock> 190 void operator()(_Lock* __m) {__m->lock();} 191}; 192 193template <class _Lock> 194void 195condition_variable_any::wait(_Lock& __lock) 196{ 197 shared_ptr<mutex> __mut = __mut_; 198 unique_lock<mutex> __lk(*__mut); 199 __lock.unlock(); 200 unique_ptr<_Lock, __lock_external> __lxx(&__lock); 201 lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock); 202 __cv_.wait(__lk); 203} // __mut_.unlock(), __lock.lock() 204 205template <class _Lock, class _Predicate> 206inline 207void 208condition_variable_any::wait(_Lock& __lock, _Predicate __pred) 209{ 210 while (!__pred()) 211 wait(__lock); 212} 213 214template <class _Lock, class _Clock, class _Duration> 215cv_status 216condition_variable_any::wait_until(_Lock& __lock, 217 const chrono::time_point<_Clock, _Duration>& __t) 218{ 219 shared_ptr<mutex> __mut = __mut_; 220 unique_lock<mutex> __lk(*__mut); 221 __lock.unlock(); 222 unique_ptr<_Lock, __lock_external> __lxx(&__lock); 223 lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock); 224 return __cv_.wait_until(__lk, __t); 225} // __mut_.unlock(), __lock.lock() 226 227template <class _Lock, class _Clock, class _Duration, class _Predicate> 228inline 229bool 230condition_variable_any::wait_until(_Lock& __lock, 231 const chrono::time_point<_Clock, _Duration>& __t, 232 _Predicate __pred) 233{ 234 while (!__pred()) 235 if (wait_until(__lock, __t) == cv_status::timeout) 236 return __pred(); 237 return true; 238} 239 240template <class _Lock, class _Rep, class _Period> 241inline 242cv_status 243condition_variable_any::wait_for(_Lock& __lock, 244 const chrono::duration<_Rep, _Period>& __d) 245{ 246 return wait_until(__lock, chrono::steady_clock::now() + __d); 247} 248 249template <class _Lock, class _Rep, class _Period, class _Predicate> 250inline 251bool 252condition_variable_any::wait_for(_Lock& __lock, 253 const chrono::duration<_Rep, _Period>& __d, 254 _Predicate __pred) 255{ 256 return wait_until(__lock, chrono::steady_clock::now() + __d, 257 _VSTD::move(__pred)); 258} 259 260_LIBCPP_FUNC_VIS 261void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); 262 263_LIBCPP_END_NAMESPACE_STD 264 265#endif // !_LIBCPP_HAS_NO_THREADS 266 267#endif // _LIBCPP_CONDITION_VARIABLE 268