1 //===- RWMutex.h - Reader/Writer Mutual Exclusion Lock ----------*- C++ -*-===// 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 // This file declares the llvm::sys::RWMutex class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_SUPPORT_RWMUTEX_H 14 #define LLVM_SUPPORT_RWMUTEX_H 15 16 #include "llvm/Config/llvm-config.h" 17 #include "llvm/Support/Threading.h" 18 #include <cassert> 19 #include <mutex> 20 #include <shared_mutex> 21 22 // std::shared_timed_mutex is only availble on macOS 10.12 and later. 23 #if defined(__APPLE__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) 24 #if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200 25 #define LLVM_USE_RW_MUTEX_IMPL 26 #endif 27 #endif 28 29 namespace llvm { 30 namespace sys { 31 32 #if defined(LLVM_USE_RW_MUTEX_IMPL) 33 /// Platform agnostic RWMutex class. 34 class RWMutexImpl { 35 /// @name Constructors 36 /// @{ 37 public: 38 /// Initializes the lock but doesn't acquire it. 39 /// Default Constructor. 40 explicit RWMutexImpl(); 41 42 /// @} 43 /// @name Do Not Implement 44 /// @{ 45 RWMutexImpl(const RWMutexImpl &original) = delete; 46 RWMutexImpl &operator=(const RWMutexImpl &) = delete; 47 /// @} 48 49 /// Releases and removes the lock 50 /// Destructor 51 ~RWMutexImpl(); 52 53 /// @} 54 /// @name Methods 55 /// @{ 56 public: 57 /// Attempts to unconditionally acquire the lock in reader mode. If the 58 /// lock is held by a writer, this method will wait until it can acquire 59 /// the lock. 60 /// @returns false if any kind of error occurs, true otherwise. 61 /// Unconditionally acquire the lock in reader mode. 62 bool lock_shared(); 63 64 /// Attempts to release the lock in reader mode. 65 /// @returns false if any kind of error occurs, true otherwise. 66 /// Unconditionally release the lock in reader mode. 67 bool unlock_shared(); 68 69 /// Attempts to unconditionally acquire the lock in reader mode. If the 70 /// lock is held by any readers, this method will wait until it can 71 /// acquire the lock. 72 /// @returns false if any kind of error occurs, true otherwise. 73 /// Unconditionally acquire the lock in writer mode. 74 bool lock(); 75 76 /// Attempts to release the lock in writer mode. 77 /// @returns false if any kind of error occurs, true otherwise. 78 /// Unconditionally release the lock in write mode. 79 bool unlock(); 80 81 //@} 82 /// @name Platform Dependent Data 83 /// @{ 84 private: 85 #if defined(LLVM_ENABLE_THREADS) && LLVM_ENABLE_THREADS != 0 86 void *data_ = nullptr; ///< We don't know what the data will be 87 #endif 88 }; 89 #endif 90 91 /// SmartMutex - An R/W mutex with a compile time constant parameter that 92 /// indicates whether this mutex should become a no-op when we're not 93 /// running in multithreaded mode. 94 template <bool mt_only> class SmartRWMutex { 95 // shared_mutex (C++17) is more efficient than shared_timed_mutex (C++14) 96 // on Windows and always available on MSVC. 97 #if defined(_MSC_VER) || __cplusplus > 201402L 98 std::shared_mutex impl; 99 #else 100 #if !defined(LLVM_USE_RW_MUTEX_IMPL) 101 std::shared_timed_mutex impl; 102 #else 103 RWMutexImpl impl; 104 #endif 105 #endif 106 unsigned readers = 0; 107 unsigned writers = 0; 108 109 public: 110 bool lock_shared() { 111 if (!mt_only || llvm_is_multithreaded()) { 112 impl.lock_shared(); 113 return true; 114 } 115 116 // Single-threaded debugging code. This would be racy in multithreaded 117 // mode, but provides not sanity checks in single threaded mode. 118 ++readers; 119 return true; 120 } 121 122 bool unlock_shared() { 123 if (!mt_only || llvm_is_multithreaded()) { 124 impl.unlock_shared(); 125 return true; 126 } 127 128 // Single-threaded debugging code. This would be racy in multithreaded 129 // mode, but provides not sanity checks in single threaded mode. 130 assert(readers > 0 && "Reader lock not acquired before release!"); 131 --readers; 132 return true; 133 } 134 135 bool lock() { 136 if (!mt_only || llvm_is_multithreaded()) { 137 impl.lock(); 138 return true; 139 } 140 141 // Single-threaded debugging code. This would be racy in multithreaded 142 // mode, but provides not sanity checks in single threaded mode. 143 assert(writers == 0 && "Writer lock already acquired!"); 144 ++writers; 145 return true; 146 } 147 148 bool unlock() { 149 if (!mt_only || llvm_is_multithreaded()) { 150 impl.unlock(); 151 return true; 152 } 153 154 // Single-threaded debugging code. This would be racy in multithreaded 155 // mode, but provides not sanity checks in single threaded mode. 156 assert(writers == 1 && "Writer lock not acquired before release!"); 157 --writers; 158 return true; 159 } 160 }; 161 162 typedef SmartRWMutex<false> RWMutex; 163 164 /// ScopedReader - RAII acquisition of a reader lock 165 #if !defined(LLVM_USE_RW_MUTEX_IMPL) 166 template <bool mt_only> 167 using SmartScopedReader = const std::shared_lock<SmartRWMutex<mt_only>>; 168 #else 169 template <bool mt_only> struct SmartScopedReader { 170 SmartRWMutex<mt_only> &mutex; 171 172 explicit SmartScopedReader(SmartRWMutex<mt_only> &m) : mutex(m) { 173 mutex.lock_shared(); 174 } 175 176 ~SmartScopedReader() { mutex.unlock_shared(); } 177 }; 178 #endif 179 typedef SmartScopedReader<false> ScopedReader; 180 181 /// ScopedWriter - RAII acquisition of a writer lock 182 #if !defined(LLVM_USE_RW_MUTEX_IMPL) 183 template <bool mt_only> 184 using SmartScopedWriter = std::lock_guard<SmartRWMutex<mt_only>>; 185 #else 186 template <bool mt_only> struct SmartScopedWriter { 187 SmartRWMutex<mt_only> &mutex; 188 189 explicit SmartScopedWriter(SmartRWMutex<mt_only> &m) : mutex(m) { 190 mutex.lock(); 191 } 192 193 ~SmartScopedWriter() { mutex.unlock(); } 194 }; 195 #endif 196 typedef SmartScopedWriter<false> ScopedWriter; 197 198 } // end namespace sys 199 } // end namespace llvm 200 201 #endif // LLVM_SUPPORT_RWMUTEX_H 202