[libcxx] Add Atomic test helper and fix TSAN failures.

[EricWF]

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.

[mclow.lists]

Should these tests go into the std/ hierarchy, or the libcxx/ hierarchy?

[EricWF]

In D11046#203989, @mclow.lists wrote:

Should these tests go into the std/ hierarchy, or the libcxx/ hierarchy?

They belong in std/. There is a remark on each of the following wait* methods that states

[thread.condition.condvarany]
Postcondition: lock.owns_lock() is true and lock.mutex() is locked by the calling thread.
Remarks: If the function fails to meet the postcondition, std::terminate() shall be called

[EricWF]

Add more explanation to the wait tests.

[EricWF]

Fix more failing TSAN tests.

test/std/thread/thread.condition/notify_all_at_thread_exit.pass.cpp

 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();
 }

test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp

 #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()
 {

     }
     if (test1 == 2)
     {
+        assert(test2 == 1);
         t1.join();
         test1 = 0;
     }
     else if (test2 == 2)
     {
+        assert(test1 == 1);
         t2.join();
         test2 = 0;
     }

     }
     if (test1 == 2)
     {
+        assert(test2 == 0);
         t1.join();
         test1 = 0;
     }
     else if (test2 == 2)
     {
+        assert(test1 == 0);
         t2.join();
         test2 = 0;
     }

test/std/thread/thread.condition/thread.condition.condvarany/wait.exception.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-//                     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);
-}

test/std/thread/thread.condition/thread.condition.condvarany/wait_for.exception.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-//                     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);
-}

test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     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);
+}

test/std/thread/thread.threads/thread.thread.class/thread.thread.constr/F.pass.cpp

 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 unsigned throw_one = 0xFFFF;
 
 void* operator new(std::size_t s) throw(std::bad_alloc)

 int G::n_alive = 0;
 bool G::op_run = false;
 
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#if TEST_STD_VER >= 11
 
 class MoveOnly
 {

             assert(!G::op_run);
         }
     }
-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#if TEST_STD_VER >= 11
     {
         assert(G::n_alive == 0);
         assert(!G::op_run);

         std::thread t = std::thread(MoveOnly(), MoveOnly());
         t.join();
     }
-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif
 }

test/std/thread/thread.threads/thread.thread.class/thread.thread.destr/dtor.pass.cpp

 //
 // UNSUPPORTED: libcpp-has-no-threads
 
-// NOTE: TSAN will report this test as leaking a thread.
-// XFAIL: tsan
 
 // <thread>
 

 
 void f1()
 {
-    std::exit(0);
+    std::_Exit(0);
 }
 
 int main()

test/support/test_atomic.h

+#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