LLVM  9.0.0svn
UniqueLock.h
Go to the documentation of this file.
1 //===- Support/UniqueLock.h - Acquire/Release Mutex In Scope ----*- 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 defines a guard for a block of code that ensures a Mutex is locked
10 // upon construction and released upon destruction.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_SUPPORT_UNIQUE_LOCK_H
15 #define LLVM_SUPPORT_UNIQUE_LOCK_H
16 
17 #include <cassert>
18 
19 namespace llvm {
20 
21  /// A pared-down imitation of std::unique_lock from C++11. Contrary to the
22  /// name, it's really more of a wrapper for a lock. It may or may not have
23  /// an associated mutex, which is guaranteed to be locked upon creation
24  /// and unlocked after destruction. unique_lock can also unlock the mutex
25  /// and re-lock it freely during its lifetime.
26  /// Guard a section of code with a mutex.
27  template<typename MutexT>
28  class unique_lock {
29  MutexT *M = nullptr;
30  bool locked = false;
31 
32  public:
33  unique_lock() = default;
34  explicit unique_lock(MutexT &m) : M(&m), locked(true) { M->lock(); }
35  unique_lock(const unique_lock &) = delete;
36  unique_lock &operator=(const unique_lock &) = delete;
37 
38  void operator=(unique_lock &&o) {
39  if (owns_lock())
40  M->unlock();
41  M = o.M;
42  locked = o.locked;
43  o.M = nullptr;
44  o.locked = false;
45  }
46 
47  ~unique_lock() { if (owns_lock()) M->unlock(); }
48 
49  void lock() {
50  assert(!locked && "mutex already locked!");
51  assert(M && "no associated mutex!");
52  M->lock();
53  locked = true;
54  }
55 
56  void unlock() {
57  assert(locked && "unlocking a mutex that isn't locked!");
58  assert(M && "no associated mutex!");
59  M->unlock();
60  locked = false;
61  }
62 
63  bool owns_lock() { return locked; }
64  };
65 
66 } // end namespace llvm
67 
68 #endif // LLVM_SUPPORT_UNIQUE_LOCK_H
This class represents lattice values for constants.
Definition: AllocatorList.h:23
block Block Frequency true
unique_lock()=default
unique_lock & operator=(const unique_lock &)=delete
A pared-down imitation of std::unique_lock from C++11.
Definition: UniqueLock.h:28
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void operator=(unique_lock &&o)
Definition: UniqueLock.h:38
unique_lock(MutexT &m)
Definition: UniqueLock.h:34