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