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_MUTEX 11#define _LIBCPP_MUTEX 12 13/* 14 mutex synopsis 15 16namespace std 17{ 18 19class mutex 20{ 21public: 22 constexpr mutex() noexcept; 23 ~mutex(); 24 25 mutex(const mutex&) = delete; 26 mutex& operator=(const mutex&) = delete; 27 28 void lock(); 29 bool try_lock(); 30 void unlock(); 31 32 typedef pthread_mutex_t* native_handle_type; 33 native_handle_type native_handle(); 34}; 35 36class recursive_mutex 37{ 38public: 39 recursive_mutex(); 40 ~recursive_mutex(); 41 42 recursive_mutex(const recursive_mutex&) = delete; 43 recursive_mutex& operator=(const recursive_mutex&) = delete; 44 45 void lock(); 46 bool try_lock() noexcept; 47 void unlock(); 48 49 typedef pthread_mutex_t* native_handle_type; 50 native_handle_type native_handle(); 51}; 52 53class timed_mutex 54{ 55public: 56 timed_mutex(); 57 ~timed_mutex(); 58 59 timed_mutex(const timed_mutex&) = delete; 60 timed_mutex& operator=(const timed_mutex&) = delete; 61 62 void lock(); 63 bool try_lock(); 64 template <class Rep, class Period> 65 bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); 66 template <class Clock, class Duration> 67 bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); 68 void unlock(); 69}; 70 71class recursive_timed_mutex 72{ 73public: 74 recursive_timed_mutex(); 75 ~recursive_timed_mutex(); 76 77 recursive_timed_mutex(const recursive_timed_mutex&) = delete; 78 recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; 79 80 void lock(); 81 bool try_lock() noexcept; 82 template <class Rep, class Period> 83 bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); 84 template <class Clock, class Duration> 85 bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); 86 void unlock(); 87}; 88 89struct defer_lock_t { explicit defer_lock_t() = default; }; 90struct try_to_lock_t { explicit try_to_lock_t() = default; }; 91struct adopt_lock_t { explicit adopt_lock_t() = default; }; 92 93inline constexpr defer_lock_t defer_lock{}; 94inline constexpr try_to_lock_t try_to_lock{}; 95inline constexpr adopt_lock_t adopt_lock{}; 96 97template <class Mutex> 98class lock_guard 99{ 100public: 101 typedef Mutex mutex_type; 102 103 explicit lock_guard(mutex_type& m); 104 lock_guard(mutex_type& m, adopt_lock_t); 105 ~lock_guard(); 106 107 lock_guard(lock_guard const&) = delete; 108 lock_guard& operator=(lock_guard const&) = delete; 109}; 110 111template <class... MutexTypes> 112class scoped_lock // C++17 113{ 114public: 115 using mutex_type = Mutex; // Only if sizeof...(MutexTypes) == 1 116 117 explicit scoped_lock(MutexTypes&... m); 118 scoped_lock(adopt_lock_t, MutexTypes&... m); 119 ~scoped_lock(); 120 scoped_lock(scoped_lock const&) = delete; 121 scoped_lock& operator=(scoped_lock const&) = delete; 122private: 123 tuple<MutexTypes&...> pm; // exposition only 124}; 125 126template <class Mutex> 127class unique_lock 128{ 129public: 130 typedef Mutex mutex_type; 131 unique_lock() noexcept; 132 explicit unique_lock(mutex_type& m); 133 unique_lock(mutex_type& m, defer_lock_t) noexcept; 134 unique_lock(mutex_type& m, try_to_lock_t); 135 unique_lock(mutex_type& m, adopt_lock_t); 136 template <class Clock, class Duration> 137 unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time); 138 template <class Rep, class Period> 139 unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time); 140 ~unique_lock(); 141 142 unique_lock(unique_lock const&) = delete; 143 unique_lock& operator=(unique_lock const&) = delete; 144 145 unique_lock(unique_lock&& u) noexcept; 146 unique_lock& operator=(unique_lock&& u) noexcept; 147 148 void lock(); 149 bool try_lock(); 150 151 template <class Rep, class Period> 152 bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); 153 template <class Clock, class Duration> 154 bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); 155 156 void unlock(); 157 158 void swap(unique_lock& u) noexcept; 159 mutex_type* release() noexcept; 160 161 bool owns_lock() const noexcept; 162 explicit operator bool () const noexcept; 163 mutex_type* mutex() const noexcept; 164}; 165 166template <class Mutex> 167 void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept; 168 169template <class L1, class L2, class... L3> 170 int try_lock(L1&, L2&, L3&...); 171template <class L1, class L2, class... L3> 172 void lock(L1&, L2&, L3&...); 173 174struct once_flag 175{ 176 constexpr once_flag() noexcept; 177 178 once_flag(const once_flag&) = delete; 179 once_flag& operator=(const once_flag&) = delete; 180}; 181 182template<class Callable, class ...Args> 183 void call_once(once_flag& flag, Callable&& func, Args&&... args); 184 185} // std 186 187*/ 188 189#include <__assert> // all public C++ headers provide the assertion handler 190#include <__chrono/steady_clock.h> 191#include <__chrono/time_point.h> 192#include <__condition_variable/condition_variable.h> 193#include <__config> 194#include <__memory/shared_ptr.h> 195#include <__mutex/lock_guard.h> 196#include <__mutex/mutex.h> 197#include <__mutex/once_flag.h> 198#include <__mutex/tag_types.h> 199#include <__mutex/unique_lock.h> 200#include <__thread/id.h> 201#include <__threading_support> 202#include <__utility/forward.h> 203#include <cstddef> 204#include <limits> 205#ifndef _LIBCPP_CXX03_LANG 206# include <tuple> 207#endif 208#include <version> 209 210#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 211# pragma GCC system_header 212#endif 213 214_LIBCPP_PUSH_MACROS 215#include <__undef_macros> 216 217_LIBCPP_BEGIN_NAMESPACE_STD 218 219#ifndef _LIBCPP_HAS_NO_THREADS 220 221class _LIBCPP_EXPORTED_FROM_ABI recursive_mutex { 222 __libcpp_recursive_mutex_t __m_; 223 224public: 225 recursive_mutex(); 226 ~recursive_mutex(); 227 228 recursive_mutex(const recursive_mutex&) = delete; 229 recursive_mutex& operator=(const recursive_mutex&) = delete; 230 231 void lock(); 232 bool try_lock() _NOEXCEPT; 233 void unlock() _NOEXCEPT; 234 235 typedef __libcpp_recursive_mutex_t* native_handle_type; 236 237 _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__m_; } 238}; 239 240class _LIBCPP_EXPORTED_FROM_ABI timed_mutex { 241 mutex __m_; 242 condition_variable __cv_; 243 bool __locked_; 244 245public: 246 timed_mutex(); 247 ~timed_mutex(); 248 249 timed_mutex(const timed_mutex&) = delete; 250 timed_mutex& operator=(const timed_mutex&) = delete; 251 252public: 253 void lock(); 254 bool try_lock() _NOEXCEPT; 255 template <class _Rep, class _Period> 256 _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) { 257 return try_lock_until(chrono::steady_clock::now() + __d); 258 } 259 template <class _Clock, class _Duration> 260 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool 261 try_lock_until(const chrono::time_point<_Clock, _Duration>& __t); 262 void unlock() _NOEXCEPT; 263}; 264 265template <class _Clock, class _Duration> 266bool timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) { 267 using namespace chrono; 268 unique_lock<mutex> __lk(__m_); 269 bool __no_timeout = _Clock::now() < __t; 270 while (__no_timeout && __locked_) 271 __no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout; 272 if (!__locked_) { 273 __locked_ = true; 274 return true; 275 } 276 return false; 277} 278 279class _LIBCPP_EXPORTED_FROM_ABI recursive_timed_mutex { 280 mutex __m_; 281 condition_variable __cv_; 282 size_t __count_; 283 __thread_id __id_; 284 285public: 286 recursive_timed_mutex(); 287 ~recursive_timed_mutex(); 288 289 recursive_timed_mutex(const recursive_timed_mutex&) = delete; 290 recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; 291 292 void lock(); 293 bool try_lock() _NOEXCEPT; 294 template <class _Rep, class _Period> 295 _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) { 296 return try_lock_until(chrono::steady_clock::now() + __d); 297 } 298 template <class _Clock, class _Duration> 299 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool 300 try_lock_until(const chrono::time_point<_Clock, _Duration>& __t); 301 void unlock() _NOEXCEPT; 302}; 303 304template <class _Clock, class _Duration> 305bool recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) { 306 using namespace chrono; 307 __thread_id __id = this_thread::get_id(); 308 unique_lock<mutex> __lk(__m_); 309 if (__id == __id_) { 310 if (__count_ == numeric_limits<size_t>::max()) 311 return false; 312 ++__count_; 313 return true; 314 } 315 bool __no_timeout = _Clock::now() < __t; 316 while (__no_timeout && __count_ != 0) 317 __no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout; 318 if (__count_ == 0) { 319 __count_ = 1; 320 __id_ = __id; 321 return true; 322 } 323 return false; 324} 325 326template <class _L0, class _L1> 327_LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1) { 328 unique_lock<_L0> __u0(__l0, try_to_lock_t()); 329 if (__u0.owns_lock()) { 330 if (__l1.try_lock()) { 331 __u0.release(); 332 return -1; 333 } else 334 return 1; 335 } 336 return 0; 337} 338 339# ifndef _LIBCPP_CXX03_LANG 340 341template <class _L0, class _L1, class _L2, class... _L3> 342_LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) { 343 int __r = 0; 344 unique_lock<_L0> __u0(__l0, try_to_lock); 345 if (__u0.owns_lock()) { 346 __r = std::try_lock(__l1, __l2, __l3...); 347 if (__r == -1) 348 __u0.release(); 349 else 350 ++__r; 351 } 352 return __r; 353} 354 355# endif // _LIBCPP_CXX03_LANG 356 357template <class _L0, class _L1> 358_LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1) { 359 while (true) { 360 { 361 unique_lock<_L0> __u0(__l0); 362 if (__l1.try_lock()) { 363 __u0.release(); 364 break; 365 } 366 } 367 __libcpp_thread_yield(); 368 { 369 unique_lock<_L1> __u1(__l1); 370 if (__l0.try_lock()) { 371 __u1.release(); 372 break; 373 } 374 } 375 __libcpp_thread_yield(); 376 } 377} 378 379# ifndef _LIBCPP_CXX03_LANG 380 381template <class _L0, class _L1, class _L2, class... _L3> 382void __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) { 383 while (true) { 384 switch (__i) { 385 case 0: { 386 unique_lock<_L0> __u0(__l0); 387 __i = std::try_lock(__l1, __l2, __l3...); 388 if (__i == -1) { 389 __u0.release(); 390 return; 391 } 392 } 393 ++__i; 394 __libcpp_thread_yield(); 395 break; 396 case 1: { 397 unique_lock<_L1> __u1(__l1); 398 __i = std::try_lock(__l2, __l3..., __l0); 399 if (__i == -1) { 400 __u1.release(); 401 return; 402 } 403 } 404 if (__i == sizeof...(_L3) + 1) 405 __i = 0; 406 else 407 __i += 2; 408 __libcpp_thread_yield(); 409 break; 410 default: 411 std::__lock_first(__i - 2, __l2, __l3..., __l0, __l1); 412 return; 413 } 414 } 415} 416 417template <class _L0, class _L1, class _L2, class... _L3> 418inline _LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) { 419 std::__lock_first(0, __l0, __l1, __l2, __l3...); 420} 421 422template <class _L0> 423inline _LIBCPP_HIDE_FROM_ABI void __unlock(_L0& __l0) { 424 __l0.unlock(); 425} 426 427template <class _L0, class _L1> 428inline _LIBCPP_HIDE_FROM_ABI void __unlock(_L0& __l0, _L1& __l1) { 429 __l0.unlock(); 430 __l1.unlock(); 431} 432 433template <class _L0, class _L1, class _L2, class... _L3> 434inline _LIBCPP_HIDE_FROM_ABI void __unlock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) { 435 __l0.unlock(); 436 __l1.unlock(); 437 std::__unlock(__l2, __l3...); 438} 439 440# endif // _LIBCPP_CXX03_LANG 441 442# if _LIBCPP_STD_VER >= 17 443template <class... _Mutexes> 444class _LIBCPP_TEMPLATE_VIS scoped_lock; 445 446template <> 447class _LIBCPP_TEMPLATE_VIS scoped_lock<> { 448public: 449 explicit scoped_lock() {} 450 ~scoped_lock() = default; 451 452 _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(adopt_lock_t) {} 453 454 scoped_lock(scoped_lock const&) = delete; 455 scoped_lock& operator=(scoped_lock const&) = delete; 456}; 457 458template <class _Mutex> 459class _LIBCPP_TEMPLATE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) scoped_lock<_Mutex> { 460public: 461 typedef _Mutex mutex_type; 462 463private: 464 mutex_type& __m_; 465 466public: 467 explicit scoped_lock(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m)) : __m_(__m) { 468 __m_.lock(); 469 } 470 471 ~scoped_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) { __m_.unlock(); } 472 473 _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(adopt_lock_t, mutex_type& __m) 474 _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m)) 475 : __m_(__m) {} 476 477 scoped_lock(scoped_lock const&) = delete; 478 scoped_lock& operator=(scoped_lock const&) = delete; 479}; 480 481template <class... _MArgs> 482class _LIBCPP_TEMPLATE_VIS scoped_lock { 483 static_assert(sizeof...(_MArgs) > 1, "At least 2 lock types required"); 484 typedef tuple<_MArgs&...> _MutexTuple; 485 486public: 487 _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(_MArgs&... __margs) : __t_(__margs...) { std::lock(__margs...); } 488 489 _LIBCPP_HIDE_FROM_ABI scoped_lock(adopt_lock_t, _MArgs&... __margs) : __t_(__margs...) {} 490 491 _LIBCPP_HIDE_FROM_ABI ~scoped_lock() { 492 typedef typename __make_tuple_indices<sizeof...(_MArgs)>::type _Indices; 493 __unlock_unpack(_Indices{}, __t_); 494 } 495 496 scoped_lock(scoped_lock const&) = delete; 497 scoped_lock& operator=(scoped_lock const&) = delete; 498 499private: 500 template <size_t... _Indx> 501 _LIBCPP_HIDE_FROM_ABI static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) { 502 std::__unlock(std::get<_Indx>(__mt)...); 503 } 504 505 _MutexTuple __t_; 506}; 507_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scoped_lock); 508 509# endif // _LIBCPP_STD_VER >= 17 510#endif // !_LIBCPP_HAS_NO_THREADS 511 512_LIBCPP_END_NAMESPACE_STD 513 514_LIBCPP_POP_MACROS 515 516#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 517# include <atomic> 518# include <concepts> 519# include <cstdlib> 520# include <cstring> 521# include <ctime> 522# include <initializer_list> 523# include <iosfwd> 524# include <new> 525# include <stdexcept> 526# include <system_error> 527# include <type_traits> 528# include <typeinfo> 529#endif 530 531#endif // _LIBCPP_MUTEX 532