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: Mutex()77 Mutex() {} 78 lock()79 void lock() ACQUIRE() { mut_.lock(); } unlock()80 void unlock() RELEASE() { mut_.unlock(); } native_handle()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: MutexLock(Mutex & m)91 MutexLock(Mutex& m) ACQUIRE(m) : ml_(m.native_handle()) {} RELEASE()92 ~MutexLock() RELEASE() {} native_handle()93 MutexLockImp& native_handle() { return ml_; } 94 95 private: 96 MutexLockImp ml_; 97 }; 98 99 class Barrier { 100 public: Barrier(int num_threads)101 Barrier(int num_threads) : running_threads_(num_threads) {} 102 103 // Called by each thread wait()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 removeThread()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. createBarrier(MutexLock & ml)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_ 156