156 lines · c
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#else14#define THREAD_ANNOTATION_ATTRIBUTE_(x) // no-op15#endif16 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 that72// we can annotate them with thread safety attributes and use the73// -Wthread-safety warning with clang. The standard library types cannot be74// used directly because they do not provide 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 thread104 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 management126 int phase_number_ = 0;127 int entered_ = 0; // Number of threads that have entered this barrier128 129 // Enter the barrier and wait until all other threads have also130 // entered the barrier. Returns iff this is the last thread to131 // 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 enter137 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 error141 };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 barrier147 phase_number_++;148 entered_ = 0;149 return true;150 }151};152 153} // end namespace benchmark154 155#endif // BENCHMARK_MUTEX_H_156