libcxx/src/shared_mutex.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include <mutex>
  10 #include <shared_mutex>
  11 #if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
  12 #  pragma comment(lib, "pthread")
  13 #endif
  14
  15 _LIBCPP_BEGIN_NAMESPACE_STD
  16
  17 // Shared Mutex Base
  18 __shared_mutex_base::__shared_mutex_base() : __state_(0) {}
  19
  20 // Exclusive ownership
  21
  22 void __shared_mutex_base::lock() {
  23   unique_lock<mutex> lk(__mut_);
  24   while (__state_ & __write_entered_)
  25     __gate1_.wait(lk);
  26   __state_ |= __write_entered_;
  27   while (__state_ & __n_readers_)
  28     __gate2_.wait(lk);
  29 }
  30
  31 bool __shared_mutex_base::try_lock() {
  32   unique_lock<mutex> lk(__mut_);
  33   if (__state_ == 0) {
  34     __state_ = __write_entered_;
  35     return true;
  36   }
  37   return false;
  38 }
  39
  40 void __shared_mutex_base::unlock() {
  41   lock_guard<mutex> _(__mut_);
  42   __state_ = 0;
  43   __gate1_.notify_all();
  44 }
  45
  46 // Shared ownership
  47
  48 void __shared_mutex_base::lock_shared() {
  49   unique_lock<mutex> lk(__mut_);
  50   while ((__state_ & __write_entered_) || (__state_ & __n_readers_) == __n_readers_)
  51     __gate1_.wait(lk);
  52   unsigned num_readers = (__state_ & __n_readers_) + 1;
  53   __state_ &= ~__n_readers_;
  54   __state_ |= num_readers;
  55 }
  56
  57 bool __shared_mutex_base::try_lock_shared() {
  58   unique_lock<mutex> lk(__mut_);
  59   unsigned num_readers = __state_ & __n_readers_;
  60   if (!(__state_ & __write_entered_) && num_readers != __n_readers_) {
  61     ++num_readers;
  62     __state_ &= ~__n_readers_;
  63     __state_ |= num_readers;
  64     return true;
  65   }
  66   return false;
  67 }
  68
  69 void __shared_mutex_base::unlock_shared() {
  70   lock_guard<mutex> _(__mut_);
  71   unsigned num_readers = (__state_ & __n_readers_) - 1;
  72   __state_ &= ~__n_readers_;
  73   __state_ |= num_readers;
  74   if (__state_ & __write_entered_) {
  75     if (num_readers == 0)
  76       __gate2_.notify_one();
  77   } else {
  78     if (num_readers == __n_readers_ - 1)
  79       __gate1_.notify_one();
  80   }
  81 }
  82
  83 // Shared Timed Mutex
  84 // These routines are here for ABI stability
  85 shared_timed_mutex::shared_timed_mutex() : __base_() {}
  86 void shared_timed_mutex::lock() { return __base_.lock(); }
  87 bool shared_timed_mutex::try_lock() { return __base_.try_lock(); }
  88 void shared_timed_mutex::unlock() { return __base_.unlock(); }
  89 void shared_timed_mutex::lock_shared() { return __base_.lock_shared(); }
  90 bool shared_timed_mutex::try_lock_shared() { return __base_.try_lock_shared(); }
  91 void shared_timed_mutex::unlock_shared() { return __base_.unlock_shared(); }
  92
  93 _LIBCPP_END_NAMESPACE_STD