From 5301e3c3db996feb4fd622d4449f740da1064477 Mon Sep 17 00:00:00 2001 From: danilchap Date: Wed, 6 Sep 2017 04:10:21 -0700 Subject: [PATCH] Add thread annotation macros with RTC_ prefix. Update samples unittests to use RTC_ versions. BUG=webrtc:8198 Review-Url: https://codereview.webrtc.org/3011973002 Cr-Commit-Position: refs/heads/master@{#19708} --- webrtc/rtc_base/thread_annotations.h | 70 +++++++++++++------ .../rtc_base/thread_annotations_unittest.cc | 40 ++++++----- webrtc/rtc_base/thread_checker.h | 18 ++--- webrtc/rtc_base/thread_checker_unittest.cc | 10 +-- 4 files changed, 85 insertions(+), 53 deletions(-) diff --git a/webrtc/rtc_base/thread_annotations.h b/webrtc/rtc_base/thread_annotations.h index 175b6b6704..b07a75ed67 100644 --- a/webrtc/rtc_base/thread_annotations.h +++ b/webrtc/rtc_base/thread_annotations.h @@ -20,9 +20,9 @@ #define WEBRTC_RTC_BASE_THREAD_ANNOTATIONS_H_ #if defined(__clang__) && (!defined(SWIG)) -#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x)) +#define RTC_THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x)) #else -#define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op +#define RTC_THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op #endif // Document if a shared variable/field needs to be protected by a lock. @@ -31,11 +31,13 @@ // indicates a shared variable should be guarded (by any lock). GUARDED_VAR // is primarily used when the client cannot express the name of the lock. #if !defined(GUARDED_BY) -#define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) +#define GUARDED_BY(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) #endif +#define RTC_GUARDED_BY(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) #if !defined(GUARDED_VAR) -#define GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(guarded_var) +#define GUARDED_VAR RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_var) #endif +#define RTC_GUARDED_VAR RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_var) // Document if the memory location pointed to by a pointer should be guarded // by a lock when dereferencing the pointer. Similar to GUARDED_VAR, @@ -46,11 +48,13 @@ // guarded by mu2, q should be annotated as follows: // int *q GUARDED_BY(mu1) PT_GUARDED_BY(mu2); #if !defined(PT_GUARDED_BY) -#define PT_GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x)) +#define PT_GUARDED_BY(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x)) #endif +#define RTC_PT_GUARDED_BY(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x)) #if !defined(PT_GUARDED_VAR) -#define PT_GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_var) +#define PT_GUARDED_VAR RTC_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_var) #endif +#define RTC_PT_GUARDED_VAR RTC_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_var) // Document the acquisition order between locks that can be held // simultaneously by a thread. For any two locks that need to be annotated @@ -58,11 +62,15 @@ // (i.e. You don't have to annotate both locks with both ACQUIRED_AFTER // and ACQUIRED_BEFORE.) #if !defined(ACQUIRED_AFTER) -#define ACQUIRED_AFTER(x) THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(x)) +#define ACQUIRED_AFTER(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(x)) #endif +#define RTC_ACQUIRED_AFTER(x) \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(x)) #if !defined(ACQUIRED_BEFORE) -#define ACQUIRED_BEFORE(x) THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x)) +#define ACQUIRED_BEFORE(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x)) #endif +#define RTC_ACQUIRED_BEFORE(x) \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x)) // The following three annotations document the lock requirements for // functions/methods. @@ -70,67 +78,87 @@ // Document if a function expects certain locks to be held before it is called #if !defined(EXCLUSIVE_LOCKS_REQUIRED) #define EXCLUSIVE_LOCKS_REQUIRED(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__)) + RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__)) #endif - +#define RTC_EXCLUSIVE_LOCKS_REQUIRED(...) \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__)) #if !defined(SHARED_LOCKS_REQUIRED) #define SHARED_LOCKS_REQUIRED(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__)) + RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__)) #endif +#define RTC_SHARED_LOCKS_REQUIRED(...) \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__)) // Document the locks acquired in the body of the function. These locks // cannot be held when calling this function (as google3's Mutex locks are // non-reentrant). #if !defined(LOCKS_EXCLUDED) #define LOCKS_EXCLUDED(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__)) + RTC_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__)) #endif +#define RTC_LOCKS_EXCLUDED(...) \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__)) // Document the lock the annotated function returns without acquiring it. #if !defined(LOCK_RETURNED) -#define LOCK_RETURNED(x) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x)) +#define LOCK_RETURNED(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x)) #endif +#define RTC_LOCK_RETURNED(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x)) // Document if a class/type is a lockable type (such as the Mutex class). #if !defined(LOCKABLE) -#define LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(lockable) +#define LOCKABLE RTC_THREAD_ANNOTATION_ATTRIBUTE__(lockable) #endif +#define RTC_LOCKABLE RTC_THREAD_ANNOTATION_ATTRIBUTE__(lockable) // Document if a class is a scoped lockable type (such as the MutexLock class). #if !defined(SCOPED_LOCKABLE) -#define SCOPED_LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable) +#define SCOPED_LOCKABLE RTC_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable) #endif +#define RTC_SCOPED_LOCKABLE RTC_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable) // The following annotations specify lock and unlock primitives. #if !defined(EXCLUSIVE_LOCK_FUNCTION) #define EXCLUSIVE_LOCK_FUNCTION(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__)) + RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__)) #endif +#define RTC_EXCLUSIVE_LOCK_FUNCTION(...) \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__)) #if !defined(SHARED_LOCK_FUNCTION) #define SHARED_LOCK_FUNCTION(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__)) + RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__)) #endif +#define RTC_SHARED_LOCK_FUNCTION(...) \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__)) #if !defined(EXCLUSIVE_TRYLOCK_FUNCTION) #define EXCLUSIVE_TRYLOCK_FUNCTION(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__)) + RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__)) #endif +#define RTC_EXCLUSIVE_TRYLOCK_FUNCTION(...) \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__)) #if !defined(SHARED_TRYLOCK_FUNCTION) #define SHARED_TRYLOCK_FUNCTION(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__)) + RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__)) #endif +#define RTC_SHARED_TRYLOCK_FUNCTION(...) \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__)) #if !defined(UNLOCK_FUNCTION) #define UNLOCK_FUNCTION(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__)) + RTC_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__)) #endif +#define RTC_UNLOCK_FUNCTION(...) \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__)) // An escape hatch for thread safety analysis to ignore the annotated function. #if !defined(NO_THREAD_SAFETY_ANALYSIS) #define NO_THREAD_SAFETY_ANALYSIS \ - THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis) + RTC_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis) #endif +#define RTC_NO_THREAD_SAFETY_ANALYSIS \ + RTC_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis) #endif // WEBRTC_RTC_BASE_THREAD_ANNOTATIONS_H_ diff --git a/webrtc/rtc_base/thread_annotations_unittest.cc b/webrtc/rtc_base/thread_annotations_unittest.cc index a8ff014eed..c8c3c3701e 100644 --- a/webrtc/rtc_base/thread_annotations_unittest.cc +++ b/webrtc/rtc_base/thread_annotations_unittest.cc @@ -13,19 +13,21 @@ namespace { -class LOCKABLE Lock { +class RTC_LOCKABLE Lock { public: - void EnterWrite() const EXCLUSIVE_LOCK_FUNCTION() {} - void EnterRead() const SHARED_LOCK_FUNCTION() {} - bool TryEnterWrite() const EXCLUSIVE_TRYLOCK_FUNCTION(true) { return true; } - bool TryEnterRead() const SHARED_TRYLOCK_FUNCTION(true) { return true; } - void Leave() const UNLOCK_FUNCTION() {} + void EnterWrite() const RTC_EXCLUSIVE_LOCK_FUNCTION() {} + void EnterRead() const RTC_SHARED_LOCK_FUNCTION() {} + bool TryEnterWrite() const RTC_EXCLUSIVE_TRYLOCK_FUNCTION(true) { + return true; + } + bool TryEnterRead() const RTC_SHARED_TRYLOCK_FUNCTION(true) { return true; } + void Leave() const RTC_UNLOCK_FUNCTION() {} }; -class SCOPED_LOCKABLE ScopeLock { +class RTC_SCOPED_LOCKABLE ScopeLock { public: - explicit ScopeLock(const Lock& lock) EXCLUSIVE_LOCK_FUNCTION(lock) {} - ~ScopeLock() UNLOCK_FUNCTION() {} + explicit ScopeLock(const Lock& lock) RTC_EXCLUSIVE_LOCK_FUNCTION(lock) {} + ~ScopeLock() RTC_UNLOCK_FUNCTION() {} }; class ThreadSafe { @@ -50,7 +52,7 @@ class ThreadSafe { anylock_.Leave(); } - void UnprotectedFunction() LOCKS_EXCLUDED(anylock_, lock_, pt_lock_) { + void UnprotectedFunction() RTC_LOCKS_EXCLUDED(anylock_, lock_, pt_lock_) { // Can access unprotected Value. unprotected_ = 15; // Can access pointers themself, but not data they point to. @@ -110,30 +112,30 @@ class ThreadSafe { } private: - void ReadProtectedFunction() SHARED_LOCKS_REQUIRED(lock_, pt_lock_) { + void ReadProtectedFunction() RTC_SHARED_LOCKS_REQUIRED(lock_, pt_lock_) { unprotected_ = protected_by_lock_; unprotected_ = *pt_protected_by_lock_; } - void WriteProtectedFunction() EXCLUSIVE_LOCKS_REQUIRED(lock_, pt_lock_) { + void WriteProtectedFunction() RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_, pt_lock_) { int x = protected_by_lock_; *pt_protected_by_lock_ = x; protected_by_lock_ = unprotected_; } - const Lock& GetLock() LOCK_RETURNED(lock_) { return lock_; } + const Lock& GetLock() RTC_LOCK_RETURNED(lock_) { return lock_; } - Lock anylock_ ACQUIRED_BEFORE(lock_); + Lock anylock_ RTC_ACQUIRED_BEFORE(lock_); Lock lock_; - Lock pt_lock_ ACQUIRED_AFTER(lock_); + Lock pt_lock_ RTC_ACQUIRED_AFTER(lock_); int unprotected_ = 0; - int protected_by_lock_ GUARDED_BY(lock_) = 0; - int protected_by_anything_ GUARDED_VAR = 0; + int protected_by_lock_ RTC_GUARDED_BY(lock_) = 0; + int protected_by_anything_ RTC_GUARDED_VAR = 0; - int* pt_protected_by_lock_ PT_GUARDED_BY(pt_lock_); - int* pt_protected_by_anything_ PT_GUARDED_VAR; + int* pt_protected_by_lock_ RTC_PT_GUARDED_BY(pt_lock_); + int* pt_protected_by_anything_ RTC_PT_GUARDED_VAR; }; } // namespace diff --git a/webrtc/rtc_base/thread_checker.h b/webrtc/rtc_base/thread_checker.h index b6ce017538..70daf5a0fe 100644 --- a/webrtc/rtc_base/thread_checker.h +++ b/webrtc/rtc_base/thread_checker.h @@ -103,8 +103,8 @@ class SCOPED_LOCKABLE AnnounceOnThread { } // namespace internal } // namespace rtc -// RUN_ON/ACCESS_ON/RTC_DCHECK_RUN_ON macros allows to annotate variables are -// accessed from same thread/task queue. +// RTC_RUN_ON/RTC_ACCESS_ON/RTC_DCHECK_RUN_ON macros allows to annotate +// variables are accessed from same thread/task queue. // Using tools designed to check mutexes, it checks at compile time everywhere // variable is access, there is a run-time dcheck thread/task queue is correct. // @@ -117,12 +117,12 @@ class SCOPED_LOCKABLE AnnounceOnThread { // // private: // rtc::Thread* network_thread_; -// int transport_ ACCESS_ON(network_thread_); +// int transport_ RTC_ACCESS_ON(network_thread_); // }; // // class ExampleThreadChecker { // public: -// int CalledFromPacer() RUN_ON(pacer_thread_checker_) { +// int CalledFromPacer() RTC_RUN_ON(pacer_thread_checker_) { // return var2_; // } // @@ -133,7 +133,7 @@ class SCOPED_LOCKABLE AnnounceOnThread { // } // // private: -// int pacer_var_ ACCESS_ON(pacer_thread_checker_); +// int pacer_var_ RTC_ACCESS_ON(pacer_thread_checker_); // rtc::ThreadChecker pacer_thread_checker_; // }; // @@ -149,7 +149,7 @@ class SCOPED_LOCKABLE AnnounceOnThread { // // private: // rtc::TaskQueue* const encoder_queue_; -// Frame var_ ACCESS_ON(encoder_queue_); +// Frame var_ RTC_ACCESS_ON(encoder_queue_); // }; // // void Encode() { @@ -166,10 +166,12 @@ class SCOPED_LOCKABLE AnnounceOnThread { // Document if a variable/field is not shared and should be accessed from // same thread/task queue. -#define ACCESS_ON(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) +#define ACCESS_ON(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) +#define RTC_ACCESS_ON(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) // Document if a function expected to be called from same thread/task queue. -#define RUN_ON(x) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(x)) +#define RUN_ON(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(x)) +#define RTC_RUN_ON(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(x)) #define RTC_DCHECK_RUN_ON(thread_like_object) \ rtc::internal::AnnounceOnThread thread_announcer(thread_like_object); \ diff --git a/webrtc/rtc_base/thread_checker_unittest.cc b/webrtc/rtc_base/thread_checker_unittest.cc index d8ad830862..ba5c695801 100644 --- a/webrtc/rtc_base/thread_checker_unittest.cc +++ b/webrtc/rtc_base/thread_checker_unittest.cc @@ -241,16 +241,16 @@ class ThreadAnnotateTest { } private: - void function() RUN_ON(thread_) {} - void fun_acccess_var() RUN_ON(thread_) { var_thread_ = 13; } + void function() RTC_RUN_ON(thread_) {} + void fun_acccess_var() RTC_RUN_ON(thread_) { var_thread_ = 13; } rtc::Thread* thread_; rtc::ThreadChecker checker_; rtc::TaskQueue* queue_; - int var_thread_ ACCESS_ON(thread_); - int var_checker_ GUARDED_BY(checker_); - int var_queue_ ACCESS_ON(queue_); + int var_thread_ RTC_ACCESS_ON(thread_); + int var_checker_ RTC_GUARDED_BY(checker_); + int var_queue_ RTC_ACCESS_ON(queue_); }; // Just in case we ever get lumped together with other compilation units.