[libcxx] Add Atomic test helper and fix TSAN failures.
Summary:
This patch attempts to fix the last 3 TSAN failures on the libc++ bot (http://lab.llvm.org:8011/builders/libcxx-libcxxabi-x86_64-linux-ubuntu-tsan/builds/143). This patch also adds a `Atomic` test type that can be used where `<atomic>` cannot.
`wait.exception.pass.cpp` and `wait_for.exception.pass.cpp` were failing because the test replaced `std::terminate` with `std::exit`. `std::exit` would asynchronously run the TLS and static destructors and this would cause a race condition. See PR22606 and D8802 for more details.
This is fixed by using `_Exit` to prevent cleanup.
`notify_all_at_thread_exit.pass.cpp` exercises the same race condition but for different reasons. I fixed this test by manually joining the thread before beginning program termination.
Reviewers: EricWF, mclow.lists
Subscribers: cfe-commits
Differential Revision: http://reviews.llvm.org/D11046
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@245389 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp b/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
index 2b8772f..3292d8b 100644
--- a/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
+++ b/test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp
@@ -36,9 +36,10 @@
int main()
{
std::unique_lock<std::mutex> lk(mut);
- std::thread(func).detach();
+ std::thread t(func);
Clock::time_point t0 = Clock::now();
cv.wait(lk);
Clock::time_point t1 = Clock::now();
assert(t1-t0 > ms(250));
+ t.join();
}
diff --git a/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
index 6236a13..1341e90 100644
--- a/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
+++ b/test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp
@@ -20,12 +20,13 @@
#include <thread>
#include <cassert>
+#include "test_atomic.h"
+
std::condition_variable cv;
std::mutex mut;
-int test0 = 0;
-int test1 = 0;
-int test2 = 0;
+AtomicInt test1(0);
+AtomicInt test2(0);
void f1()
{
@@ -64,11 +65,13 @@
}
if (test1 == 2)
{
+ assert(test2 == 1);
t1.join();
test1 = 0;
}
else if (test2 == 2)
{
+ assert(test1 == 1);
t2.join();
test2 = 0;
}
@@ -81,11 +84,13 @@
}
if (test1 == 2)
{
+ assert(test2 == 0);
t1.join();
test1 = 0;
}
else if (test2 == 2)
{
+ assert(test1 == 0);
t2.join();
test2 = 0;
}
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait.exception.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait.exception.pass.cpp
deleted file mode 100644
index 522c61b..0000000
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait.exception.pass.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// UNSUPPORTED: libcpp-has-no-threads
-
-#include <thread>
-#include <condition_variable>
-#include <mutex>
-#include <chrono>
-#include <iostream>
-#include <cassert>
-
-void f1()
-{
- std::exit(0);
-}
-
-struct Mutex
-{
- unsigned state = 0;
- Mutex() = default;
- ~Mutex() = default;
- Mutex(const Mutex&) = delete;
- Mutex& operator=(const Mutex&) = delete;
-
- void lock()
- {
- if (++state == 2)
- throw 1; // this throw should end up calling terminate()
- }
-
- void unlock() {}
-};
-
-Mutex mut;
-std::condition_variable_any cv;
-
-void
-signal_me()
-{
- std::this_thread::sleep_for(std::chrono::milliseconds(500));
- cv.notify_one();
-}
-
-int
-main()
-{
- std::set_terminate(f1);
- try
- {
- std::thread(signal_me).detach();
- mut.lock();
- cv.wait(mut);
- }
- catch (...) {}
- assert(false);
-}
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.exception.pass.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.exception.pass.cpp
deleted file mode 100644
index 1906b58..0000000
--- a/test/std/thread/thread.condition/thread.condition.condvarany/wait_for.exception.pass.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// UNSUPPORTED: libcpp-has-no-threads
-
-#include <thread>
-#include <condition_variable>
-#include <mutex>
-#include <chrono>
-#include <iostream>
-#include <cassert>
-
-void f1()
-{
- std::exit(0);
-}
-
-struct Mutex
-{
- unsigned state = 0;
- Mutex() = default;
- ~Mutex() = default;
- Mutex(const Mutex&) = delete;
- Mutex& operator=(const Mutex&) = delete;
-
- void lock()
- {
- if (++state == 2)
- throw 1; // this throw should end up calling terminate()
- }
-
- void unlock() {}
-};
-
-Mutex mut;
-std::condition_variable_any cv;
-
-void
-signal_me()
-{
- std::this_thread::sleep_for(std::chrono::milliseconds(500));
- cv.notify_one();
-}
-
-int
-main()
-{
- std::set_terminate(f1);
- try
- {
- std::thread(signal_me).detach();
- mut.lock();
- cv.wait_for(mut, std::chrono::milliseconds(250));
- }
- catch (...) {}
- assert(false);
-}
diff --git a/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp b/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
new file mode 100644
index 0000000..ed8c55d
--- /dev/null
+++ b/test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp
@@ -0,0 +1,132 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: libcpp-has-no-threads
+
+// <condition_variable>
+
+// class condition_variable_any;
+
+// RUN: %build
+// RUN: %run 1
+// RUN: %run 2
+// RUN: %run 3
+// RUN: %run 4
+// RUN: %run 5
+// RUN: %run 6
+
+// -----------------------------------------------------------------------------
+// Overview
+// Check that std::terminate is called if wait(...) fails to meet it's post
+// conditions. This can happens when reacquiring the mutex throws
+// an exception.
+//
+// The following methods are tested within this file
+// 1. void wait(Lock& lock);
+// 2. void wait(Lock& lock, Pred);
+// 3. void wait_for(Lock& lock, Duration);
+// 4. void wait_for(Lock& lock, Duration, Pred);
+// 5. void wait_until(Lock& lock, TimePoint);
+// 6. void wait_until(Lock& lock, TimePoint, Pred);
+//
+// Plan
+// 1 Create a mutex type, 'ThrowingMutex', that throws when the lock is aquired
+// for the *second* time.
+//
+// 2 Replace the terminate handler with one that exits with a '0' exit code.
+//
+// 3 Create a 'condition_variable_any' object 'cv' and a 'ThrowingMutex'
+// object 'm' and lock 'm'.
+//
+// 4 Start a thread 'T2' that will notify 'cv' once 'm' has been unlocked.
+//
+// 5 From the main thread call the specified wait method on 'cv' with 'm'.
+// When 'T2' notifies 'cv' and the wait method attempts to re-lock
+// 'm' an exception will be thrown from 'm.lock()'.
+//
+// 6 Check that control flow does not return from the wait method and that
+// terminate is called (If the program exits with a 0 exit code we know
+// that terminate has been called)
+
+
+#include <condition_variable>
+#include <thread>
+#include <chrono>
+#include <string>
+#include <cstdlib>
+#include <cassert>
+
+#include "test_atomic.h"
+
+void my_terminate() {
+ std::_Exit(0); // Use _Exit to prevent cleanup from taking place.
+}
+
+// The predicate used in the cv.wait calls.
+bool pred = false;
+bool pred_function() {
+ return pred == true;
+}
+
+class ThrowingMutex
+{
+ AtomicBool locked;
+ unsigned state = 0;
+ ThrowingMutex(const ThrowingMutex&) = delete;
+ ThrowingMutex& operator=(const ThrowingMutex&) = delete;
+public:
+ ThrowingMutex() = default;
+ ~ThrowingMutex() = default;
+
+ void lock() {
+ locked = true;
+ if (++state == 2) {
+ assert(pred); // Check that we actually waited until we were signaled.
+ throw 1; // this throw should end up calling terminate()
+ }
+ }
+
+ void unlock() { locked = false; }
+ bool isLocked() const { return locked == true; }
+};
+
+ThrowingMutex mut;
+std::condition_variable_any cv;
+
+void signal_me() {
+ while (mut.isLocked()) {} // wait until T1 releases mut inside the cv.wait call.
+ pred = true;
+ cv.notify_one();
+}
+
+typedef std::chrono::system_clock Clock;
+typedef std::chrono::milliseconds MS;
+
+int main(int argc, char** argv) {
+ assert(argc == 2);
+ int id = std::stoi(argv[1]);
+ assert(id >= 1 && id <= 6);
+ std::set_terminate(my_terminate); // set terminate after std::stoi because it can throw.
+ MS wait(250);
+ try {
+ mut.lock();
+ assert(pred == false);
+ std::thread(signal_me).detach();
+ switch (id) {
+ case 1: cv.wait(mut); break;
+ case 2: cv.wait(mut, pred_function); break;
+ case 3: cv.wait_for(mut, wait); break;
+ case 4: cv.wait_for(mut, wait, pred_function); break;
+ case 5: cv.wait_until(mut, Clock::now() + wait); break;
+ case 6: cv.wait_until(mut, Clock::now() + wait, pred_function); break;
+ default: assert(false);
+ }
+ } catch (...) {}
+ assert(false);
+}
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
index a8b4be1..ff3bd82 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp
@@ -22,6 +22,8 @@
#include <cstdlib>
#include <cassert>
+#include "test_macros.h"
+
unsigned throw_one = 0xFFFF;
void* operator new(std::size_t s) throw(std::bad_alloc)
@@ -75,7 +77,7 @@
int G::n_alive = 0;
bool G::op_run = false;
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#if TEST_STD_VER >= 11
class MoveOnly
{
@@ -137,7 +139,7 @@
assert(!G::op_run);
}
}
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#if TEST_STD_VER >= 11
{
assert(G::n_alive == 0);
assert(!G::op_run);
@@ -150,5 +152,5 @@
std::thread t = std::thread(MoveOnly(), MoveOnly());
t.join();
}
-#endif // _LIBCPP_HAS_NO_VARIADICS
+#endif
}
diff --git a/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp b/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
index ddf96d0..0efb771 100644
--- a/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp
@@ -9,8 +9,6 @@
//
// UNSUPPORTED: libcpp-has-no-threads
-// NOTE: TSAN will report this test as leaking a thread.
-// XFAIL: tsan
// <thread>
@@ -47,7 +45,7 @@
void f1()
{
- std::exit(0);
+ std::_Exit(0);
}
int main()
diff --git a/test/support/test_atomic.h b/test/support/test_atomic.h
new file mode 100644
index 0000000..13a0b20
--- /dev/null
+++ b/test/support/test_atomic.h
@@ -0,0 +1,109 @@
+#ifndef SUPPORT_TEST_ATOMIC_H
+#define SUPPORT_TEST_ATOMIC_H
+
+// If the atomic memory order macros are defined then assume
+// the compiler supports the required atomic builtins.
+#if !defined(__ATOMIC_SEQ_CST)
+#define TEST_HAS_NO_ATOMICS
+#endif
+
+template <class ValType>
+class Atomic {
+ ValType value;
+ Atomic(Atomic const&);
+ Atomic& operator=(Atomic const&);
+ Atomic& operator=(Atomic const&) volatile;
+private:
+ enum {
+#if !defined(TEST_HAS_NO_ATOMICS)
+ AO_Relaxed = __ATOMIC_RELAXED,
+ AO_Seq = __ATOMIC_SEQ_CST
+#else
+ AO_Relaxed,
+ AO_Seq
+#endif
+ };
+ template <class Tp, class FromType>
+ static inline void atomic_store_imp(Tp* dest, FromType from, int order = AO_Seq) {
+#if !defined(TEST_HAS_NO_ATOMICS)
+ __atomic_store_n(dest, from, order);
+#else
+ *dest = from;
+#endif
+ }
+
+ template <class Tp>
+ static inline Tp atomic_load_imp(Tp* from, int order = AO_Seq) {
+#if !defined(TEST_HAS_NO_ATOMICS)
+ return __atomic_load_n(from, order);
+#else
+ return *from;
+#endif
+ }
+
+ template <class Tp, class AddType>
+ static inline Tp atomic_add_imp(Tp* val, AddType add, int order = AO_Seq) {
+#if !defined(TEST_HAS_NO_ATOMICS)
+ return __atomic_add_fetch(val, add, order);
+#else
+ return *val += add;
+#endif
+ }
+
+ template <class Tp>
+ static inline Tp atomic_exchange_imp(Tp* val, Tp other, int order = AO_Seq) {
+#if !defined(TEST_HAS_NO_ATOMICS)
+ return __atomic_exchange_n(val, other, order);
+#else
+ Tp old = *val;
+ *val = other;
+ return old;
+#endif
+ }
+public:
+ Atomic() : value(0) {}
+ Atomic(ValType x) : value(x) {}
+
+ ValType operator=(ValType val) {
+ atomic_store_imp(&value, val);
+ return val;
+ }
+
+ ValType operator=(ValType val) volatile {
+ atomic_store_imp(&value, val);
+ return val;
+ }
+
+ ValType load() const volatile { return atomic_load_imp(&value); }
+ void store(ValType val) volatile { atomic_store_imp(&value, val); }
+
+ ValType relaxedLoad() const volatile { return atomic_load_imp(&value, AO_Relaxed); }
+ void relaxedStore(ValType val) volatile { atomic_store_imp(&value, val, AO_Relaxed); }
+
+ ValType exchange(ValType other) volatile { return atomic_exchange_imp(&value, other); }
+ bool testAndSet() volatile { return atomic_exchange_imp(&value, 1); }
+ void clear() volatile { atomic_store_imp(&value, 0); }
+
+ operator ValType() const { return atomic_load_imp(&value); }
+ operator ValType() const volatile { return atomic_load_imp(&value); }
+
+ ValType operator+=(ValType val) { return atomic_add_imp(&value, val); }
+ ValType operator-=(ValType val) { return atomic_add_imp(&value, -val); }
+ ValType operator+=(ValType val) volatile { return atomic_add_imp(&value, val); }
+ ValType operator-=(ValType val) volatile { return atomic_add_imp(&value, -val); }
+
+ ValType operator++() { return *this += 1; }
+ ValType operator++(int) { return (*this += 1) - 1; }
+ ValType operator++() volatile { return *this += 1; }
+ ValType operator++(int) volatile { return (*this += 1) - 1; }
+
+ ValType operator--() { return *this -= 1; }
+ ValType operator--(int) { return (*this -= 1) + 1; }
+ ValType operator--() volatile { return *this -= 1; }
+ ValType operator--(int) volatile { return (*this -= 1) + 1; }
+};
+
+typedef Atomic<int> AtomicInt;
+typedef Atomic<bool> AtomicBool;
+
+#endif // SUPPORT_TEST_ATOMIC_H