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