1#ifndef BENCHMARK_MUTEX_H_
2#define BENCHMARK_MUTEX_H_
3
4#include <condition_variable>
5#include <mutex>
6
7#include "check.h"
8
9// Enable thread safety attributes only with clang.
10// The attributes can be safely erased when compiling with other compilers.
11#if defined(HAVE_THREAD_SAFETY_ATTRIBUTES)
12#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
13#else
14#define THREAD_ANNOTATION_ATTRIBUTE__(x)  // no-op
15#endif
16
17#define CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(capability(x))
18
19#define SCOPED_CAPABILITY THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
20
21#define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
22
23#define PT_GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
24
25#define ACQUIRED_BEFORE(...) \
26  THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
27
28#define ACQUIRED_AFTER(...) \
29  THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
30
31#define REQUIRES(...) \
32  THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__))
33
34#define REQUIRES_SHARED(...) \
35  THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__))
36
37#define ACQUIRE(...) \
38  THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__))
39
40#define ACQUIRE_SHARED(...) \
41  THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__))
42
43#define RELEASE(...) \
44  THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__))
45
46#define RELEASE_SHARED(...) \
47  THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__))
48
49#define TRY_ACQUIRE(...) \
50  THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__))
51
52#define TRY_ACQUIRE_SHARED(...) \
53  THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__))
54
55#define EXCLUDES(...) THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
56
57#define ASSERT_CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x))
58
59#define ASSERT_SHARED_CAPABILITY(x) \
60  THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x))
61
62#define RETURN_CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
63
64#define NO_THREAD_SAFETY_ANALYSIS \
65  THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
66
67namespace benchmark {
68
69typedef std::condition_variable Condition;
70
71// NOTE: Wrappers for std::mutex and std::unique_lock are provided so that
72// we can annotate them with thread safety attributes and use the
73// -Wthread-safety warning with clang. The standard library types cannot be
74// used directly because they do not provided the required annotations.
75class CAPABILITY("mutex") Mutex {
76 public:
77  Mutex() {}
78
79  void lock() ACQUIRE() { mut_.lock(); }
80  void unlock() RELEASE() { mut_.unlock(); }
81  std::mutex& native_handle() { return mut_; }
82
83 private:
84  std::mutex mut_;
85};
86
87class SCOPED_CAPABILITY MutexLock {
88  typedef std::unique_lock<std::mutex> MutexLockImp;
89
90 public:
91  MutexLock(Mutex& m) ACQUIRE(m) : ml_(m.native_handle()) {}
92  ~MutexLock() RELEASE() {}
93  MutexLockImp& native_handle() { return ml_; }
94
95 private:
96  MutexLockImp ml_;
97};
98
99class Barrier {
100 public:
101  Barrier(int num_threads) : running_threads_(num_threads) {}
102
103  // Called by each thread
104  bool wait() EXCLUDES(lock_) {
105    bool last_thread = false;
106    {
107      MutexLock ml(lock_);
108      last_thread = createBarrier(ml);
109    }
110    if (last_thread) phase_condition_.notify_all();
111    return last_thread;
112  }
113
114  void removeThread() EXCLUDES(lock_) {
115    MutexLock ml(lock_);
116    --running_threads_;
117    if (entered_ != 0) phase_condition_.notify_all();
118  }
119
120 private:
121  Mutex lock_;
122  Condition phase_condition_;
123  int running_threads_;
124
125  // State for barrier management
126  int phase_number_ = 0;
127  int entered_ = 0;  // Number of threads that have entered this barrier
128
129  // Enter the barrier and wait until all other threads have also
130  // entered the barrier.  Returns iff this is the last thread to
131  // enter the barrier.
132  bool createBarrier(MutexLock& ml) REQUIRES(lock_) {
133    CHECK_LT(entered_, running_threads_);
134    entered_++;
135    if (entered_ < running_threads_) {
136      // Wait for all threads to enter
137      int phase_number_cp = phase_number_;
138      auto cb = [this, phase_number_cp]() {
139        return this->phase_number_ > phase_number_cp ||
140               entered_ == running_threads_;  // A thread has aborted in error
141      };
142      phase_condition_.wait(ml.native_handle(), cb);
143      if (phase_number_ > phase_number_cp) return false;
144      // else (running_threads_ == entered_) and we are the last thread.
145    }
146    // Last thread has reached the barrier
147    phase_number_++;
148    entered_ = 0;
149    return true;
150  }
151};
152
153}  // end namespace benchmark
154
155#endif  // BENCHMARK_MUTEX_H_
156