1// -*- C++ -*- 2//===----------------------------------------------------------------------===// 3// 4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5// See https://llvm.org/LICENSE.txt for license information. 6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef _LIBCPP_CONDITION_VARIABLE 11#define _LIBCPP_CONDITION_VARIABLE 12 13/* 14 condition_variable synopsis 15 16namespace std 17{ 18 19enum class cv_status { no_timeout, timeout }; 20 21class condition_variable 22{ 23public: 24 condition_variable(); 25 ~condition_variable(); 26 27 condition_variable(const condition_variable&) = delete; 28 condition_variable& operator=(const condition_variable&) = delete; 29 30 void notify_one() noexcept; 31 void notify_all() noexcept; 32 33 void wait(unique_lock<mutex>& lock); 34 template <class Predicate> 35 void wait(unique_lock<mutex>& lock, Predicate pred); 36 37 template <class Clock, class Duration> 38 cv_status 39 wait_until(unique_lock<mutex>& lock, 40 const chrono::time_point<Clock, Duration>& abs_time); 41 42 template <class Clock, class Duration, class Predicate> 43 bool 44 wait_until(unique_lock<mutex>& lock, 45 const chrono::time_point<Clock, Duration>& abs_time, 46 Predicate pred); 47 48 template <class Rep, class Period> 49 cv_status 50 wait_for(unique_lock<mutex>& lock, 51 const chrono::duration<Rep, Period>& rel_time); 52 53 template <class Rep, class Period, class Predicate> 54 bool 55 wait_for(unique_lock<mutex>& lock, 56 const chrono::duration<Rep, Period>& rel_time, 57 Predicate pred); 58 59 typedef pthread_cond_t* native_handle_type; 60 native_handle_type native_handle(); 61}; 62 63void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk); 64 65class condition_variable_any 66{ 67public: 68 condition_variable_any(); 69 ~condition_variable_any(); 70 71 condition_variable_any(const condition_variable_any&) = delete; 72 condition_variable_any& operator=(const condition_variable_any&) = delete; 73 74 void notify_one() noexcept; 75 void notify_all() noexcept; 76 77 template <class Lock> 78 void wait(Lock& lock); 79 template <class Lock, class Predicate> 80 void wait(Lock& lock, Predicate pred); 81 82 template <class Lock, class Clock, class Duration> 83 cv_status 84 wait_until(Lock& lock, 85 const chrono::time_point<Clock, Duration>& abs_time); 86 87 template <class Lock, class Clock, class Duration, class Predicate> 88 bool 89 wait_until(Lock& lock, 90 const chrono::time_point<Clock, Duration>& abs_time, 91 Predicate pred); 92 93 template <class Lock, class Rep, class Period> 94 cv_status 95 wait_for(Lock& lock, 96 const chrono::duration<Rep, Period>& rel_time); 97 98 template <class Lock, class Rep, class Period, class Predicate> 99 bool 100 wait_for(Lock& lock, 101 const chrono::duration<Rep, Period>& rel_time, 102 Predicate pred); 103 104 // [thread.condvarany.intwait], interruptible waits 105 template <class Lock, class Predicate> 106 bool wait(Lock& lock, stop_token stoken, Predicate pred); // since C++20 107 108 template <class Lock, class Clock, class Duration, class Predicate> 109 bool wait_until(Lock& lock, stop_token stoken, 110 const chrono::time_point<Clock, Duration>& abs_time, Predicate pred); // since C++20 111 112 template <class Lock, class Rep, class Period, class Predicate> 113 bool wait_for(Lock& lock, stop_token stoken, 114 const chrono::duration<Rep, Period>& rel_time, Predicate pred); // since C++20 115}; 116 117} // std 118 119*/ 120 121#include <__assert> // all public C++ headers provide the assertion handler 122#include <__availability> 123#include <__chrono/duration.h> 124#include <__chrono/steady_clock.h> 125#include <__chrono/time_point.h> 126#include <__condition_variable/condition_variable.h> 127#include <__config> 128#include <__memory/shared_ptr.h> 129#include <__mutex/lock_guard.h> 130#include <__mutex/mutex.h> 131#include <__mutex/tag_types.h> 132#include <__mutex/unique_lock.h> 133#include <__stop_token/stop_callback.h> 134#include <__stop_token/stop_token.h> 135#include <__utility/move.h> 136#include <version> 137 138#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 139# pragma GCC system_header 140#endif 141 142_LIBCPP_PUSH_MACROS 143#include <__undef_macros> 144 145#ifndef _LIBCPP_HAS_NO_THREADS 146 147_LIBCPP_BEGIN_NAMESPACE_STD 148 149class _LIBCPP_EXPORTED_FROM_ABI condition_variable_any { 150 condition_variable __cv_; 151 shared_ptr<mutex> __mut_; 152 153public: 154 _LIBCPP_HIDE_FROM_ABI condition_variable_any(); 155 156 _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT; 157 _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT; 158 159 template <class _Lock> 160 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS void wait(_Lock& __lock); 161 template <class _Lock, class _Predicate> 162 _LIBCPP_HIDE_FROM_ABI void wait(_Lock& __lock, _Predicate __pred); 163 164 template <class _Lock, class _Clock, class _Duration> 165 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS cv_status 166 wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t); 167 168 template <class _Lock, class _Clock, class _Duration, class _Predicate> 169 bool _LIBCPP_HIDE_FROM_ABI 170 wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred); 171 172 template <class _Lock, class _Rep, class _Period> 173 cv_status _LIBCPP_HIDE_FROM_ABI wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d); 174 175 template <class _Lock, class _Rep, class _Period, class _Predicate> 176 bool _LIBCPP_HIDE_FROM_ABI wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred); 177 178# if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) 179 180 template <class _Lock, class _Predicate> 181 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait(_Lock& __lock, stop_token __stoken, _Predicate __pred); 182 183 template <class _Lock, class _Clock, class _Duration, class _Predicate> 184 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait_until( 185 _Lock& __lock, stop_token __stoken, const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred); 186 187 template <class _Lock, class _Rep, class _Period, class _Predicate> 188 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool 189 wait_for(_Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred); 190 191# endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) 192}; 193 194inline condition_variable_any::condition_variable_any() : __mut_(make_shared<mutex>()) {} 195 196inline void condition_variable_any::notify_one() _NOEXCEPT { 197 { lock_guard<mutex> __lx(*__mut_); } 198 __cv_.notify_one(); 199} 200 201inline void condition_variable_any::notify_all() _NOEXCEPT { 202 { lock_guard<mutex> __lx(*__mut_); } 203 __cv_.notify_all(); 204} 205 206template <class _Lock> 207struct __unlock_guard { 208 _Lock& __lock_; 209 210 _LIBCPP_HIDE_FROM_ABI __unlock_guard(_Lock& __lock) : __lock_(__lock) { __lock_.unlock(); } 211 212 _LIBCPP_HIDE_FROM_ABI ~__unlock_guard() _NOEXCEPT // turns exception to std::terminate 213 { 214 __lock_.lock(); 215 } 216 217 __unlock_guard(const __unlock_guard&) = delete; 218 __unlock_guard& operator=(const __unlock_guard&) = delete; 219}; 220 221template <class _Lock> 222void condition_variable_any::wait(_Lock& __lock) { 223 shared_ptr<mutex> __mut = __mut_; 224 unique_lock<mutex> __lk(*__mut); 225 __unlock_guard<_Lock> __unlock(__lock); 226 lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock_t()); 227 __cv_.wait(__lk); 228} // __mut_.unlock(), __lock.lock() 229 230template <class _Lock, class _Predicate> 231inline void condition_variable_any::wait(_Lock& __lock, _Predicate __pred) { 232 while (!__pred()) 233 wait(__lock); 234} 235 236template <class _Lock, class _Clock, class _Duration> 237cv_status condition_variable_any::wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t) { 238 shared_ptr<mutex> __mut = __mut_; 239 unique_lock<mutex> __lk(*__mut); 240 __unlock_guard<_Lock> __unlock(__lock); 241 lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock_t()); 242 return __cv_.wait_until(__lk, __t); 243} // __mut_.unlock(), __lock.lock() 244 245template <class _Lock, class _Clock, class _Duration, class _Predicate> 246inline bool 247condition_variable_any::wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred) { 248 while (!__pred()) 249 if (wait_until(__lock, __t) == cv_status::timeout) 250 return __pred(); 251 return true; 252} 253 254template <class _Lock, class _Rep, class _Period> 255inline cv_status condition_variable_any::wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d) { 256 return wait_until(__lock, chrono::steady_clock::now() + __d); 257} 258 259template <class _Lock, class _Rep, class _Period, class _Predicate> 260inline bool 261condition_variable_any::wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred) { 262 return wait_until(__lock, chrono::steady_clock::now() + __d, std::move(__pred)); 263} 264 265# if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) 266 267template <class _Lock, class _Predicate> 268bool condition_variable_any::wait(_Lock& __user_lock, stop_token __stoken, _Predicate __pred) { 269 if (__stoken.stop_requested()) 270 return __pred(); 271 272 // Per https://eel.is/c++draft/thread.condition.condvarany#general-note-2, 273 // we do need to take a copy of the shared pointer __mut_ 274 // This ensures that a thread can call the destructor immediately after calling 275 // notify_all, without waiting all the wait calls. 276 // A thread can also safely call the destructor immediately after calling 277 // request_stop, as the call to request_stop would evaluate the callback, 278 // which accesses the internal condition variable, immediately on the same thread. 279 // In this situation, it is OK even without copying a shared ownership the internal 280 // condition variable. However, this needs the evaluation of stop_callback to 281 // happen-before the destruction. 282 // The spec only says "Only the notification to unblock the wait needs to happen 283 // before destruction". To make this work, we need to copy the shared ownership of 284 // the internal condition variable inside this function, which is not possible 285 // with the current ABI. 286 shared_ptr<mutex> __mut = __mut_; 287 288 stop_callback __cb(__stoken, [this] { notify_all(); }); 289 290 while (true) { 291 if (__pred()) 292 return true; 293 294 // We need to take the internal lock before checking stop_requested, 295 // so that the notification cannot come in between the stop_requested 296 // check and entering the wait. 297 // Note that the stop_callback takes the same internal lock before notifying 298 unique_lock<mutex> __internal_lock(*__mut); 299 if (__stoken.stop_requested()) 300 break; 301 302 __unlock_guard<_Lock> __unlock(__user_lock); 303 unique_lock<mutex> __internal_lock2( 304 std::move(__internal_lock)); // switch unlock order between __internal_lock and __user_lock 305 __cv_.wait(__internal_lock2); 306 } // __internal_lock2.unlock(), __user_lock.lock() 307 return __pred(); 308} 309 310template <class _Lock, class _Clock, class _Duration, class _Predicate> 311bool condition_variable_any::wait_until( 312 _Lock& __user_lock, 313 stop_token __stoken, 314 const chrono::time_point<_Clock, _Duration>& __abs_time, 315 _Predicate __pred) { 316 if (__stoken.stop_requested()) 317 return __pred(); 318 319 shared_ptr<mutex> __mut = __mut_; 320 stop_callback __cb(__stoken, [this] { notify_all(); }); 321 322 while (true) { 323 if (__pred()) 324 return true; 325 326 unique_lock<mutex> __internal_lock(*__mut); 327 if (__stoken.stop_requested()) 328 break; 329 330 __unlock_guard<_Lock> __unlock(__user_lock); 331 unique_lock<mutex> __internal_lock2( 332 std::move(__internal_lock)); // switch unlock order between __internal_lock and __user_lock 333 334 if (__cv_.wait_until(__internal_lock2, __abs_time) == cv_status::timeout) 335 break; 336 } // __internal_lock2.unlock(), __user_lock.lock() 337 return __pred(); 338} 339 340template <class _Lock, class _Rep, class _Period, class _Predicate> 341bool condition_variable_any::wait_for( 342 _Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred) { 343 return wait_until(__lock, std::move(__stoken), chrono::steady_clock::now() + __rel_time, std::move(__pred)); 344} 345 346# endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) 347 348_LIBCPP_EXPORTED_FROM_ABI void notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>); 349 350_LIBCPP_END_NAMESPACE_STD 351 352#endif // !_LIBCPP_HAS_NO_THREADS 353 354_LIBCPP_POP_MACROS 355 356#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 357# include <atomic> 358# include <concepts> 359# include <cstdint> 360# include <cstdlib> 361# include <cstring> 362# include <initializer_list> 363# include <iosfwd> 364# include <new> 365# include <stdexcept> 366# include <system_error> 367# include <type_traits> 368# include <typeinfo> 369#endif 370 371#endif // _LIBCPP_CONDITION_VARIABLE 372