contrib/libc++/include/shared_mutex

   1 // -*- C++ -*-
   2 //===------------------------ shared_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_SHARED_MUTEX
  12 #define _LIBCPP_SHARED_MUTEX
  13
  14 /*
  15     shared_mutex synopsis
  16
  17 // C++1y
  18
  19 namespace std
  20 {
  21
  22 class shared_mutex      // C++17
  23 {
  24 public:
  25     shared_mutex();
  26     ~shared_mutex();
  27
  28     shared_mutex(const shared_mutex&) = delete;
  29     shared_mutex& operator=(const shared_mutex&) = delete;
  30
  31     // Exclusive ownership
  32     void lock(); // blocking
  33     bool try_lock();
  34     void unlock();
  35
  36     // Shared ownership
  37     void lock_shared(); // blocking
  38     bool try_lock_shared();
  39     void unlock_shared();
  40
  41     typedef implementation-defined native_handle_type; // See 30.2.3
  42     native_handle_type native_handle(); // See 30.2.3
  43 };
  44
  45 class shared_timed_mutex
  46 {
  47 public:
  48     shared_timed_mutex();
  49     ~shared_timed_mutex();
  50
  51     shared_timed_mutex(const shared_timed_mutex&) = delete;
  52     shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
  53
  54     // Exclusive ownership
  55     void lock(); // blocking
  56     bool try_lock();
  57     template <class Rep, class Period>
  58         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
  59     template <class Clock, class Duration>
  60         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
  61     void unlock();
  62
  63     // Shared ownership
  64     void lock_shared(); // blocking
  65     bool try_lock_shared();
  66     template <class Rep, class Period>
  67         bool
  68         try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time);
  69     template <class Clock, class Duration>
  70         bool
  71         try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
  72     void unlock_shared();
  73 };
  74
  75 template <class Mutex>
  76 class shared_lock
  77 {
  78 public:
  79     typedef Mutex mutex_type;
  80
  81     // Shared locking
  82     shared_lock() noexcept;
  83     explicit shared_lock(mutex_type& m); // blocking
  84     shared_lock(mutex_type& m, defer_lock_t) noexcept;
  85     shared_lock(mutex_type& m, try_to_lock_t);
  86     shared_lock(mutex_type& m, adopt_lock_t);
  87     template <class Clock, class Duration>
  88         shared_lock(mutex_type& m,
  89                     const chrono::time_point<Clock, Duration>& abs_time);
  90     template <class Rep, class Period>
  91         shared_lock(mutex_type& m,
  92                     const chrono::duration<Rep, Period>& rel_time);
  93     ~shared_lock();
  94
  95     shared_lock(shared_lock const&) = delete;
  96     shared_lock& operator=(shared_lock const&) = delete;
  97
  98     shared_lock(shared_lock&& u) noexcept;
  99     shared_lock& operator=(shared_lock&& u) noexcept;
 100
 101     void lock(); // blocking
 102     bool try_lock();
 103     template <class Rep, class Period>
 104         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 105     template <class Clock, class Duration>
 106         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 107     void unlock();
 108
 109     // Setters
 110     void swap(shared_lock& u) noexcept;
 111     mutex_type* release() noexcept;
 112
 113     // Getters
 114     bool owns_lock() const noexcept;
 115     explicit operator bool () const noexcept;
 116     mutex_type* mutex() const noexcept;
 117 };
 118
 119 template <class Mutex>
 120     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 121
 122 }  // std
 123
 124 */
 125
 126 #include <__config>
 127
 128 _LIBCPP_PUSH_MACROS
 129 #include <__undef_macros>
 130
 131
 132 #if _LIBCPP_STD_VER > 11 || defined(_LIBCPP_BUILDING_SHARED_MUTEX)
 133
 134 #include <__mutex_base>
 135
 136 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 137 #pragma GCC system_header
 138 #endif
 139
 140 #ifdef _LIBCPP_HAS_NO_THREADS
 141 #error <shared_mutex> is not supported on this single threaded system
 142 #else // !_LIBCPP_HAS_NO_THREADS
 143
 144 _LIBCPP_BEGIN_NAMESPACE_STD
 145
 146 struct _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX __shared_mutex_base
 147 {
 148     mutex               __mut_;
 149     condition_variable  __gate1_;
 150     condition_variable  __gate2_;
 151     unsigned            __state_;
 152
 153     static const unsigned __write_entered_ = 1U << (sizeof(unsigned)*__CHAR_BIT__ - 1);
 154     static const unsigned __n_readers_ = ~__write_entered_;
 155
 156     __shared_mutex_base();
 157     _LIBCPP_INLINE_VISIBILITY ~__shared_mutex_base() = default;
 158
 159     __shared_mutex_base(const __shared_mutex_base&) = delete;
 160     __shared_mutex_base& operator=(const __shared_mutex_base&) = delete;
 161
 162     // Exclusive ownership
 163     void lock(); // blocking
 164     bool try_lock();
 165     void unlock();
 166
 167     // Shared ownership
 168     void lock_shared(); // blocking
 169     bool try_lock_shared();
 170     void unlock_shared();
 171
 172 //     typedef implementation-defined native_handle_type; // See 30.2.3
 173 //     native_handle_type native_handle(); // See 30.2.3
 174 };
 175
 176
 177 #if _LIBCPP_STD_VER > 14
 178 class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX shared_mutex
 179 {
 180     __shared_mutex_base __base;
 181 public:
 182     _LIBCPP_INLINE_VISIBILITY shared_mutex() : __base() {}
 183     _LIBCPP_INLINE_VISIBILITY ~shared_mutex() = default;
 184
 185     shared_mutex(const shared_mutex&) = delete;
 186     shared_mutex& operator=(const shared_mutex&) = delete;
 187
 188     // Exclusive ownership
 189     _LIBCPP_INLINE_VISIBILITY void lock()     { return __base.lock(); }
 190     _LIBCPP_INLINE_VISIBILITY bool try_lock() { return __base.try_lock(); }
 191     _LIBCPP_INLINE_VISIBILITY void unlock()   { return __base.unlock(); }
 192
 193     // Shared ownership
 194     _LIBCPP_INLINE_VISIBILITY void lock_shared()     { return __base.lock_shared(); }
 195     _LIBCPP_INLINE_VISIBILITY bool try_lock_shared() { return __base.try_lock_shared(); }
 196     _LIBCPP_INLINE_VISIBILITY void unlock_shared()   { return __base.unlock_shared(); }
 197
 198 //     typedef __shared_mutex_base::native_handle_type native_handle_type;
 199 //     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() { return __base::unlock_shared(); }
 200 };
 201 #endif
 202
 203
 204 class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX shared_timed_mutex
 205 {
 206     __shared_mutex_base __base;
 207 public:
 208     shared_timed_mutex();
 209     _LIBCPP_INLINE_VISIBILITY ~shared_timed_mutex() = default;
 210
 211     shared_timed_mutex(const shared_timed_mutex&) = delete;
 212     shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
 213
 214     // Exclusive ownership
 215     void lock();
 216     bool try_lock();
 217     template <class _Rep, class _Period>
 218         _LIBCPP_INLINE_VISIBILITY
 219         bool
 220         try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
 221         {
 222             return try_lock_until(chrono::steady_clock::now() + __rel_time);
 223         }
 224     template <class _Clock, class _Duration>
 225         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 226         bool
 227         try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
 228     void unlock();
 229
 230     // Shared ownership
 231     void lock_shared();
 232     bool try_lock_shared();
 233     template <class _Rep, class _Period>
 234         _LIBCPP_INLINE_VISIBILITY
 235         bool
 236         try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time)
 237         {
 238             return try_lock_shared_until(chrono::steady_clock::now() + __rel_time);
 239         }
 240     template <class _Clock, class _Duration>
 241         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 242         bool
 243         try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
 244     void unlock_shared();
 245 };
 246
 247 template <class _Clock, class _Duration>
 248 bool
 249 shared_timed_mutex::try_lock_until(
 250                         const chrono::time_point<_Clock, _Duration>& __abs_time)
 251 {
 252     unique_lock<mutex> __lk(__base.__mut_);
 253     if (__base.__state_ & __base.__write_entered_)
 254     {
 255         while (true)
 256         {
 257             cv_status __status = __base.__gate1_.wait_until(__lk, __abs_time);
 258             if ((__base.__state_ & __base.__write_entered_) == 0)
 259                 break;
 260             if (__status == cv_status::timeout)
 261                 return false;
 262         }
 263     }
 264     __base.__state_ |= __base.__write_entered_;
 265     if (__base.__state_ & __base.__n_readers_)
 266     {
 267         while (true)
 268         {
 269             cv_status __status = __base.__gate2_.wait_until(__lk, __abs_time);
 270             if ((__base.__state_ & __base.__n_readers_) == 0)
 271                 break;
 272             if (__status == cv_status::timeout)
 273             {
 274                 __base.__state_ &= ~__base.__write_entered_;
 275                 __base.__gate1_.notify_all();
 276                 return false;
 277             }
 278         }
 279     }
 280     return true;
 281 }
 282
 283 template <class _Clock, class _Duration>
 284 bool
 285 shared_timed_mutex::try_lock_shared_until(
 286                         const chrono::time_point<_Clock, _Duration>& __abs_time)
 287 {
 288     unique_lock<mutex> __lk(__base.__mut_);
 289     if ((__base.__state_ & __base.__write_entered_) || (__base.__state_ & __base.__n_readers_) == __base.__n_readers_)
 290     {
 291         while (true)
 292         {
 293             cv_status status = __base.__gate1_.wait_until(__lk, __abs_time);
 294             if ((__base.__state_ & __base.__write_entered_) == 0 &&
 295                                        (__base.__state_ & __base.__n_readers_) < __base.__n_readers_)
 296                 break;
 297             if (status == cv_status::timeout)
 298                 return false;
 299         }
 300     }
 301     unsigned __num_readers = (__base.__state_ & __base.__n_readers_) + 1;
 302     __base.__state_ &= ~__base.__n_readers_;
 303     __base.__state_ |= __num_readers;
 304     return true;
 305 }
 306
 307 template <class _Mutex>
 308 class shared_lock
 309 {
 310 public:
 311     typedef _Mutex mutex_type;
 312
 313 private:
 314     mutex_type* __m_;
 315     bool __owns_;
 316
 317 public:
 318     _LIBCPP_INLINE_VISIBILITY
 319     shared_lock() _NOEXCEPT
 320         : __m_(nullptr),
 321           __owns_(false)
 322         {}
 323
 324     _LIBCPP_INLINE_VISIBILITY
 325     explicit shared_lock(mutex_type& __m)
 326         : __m_(_VSTD::addressof(__m)),
 327           __owns_(true)
 328         {__m_->lock_shared();}
 329
 330     _LIBCPP_INLINE_VISIBILITY
 331     shared_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
 332         : __m_(_VSTD::addressof(__m)),
 333           __owns_(false)
 334         {}
 335
 336     _LIBCPP_INLINE_VISIBILITY
 337     shared_lock(mutex_type& __m, try_to_lock_t)
 338         : __m_(_VSTD::addressof(__m)),
 339           __owns_(__m.try_lock_shared())
 340         {}
 341
 342     _LIBCPP_INLINE_VISIBILITY
 343     shared_lock(mutex_type& __m, adopt_lock_t)
 344         : __m_(_VSTD::addressof(__m)),
 345           __owns_(true)
 346         {}
 347
 348     template <class _Clock, class _Duration>
 349         _LIBCPP_INLINE_VISIBILITY
 350         shared_lock(mutex_type& __m,
 351                     const chrono::time_point<_Clock, _Duration>& __abs_time)
 352             : __m_(_VSTD::addressof(__m)),
 353               __owns_(__m.try_lock_shared_until(__abs_time))
 354             {}
 355
 356     template <class _Rep, class _Period>
 357         _LIBCPP_INLINE_VISIBILITY
 358         shared_lock(mutex_type& __m,
 359                     const chrono::duration<_Rep, _Period>& __rel_time)
 360             : __m_(_VSTD::addressof(__m)),
 361               __owns_(__m.try_lock_shared_for(__rel_time))
 362             {}
 363
 364     _LIBCPP_INLINE_VISIBILITY
 365     ~shared_lock()
 366     {
 367         if (__owns_)
 368             __m_->unlock_shared();
 369     }
 370
 371     shared_lock(shared_lock const&) = delete;
 372     shared_lock& operator=(shared_lock const&) = delete;
 373
 374     _LIBCPP_INLINE_VISIBILITY
 375     shared_lock(shared_lock&& __u) _NOEXCEPT
 376         : __m_(__u.__m_),
 377           __owns_(__u.__owns_)
 378         {
 379             __u.__m_ = nullptr;
 380             __u.__owns_ = false;
 381         }
 382
 383     _LIBCPP_INLINE_VISIBILITY
 384     shared_lock& operator=(shared_lock&& __u) _NOEXCEPT
 385     {
 386         if (__owns_)
 387             __m_->unlock_shared();
 388         __m_ = nullptr;
 389         __owns_ = false;
 390         __m_ = __u.__m_;
 391         __owns_ = __u.__owns_;
 392         __u.__m_ = nullptr;
 393         __u.__owns_ = false;
 394         return *this;
 395     }
 396
 397     void lock();
 398     bool try_lock();
 399     template <class Rep, class Period>
 400         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 401     template <class Clock, class Duration>
 402         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 403     void unlock();
 404
 405     // Setters
 406     _LIBCPP_INLINE_VISIBILITY
 407     void swap(shared_lock& __u) _NOEXCEPT
 408     {
 409         _VSTD::swap(__m_, __u.__m_);
 410         _VSTD::swap(__owns_, __u.__owns_);
 411     }
 412
 413     _LIBCPP_INLINE_VISIBILITY
 414     mutex_type* release() _NOEXCEPT
 415     {
 416         mutex_type* __m = __m_;
 417         __m_ = nullptr;
 418         __owns_ = false;
 419         return __m;
 420     }
 421
 422     // Getters
 423     _LIBCPP_INLINE_VISIBILITY
 424     bool owns_lock() const _NOEXCEPT {return __owns_;}
 425
 426     _LIBCPP_INLINE_VISIBILITY
 427     explicit operator bool () const _NOEXCEPT {return __owns_;}
 428
 429     _LIBCPP_INLINE_VISIBILITY
 430     mutex_type* mutex() const _NOEXCEPT {return __m_;}
 431 };
 432
 433 template <class _Mutex>
 434 void
 435 shared_lock<_Mutex>::lock()
 436 {
 437     if (__m_ == nullptr)
 438         __throw_system_error(EPERM, "shared_lock::lock: references null mutex");
 439     if (__owns_)
 440         __throw_system_error(EDEADLK, "shared_lock::lock: already locked");
 441     __m_->lock_shared();
 442     __owns_ = true;
 443 }
 444
 445 template <class _Mutex>
 446 bool
 447 shared_lock<_Mutex>::try_lock()
 448 {
 449     if (__m_ == nullptr)
 450         __throw_system_error(EPERM, "shared_lock::try_lock: references null mutex");
 451     if (__owns_)
 452         __throw_system_error(EDEADLK, "shared_lock::try_lock: already locked");
 453     __owns_ = __m_->try_lock_shared();
 454     return __owns_;
 455 }
 456
 457 template <class _Mutex>
 458 template <class _Rep, class _Period>
 459 bool
 460 shared_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d)
 461 {
 462     if (__m_ == nullptr)
 463         __throw_system_error(EPERM, "shared_lock::try_lock_for: references null mutex");
 464     if (__owns_)
 465         __throw_system_error(EDEADLK, "shared_lock::try_lock_for: already locked");
 466     __owns_ = __m_->try_lock_shared_for(__d);
 467     return __owns_;
 468 }
 469
 470 template <class _Mutex>
 471 template <class _Clock, class _Duration>
 472 bool
 473 shared_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 474 {
 475     if (__m_ == nullptr)
 476         __throw_system_error(EPERM, "shared_lock::try_lock_until: references null mutex");
 477     if (__owns_)
 478         __throw_system_error(EDEADLK, "shared_lock::try_lock_until: already locked");
 479     __owns_ = __m_->try_lock_shared_until(__t);
 480     return __owns_;
 481 }
 482
 483 template <class _Mutex>
 484 void
 485 shared_lock<_Mutex>::unlock()
 486 {
 487     if (!__owns_)
 488         __throw_system_error(EPERM, "shared_lock::unlock: not locked");
 489     __m_->unlock_shared();
 490     __owns_ = false;
 491 }
 492
 493 template <class _Mutex>
 494 inline _LIBCPP_INLINE_VISIBILITY
 495 void
 496 swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) _NOEXCEPT
 497     {__x.swap(__y);}
 498
 499 _LIBCPP_END_NAMESPACE_STD
 500
 501 #endif  // !_LIBCPP_HAS_NO_THREADS
 502
 503 #endif  // _LIBCPP_STD_VER > 11
 504
 505 _LIBCPP_POP_MACROS
 506
 507 #endif  // _LIBCPP_SHARED_MUTEX