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:
lock_shared()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 
unlock_shared()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 
lock()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 
unlock()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 
SmartScopedReaderSmartScopedReader172   explicit SmartScopedReader(SmartRWMutex<mt_only> &m) : mutex(m) {
173     mutex.lock_shared();
174   }
175 
~SmartScopedReaderSmartScopedReader176   ~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 
SmartScopedWriterSmartScopedWriter189   explicit SmartScopedWriter(SmartRWMutex<mt_only> &m) : mutex(m) {
190     mutex.lock();
191   }
192 
~SmartScopedWriterSmartScopedWriter193   ~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