LLVM  16.0.0git
RWMutex.h
Go to the documentation of this file.
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 #if !defined(LLVM_USE_RW_MUTEX_IMPL)
96  std::shared_mutex impl;
97 #else
98  RWMutexImpl impl;
99 #endif
100  unsigned readers = 0;
101  unsigned writers = 0;
102 
103 public:
104  bool lock_shared() {
105  if (!mt_only || llvm_is_multithreaded()) {
106  impl.lock_shared();
107  return true;
108  }
109 
110  // Single-threaded debugging code. This would be racy in multithreaded
111  // mode, but provides not basic checks in single threaded mode.
112  ++readers;
113  return true;
114  }
115 
116  bool unlock_shared() {
117  if (!mt_only || llvm_is_multithreaded()) {
118  impl.unlock_shared();
119  return true;
120  }
121 
122  // Single-threaded debugging code. This would be racy in multithreaded
123  // mode, but provides not basic checks in single threaded mode.
124  assert(readers > 0 && "Reader lock not acquired before release!");
125  --readers;
126  return true;
127  }
128 
129  bool lock() {
130  if (!mt_only || llvm_is_multithreaded()) {
131  impl.lock();
132  return true;
133  }
134 
135  // Single-threaded debugging code. This would be racy in multithreaded
136  // mode, but provides not basic checks in single threaded mode.
137  assert(writers == 0 && "Writer lock already acquired!");
138  ++writers;
139  return true;
140  }
141 
142  bool unlock() {
143  if (!mt_only || llvm_is_multithreaded()) {
144  impl.unlock();
145  return true;
146  }
147 
148  // Single-threaded debugging code. This would be racy in multithreaded
149  // mode, but provides not basic checks in single threaded mode.
150  assert(writers == 1 && "Writer lock not acquired before release!");
151  --writers;
152  return true;
153  }
154 };
155 
157 
158 /// ScopedReader - RAII acquisition of a reader lock
159 #if !defined(LLVM_USE_RW_MUTEX_IMPL)
160 template <bool mt_only>
161 using SmartScopedReader = const std::shared_lock<SmartRWMutex<mt_only>>;
162 #else
163 template <bool mt_only> struct SmartScopedReader {
164  SmartRWMutex<mt_only> &mutex;
165 
166  explicit SmartScopedReader(SmartRWMutex<mt_only> &m) : mutex(m) {
167  mutex.lock_shared();
168  }
169 
170  ~SmartScopedReader() { mutex.unlock_shared(); }
171 };
172 #endif
174 
175 /// ScopedWriter - RAII acquisition of a writer lock
176 #if !defined(LLVM_USE_RW_MUTEX_IMPL)
177 template <bool mt_only>
178 using SmartScopedWriter = std::lock_guard<SmartRWMutex<mt_only>>;
179 #else
180 template <bool mt_only> struct SmartScopedWriter {
181  SmartRWMutex<mt_only> &mutex;
182 
183  explicit SmartScopedWriter(SmartRWMutex<mt_only> &m) : mutex(m) {
184  mutex.lock();
185  }
186 
187  ~SmartScopedWriter() { mutex.unlock(); }
188 };
189 #endif
191 
192 } // end namespace sys
193 } // end namespace llvm
194 
195 #endif // LLVM_SUPPORT_RWMUTEX_H
llvm::sys::SmartScopedWriter
std::lock_guard< SmartRWMutex< mt_only > > SmartScopedWriter
ScopedWriter - RAII acquisition of a writer lock.
Definition: RWMutex.h:178
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
impl
place backedge safepoints impl
Definition: PlaceSafepoints.cpp:613
llvm::sys::SmartRWMutex::lock_shared
bool lock_shared()
Definition: RWMutex.h:104
llvm::sys::ScopedWriter
SmartScopedWriter< false > ScopedWriter
Definition: RWMutex.h:190
Threading.h
llvm::sys::SmartScopedReader
const std::shared_lock< SmartRWMutex< mt_only > > SmartScopedReader
ScopedReader - RAII acquisition of a reader lock.
Definition: RWMutex.h:161
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::llvm_is_multithreaded
constexpr bool llvm_is_multithreaded()
Returns true if LLVM is compiled with support for multi-threading, and false otherwise.
Definition: Threading.h:52
llvm::sys::SmartRWMutex::unlock
bool unlock()
Definition: RWMutex.h:142
llvm::sys::SmartRWMutex::lock
bool lock()
Definition: RWMutex.h:129
llvm::sys::ScopedReader
SmartScopedReader< false > ScopedReader
Definition: RWMutex.h:173
llvm::sys::SmartRWMutex::unlock_shared
bool unlock_shared()
Definition: RWMutex.h:116
llvm::sys::RWMutex
SmartRWMutex< false > RWMutex
Definition: RWMutex.h:156
llvm::sys::SmartRWMutex
SmartMutex - An R/W mutex with a compile time constant parameter that indicates whether this mutex sh...
Definition: RWMutex.h:94