| 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 |
|
| 67 |
namespace benchmark { |
| 68 |
|
| 69 |
typedef 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 provide the required annotations. |
| 75 |
class 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 |
|
| 87 |
class 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 |
|
| 99 |
class 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 |
BM_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_ |