2024-03-12 17:21:00 -07:00
|
|
|
// RUN: %clangxx_tsan -O1 %s %link_libcxx_tsan -o %t && %run %t 2>&1
|
Fix race in the implementation of __tsan_acquire() (#84923)
`__tsan::Acquire()`, which is called by `__tsan_acquire()`, has a
performance optimization which attempts to avoid acquiring the atomic
variable's mutex if the variable has no associated memory model state.
However, if the atomic variable was recently written to by a
`compare_exchange_weak/strong` on another thread, the memory model state
may be created *after* the atomic variable is updated. This is a data
race, and can cause the thread calling `Acquire()` to not realize that
the atomic variable was previously written to by another thread.
Specifically, if you have code that writes to an atomic variable using
`compare_exchange_weak/strong`, and then in another thread you read the
value using a relaxed load, followed by an
`atomic_thread_fence(memory_order_acquire)`, followed by a call to
`__tsan_acquire()`, TSAN may not realize that the store happened before
the fence, and so it will complain about any other variables you access
from both threads if the thread-safety of those accesses depended on the
happens-before relationship between the store and the fence.
This change eliminates the unsafe optimization in `Acquire()`. Now,
`Acquire()` acquires the mutex before checking for the existence of the
memory model state.
2024-03-12 18:36:48 -04:00
|
|
|
// This is a correct program and tsan should not report a race.
|
|
|
|
//
|
|
|
|
// Verify that there is a happens-before relationship between a
|
|
|
|
// memory_order_release store that happens as part of a successful
|
|
|
|
// compare_exchange_strong(), and an atomic_thread_fence(memory_order_acquire)
|
|
|
|
// that happens after a relaxed load.
|
|
|
|
|
|
|
|
#include <atomic>
|
|
|
|
#include <sanitizer/tsan_interface.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <thread>
|
|
|
|
|
|
|
|
std::atomic<bool> a;
|
|
|
|
unsigned int b;
|
|
|
|
constexpr int loops = 100000;
|
|
|
|
|
|
|
|
void Thread1() {
|
|
|
|
for (int i = 0; i < loops; ++i) {
|
|
|
|
while (a.load(std::memory_order_acquire)) {
|
|
|
|
}
|
|
|
|
b = i;
|
|
|
|
bool expected = false;
|
|
|
|
a.compare_exchange_strong(expected, true, std::memory_order_acq_rel);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int main() {
|
|
|
|
std::thread t(Thread1);
|
|
|
|
unsigned int sum = 0;
|
|
|
|
for (int i = 0; i < loops; ++i) {
|
|
|
|
while (!a.load(std::memory_order_relaxed)) {
|
|
|
|
}
|
|
|
|
std::atomic_thread_fence(std::memory_order_acquire);
|
|
|
|
__tsan_acquire(&a);
|
|
|
|
sum += b;
|
|
|
|
a.store(false, std::memory_order_release);
|
|
|
|
}
|
|
|
|
t.join();
|
|
|
|
fprintf(stderr, "DONE: %u\n", sum);
|
|
|
|
return 0;
|
|
|
|
}
|