Abseil thread_annotations — clang TSA 통합

1
class Server {
2
public:
3
    void HandleRequest() {
4
        // queue_를 손대는데 lock 잡았나?
5
        queue_.push(request);  // 깜빡하면 race
6
    }
7

8
private:
9
    absl::Mutex mu_;
10
    std::queue<Request> queue_;  // 어떤 mutex로 보호되는지 헤더만 봐서는 모름
11
};

1
#include "absl/base/thread_annotations.h"
2

3
class Server {
4
public:
5
    void HandleRequest(const Request& req) {
6
        absl::MutexLock lock(&mu_);
7
        queue_.push(req);  // OK — mu_ 잡고 있음
8
    }
9

10
    void Unsafe(const Request& req) {
11
        queue_.push(req);  // 컴파일 경고: must hold mu_
12
    }
13

14
private:
15
    absl::Mutex mu_;
16
    std::queue<Request> queue_ ABSL_GUARDED_BY(mu_);
17
};

1
class Server {
2
private:
3
    absl::Mutex mu_;
4
    int* data_ ABSL_PT_GUARDED_BY(mu_);
5
    // data_ 변수 자체는 누구나 읽을 수 있음
6
    // *data_ 또는 data_[i]는 mu_가 필요
7
};

1
int* p1 ABSL_GUARDED_BY(mu_);    // p1 자체에 접근하려면 mu_ 필요
2
int* p2 ABSL_PT_GUARDED_BY(mu_); // p2가 가리키는 값에 접근하려면 mu_ 필요

1
class Server {
2
public:
3
    void Process() ABSL_LOCKS_EXCLUDED(mu_) {
4
        // 이 함수 진입 시점에 mu_가 unlocked여야 함
5
        absl::MutexLock lock(&mu_);
6
        DoWork();
7
    }
8
};
9

10
void BadCaller(Server* s) {
11
    absl::MutexLock lock(&s->mu_);  // 잡고
12
    s->Process();                    // 호출 — 경고: re-entrant lock 시도
13
}

1
class Server {
2
private:
3
    absl::Mutex mu_;
4
    int counter_ ABSL_GUARDED_BY(mu_);
5

6
    void IncrementLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
7
        ++counter_;  // OK — caller가 mu_를 잡은 걸 보장
8
    }
9

10
public:
11
    void Increment() {
12
        absl::MutexLock lock(&mu_);
13
        IncrementLocked();
14
    }
15
};

1
void Hack() ABSL_NO_THREAD_SAFETY_ANALYSIS {
2
    // 이 함수 안의 mutex 사용은 분석 대상에서 제외
3
}

1
class A {
2
private:
3
    absl::Mutex mu_a_;
4
    absl::Mutex mu_b_ ABSL_ACQUIRED_AFTER(mu_a_);
5
    // mu_a_ 먼저, 그 다음 mu_b_
6

7
    void Bad() {
8
        absl::MutexLock l_b(&mu_b_);
9
        absl::MutexLock l_a(&mu_a_);  // 경고: order 위반
10
    }
11
};

1
class Container {
2
public:
3
    absl::Mutex* GetMutex() ABSL_LOCK_RETURNED(mu_) {
4
        return &mu_;
5
    }
6
private:
7
    absl::Mutex mu_;
8
    int value_ ABSL_GUARDED_BY(mu_);
9
};
10

11
void User(Container* c) {
12
    absl::MutexLock lock(c->GetMutex());
13
    // TSA가 이 lock이 c->mu_와 같음을 안다
14
    c->value_ = 1;  // OK
15
}

1
target_compile_options(my_lib PRIVATE
2
    -Wthread-safety
3
    -Wthread-safety-beta  # 일부 실험적 기능
4
)

1
// 실제 매크로 정의
2
#if defined(__clang__) && (!defined(SWIG))
3
    #define ABSL_GUARDED_BY(x) __attribute__((guarded_by(x)))
4
    #define ABSL_LOCKS_EXCLUDED(...) __attribute__((locks_excluded(__VA_ARGS__)))
5
#else
6
    #define ABSL_GUARDED_BY(x)
7
    #define ABSL_LOCKS_EXCLUDED(...)
8
#endif

1
// absl/synchronization/mutex.h에서 발췌
2
class ABSL_LOCKABLE Mutex {
3
public:
4
    void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION();
5
    void Unlock() ABSL_UNLOCK_FUNCTION();
6
    bool TryLock() ABSL_EXCLUSIVE_TRYLOCK_FUNCTION(true);
7
    // ...
8
};

1
// 회피 — mutex로 보호되는 변수에 annotation 없음
2
class Server {
3
private:
4
    absl::Mutex mu_;
5
    std::queue<int> queue_;  // 어느 mutex가 보호?
6
};
7

8
// Good
9
class Server {
10
private:
11
    absl::Mutex mu_;
12
    std::queue<int> queue_ ABSL_GUARDED_BY(mu_);
13
};

1
// 회피 — private helper에 lock 요구 명시 없음
2
class Server {
3
private:
4
    void IncrementUnsafe() {  // caller가 lock 잡았는지 모름
5
        ++counter_;
6
    }
7
    int counter_ ABSL_GUARDED_BY(mu_);
8
};
9

10
// Good
11
class Server {
12
private:
13
    void IncrementLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
14
        ++counter_;
15
    }
16
};

1
// 회피 — NO_THREAD_SAFETY_ANALYSIS 남용
2
void Process() ABSL_NO_THREAD_SAFETY_ANALYSIS {
3
    // ...
4
}
5
// 안전성 검사를 꺼버림. 정말 필요한지 검토.

1
// 회피 — GUARDED_BY인데 mutex 안 잡고 접근
2
class Server {
3
private:
4
    absl::Mutex mu_;
5
    int counter_ ABSL_GUARDED_BY(mu_);
6

7
public:
8
    int GetCounter() const { return counter_; }  // 경고: must hold mu_
9
};
10

11
// Good
12
int GetCounter() const ABSL_LOCKS_EXCLUDED(mu_) {
13
    absl::MutexLock lock(&mu_);
14
    return counter_;
15
}

1
// 회피 — public method에서 mutex를 잡고 다른 public method 호출
2
void A() ABSL_LOCKS_EXCLUDED(mu_) {
3
    absl::MutexLock lock(&mu_);
4
    B();  // B도 mu_를 잡으려 함 → deadlock
5
}
6

7
void B() ABSL_LOCKS_EXCLUDED(mu_) {
8
    absl::MutexLock lock(&mu_);
9
    // ...
10
}
11

12
// Good — internal helper로 분리
13
void A() ABSL_LOCKS_EXCLUDED(mu_) {
14
    absl::MutexLock lock(&mu_);
15
    BLocked();
16
}
17

18
void B() ABSL_LOCKS_EXCLUDED(mu_) {
19
    absl::MutexLock lock(&mu_);
20
    BLocked();
21
}
22

23
void BLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
24
    // ...
25
}