clang的线程安全分析模块 thread safety analysis
- #include "mutex.h"
- class BankAccount {
- private:
- Mutex mu;
- int balance GUARDED_BY(mu);
- void depositImpl(int amount) {
- balance += amount; // WARNING! Cannot write balance without locking mu.
- }
- void withdrawImpl(int amount) REQUIRES(mu) {
- balance -= amount; // OK. Caller must have locked mu.
- }
- public:
- void withdraw(int amount) {
- mu.Lock();
- withdrawImpl(amount); // OK. We've locked mu.
- } // WARNING! Failed to unlock mu.
- void transferFrom(BankAccount& b, int amount) {
- mu.Lock();
- b.withdrawImpl(amount); // WARNING! Calling withdrawImpl() requires locking b.mu.
- depositImpl(amount); // OK. depositImpl() has no requirements.
- mu.Unlock();
- }
- };
- clang -c -Wthread-safety example.cpp
- Mutex mu;
- int *p1 GUARDED_BY(mu);
- int *p2 PT_GUARDED_BY(mu);
- unique_ptr<int> p3 PT_GUARDED_BY(mu);
- void test() {
- p1 = 0; // Warning!
- *p2 = 42; // Warning!
- p2 = new int; // OK.
- *p3 = 42; // Warning!
- p3.reset(new int); // OK.
- }
- Mutex mu1, mu2;
- int a GUARDED_BY(mu1);
- int b GUARDED_BY(mu2);
- void foo() REQUIRES(mu1, mu2) {
- a = 0;
- b = 0;
- }
- void test() {
- mu1.Lock();
- foo(); // Warning! Requires mu2.
- mu1.Unlock();
- }
- Mutex mu;
- MyClass myObject GUARDED_BY(mu);
- void lockAndInit() ACQUIRE(mu) {
- mu.Lock();
- myObject.init();
- }
- void cleanupAndUnlock() RELEASE(mu) {
- myObject.cleanup();
- } // Warning! Need to unlock mu.
- void test() {
- lockAndInit();
- myObject.doSomething();
- cleanupAndUnlock();
- myObject.doSomething(); // Warning, mu is not locked.
- }
- template <class T>
- class CAPABILITY("mutex") Container {
- private:
- Mutex mu;
- T* data;
- public:
- // Hide mu from public interface.
- void Lock() ACQUIRE() { mu.Lock(); }
- void Unlock() RELEASE() { mu.Unlock(); }
- T& getElem(int i) { return data[i]; }
- };
- void test() {
- Container<int> c;
- c.Lock();
- int i = c.getElem(0);
- c.Unlock();
- }
- Mutex mu;
- int a GUARDED_BY(mu);
- void clear() EXCLUDES(mu) {
- mu.Lock();
- a = 0;
- mu.Unlock();
- }
- void reset() {
- mu.Lock();
- clear(); // Warning! Caller cannot hold 'mu'.
- mu.Unlock();
- }
- class Counter {
- Mutex mu;
- int a GUARDED_BY(mu);
- void unsafeIncrement() NO_THREAD_SAFETY_ANALYSIS { a++; }
- };
- class MyClass {
- private:
- Mutex mu;
- int a GUARDED_BY(mu);
- public:
- Mutex* getMu() RETURN_CAPABILITY(mu) { return μ }
- // analysis knows that getMu() == mu
- void clear() REQUIRES(getMu()) { a = 0; }
- };
- Mutex m1;
- Mutex m2 ACQUIRED_AFTER(m1);
- // Alternative declaration
- // Mutex m2;
- // Mutex m1 ACQUIRED_BEFORE(m2);
- void foo() {
- m2.Lock();
- m1.Lock(); // Warning! m2 must be acquired after m1.
- m1.Unlock();
- m2.Unlock();
- }
- #ifndef THREAD_SAFETY_ANALYSIS_MUTEX_H
- #define THREAD_SAFETY_ANALYSIS_MUTEX_H
- // Enable thread safety attributes only with clang.
- // The attributes can be safely erased when compiling with other compilers.
- #if defined(__clang__) && (!defined(SWIG))
- #define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
- #else
- #define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op
- #endif
- #define CAPABILITY(x) \
- THREAD_ANNOTATION_ATTRIBUTE__(capability(x))
- #define SCOPED_CAPABILITY \
- THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
- #define GUARDED_BY(x) \
- THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
- #define PT_GUARDED_BY(x) \
- THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
- #define ACQUIRED_BEFORE(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
- #define ACQUIRED_AFTER(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
- #define REQUIRES(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__))
- #define REQUIRES_SHARED(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__))
- #define ACQUIRE(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__))
- #define ACQUIRE_SHARED(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__))
- #define RELEASE(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__))
- #define RELEASE_SHARED(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__))
- #define TRY_ACQUIRE(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__))
- #define TRY_ACQUIRE_SHARED(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__))
- #define EXCLUDES(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
- #define ASSERT_CAPABILITY(x) \
- THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x))
- #define ASSERT_SHARED_CAPABILITY(x) \
- THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x))
- #define RETURN_CAPABILITY(x) \
- THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
- #define NO_THREAD_SAFETY_ANALYSIS \
- THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
- // Defines an annotated interface for mutexes.
- // These methods can be implemented to use any internal mutex implementation.
- class CAPABILITY("mutex") Mutex {
- public:
- // Acquire/lock this mutex exclusively. Only one thread can have exclusive
- // access at any one time. Write operations to guarded data require an
- // exclusive lock.
- void Lock() ACQUIRE();
- // Acquire/lock this mutex for read operations, which require only a shared
- // lock. This assumes a multiple-reader, single writer semantics. Multiple
- // threads may acquire the mutex simultaneously as readers, but a writer
- // must wait for all of them to release the mutex before it can acquire it
- // exclusively.
- void ReaderLock() ACQUIRE_SHARED();
- // Release/unlock an exclusive mutex.
- void Unlock() RELEASE();
- // Release/unlock a shared mutex.
- void ReaderUnlock() RELEASE_SHARED();
- // Try to acquire the mutex. Returns true on success, and false on failure.
- bool TryLock() TRY_ACQUIRE(true);
- // Try to acquire the mutex for read operations.
- bool ReaderTryLock() TRY_ACQUIRE_SHARED(true);
- // Assert that this mutex is currently held by the calling thread.
- void AssertHeld() ASSERT_CAPABILITY(this);
- // Assert that is mutex is currently held for read operations.
- void AssertReaderHeld() ASSERT_SHARED_CAPABILITY(this);
- // For negative capabilities.
- const Mutex& operator!() const { return *this; }
- };
- // MutexLocker is an RAII class that acquires a mutex in its constructor, and
- // releases it in its destructor.
- class SCOPED_CAPABILITY MutexLocker {
- private:
- Mutex* mut;
- public:
- MutexLocker(Mutex *mu) ACQUIRE(mu) : mut(mu) {
- mu->Lock();
- }
- ~MutexLocker() RELEASE() {
- mut->Unlock();
- }
- };
- #ifdef USE_LOCK_STYLE_THREAD_SAFETY_ATTRIBUTES
- // The original version of thread safety analysis the following attribute
- // definitions. These use a lock-based terminology. They are still in use
- // by existing thread safety code, and will continue to be supported.
- // Deprecated.
- #define PT_GUARDED_VAR \
- THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_var)
- // Deprecated.
- #define GUARDED_VAR \
- THREAD_ANNOTATION_ATTRIBUTE__(guarded_var)
- // Replaced by REQUIRES
- #define EXCLUSIVE_LOCKS_REQUIRED(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
- // Replaced by REQUIRES_SHARED
- #define SHARED_LOCKS_REQUIRED(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
- // Replaced by CAPABILITY
- #define LOCKABLE \
- THREAD_ANNOTATION_ATTRIBUTE__(lockable)
- // Replaced by SCOPED_CAPABILITY
- #define SCOPED_LOCKABLE \
- THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
- // Replaced by ACQUIRE
- #define EXCLUSIVE_LOCK_FUNCTION(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
- // Replaced by ACQUIRE_SHARED
- #define SHARED_LOCK_FUNCTION(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
- // Replaced by RELEASE and RELEASE_SHARED
- #define UNLOCK_FUNCTION(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
- // Replaced by TRY_ACQUIRE
- #define EXCLUSIVE_TRYLOCK_FUNCTION(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
- // Replaced by TRY_ACQUIRE_SHARED
- #define SHARED_TRYLOCK_FUNCTION(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
- // Replaced by ASSERT_CAPABILITY
- #define ASSERT_EXCLUSIVE_LOCK(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
- // Replaced by ASSERT_SHARED_CAPABILITY
- #define ASSERT_SHARED_LOCK(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
- // Replaced by EXCLUDE_CAPABILITY.
- #define LOCKS_EXCLUDED(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
- // Replaced by RETURN_CAPABILITY
- #define LOCK_RETURNED(x) \
- THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
- #endif // USE_LOCK_STYLE_THREAD_SAFETY_ATTRIBUTES
- #endif // THREAD_SAFETY_ANALYSIS_MUTEX_H
clang的线程安全分析模块 thread safety analysis的更多相关文章
- Clang的线程安全分析静态工具
本文内容来自 Thread Safety Analysis,如需完整学习,请参考相关链接. Clang线程安全分析工具是C++语言的一种扩展,用于警告代码中潜在的竞争条件.它在编译期间进行静态分析,无 ...
- Thread Safety线程安全
Thread Safe(线程安全)和None Thread Safe(NTS,非线程安全)之分 如果disabled就选择nts(php_stomp-1.0.9-5.5-nts-vc11-x86.zi ...
- 折返(Reentrancy)VS线程安全(Thread safety)
在Wiki上,折返例如,下面的定义(接) In computing, a computer program or subroutine is called reentrant if it can be ...
- 线程安全 Thread Safety Problem scala concurrency 并发
小结: 1.基于java并发模型 Scala concurrency is built on top of the Java concurrency model. 2. 将每个请求放入一个新的线程 T ...
- Thread Safety in Java(java中的线程安全)
Thread Safety in Java is a very important topic. Java provide multi-threaded environment support usi ...
- {Python之线程} 一 背景知识 二 线程与进程的关系 三 线程的特点 四 线程的实际应用场景 五 内存中的线程 六 用户级线程和内核级线程(了解) 七 python与线程 八 Threading模块 九 锁 十 信号量 十一 事件Event 十二 条件Condition(了解) 十三 定时器
Python之线程 线程 本节目录 一 背景知识 二 线程与进程的关系 三 线程的特点 四 线程的实际应用场景 五 内存中的线程 六 用户级线程和内核级线程(了解) 七 python与线程 八 Thr ...
- Java线程问题分析定位
Java线程问题分析定位 分析步骤: 1.使用top命令查看系统资源占用情况,发现Java进程占用大量CPU资源,PID为11572: 2.显示进程详细列表命令:ps -mp 11572 -o THR ...
- jstack和线程dump分析
转自:http://jameswxx.iteye.com/blog/1041173 一:jstack jstack命令的语法格式: jstack <pid>.可以用jps查看java进程 ...
- java线程池分析和应用
比较 在前面的一些文章里,我们已经讨论了手工创建和管理线程.在实际应用中我们有的时候也会经常听到线程池这个概念.在这里,我们可以先针对手工创建管理线程和通过线程池来管理做一个比较.通常,我们如果手工创 ...
随机推荐
- Swift字符串的介绍
字符串的介绍 字符串在任何的开发中使用都是非常频繁的 OC和Swift中字符串的区别 在OC中字符串类型时NSString,在Swift中字符串类型是String OC中字符串@"" ...
- Android状态栏微技巧,带你真正理解沉浸式模式【转】
感谢! 本文转自大佬郭霖:http://blog.csdn.net/guolin_blog/article/details/51763825 转载请注明出处:http://blog.csdn.net/ ...
- 关于CSS3样式中的前缀问题
作为新手,有的时候在写css时分不清什么属性需要用到前缀,或者用什么前缀,下面是我平时学习的一些总结. 在了解这些前缀之前,先介绍一下各大主流浏览器的内核: IE--trident(国内很多双核浏览器 ...
- Foundation框架介绍
1.Foundation框架介绍 什么是框架? 众多功能\API的集合 框架是由许多类.方法.函数.文档按照一定的逻辑组织起来的集合,以便使研发程序变得更容易,在OS X下的Mac操作系统中大约有80 ...
- 简单实现UITableView索引功能(中英文首字母索引)(一) ByH罗
UITableView索引功能是常见的,主要是获取中英文的首字母并排序,系统自带获取首字母 //系统获取首字母 - (NSString *) pinyinFirstLetter:(NSString*) ...
- SQL 游标 指针
DECLARE @radioScoreRate decimal DECLARE @checkScoreRate decimal DECLARE @judgeScoreRate decimal DECL ...
- 「 题解 」P2487 [SDOI2011]拦截导弹
简单题意 给定 \(n\) 个数对 \((h_i, v_i)\). 求: 最长不上升子序列的长度. 对于每个 \(i\),分别求出包含数对 \((h_i, v_i)\) 的最长上升子序列的个数和最长不 ...
- 他人学习Python感悟
作者:王一 链接:https://www.zhihu.com/question/26235428/answer/36568428 来源:知乎 著作权归作者所有.商业转载请联系作者获得授权,非商业转载请 ...
- 有手就行7——*项目构建细节2-钩子(webhook) 配置
有手就行7--*项目构建细节2-钩子(webhook) 配置 钩子服务 1)开启webhook功能 使用root账户登录到后台,点击Admin Area -> Settings -> N ...
- Worms
474B Worms time limit per test 1 second memory limit per test 256 megabytes input standard input out ...