LLVM  3.7.0
RWMutex.h
Go to the documentation of this file.
1 //===- RWMutex.h - Reader/Writer Mutual Exclusion Lock ----------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file declares the llvm::sys::RWMutex class.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_SUPPORT_RWMUTEX_H
15 #define LLVM_SUPPORT_RWMUTEX_H
16 
17 #include "llvm/Support/Compiler.h"
18 #include "llvm/Support/Threading.h"
19 #include <cassert>
20 
21 namespace llvm
22 {
23  namespace sys
24  {
25  /// @brief Platform agnostic RWMutex class.
27  {
28  /// @name Constructors
29  /// @{
30  public:
31 
32  /// Initializes the lock but doesn't acquire it.
33  /// @brief Default Constructor.
34  explicit RWMutexImpl();
35 
36  /// Releases and removes the lock
37  /// @brief Destructor
38  ~RWMutexImpl();
39 
40  /// @}
41  /// @name Methods
42  /// @{
43  public:
44 
45  /// Attempts to unconditionally acquire the lock in reader mode. If the
46  /// lock is held by a writer, this method will wait until it can acquire
47  /// the lock.
48  /// @returns false if any kind of error occurs, true otherwise.
49  /// @brief Unconditionally acquire the lock in reader mode.
50  bool reader_acquire();
51 
52  /// Attempts to release the lock in reader mode.
53  /// @returns false if any kind of error occurs, true otherwise.
54  /// @brief Unconditionally release the lock in reader mode.
55  bool reader_release();
56 
57  /// Attempts to unconditionally acquire the lock in reader mode. If the
58  /// lock is held by any readers, this method will wait until it can
59  /// acquire the lock.
60  /// @returns false if any kind of error occurs, true otherwise.
61  /// @brief Unconditionally acquire the lock in writer mode.
62  bool writer_acquire();
63 
64  /// Attempts to release the lock in writer mode.
65  /// @returns false if any kind of error occurs, true otherwise.
66  /// @brief Unconditionally release the lock in write mode.
67  bool writer_release();
68 
69  //@}
70  /// @name Platform Dependent Data
71  /// @{
72  private:
73 #if defined(LLVM_ENABLE_THREADS) && LLVM_ENABLE_THREADS != 0
74  void* data_; ///< We don't know what the data will be
75 #endif
76 
77  /// @}
78  /// @name Do Not Implement
79  /// @{
80  private:
81  RWMutexImpl(const RWMutexImpl & original) = delete;
82  void operator=(const RWMutexImpl &) = delete;
83  /// @}
84  };
85 
86  /// SmartMutex - An R/W mutex with a compile time constant parameter that
87  /// indicates whether this mutex should become a no-op when we're not
88  /// running in multithreaded mode.
89  template<bool mt_only>
90  class SmartRWMutex {
91  RWMutexImpl impl;
92  unsigned readers, writers;
93  public:
94  explicit SmartRWMutex() : impl(), readers(0), writers(0) { }
95 
96  bool lock_shared() {
97  if (!mt_only || llvm_is_multithreaded())
98  return impl.reader_acquire();
99 
100  // Single-threaded debugging code. This would be racy in multithreaded
101  // mode, but provides not sanity checks in single threaded mode.
102  ++readers;
103  return true;
104  }
105 
106  bool unlock_shared() {
107  if (!mt_only || llvm_is_multithreaded())
108  return impl.reader_release();
109 
110  // Single-threaded debugging code. This would be racy in multithreaded
111  // mode, but provides not sanity checks in single threaded mode.
112  assert(readers > 0 && "Reader lock not acquired before release!");
113  --readers;
114  return true;
115  }
116 
117  bool lock() {
118  if (!mt_only || llvm_is_multithreaded())
119  return impl.writer_acquire();
120 
121  // Single-threaded debugging code. This would be racy in multithreaded
122  // mode, but provides not sanity checks in single threaded mode.
123  assert(writers == 0 && "Writer lock already acquired!");
124  ++writers;
125  return true;
126  }
127 
128  bool unlock() {
129  if (!mt_only || llvm_is_multithreaded())
130  return impl.writer_release();
131 
132  // Single-threaded debugging code. This would be racy in multithreaded
133  // mode, but provides not sanity checks in single threaded mode.
134  assert(writers == 1 && "Writer lock not acquired before release!");
135  --writers;
136  return true;
137  }
138 
139  private:
140  SmartRWMutex(const SmartRWMutex<mt_only> & original);
141  void operator=(const SmartRWMutex<mt_only> &);
142  };
144 
145  /// ScopedReader - RAII acquisition of a reader lock
146  template<bool mt_only>
149 
151  mutex.lock_shared();
152  }
153 
155  mutex.unlock_shared();
156  }
157  };
159 
160  /// ScopedWriter - RAII acquisition of a writer lock
161  template<bool mt_only>
164 
166  mutex.lock();
167  }
168 
170  mutex.unlock();
171  }
172  };
174  }
175 }
176 
177 #endif
SmartRWMutex< mt_only > & mutex
Definition: RWMutex.h:163
~RWMutexImpl()
Releases and removes the lock.
Definition: RWMutex.cpp:68
SmartRWMutex< false > RWMutex
Definition: RWMutex.h:143
SmartMutex - An R/W mutex with a compile time constant parameter that indicates whether this mutex sh...
Definition: RWMutex.h:90
bool writer_release()
Attempts to release the lock in writer mode.
Definition: RWMutex.cpp:107
bool writer_acquire()
Attempts to unconditionally acquire the lock in reader mode.
Definition: RWMutex.cpp:97
ScopedReader - RAII acquisition of a reader lock.
Definition: RWMutex.h:147
ScopedWriter - RAII acquisition of a writer lock.
Definition: RWMutex.h:162
bool reader_acquire()
Attempts to unconditionally acquire the lock in reader mode.
Definition: RWMutex.cpp:77
RWMutexImpl()
Initializes the lock but doesn't acquire it.
Definition: RWMutex.cpp:46
Platform agnostic RWMutex class.
Definition: RWMutex.h:26
bool llvm_is_multithreaded()
Returns true if LLVM is compiled with support for multi-threading, and false otherwise.
Definition: Threading.cpp:23
SmartRWMutex< mt_only > & mutex
Definition: RWMutex.h:148
SmartScopedReader< false > ScopedReader
Definition: RWMutex.h:158
SmartScopedReader(SmartRWMutex< mt_only > &m)
Definition: RWMutex.h:150
SmartScopedWriter< false > ScopedWriter
Definition: RWMutex.h:173
SmartScopedWriter(SmartRWMutex< mt_only > &m)
Definition: RWMutex.h:165
bool reader_release()
Attempts to release the lock in reader mode.
Definition: RWMutex.cpp:87