Valgrind Helgrind와 DRD — 멀티스레드 레이스 진단

1
std::mutex m1, m2;
2
int counter = 0;
3

4
// 스레드 A
5
{
6
    std::lock_guard<std::mutex> g(m1);
7
    counter++;     // 이 접근 시점 lockset = {m1}
8
}
9

10
// 스레드 B
11
{
12
    std::lock_guard<std::mutex> g(m2);
13
    counter++;     // 이 접근 시점 lockset = {m2}
14
}

1
Possible data race during write of size 4 at 0x10c020 by thread #2
2
   at 0x40119A: increment (race.c:8)
3
   by 0x40120F: thread_run (race.c:15)
4
   by 0x4842B61: ??? (pthread_create.c:478)
5

6
This conflicts with a previous write of size 4 by thread #1
7
   at 0x40119A: increment (race.c:8)
8
   by 0x40120F: thread_run (race.c:15)
9

10
Location 0x10c020 is 0 bytes inside data symbol "counter"

1
std::mutex m;
2

3
void buggy() {
4
    m.lock();
5
    if (some_condition()) {
6
        return;       // ❌ unlock 안 함
7
    }
8
    m.unlock();
9
}

1
Thread #1's call to pthread_mutex_lock failed
2
   ...

1
// 스레드 A
2
std::lock_guard<std::mutex> a(m1);
3
std::lock_guard<std::mutex> b(m2);   // m1 → m2
4

5
// 스레드 B
6
std::lock_guard<std::mutex> b(m2);
7
std::lock_guard<std::mutex> a(m1);   // m2 → m1 ← 데드락 위험

1
Thread #2: lock order "m1 before m2" violated
2
   ...
3
This required order was established by acquisition of lock at 0x...
4
   by thread #1

1
       T1: a=1
2
        \
3
         sem_post
4
            \
5
             sem_wait → T2 (a 읽기 안전)
6

7
       T1: b=1
8

9
        T2: b 읽기  ← 동기화 없음, race

1
// Helgrind는 놓칠 수 있지만 DRD가 잡는 패턴
2
std::atomic<int> seq{0};
3

4
// 스레드 A
5
data = compute();
6
seq.store(seq.load() + 1, std::memory_order_relaxed);   // sequence number 갱신
7

8
// 스레드 B
9
int s = seq.load(std::memory_order_relaxed);
10
if (s > last_seq) {
11
    use(data);   // ← relaxed라 happens-before 없음. race
12
}

1
일반 실행:           1초
2
Memcheck:           10~50초
3
Helgrind:           30~100초
4
DRD:                25~80초

1
// 흔한 실수: detach 후 join
2
pthread_t t;
3
pthread_create(&t, NULL, worker, NULL);
4
pthread_detach(t);
5
// ...
6
pthread_join(t, NULL);    // ❌ 이미 detach됨

1
Thread #1: pthread_join: error code 22 (EINVAL): joining a detached thread

1
std::thread t(worker);
2
t.detach();
3
t.join();    // ❌ 이미 detach됨

1
pthread_mutex_t m;
2
pthread_cond_t c;
3
int ready = 0;
4

5
// 스레드 A (waiter)
6
pthread_mutex_lock(&m);
7
while (!ready) {
8
    pthread_cond_wait(&c, &m);
9
}
10
pthread_mutex_unlock(&m);
11

12
// 스레드 B (signaler)
13
pthread_mutex_lock(&m);
14
ready = 1;
15
pthread_cond_signal(&c);
16
pthread_mutex_unlock(&m);

1
// ❌ 락 없이 signal
2
pthread_cond_signal(&c);
3

4
// ❌ if로 wait (spurious wakeup 무시)
5
if (!ready) {
6
    pthread_cond_wait(&c, &m);
7
}
8

9
// ❌ 다른 mutex로 wait
10
pthread_mutex_t m1, m2;
11
pthread_cond_wait(&c, &m1);    // 어떤 호출은 m1, 다른 호출은 m2 → 위험

1
std::atomic<bool> spinlock{false};
2

3
void lock() {
4
    while (spinlock.exchange(true, std::memory_order_acquire)) {
5
        // spin
6
    }
7
}
8

9
void unlock() {
10
    spinlock.store(false, std::memory_order_release);
11
}

1
#include <valgrind/helgrind.h>
2

3
void lock() {
4
    while (spinlock.exchange(true)) {}
5
    ANNOTATE_RWLOCK_ACQUIRED(&spinlock, 1);
6
}
7

8
void unlock() {
9
    ANNOTATE_RWLOCK_RELEASED(&spinlock, 1);
10
    spinlock.store(false);
11
}

1
helgrind:
2
  runs-on: ubuntu-22.04
3
  steps:
4
    - uses: actions/checkout@v4
5
    - run: sudo apt install valgrind
6
    - run: cmake -B build -DCMAKE_BUILD_TYPE=Debug
7
    - run: cmake --build build
8
    - run: |
9
        valgrind --tool=helgrind \
10
                 --error-exitcode=1 \
11
                 --suppressions=tests/helgrind.supp \
12
                 ./build/concurrent_test

1
// 두 스레드가 동시에 std::cout
2
std::cout << "T1\n";
3
std::cout << "T2\n";

1
static MyClass& get_instance() {
2
    static MyClass inst;   // C++11+ 스레드 안전 초기화
3
    return inst;
4
}