mutex revision 227825
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#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 183#pragma GCC system_header 184#endif 185 186_LIBCPP_BEGIN_NAMESPACE_STD 187 188class _LIBCPP_VISIBLE recursive_mutex 189{ 190 pthread_mutex_t __m_; 191 192public: 193 recursive_mutex(); 194 ~recursive_mutex(); 195 196private: 197 recursive_mutex(const recursive_mutex&); // = delete; 198 recursive_mutex& operator=(const recursive_mutex&); // = delete; 199 200public: 201 void lock(); 202 bool try_lock(); 203 void unlock(); 204 205 typedef pthread_mutex_t* native_handle_type; 206 _LIBCPP_INLINE_VISIBILITY 207 native_handle_type native_handle() {return &__m_;} 208}; 209 210class _LIBCPP_VISIBLE timed_mutex 211{ 212 mutex __m_; 213 condition_variable __cv_; 214 bool __locked_; 215public: 216 timed_mutex(); 217 ~timed_mutex(); 218 219private: 220 timed_mutex(const timed_mutex&); // = delete; 221 timed_mutex& operator=(const timed_mutex&); // = delete; 222 223public: 224 void lock(); 225 bool try_lock(); 226 template <class _Rep, class _Period> 227 _LIBCPP_INLINE_VISIBILITY 228 bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) 229 {return try_lock_until(chrono::steady_clock::now() + __d);} 230 template <class _Clock, class _Duration> 231 bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t); 232 void unlock(); 233}; 234 235template <class _Clock, class _Duration> 236bool 237timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) 238{ 239 using namespace chrono; 240 unique_lock<mutex> __lk(__m_); 241 bool no_timeout = _Clock::now() < __t; 242 while (no_timeout && __locked_) 243 no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout; 244 if (!__locked_) 245 { 246 __locked_ = true; 247 return true; 248 } 249 return false; 250} 251 252class _LIBCPP_VISIBLE recursive_timed_mutex 253{ 254 mutex __m_; 255 condition_variable __cv_; 256 size_t __count_; 257 pthread_t __id_; 258public: 259 recursive_timed_mutex(); 260 ~recursive_timed_mutex(); 261 262private: 263 recursive_timed_mutex(const recursive_timed_mutex&); // = delete; 264 recursive_timed_mutex& operator=(const recursive_timed_mutex&); // = delete; 265 266public: 267 void lock(); 268 bool try_lock(); 269 template <class _Rep, class _Period> 270 _LIBCPP_INLINE_VISIBILITY 271 bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) 272 {return try_lock_until(chrono::steady_clock::now() + __d);} 273 template <class _Clock, class _Duration> 274 bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t); 275 void unlock(); 276}; 277 278template <class _Clock, class _Duration> 279bool 280recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) 281{ 282 using namespace chrono; 283 pthread_t __id = pthread_self(); 284 unique_lock<mutex> lk(__m_); 285 if (pthread_equal(__id, __id_)) 286 { 287 if (__count_ == numeric_limits<size_t>::max()) 288 return false; 289 ++__count_; 290 return true; 291 } 292 bool no_timeout = _Clock::now() < __t; 293 while (no_timeout && __count_ != 0) 294 no_timeout = __cv_.wait_until(lk, __t) == cv_status::no_timeout; 295 if (__count_ == 0) 296 { 297 __count_ = 1; 298 __id_ = __id; 299 return true; 300 } 301 return false; 302} 303 304template <class _L0, class _L1> 305int 306try_lock(_L0& __l0, _L1& __l1) 307{ 308 unique_lock<_L0> __u0(__l0, try_to_lock); 309 if (__u0.owns_lock()) 310 { 311 if (__l1.try_lock()) 312 { 313 __u0.release(); 314 return -1; 315 } 316 else 317 return 1; 318 } 319 return 0; 320} 321 322#ifndef _LIBCPP_HAS_NO_VARIADICS 323 324template <class _L0, class _L1, class _L2, class... _L3> 325int 326try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) 327{ 328 int __r = 0; 329 unique_lock<_L0> __u0(__l0, try_to_lock); 330 if (__u0.owns_lock()) 331 { 332 __r = try_lock(__l1, __l2, __l3...); 333 if (__r == -1) 334 __u0.release(); 335 else 336 ++__r; 337 } 338 return __r; 339} 340 341#endif // _LIBCPP_HAS_NO_VARIADICS 342 343template <class _L0, class _L1> 344void 345lock(_L0& __l0, _L1& __l1) 346{ 347 while (true) 348 { 349 { 350 unique_lock<_L0> __u0(__l0); 351 if (__l1.try_lock()) 352 { 353 __u0.release(); 354 break; 355 } 356 } 357 sched_yield(); 358 { 359 unique_lock<_L1> __u1(__l1); 360 if (__l0.try_lock()) 361 { 362 __u1.release(); 363 break; 364 } 365 } 366 sched_yield(); 367 } 368} 369 370#ifndef _LIBCPP_HAS_NO_VARIADICS 371 372template <class _L0, class _L1, class _L2, class ..._L3> 373void 374__lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3) 375{ 376 while (true) 377 { 378 switch (__i) 379 { 380 case 0: 381 { 382 unique_lock<_L0> __u0(__l0); 383 __i = try_lock(__l1, __l2, __l3...); 384 if (__i == -1) 385 { 386 __u0.release(); 387 return; 388 } 389 } 390 ++__i; 391 sched_yield(); 392 break; 393 case 1: 394 { 395 unique_lock<_L1> __u1(__l1); 396 __i = try_lock(__l2, __l3..., __l0); 397 if (__i == -1) 398 { 399 __u1.release(); 400 return; 401 } 402 } 403 if (__i == sizeof...(_L3) + 1) 404 __i = 0; 405 else 406 __i += 2; 407 sched_yield(); 408 break; 409 default: 410 __lock_first(__i - 2, __l2, __l3..., __l0, __l1); 411 return; 412 } 413 } 414} 415 416template <class _L0, class _L1, class _L2, class ..._L3> 417inline _LIBCPP_INLINE_VISIBILITY 418void 419lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3) 420{ 421 __lock_first(0, __l0, __l1, __l2, __l3...); 422} 423 424#endif // _LIBCPP_HAS_NO_VARIADICS 425 426struct once_flag; 427 428#ifndef _LIBCPP_HAS_NO_VARIADICS 429 430template<class _Callable, class... _Args> 431 void call_once(once_flag&, _Callable&&, _Args&&...); 432 433#else // _LIBCPP_HAS_NO_VARIADICS 434 435template<class _Callable> 436 void call_once(once_flag&, _Callable); 437 438#endif // _LIBCPP_HAS_NO_VARIADICS 439 440struct _LIBCPP_VISIBLE once_flag 441{ 442 _LIBCPP_INLINE_VISIBILITY 443 // constexpr 444 once_flag() {} 445 446private: 447 once_flag(const once_flag&); // = delete; 448 once_flag& operator=(const once_flag&); // = delete; 449 450 unsigned long __state_; 451 452#ifndef _LIBCPP_HAS_NO_VARIADICS 453 template<class _Callable, class... _Args> 454 friend 455 void call_once(once_flag&, _Callable&&, _Args&&...); 456#else // _LIBCPP_HAS_NO_VARIADICS 457 template<class _Callable> 458 friend 459 void call_once(once_flag&, _Callable); 460#endif // _LIBCPP_HAS_NO_VARIADICS 461}; 462 463#ifndef _LIBCPP_HAS_NO_VARIADICS 464 465template <class _F> 466class __call_once_param 467{ 468 _F __f_; 469public: 470#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 471 _LIBCPP_INLINE_VISIBILITY 472 explicit __call_once_param(_F&& __f) : __f_(_VSTD::move(__f)) {} 473#else 474 _LIBCPP_INLINE_VISIBILITY 475 explicit __call_once_param(const _F& __f) : __f_(__f) {} 476#endif 477 478 _LIBCPP_INLINE_VISIBILITY 479 void operator()() 480 { 481 typedef typename __make_tuple_indices<tuple_size<_F>::value, 1>::type _Index; 482 __execute(_Index()); 483 } 484 485private: 486 template <size_t ..._Indices> 487 _LIBCPP_INLINE_VISIBILITY 488 void __execute(__tuple_indices<_Indices...>) 489 { 490 __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...); 491 } 492}; 493 494#else 495 496template <class _F> 497class __call_once_param 498{ 499 _F __f_; 500public: 501#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 502 _LIBCPP_INLINE_VISIBILITY 503 explicit __call_once_param(_F&& __f) : __f_(_VSTD::move(__f)) {} 504#else 505 _LIBCPP_INLINE_VISIBILITY 506 explicit __call_once_param(const _F& __f) : __f_(__f) {} 507#endif 508 509 _LIBCPP_INLINE_VISIBILITY 510 void operator()() 511 { 512 __f_(); 513 } 514}; 515 516#endif 517 518template <class _F> 519void 520__call_once_proxy(void* __vp) 521{ 522 __call_once_param<_F>* __p = static_cast<__call_once_param<_F>*>(__vp); 523 (*__p)(); 524} 525 526void __call_once(volatile unsigned long&, void*, void(*)(void*)); 527 528#ifndef _LIBCPP_HAS_NO_VARIADICS 529 530template<class _Callable, class... _Args> 531inline _LIBCPP_INLINE_VISIBILITY 532void 533call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args) 534{ 535 if (__builtin_expect(__flag.__state_ , ~0ul) != ~0ul) 536 { 537 typedef tuple<typename decay<_Callable>::type, typename decay<_Args>::type...> _G; 538 __call_once_param<_G> __p(_G(__decay_copy(_VSTD::forward<_Callable>(__func)), 539 __decay_copy(_VSTD::forward<_Args>(__args))...)); 540 __call_once(__flag.__state_, &__p, &__call_once_proxy<_G>); 541 } 542} 543 544#else // _LIBCPP_HAS_NO_VARIADICS 545 546template<class _Callable> 547inline _LIBCPP_INLINE_VISIBILITY 548void 549call_once(once_flag& __flag, _Callable __func) 550{ 551 if (__flag.__state_ != ~0ul) 552 { 553 __call_once_param<_Callable> __p(__func); 554 __call_once(__flag.__state_, &__p, &__call_once_proxy<_Callable>); 555 } 556} 557 558#endif // _LIBCPP_HAS_NO_VARIADICS 559 560_LIBCPP_END_NAMESPACE_STD 561 562#endif // _LIBCPP_MUTEX 563