external/bsd/libc++/dist/libcxx/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 #if _LIBCPP_STD_VER > 11 || defined(_LIBCPP_BUILDING_SHARED_MUTEX)
 129
 130 #include <__mutex_base>
 131
 132 #include <__undef_min_max>
 133
 134 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 135 #pragma GCC system_header
 136 #endif
 137
 138 #ifdef _LIBCPP_HAS_NO_THREADS
 139 #error <shared_mutex> is not supported on this single threaded system
 140 #else // !_LIBCPP_HAS_NO_THREADS
 141
 142 _LIBCPP_BEGIN_NAMESPACE_STD
 143
 144 struct _LIBCPP_TYPE_VIS __shared_mutex_base
 145 {
 146     mutex               __mut_;
 147     condition_variable  __gate1_;
 148     condition_variable  __gate2_;
 149     unsigned            __state_;
 150
 151     static const unsigned __write_entered_ = 1U << (sizeof(unsigned)*__CHAR_BIT__ - 1);
 152     static const unsigned __n_readers_ = ~__write_entered_;
 153
 154     __shared_mutex_base();
 155     _LIBCPP_INLINE_VISIBILITY ~__shared_mutex_base() = default;
 156
 157     __shared_mutex_base(const __shared_mutex_base&) = delete;
 158     __shared_mutex_base& operator=(const __shared_mutex_base&) = delete;
 159
 160     // Exclusive ownership
 161     void lock(); // blocking
 162     bool try_lock();
 163     void unlock();
 164
 165     // Shared ownership
 166     void lock_shared(); // blocking
 167     bool try_lock_shared();
 168     void unlock_shared();
 169
 170 //     typedef implementation-defined native_handle_type; // See 30.2.3
 171 //     native_handle_type native_handle(); // See 30.2.3
 172 };
 173
 174
 175 #if _LIBCPP_STD_VER > 14
 176 class _LIBCPP_TYPE_VIS shared_mutex
 177 {
 178         __shared_mutex_base __base;
 179 public:
 180     shared_mutex() : __base() {}
 181     _LIBCPP_INLINE_VISIBILITY ~shared_mutex() = default;
 182
 183     shared_mutex(const shared_mutex&) = delete;
 184     shared_mutex& operator=(const shared_mutex&) = delete;
 185
 186     // Exclusive ownership
 187     _LIBCPP_INLINE_VISIBILITY void lock()     { return __base.lock(); }
 188     _LIBCPP_INLINE_VISIBILITY bool try_lock() { return __base.try_lock(); }
 189     _LIBCPP_INLINE_VISIBILITY void unlock()   { return __base.unlock(); }
 190
 191     // Shared ownership
 192     _LIBCPP_INLINE_VISIBILITY void lock_shared()     { return __base.lock_shared(); }
 193     _LIBCPP_INLINE_VISIBILITY bool try_lock_shared() { return __base.try_lock_shared(); }
 194     _LIBCPP_INLINE_VISIBILITY void unlock_shared()   { return __base.unlock_shared(); }
 195
 196 //     typedef __shared_mutex_base::native_handle_type native_handle_type;
 197 //     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() { return __base::unlock_shared(); }
 198 };
 199 #endif
 200
 201
 202 class _LIBCPP_TYPE_VIS shared_timed_mutex
 203 {
 204         __shared_mutex_base __base;
 205 public:
 206     shared_timed_mutex();
 207     _LIBCPP_INLINE_VISIBILITY ~shared_timed_mutex() = default;
 208
 209     shared_timed_mutex(const shared_timed_mutex&) = delete;
 210     shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
 211
 212     // Exclusive ownership
 213     void lock();
 214     bool try_lock();
 215     template <class _Rep, class _Period>
 216         _LIBCPP_INLINE_VISIBILITY
 217         bool
 218         try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
 219         {
 220             return try_lock_until(chrono::steady_clock::now() + __rel_time);
 221         }
 222     template <class _Clock, class _Duration>
 223         bool
 224         try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
 225     void unlock();
 226
 227     // Shared ownership
 228     void lock_shared();
 229     bool try_lock_shared();
 230     template <class _Rep, class _Period>
 231         _LIBCPP_INLINE_VISIBILITY
 232         bool
 233         try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time)
 234         {
 235             return try_lock_shared_until(chrono::steady_clock::now() + __rel_time);
 236         }
 237     template <class _Clock, class _Duration>
 238         bool
 239         try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
 240     void unlock_shared();
 241 };
 242
 243 template <class _Clock, class _Duration>
 244 bool
 245 shared_timed_mutex::try_lock_until(
 246                         const chrono::time_point<_Clock, _Duration>& __abs_time)
 247 {
 248     unique_lock<mutex> __lk(__base.__mut_);
 249     if (__base.__state_ & __base.__write_entered_)
 250     {
 251         while (true)
 252         {
 253             cv_status __status = __base.__gate1_.wait_until(__lk, __abs_time);
 254             if ((__base.__state_ & __base.__write_entered_) == 0)
 255                 break;
 256             if (__status == cv_status::timeout)
 257                 return false;
 258         }
 259     }
 260     __base.__state_ |= __base.__write_entered_;
 261     if (__base.__state_ & __base.__n_readers_)
 262     {
 263         while (true)
 264         {
 265             cv_status __status = __base.__gate2_.wait_until(__lk, __abs_time);
 266             if ((__base.__state_ & __base.__n_readers_) == 0)
 267                 break;
 268             if (__status == cv_status::timeout)
 269             {
 270                 __base.__state_ &= ~__base.__write_entered_;
 271                 __base.__gate1_.notify_all();
 272                 return false;
 273             }
 274         }
 275     }
 276     return true;
 277 }
 278
 279 template <class _Clock, class _Duration>
 280 bool
 281 shared_timed_mutex::try_lock_shared_until(
 282                         const chrono::time_point<_Clock, _Duration>& __abs_time)
 283 {
 284     unique_lock<mutex> __lk(__base.__mut_);
 285     if ((__base.__state_ & __base.__write_entered_) || (__base.__state_ & __base.__n_readers_) == __base.__n_readers_)
 286     {
 287         while (true)
 288         {
 289             cv_status status = __base.__gate1_.wait_until(__lk, __abs_time);
 290             if ((__base.__state_ & __base.__write_entered_) == 0 &&
 291                                        (__base.__state_ & __base.__n_readers_) < __base.__n_readers_)
 292                 break;
 293             if (status == cv_status::timeout)
 294                 return false;
 295         }
 296     }
 297     unsigned __num_readers = (__base.__state_ & __base.__n_readers_) + 1;
 298     __base.__state_ &= ~__base.__n_readers_;
 299     __base.__state_ |= __num_readers;
 300     return true;
 301 }
 302
 303 template <class _Mutex>
 304 class shared_lock
 305 {
 306 public:
 307     typedef _Mutex mutex_type;
 308
 309 private:
 310     mutex_type* __m_;
 311     bool __owns_;
 312
 313 public:
 314     _LIBCPP_INLINE_VISIBILITY
 315     shared_lock() _NOEXCEPT
 316         : __m_(nullptr),
 317           __owns_(false)
 318         {}
 319
 320     _LIBCPP_INLINE_VISIBILITY
 321     explicit shared_lock(mutex_type& __m)
 322         : __m_(&__m),
 323           __owns_(true)
 324         {__m_->lock_shared();}
 325
 326     _LIBCPP_INLINE_VISIBILITY
 327     shared_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
 328         : __m_(&__m),
 329           __owns_(false)
 330         {}
 331
 332     _LIBCPP_INLINE_VISIBILITY
 333     shared_lock(mutex_type& __m, try_to_lock_t)
 334         : __m_(&__m),
 335           __owns_(__m.try_lock_shared())
 336         {}
 337
 338     _LIBCPP_INLINE_VISIBILITY
 339     shared_lock(mutex_type& __m, adopt_lock_t)
 340         : __m_(&__m),
 341           __owns_(true)
 342         {}
 343
 344     template <class _Clock, class _Duration>
 345         _LIBCPP_INLINE_VISIBILITY
 346         shared_lock(mutex_type& __m,
 347                     const chrono::time_point<_Clock, _Duration>& __abs_time)
 348             : __m_(&__m),
 349               __owns_(__m.try_lock_shared_until(__abs_time))
 350             {}
 351
 352     template <class _Rep, class _Period>
 353         _LIBCPP_INLINE_VISIBILITY
 354         shared_lock(mutex_type& __m,
 355                     const chrono::duration<_Rep, _Period>& __rel_time)
 356             : __m_(&__m),
 357               __owns_(__m.try_lock_shared_for(__rel_time))
 358             {}
 359
 360     _LIBCPP_INLINE_VISIBILITY
 361     ~shared_lock()
 362     {
 363         if (__owns_)
 364             __m_->unlock_shared();
 365     }
 366
 367     shared_lock(shared_lock const&) = delete;
 368     shared_lock& operator=(shared_lock const&) = delete;
 369
 370     _LIBCPP_INLINE_VISIBILITY
 371     shared_lock(shared_lock&& __u) _NOEXCEPT
 372         : __m_(__u.__m_),
 373           __owns_(__u.__owns_)
 374         {
 375             __u.__m_ = nullptr;
 376             __u.__owns_ = false;
 377         }
 378
 379     _LIBCPP_INLINE_VISIBILITY
 380     shared_lock& operator=(shared_lock&& __u) _NOEXCEPT
 381     {
 382         if (__owns_)
 383             __m_->unlock_shared();
 384         __m_ = nullptr;
 385         __owns_ = false;
 386         __m_ = __u.__m_;
 387         __owns_ = __u.__owns_;
 388         __u.__m_ = nullptr;
 389         __u.__owns_ = false;
 390         return *this;
 391     }
 392
 393     void lock();
 394     bool try_lock();
 395     template <class Rep, class Period>
 396         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 397     template <class Clock, class Duration>
 398         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 399     void unlock();
 400
 401     // Setters
 402     _LIBCPP_INLINE_VISIBILITY
 403     void swap(shared_lock& __u) _NOEXCEPT
 404     {
 405         _VSTD::swap(__m_, __u.__m_);
 406         _VSTD::swap(__owns_, __u.__owns_);
 407     }
 408
 409     _LIBCPP_INLINE_VISIBILITY
 410     mutex_type* release() _NOEXCEPT
 411     {
 412         mutex_type* __m = __m_;
 413         __m_ = nullptr;
 414         __owns_ = false;
 415         return __m;
 416     }
 417
 418     // Getters
 419     _LIBCPP_INLINE_VISIBILITY
 420     bool owns_lock() const _NOEXCEPT {return __owns_;}
 421
 422     _LIBCPP_INLINE_VISIBILITY
 423     explicit operator bool () const _NOEXCEPT {return __owns_;}
 424
 425     _LIBCPP_INLINE_VISIBILITY
 426     mutex_type* mutex() const _NOEXCEPT {return __m_;}
 427 };
 428
 429 template <class _Mutex>
 430 void
 431 shared_lock<_Mutex>::lock()
 432 {
 433     if (__m_ == nullptr)
 434         __throw_system_error(EPERM, "shared_lock::lock: references null mutex");
 435     if (__owns_)
 436         __throw_system_error(EDEADLK, "shared_lock::lock: already locked");
 437     __m_->lock_shared();
 438     __owns_ = true;
 439 }
 440
 441 template <class _Mutex>
 442 bool
 443 shared_lock<_Mutex>::try_lock()
 444 {
 445     if (__m_ == nullptr)
 446         __throw_system_error(EPERM, "shared_lock::try_lock: references null mutex");
 447     if (__owns_)
 448         __throw_system_error(EDEADLK, "shared_lock::try_lock: already locked");
 449     __owns_ = __m_->try_lock_shared();
 450     return __owns_;
 451 }
 452
 453 template <class _Mutex>
 454 template <class _Rep, class _Period>
 455 bool
 456 shared_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d)
 457 {
 458     if (__m_ == nullptr)
 459         __throw_system_error(EPERM, "shared_lock::try_lock_for: references null mutex");
 460     if (__owns_)
 461         __throw_system_error(EDEADLK, "shared_lock::try_lock_for: already locked");
 462     __owns_ = __m_->try_lock_shared_for(__d);
 463     return __owns_;
 464 }
 465
 466 template <class _Mutex>
 467 template <class _Clock, class _Duration>
 468 bool
 469 shared_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 470 {
 471     if (__m_ == nullptr)
 472         __throw_system_error(EPERM, "shared_lock::try_lock_until: references null mutex");
 473     if (__owns_)
 474         __throw_system_error(EDEADLK, "shared_lock::try_lock_until: already locked");
 475     __owns_ = __m_->try_lock_shared_until(__t);
 476     return __owns_;
 477 }
 478
 479 template <class _Mutex>
 480 void
 481 shared_lock<_Mutex>::unlock()
 482 {
 483     if (!__owns_)
 484         __throw_system_error(EPERM, "shared_lock::unlock: not locked");
 485     __m_->unlock_shared();
 486     __owns_ = false;
 487 }
 488
 489 template <class _Mutex>
 490 inline _LIBCPP_INLINE_VISIBILITY
 491 void
 492 swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) _NOEXCEPT
 493     {__x.swap(__y);}
 494
 495 _LIBCPP_END_NAMESPACE_STD
 496
 497 #endif  // !_LIBCPP_HAS_NO_THREADS
 498
 499 #endif  // _LIBCPP_STD_VER > 11
 500
 501 #endif  // _LIBCPP_SHARED_MUTEX