Почему ThreadSanitizer сообщает о гонке с этим примером без блокировки?
Я свел это к простому самодостаточному примеру. Основной поток ставит в очередь 1000 элементов, а рабочий поток пытается одновременно снять очереди. ThreadSanitizer жалуется на то, что между чтением и записью одного из элементов существует гонка, даже несмотря на то, что существует защитная последовательность защиты с запуском и освобождением.
#include <atomic>
#include <thread>
#include <cassert>
struct FakeQueue
{
int items[1000];
std::atomic<int> m_enqueueIndex;
int m_dequeueIndex;
FakeQueue() : m_enqueueIndex(0), m_dequeueIndex(0) { }
void enqueue(int x)
{
auto tail = m_enqueueIndex.load(std::memory_order_relaxed);
items[tail] = x; // <- element written
m_enqueueIndex.store(tail + 1, std::memory_order_release);
}
bool try_dequeue(int& x)
{
auto tail = m_enqueueIndex.load(std::memory_order_acquire);
assert(tail >= m_dequeueIndex);
if (tail == m_dequeueIndex)
return false;
x = items[m_dequeueIndex]; // <- element read -- tsan says race!
++m_dequeueIndex;
return true;
}
};
FakeQueue q;
int main()
{
std::thread th([&]() {
int x;
for (int i = 0; i != 1000; ++i)
q.try_dequeue(x);
});
for (int i = 0; i != 1000; ++i)
q.enqueue(i);
th.join();
}
Выход ThreadSanitizer:
==================
WARNING: ThreadSanitizer: data race (pid=17220)
Read of size 4 at 0x0000006051c0 by thread T1:
#0 FakeQueue::try_dequeue(int&) /home/cameron/projects/concurrentqueue/tests/tsan/issue49.cpp:26 (issue49+0x000000402bcd)
#1 main::{lambda()#1}::operator()() const <null> (issue49+0x000000401132)
#2 _M_invoke<> /usr/include/c++/5.3.1/functional:1531 (issue49+0x0000004025e3)
#3 operator() /usr/include/c++/5.3.1/functional:1520 (issue49+0x0000004024ed)
#4 _M_run /usr/include/c++/5.3.1/thread:115 (issue49+0x00000040244d)
#5 <null> <null> (libstdc++.so.6+0x0000000b8f2f)
Previous write of size 4 at 0x0000006051c0 by main thread:
#0 FakeQueue::enqueue(int) /home/cameron/projects/concurrentqueue/tests/tsan/issue49.cpp:16 (issue49+0x000000402a90)
#1 main /home/cameron/projects/concurrentqueue/tests/tsan/issue49.cpp:44 (issue49+0x000000401187)
Location is global 'q' of size 4008 at 0x0000006051c0 (issue49+0x0000006051c0)
Thread T1 (tid=17222, running) created by main thread at:
#0 pthread_create <null> (libtsan.so.0+0x000000027a67)
#1 std::thread::_M_start_thread(std::shared_ptr<std::thread::_Impl_base>, void (*)()) <null> (libstdc++.so.6+0x0000000b9072)
#2 main /home/cameron/projects/concurrentqueue/tests/tsan/issue49.cpp:41 (issue49+0x000000401168)
SUMMARY: ThreadSanitizer: data race /home/cameron/projects/concurrentqueue/tests/tsan/issue49.cpp:26 FakeQueue::try_dequeue(int&)
==================
ThreadSanitizer: reported 1 warnings
Командная строка:
g++ -std=c++11 -O0 -g -fsanitize=thread issue49.cpp -o issue49 -pthread
Версия g++: 5.3.1
Кто-нибудь может пролить свет на то, почему Цан считает, что это гонка данных?
ОБНОВИТЬ
Кажется, что это ложный позитив. Чтобы успокоить ThreadSanitizer, я добавил аннотации (см. Здесь для поддерживаемых и здесь для примера). Обратите внимание, что определение, что tsan включен в GCC с помощью макроса, было добавлено только недавно, поэтому мне пришлось вручную передать -D__SANITIZE_THREAD__ на g++ сейчас.
#if defined(__SANITIZE_THREAD__)
#define TSAN_ENABLED
#elif defined(__has_feature)
#if __has_feature(thread_sanitizer)
#define TSAN_ENABLED
#endif
#endif
#ifdef TSAN_ENABLED
#define TSAN_ANNOTATE_HAPPENS_BEFORE(addr) \
AnnotateHappensBefore(__FILE__, __LINE__, (void*)(addr))
#define TSAN_ANNOTATE_HAPPENS_AFTER(addr) \
AnnotateHappensAfter(__FILE__, __LINE__, (void*)(addr))
extern "C" void AnnotateHappensBefore(const char* f, int l, void* addr);
extern "C" void AnnotateHappensAfter(const char* f, int l, void* addr);
#else
#define TSAN_ANNOTATE_HAPPENS_BEFORE(addr)
#define TSAN_ANNOTATE_HAPPENS_AFTER(addr)
#endif
struct FakeQueue
{
int items[1000];
std::atomic<int> m_enqueueIndex;
int m_dequeueIndex;
FakeQueue() : m_enqueueIndex(0), m_dequeueIndex(0) { }
void enqueue(int x)
{
auto tail = m_enqueueIndex.load(std::memory_order_relaxed);
items[tail] = x;
TSAN_ANNOTATE_HAPPENS_BEFORE(&items[tail]);
m_enqueueIndex.store(tail + 1, std::memory_order_release);
}
bool try_dequeue(int& x)
{
auto tail = m_enqueueIndex.load(std::memory_order_acquire);
assert(tail >= m_dequeueIndex);
if (tail == m_dequeueIndex)
return false;
TSAN_ANNOTATE_HAPPENS_AFTER(&items[m_dequeueIndex]);
x = items[m_dequeueIndex];
++m_dequeueIndex;
return true;
}
};
// main() is as before
Теперь ThreadSanitizer счастлив во время выполнения.
2 ответа
ThreadSanitizer плохо умеет считать, он не может понять, что запись в элементы всегда происходит до чтения.
ThreadSanitizer может обнаружить, что магазины m_enqueueIndex случиться до загрузки, но он не понимает, что в магазине items[m_dequeueIndex] должно произойти до загрузки, когда tail > m_dequeueIndex,
Это выглядит как https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78158. Разборка двоичного файла, созданного GCC, показывает, что он не инструментирует атомарные операции на O0. В качестве обходного пути вы можете либо создать свой код с помощью GCC с -O1/-O2, либо получить новую сборку Clang и использовать ее для запуска ThreadSanitizer (это рекомендуемый способ, так как TSan разрабатывается как часть Clang и только перенесен в GCC).
Приведенные выше комментарии являются недопустимыми: TSan может легко понять отношение "происходит до" между атомами в вашем коде (это можно проверить, запустив вышеуказанный репродуктор в TSan в Clang).
Я также не рекомендовал бы использовать AnnotateHappensBefore()/AnnotateHappensAfter() по двум причинам:
в большинстве случаев они вам не нужны; они обозначают, что код делает что-то действительно сложное (в этом случае вы можете проверить, правильно ли вы это делаете);
Если вы допустили ошибку в своем коде без блокировки, то его распыление с помощью аннотаций может замаскировать эту ошибку, так что TSan не заметит ее.