admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add thread annotation macros with RTC_ prefix.

Browse Source 
Update samples unittests to use RTC_ versions.

BUG=webrtc:8198

Review-Url: https://codereview.webrtc.org/3011973002
Cr-Commit-Position: refs/heads/master@{#19708}
This commit is contained in:
danilchap 2017-09-06 04:10:21 -07:00 committed by Commit Bot
parent 2e75bd4ed8
commit 5301e3c3db
4 changed files with 85 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
webrtc/rtc_base/thread_annotations.h
View File

@ -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_

40
webrtc/rtc_base/thread_annotations_unittest.cc
View File

@ -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

18
webrtc/rtc_base/thread_checker.h
View File

@ -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); \

10
webrtc/rtc_base/thread_checker_unittest.cc
View File

@ -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.