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