include/mutex

   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
  17 namespace std
  18 {
  19
  20 class mutex
  21 {
  22 public:
  23      constexpr mutex() noexcept;
  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
  37 class recursive_mutex
  38 {
  39 public:
  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() noexcept;
  48     void unlock();
  49
  50     typedef pthread_mutex_t* native_handle_type;
  51     native_handle_type native_handle();
  52 };
  53
  54 class timed_mutex
  55 {
  56 public:
  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
  72 class recursive_timed_mutex
  73 {
  74 public:
  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() noexcept;
  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
  90 struct defer_lock_t {};
  91 struct try_to_lock_t {};
  92 struct adopt_lock_t {};
  93
  94 constexpr defer_lock_t  defer_lock{};
  95 constexpr try_to_lock_t try_to_lock{};
  96 constexpr adopt_lock_t  adopt_lock{};
  97
  98 template <class Mutex>
  99 class lock_guard
 100 {
 101 public:
 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
 112 template <class... MutexTypes> // Variadic lock_guard only provided in ABI V2.
 113 class lock_guard
 114 {
 115 public:
 116     explicit lock_guard(MutexTypes&... m);
 117     lock_guard(MutexTypes&... m, adopt_lock_t);
 118     ~lock_guard();
 119     lock_guard(lock_guard const&) = delete;
 120     lock_guard& operator=(lock_guard const&) = delete;
 121 private:
 122     tuple<MutexTypes&...> pm; // exposition only
 123 };
 124
 125 template <class Mutex>
 126 class unique_lock
 127 {
 128 public:
 129     typedef Mutex mutex_type;
 130     unique_lock() noexcept;
 131     explicit unique_lock(mutex_type& m);
 132     unique_lock(mutex_type& m, defer_lock_t) noexcept;
 133     unique_lock(mutex_type& m, try_to_lock_t);
 134     unique_lock(mutex_type& m, adopt_lock_t);
 135     template <class Clock, class Duration>
 136         unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 137     template <class Rep, class Period>
 138         unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 139     ~unique_lock();
 140
 141     unique_lock(unique_lock const&) = delete;
 142     unique_lock& operator=(unique_lock const&) = delete;
 143
 144     unique_lock(unique_lock&& u) noexcept;
 145     unique_lock& operator=(unique_lock&& u) noexcept;
 146
 147     void lock();
 148     bool try_lock();
 149
 150     template <class Rep, class Period>
 151         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 152     template <class Clock, class Duration>
 153         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 154
 155     void unlock();
 156
 157     void swap(unique_lock& u) noexcept;
 158     mutex_type* release() noexcept;
 159
 160     bool owns_lock() const noexcept;
 161     explicit operator bool () const noexcept;
 162     mutex_type* mutex() const noexcept;
 163 };
 164
 165 template <class Mutex>
 166   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 167
 168 template <class L1, class L2, class... L3>
 169   int try_lock(L1&, L2&, L3&...);
 170 template <class L1, class L2, class... L3>
 171   void lock(L1&, L2&, L3&...);
 172
 173 struct once_flag
 174 {
 175     constexpr once_flag() noexcept;
 176
 177     once_flag(const once_flag&) = delete;
 178     once_flag& operator=(const once_flag&) = delete;
 179 };
 180
 181 template<class Callable, class ...Args>
 182   void call_once(once_flag& flag, Callable&& func, Args&&... args);
 183
 184 }  // std
 185
 186 */
 187
 188 #include <__config>
 189 #include <__mutex_base>
 190 #include <functional>
 191 #include <memory>
 192 #ifndef _LIBCPP_HAS_NO_VARIADICS
 193 #include <tuple>
 194 #endif
 195 #include <__threading_support>
 196
 197 #include <__undef_min_max>
 198
 199 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 200 #pragma GCC system_header
 201 #endif
 202
 203 _LIBCPP_BEGIN_NAMESPACE_STD
 204
 205 #ifndef _LIBCPP_HAS_NO_THREADS
 206
 207 class _LIBCPP_TYPE_VIS recursive_mutex
 208 {
 209     __libcpp_mutex_t __m_;
 210
 211 public:
 212      recursive_mutex();
 213      ~recursive_mutex();
 214
 215 private:
 216     recursive_mutex(const recursive_mutex&); // = delete;
 217     recursive_mutex& operator=(const recursive_mutex&); // = delete;
 218
 219 public:
 220     void lock();
 221     bool try_lock() _NOEXCEPT;
 222     void unlock()  _NOEXCEPT;
 223
 224     typedef __libcpp_mutex_t* native_handle_type;
 225     _LIBCPP_INLINE_VISIBILITY
 226     native_handle_type native_handle() {return &__m_;}
 227 };
 228
 229 class _LIBCPP_TYPE_VIS timed_mutex
 230 {
 231     mutex              __m_;
 232     condition_variable __cv_;
 233     bool               __locked_;
 234 public:
 235      timed_mutex();
 236      ~timed_mutex();
 237
 238 private:
 239     timed_mutex(const timed_mutex&); // = delete;
 240     timed_mutex& operator=(const timed_mutex&); // = delete;
 241
 242 public:
 243     void lock();
 244     bool try_lock() _NOEXCEPT;
 245     template <class _Rep, class _Period>
 246         _LIBCPP_INLINE_VISIBILITY
 247         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
 248             {return try_lock_until(chrono::steady_clock::now() + __d);}
 249     template <class _Clock, class _Duration>
 250         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
 251     void unlock() _NOEXCEPT;
 252 };
 253
 254 template <class _Clock, class _Duration>
 255 bool
 256 timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 257 {
 258     using namespace chrono;
 259     unique_lock<mutex> __lk(__m_);
 260     bool no_timeout = _Clock::now() < __t;
 261     while (no_timeout && __locked_)
 262         no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
 263     if (!__locked_)
 264     {
 265         __locked_ = true;
 266         return true;
 267     }
 268     return false;
 269 }
 270
 271 class _LIBCPP_TYPE_VIS recursive_timed_mutex
 272 {
 273     mutex              __m_;
 274     condition_variable __cv_;
 275     size_t             __count_;
 276     __libcpp_thread_id __id_;
 277 public:
 278      recursive_timed_mutex();
 279      ~recursive_timed_mutex();
 280
 281 private:
 282     recursive_timed_mutex(const recursive_timed_mutex&); // = delete;
 283     recursive_timed_mutex& operator=(const recursive_timed_mutex&); // = delete;
 284
 285 public:
 286     void lock();
 287     bool try_lock() _NOEXCEPT;
 288     template <class _Rep, class _Period>
 289         _LIBCPP_INLINE_VISIBILITY
 290         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
 291             {return try_lock_until(chrono::steady_clock::now() + __d);}
 292     template <class _Clock, class _Duration>
 293         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
 294     void unlock() _NOEXCEPT;
 295 };
 296
 297 template <class _Clock, class _Duration>
 298 bool
 299 recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 300 {
 301     using namespace chrono;
 302     __libcpp_thread_id __id = __libcpp_thread_get_current_id();
 303     unique_lock<mutex> lk(__m_);
 304     if (__libcpp_thread_id_equal(__id, __id_))
 305     {
 306         if (__count_ == numeric_limits<size_t>::max())
 307             return false;
 308         ++__count_;
 309         return true;
 310     }
 311     bool no_timeout = _Clock::now() < __t;
 312     while (no_timeout && __count_ != 0)
 313         no_timeout = __cv_.wait_until(lk, __t) == cv_status::no_timeout;
 314     if (__count_ == 0)
 315     {
 316         __count_ = 1;
 317         __id_ = __id;
 318         return true;
 319     }
 320     return false;
 321 }
 322
 323 template <class _L0, class _L1>
 324 int
 325 try_lock(_L0& __l0, _L1& __l1)
 326 {
 327     unique_lock<_L0> __u0(__l0, try_to_lock);
 328     if (__u0.owns_lock())
 329     {
 330         if (__l1.try_lock())
 331         {
 332             __u0.release();
 333             return -1;
 334         }
 335         else
 336             return 1;
 337     }
 338     return 0;
 339 }
 340
 341 #ifndef _LIBCPP_HAS_NO_VARIADICS
 342
 343 template <class _L0, class _L1, class _L2, class... _L3>
 344 int
 345 try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3)
 346 {
 347     int __r = 0;
 348     unique_lock<_L0> __u0(__l0, try_to_lock);
 349     if (__u0.owns_lock())
 350     {
 351         __r = try_lock(__l1, __l2, __l3...);
 352         if (__r == -1)
 353             __u0.release();
 354         else
 355             ++__r;
 356     }
 357     return __r;
 358 }
 359
 360 #endif  // _LIBCPP_HAS_NO_VARIADICS
 361
 362 template <class _L0, class _L1>
 363 void
 364 lock(_L0& __l0, _L1& __l1)
 365 {
 366     while (true)
 367     {
 368         {
 369             unique_lock<_L0> __u0(__l0);
 370             if (__l1.try_lock())
 371             {
 372                 __u0.release();
 373                 break;
 374             }
 375         }
 376         __libcpp_thread_yield();
 377         {
 378             unique_lock<_L1> __u1(__l1);
 379             if (__l0.try_lock())
 380             {
 381                 __u1.release();
 382                 break;
 383             }
 384         }
 385         __libcpp_thread_yield();
 386     }
 387 }
 388
 389 #ifndef _LIBCPP_HAS_NO_VARIADICS
 390
 391 template <class _L0, class _L1, class _L2, class ..._L3>
 392 void
 393 __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
 394 {
 395     while (true)
 396     {
 397         switch (__i)
 398         {
 399         case 0:
 400             {
 401                 unique_lock<_L0> __u0(__l0);
 402                 __i = try_lock(__l1, __l2, __l3...);
 403                 if (__i == -1)
 404                 {
 405                     __u0.release();
 406                     return;
 407                 }
 408             }
 409             ++__i;
 410             __libcpp_thread_yield();
 411             break;
 412         case 1:
 413             {
 414                 unique_lock<_L1> __u1(__l1);
 415                 __i = try_lock(__l2, __l3..., __l0);
 416                 if (__i == -1)
 417                 {
 418                     __u1.release();
 419                     return;
 420                 }
 421             }
 422             if (__i == sizeof...(_L3) + 1)
 423                 __i = 0;
 424             else
 425                 __i += 2;
 426             __libcpp_thread_yield();
 427             break;
 428         default:
 429             __lock_first(__i - 2, __l2, __l3..., __l0, __l1);
 430             return;
 431         }
 432     }
 433 }
 434
 435 template <class _L0, class _L1, class _L2, class ..._L3>
 436 inline _LIBCPP_INLINE_VISIBILITY
 437 void
 438 lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
 439 {
 440     __lock_first(0, __l0, __l1, __l2, __l3...);
 441 }
 442
 443 template <class _L0>
 444 inline _LIBCPP_INLINE_VISIBILITY
 445 void __unlock(_L0& __l0) {
 446     __l0.unlock();
 447 }
 448
 449 template <class _L0, class _L1>
 450 inline _LIBCPP_INLINE_VISIBILITY
 451 void __unlock(_L0& __l0, _L1& __l1) {
 452     __l0.unlock();
 453     __l1.unlock();
 454 }
 455
 456 template <class _L0, class _L1, class _L2, class ..._L3>
 457 inline _LIBCPP_INLINE_VISIBILITY
 458 void __unlock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
 459     __l0.unlock();
 460     __l1.unlock();
 461     _VSTD::__unlock(__l2, __l3...);
 462 }
 463
 464 #endif  // _LIBCPP_HAS_NO_VARIADICS
 465
 466 #endif // !_LIBCPP_HAS_NO_THREADS
 467
 468 struct _LIBCPP_TYPE_VIS_ONLY once_flag;
 469
 470 #ifndef _LIBCPP_HAS_NO_VARIADICS
 471
 472 template<class _Callable, class... _Args>
 473 _LIBCPP_INLINE_VISIBILITY
 474 void call_once(once_flag&, _Callable&&, _Args&&...);
 475
 476 #else  // _LIBCPP_HAS_NO_VARIADICS
 477
 478 template<class _Callable>
 479 _LIBCPP_INLINE_VISIBILITY
 480 void call_once(once_flag&, _Callable&);
 481
 482 template<class _Callable>
 483 _LIBCPP_INLINE_VISIBILITY
 484 void call_once(once_flag&, const _Callable&);
 485
 486 #endif  // _LIBCPP_HAS_NO_VARIADICS
 487
 488 struct _LIBCPP_TYPE_VIS_ONLY once_flag
 489 {
 490     _LIBCPP_INLINE_VISIBILITY
 491     _LIBCPP_CONSTEXPR
 492         once_flag() _NOEXCEPT : __state_(0) {}
 493
 494 private:
 495     once_flag(const once_flag&); // = delete;
 496     once_flag& operator=(const once_flag&); // = delete;
 497
 498     unsigned long __state_;
 499
 500 #ifndef _LIBCPP_HAS_NO_VARIADICS
 501     template<class _Callable, class... _Args>
 502     friend
 503     void call_once(once_flag&, _Callable&&, _Args&&...);
 504 #else  // _LIBCPP_HAS_NO_VARIADICS
 505     template<class _Callable>
 506     friend
 507     void call_once(once_flag&, _Callable&);
 508
 509     template<class _Callable>
 510     friend
 511     void call_once(once_flag&, const _Callable&);
 512 #endif  // _LIBCPP_HAS_NO_VARIADICS
 513 };
 514
 515 #ifndef _LIBCPP_HAS_NO_VARIADICS
 516
 517 template <class _Fp>
 518 class __call_once_param
 519 {
 520     _Fp& __f_;
 521 public:
 522     _LIBCPP_INLINE_VISIBILITY
 523     explicit __call_once_param(_Fp& __f) : __f_(__f) {}
 524
 525     _LIBCPP_INLINE_VISIBILITY
 526     void operator()()
 527     {
 528         typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
 529         __execute(_Index());
 530     }
 531
 532 private:
 533     template <size_t ..._Indices>
 534     _LIBCPP_INLINE_VISIBILITY
 535     void __execute(__tuple_indices<_Indices...>)
 536     {
 537         __invoke(_VSTD::get<0>(_VSTD::move(__f_)), _VSTD::get<_Indices>(_VSTD::move(__f_))...);
 538     }
 539 };
 540
 541 #else
 542
 543 template <class _Fp>
 544 class __call_once_param
 545 {
 546     _Fp& __f_;
 547 public:
 548     _LIBCPP_INLINE_VISIBILITY
 549     explicit __call_once_param(_Fp& __f) : __f_(__f) {}
 550
 551     _LIBCPP_INLINE_VISIBILITY
 552     void operator()()
 553     {
 554         __f_();
 555     }
 556 };
 557
 558 #endif
 559
 560 template <class _Fp>
 561 void
 562 __call_once_proxy(void* __vp)
 563 {
 564     __call_once_param<_Fp>* __p = static_cast<__call_once_param<_Fp>*>(__vp);
 565     (*__p)();
 566 }
 567
 568 _LIBCPP_FUNC_VIS void __call_once(volatile unsigned long&, void*, void(*)(void*));
 569
 570 #ifndef _LIBCPP_HAS_NO_VARIADICS
 571
 572 template<class _Callable, class... _Args>
 573 inline _LIBCPP_INLINE_VISIBILITY
 574 void
 575 call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
 576 {
 577     if (__libcpp_acquire_load(&__flag.__state_) != ~0ul)
 578     {
 579         typedef tuple<_Callable&&, _Args&&...> _Gp;
 580         _Gp __f(_VSTD::forward<_Callable>(__func), _VSTD::forward<_Args>(__args)...);
 581         __call_once_param<_Gp> __p(__f);
 582         __call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>);
 583     }
 584 }
 585
 586 #else  // _LIBCPP_HAS_NO_VARIADICS
 587
 588 template<class _Callable>
 589 inline _LIBCPP_INLINE_VISIBILITY
 590 void
 591 call_once(once_flag& __flag, _Callable& __func)
 592 {
 593     if (__libcpp_acquire_load(&__flag.__state_) != ~0ul)
 594     {
 595         __call_once_param<_Callable> __p(__func);
 596         __call_once(__flag.__state_, &__p, &__call_once_proxy<_Callable>);
 597     }
 598 }
 599
 600 template<class _Callable>
 601 inline _LIBCPP_INLINE_VISIBILITY
 602 void
 603 call_once(once_flag& __flag, const _Callable& __func)
 604 {
 605     if (__flag.__state_ != ~0ul)
 606     {
 607         __call_once_param<const _Callable> __p(__func);
 608         __call_once(__flag.__state_, &__p, &__call_once_proxy<const _Callable>);
 609     }
 610 }
 611
 612 #endif  // _LIBCPP_HAS_NO_VARIADICS
 613
 614
 615 #if defined(_LIBCPP_ABI_VARIADIC_LOCK_GUARD) \
 616     && !defined(_LIBCPP_CXX03_LANG)
 617 template <>
 618 class _LIBCPP_TYPE_VIS_ONLY lock_guard<> {
 619 public:
 620     explicit lock_guard() {}
 621     ~lock_guard() = default;
 622
 623     _LIBCPP_INLINE_VISIBILITY
 624     explicit lock_guard(adopt_lock_t) {}
 625
 626     lock_guard(lock_guard const&) = delete;
 627     lock_guard& operator=(lock_guard const&) = delete;
 628 };
 629
 630 template <class ..._MArgs>
 631 class _LIBCPP_TYPE_VIS_ONLY lock_guard
 632 {
 633     static_assert(sizeof...(_MArgs) >= 2, "At least 2 lock types required");
 634     typedef tuple<_MArgs&...> _MutexTuple;
 635
 636 public:
 637     _LIBCPP_INLINE_VISIBILITY
 638     explicit lock_guard(_MArgs&... __margs)
 639       : __t_(__margs...)
 640     {
 641         _VSTD::lock(__margs...);
 642     }
 643
 644     _LIBCPP_INLINE_VISIBILITY
 645     lock_guard(_MArgs&... __margs, adopt_lock_t)
 646         : __t_(__margs...)
 647     {
 648     }
 649
 650     _LIBCPP_INLINE_VISIBILITY
 651     ~lock_guard() {
 652         typedef typename __make_tuple_indices<sizeof...(_MArgs)>::type _Indices;
 653         __unlock_unpack(_Indices{}, __t_);
 654     }
 655
 656     lock_guard(lock_guard const&) = delete;
 657     lock_guard& operator=(lock_guard const&) = delete;
 658
 659 private:
 660     template <size_t ..._Indx>
 661     _LIBCPP_INLINE_VISIBILITY
 662     static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) {
 663         _VSTD::__unlock(_VSTD::get<_Indx>(__mt)...);
 664     }
 665
 666     _MutexTuple __t_;
 667 };
 668
 669 #endif // _LIBCPP_ABI_VARIADIC_LOCK_GUARD
 670
 671 _LIBCPP_END_NAMESPACE_STD
 672
 673 #endif  // _LIBCPP_MUTEX