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 #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         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 224         bool
 225         try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
 226     void unlock();
 227
 228     // Shared ownership
 229     void lock_shared();
 230     bool try_lock_shared();
 231     template <class _Rep, class _Period>
 232         _LIBCPP_INLINE_VISIBILITY
 233         bool
 234         try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time)
 235         {
 236             return try_lock_shared_until(chrono::steady_clock::now() + __rel_time);
 237         }
 238     template <class _Clock, class _Duration>
 239         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 240         bool
 241         try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
 242     void unlock_shared();
 243 };
 244
 245 template <class _Clock, class _Duration>
 246 bool
 247 shared_timed_mutex::try_lock_until(
 248                         const chrono::time_point<_Clock, _Duration>& __abs_time)
 249 {
 250     unique_lock<mutex> __lk(__base.__mut_);
 251     if (__base.__state_ & __base.__write_entered_)
 252     {
 253         while (true)
 254         {
 255             cv_status __status = __base.__gate1_.wait_until(__lk, __abs_time);
 256             if ((__base.__state_ & __base.__write_entered_) == 0)
 257                 break;
 258             if (__status == cv_status::timeout)
 259                 return false;
 260         }
 261     }
 262     __base.__state_ |= __base.__write_entered_;
 263     if (__base.__state_ & __base.__n_readers_)
 264     {
 265         while (true)
 266         {
 267             cv_status __status = __base.__gate2_.wait_until(__lk, __abs_time);
 268             if ((__base.__state_ & __base.__n_readers_) == 0)
 269                 break;
 270             if (__status == cv_status::timeout)
 271             {
 272                 __base.__state_ &= ~__base.__write_entered_;
 273                 __base.__gate1_.notify_all();
 274                 return false;
 275             }
 276         }
 277     }
 278     return true;
 279 }
 280
 281 template <class _Clock, class _Duration>
 282 bool
 283 shared_timed_mutex::try_lock_shared_until(
 284                         const chrono::time_point<_Clock, _Duration>& __abs_time)
 285 {
 286     unique_lock<mutex> __lk(__base.__mut_);
 287     if ((__base.__state_ & __base.__write_entered_) || (__base.__state_ & __base.__n_readers_) == __base.__n_readers_)
 288     {
 289         while (true)
 290         {
 291             cv_status status = __base.__gate1_.wait_until(__lk, __abs_time);
 292             if ((__base.__state_ & __base.__write_entered_) == 0 &&
 293                                        (__base.__state_ & __base.__n_readers_) < __base.__n_readers_)
 294                 break;
 295             if (status == cv_status::timeout)
 296                 return false;
 297         }
 298     }
 299     unsigned __num_readers = (__base.__state_ & __base.__n_readers_) + 1;
 300     __base.__state_ &= ~__base.__n_readers_;
 301     __base.__state_ |= __num_readers;
 302     return true;
 303 }
 304
 305 template <class _Mutex>
 306 class shared_lock
 307 {
 308 public:
 309     typedef _Mutex mutex_type;
 310
 311 private:
 312     mutex_type* __m_;
 313     bool __owns_;
 314
 315 public:
 316     _LIBCPP_INLINE_VISIBILITY
 317     shared_lock() _NOEXCEPT
 318         : __m_(nullptr),
 319           __owns_(false)
 320         {}
 321
 322     _LIBCPP_INLINE_VISIBILITY
 323     explicit shared_lock(mutex_type& __m)
 324         : __m_(_VSTD::addressof(__m)),
 325           __owns_(true)
 326         {__m_->lock_shared();}
 327
 328     _LIBCPP_INLINE_VISIBILITY
 329     shared_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
 330         : __m_(_VSTD::addressof(__m)),
 331           __owns_(false)
 332         {}
 333
 334     _LIBCPP_INLINE_VISIBILITY
 335     shared_lock(mutex_type& __m, try_to_lock_t)
 336         : __m_(_VSTD::addressof(__m)),
 337           __owns_(__m.try_lock_shared())
 338         {}
 339
 340     _LIBCPP_INLINE_VISIBILITY
 341     shared_lock(mutex_type& __m, adopt_lock_t)
 342         : __m_(_VSTD::addressof(__m)),
 343           __owns_(true)
 344         {}
 345
 346     template <class _Clock, class _Duration>
 347         _LIBCPP_INLINE_VISIBILITY
 348         shared_lock(mutex_type& __m,
 349                     const chrono::time_point<_Clock, _Duration>& __abs_time)
 350             : __m_(_VSTD::addressof(__m)),
 351               __owns_(__m.try_lock_shared_until(__abs_time))
 352             {}
 353
 354     template <class _Rep, class _Period>
 355         _LIBCPP_INLINE_VISIBILITY
 356         shared_lock(mutex_type& __m,
 357                     const chrono::duration<_Rep, _Period>& __rel_time)
 358             : __m_(_VSTD::addressof(__m)),
 359               __owns_(__m.try_lock_shared_for(__rel_time))
 360             {}
 361
 362     _LIBCPP_INLINE_VISIBILITY
 363     ~shared_lock()
 364     {
 365         if (__owns_)
 366             __m_->unlock_shared();
 367     }
 368
 369     shared_lock(shared_lock const&) = delete;
 370     shared_lock& operator=(shared_lock const&) = delete;
 371
 372     _LIBCPP_INLINE_VISIBILITY
 373     shared_lock(shared_lock&& __u) _NOEXCEPT
 374         : __m_(__u.__m_),
 375           __owns_(__u.__owns_)
 376         {
 377             __u.__m_ = nullptr;
 378             __u.__owns_ = false;
 379         }
 380
 381     _LIBCPP_INLINE_VISIBILITY
 382     shared_lock& operator=(shared_lock&& __u) _NOEXCEPT
 383     {
 384         if (__owns_)
 385             __m_->unlock_shared();
 386         __m_ = nullptr;
 387         __owns_ = false;
 388         __m_ = __u.__m_;
 389         __owns_ = __u.__owns_;
 390         __u.__m_ = nullptr;
 391         __u.__owns_ = false;
 392         return *this;
 393     }
 394
 395     void lock();
 396     bool try_lock();
 397     template <class Rep, class Period>
 398         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 399     template <class Clock, class Duration>
 400         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 401     void unlock();
 402
 403     // Setters
 404     _LIBCPP_INLINE_VISIBILITY
 405     void swap(shared_lock& __u) _NOEXCEPT
 406     {
 407         _VSTD::swap(__m_, __u.__m_);
 408         _VSTD::swap(__owns_, __u.__owns_);
 409     }
 410
 411     _LIBCPP_INLINE_VISIBILITY
 412     mutex_type* release() _NOEXCEPT
 413     {
 414         mutex_type* __m = __m_;
 415         __m_ = nullptr;
 416         __owns_ = false;
 417         return __m;
 418     }
 419
 420     // Getters
 421     _LIBCPP_INLINE_VISIBILITY
 422     bool owns_lock() const _NOEXCEPT {return __owns_;}
 423
 424     _LIBCPP_INLINE_VISIBILITY
 425     explicit operator bool () const _NOEXCEPT {return __owns_;}
 426
 427     _LIBCPP_INLINE_VISIBILITY
 428     mutex_type* mutex() const _NOEXCEPT {return __m_;}
 429 };
 430
 431 template <class _Mutex>
 432 void
 433 shared_lock<_Mutex>::lock()
 434 {
 435     if (__m_ == nullptr)
 436         __throw_system_error(EPERM, "shared_lock::lock: references null mutex");
 437     if (__owns_)
 438         __throw_system_error(EDEADLK, "shared_lock::lock: already locked");
 439     __m_->lock_shared();
 440     __owns_ = true;
 441 }
 442
 443 template <class _Mutex>
 444 bool
 445 shared_lock<_Mutex>::try_lock()
 446 {
 447     if (__m_ == nullptr)
 448         __throw_system_error(EPERM, "shared_lock::try_lock: references null mutex");
 449     if (__owns_)
 450         __throw_system_error(EDEADLK, "shared_lock::try_lock: already locked");
 451     __owns_ = __m_->try_lock_shared();
 452     return __owns_;
 453 }
 454
 455 template <class _Mutex>
 456 template <class _Rep, class _Period>
 457 bool
 458 shared_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d)
 459 {
 460     if (__m_ == nullptr)
 461         __throw_system_error(EPERM, "shared_lock::try_lock_for: references null mutex");
 462     if (__owns_)
 463         __throw_system_error(EDEADLK, "shared_lock::try_lock_for: already locked");
 464     __owns_ = __m_->try_lock_shared_for(__d);
 465     return __owns_;
 466 }
 467
 468 template <class _Mutex>
 469 template <class _Clock, class _Duration>
 470 bool
 471 shared_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 472 {
 473     if (__m_ == nullptr)
 474         __throw_system_error(EPERM, "shared_lock::try_lock_until: references null mutex");
 475     if (__owns_)
 476         __throw_system_error(EDEADLK, "shared_lock::try_lock_until: already locked");
 477     __owns_ = __m_->try_lock_shared_until(__t);
 478     return __owns_;
 479 }
 480
 481 template <class _Mutex>
 482 void
 483 shared_lock<_Mutex>::unlock()
 484 {
 485     if (!__owns_)
 486         __throw_system_error(EPERM, "shared_lock::unlock: not locked");
 487     __m_->unlock_shared();
 488     __owns_ = false;
 489 }
 490
 491 template <class _Mutex>
 492 inline _LIBCPP_INLINE_VISIBILITY
 493 void
 494 swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) _NOEXCEPT
 495     {__x.swap(__y);}
 496
 497 _LIBCPP_END_NAMESPACE_STD
 498
 499 #endif  // !_LIBCPP_HAS_NO_THREADS
 500
 501 #endif  // _LIBCPP_STD_VER > 11
 502
 503 #endif  // _LIBCPP_SHARED_MUTEX