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 ////amaiorano@google.com: Fix clang-cl build (b/161554059) 98 ////#if defined(_MSC_VER) || __cplusplus > 201402L 99 #if (defined(_MSC_VER) && !defined(__clang__)) || __cplusplus > 201402L 100 std::shared_mutex impl; 101 #else 102 #if !defined(LLVM_USE_RW_MUTEX_IMPL) 103 std::shared_timed_mutex impl; 104 #else 105 RWMutexImpl impl; 106 #endif 107 #endif 108 unsigned readers = 0; 109 unsigned writers = 0; 110 111 public: lock_shared()112 bool lock_shared() { 113 if (!mt_only || llvm_is_multithreaded()) { 114 impl.lock_shared(); 115 return true; 116 } 117 118 // Single-threaded debugging code. This would be racy in multithreaded 119 // mode, but provides not sanity checks in single threaded mode. 120 ++readers; 121 return true; 122 } 123 unlock_shared()124 bool unlock_shared() { 125 if (!mt_only || llvm_is_multithreaded()) { 126 impl.unlock_shared(); 127 return true; 128 } 129 130 // Single-threaded debugging code. This would be racy in multithreaded 131 // mode, but provides not sanity checks in single threaded mode. 132 assert(readers > 0 && "Reader lock not acquired before release!"); 133 --readers; 134 return true; 135 } 136 lock()137 bool lock() { 138 if (!mt_only || llvm_is_multithreaded()) { 139 impl.lock(); 140 return true; 141 } 142 143 // Single-threaded debugging code. This would be racy in multithreaded 144 // mode, but provides not sanity checks in single threaded mode. 145 assert(writers == 0 && "Writer lock already acquired!"); 146 ++writers; 147 return true; 148 } 149 unlock()150 bool unlock() { 151 if (!mt_only || llvm_is_multithreaded()) { 152 impl.unlock(); 153 return true; 154 } 155 156 // Single-threaded debugging code. This would be racy in multithreaded 157 // mode, but provides not sanity checks in single threaded mode. 158 assert(writers == 1 && "Writer lock not acquired before release!"); 159 --writers; 160 return true; 161 } 162 }; 163 164 typedef SmartRWMutex<false> RWMutex; 165 166 /// ScopedReader - RAII acquisition of a reader lock 167 #if !defined(LLVM_USE_RW_MUTEX_IMPL) 168 template <bool mt_only> 169 using SmartScopedReader = const std::shared_lock<SmartRWMutex<mt_only>>; 170 #else 171 template <bool mt_only> struct SmartScopedReader { 172 SmartRWMutex<mt_only> &mutex; 173 SmartScopedReaderSmartScopedReader174 explicit SmartScopedReader(SmartRWMutex<mt_only> &m) : mutex(m) { 175 mutex.lock_shared(); 176 } 177 ~SmartScopedReaderSmartScopedReader178 ~SmartScopedReader() { mutex.unlock_shared(); } 179 }; 180 #endif 181 typedef SmartScopedReader<false> ScopedReader; 182 183 /// ScopedWriter - RAII acquisition of a writer lock 184 #if !defined(LLVM_USE_RW_MUTEX_IMPL) 185 template <bool mt_only> 186 using SmartScopedWriter = std::lock_guard<SmartRWMutex<mt_only>>; 187 #else 188 template <bool mt_only> struct SmartScopedWriter { 189 SmartRWMutex<mt_only> &mutex; 190 SmartScopedWriterSmartScopedWriter191 explicit SmartScopedWriter(SmartRWMutex<mt_only> &m) : mutex(m) { 192 mutex.lock(); 193 } 194 ~SmartScopedWriterSmartScopedWriter195 ~SmartScopedWriter() { mutex.unlock(); } 196 }; 197 #endif 198 typedef SmartScopedWriter<false> ScopedWriter; 199 200 } // end namespace sys 201 } // end namespace llvm 202 203 #endif // LLVM_SUPPORT_RWMUTEX_H 204