[libcxx testing] Remove ALLOW_RETRIES from another test

libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_duration.pass.cpp

@@ -10,8 +10,6 @@
 // UNSUPPORTED: c++03, c++11
 // XFAIL: dylib-has-no-shared_mutex
 
-// ALLOW_RETRIES: 2
-
 // <shared_mutex>
 
 // class timed_mutex;
@@ -35,60 +33,63 @@ typedef Clock::duration duration;
 typedef std::chrono::milliseconds ms;
 typedef std::chrono::nanoseconds ns;
 
-ms WaitTime = ms(250);
+ms LongTime = ms(5000);
+ms ShortTime = ms(50);
 
-// Thread sanitizer causes more overhead and will sometimes cause this test
-// to fail. To prevent this we give Thread sanitizer more time to complete the
-// test.
-#if !defined(TEST_HAS_SANITIZERS)
-ms Tolerance = ms(50);
-#else
-ms Tolerance = ms(50 * 5);
-#endif
+static const unsigned Threads = 5;
 
+std::atomic<unsigned> CountDown = Threads;
 
 void f1()
 {
-    time_point t0 = Clock::now();
-    std::shared_lock<std::shared_timed_mutex> lk(m, WaitTime + Tolerance);
-    assert(lk.owns_lock() == true);
-    time_point t1 = Clock::now();
-    ns d = t1 - t0 - WaitTime;
-    assert(d < Tolerance);  // within 50ms
+  // Preemptive scheduling means that one cannot make assumptions about when
+  // code executes and therefore we cannot assume anthing about when the mutex
+  // starts waiting relative to code in the main thread. We can however prove
+  // that a timeout occured and that implies that this code is waiting.
+  // See f2() below.
+  //
+  // Nevertheless, we should at least try to ensure that the mutex waits and
+  // therefore we use an atomic variable to signal to the main thread that this
+  // code is just a few instructions away from waiting.
+  --CountDown;
+  std::shared_lock<std::shared_timed_mutex> lk(m, LongTime);
+  assert(lk.owns_lock() == true);
 }
 
 void f2()
 {
-    time_point t0 = Clock::now();
-    std::shared_lock<std::shared_timed_mutex> lk(m, WaitTime);
-    assert(lk.owns_lock() == false);
-    time_point t1 = Clock::now();
-    ns d = t1 - t0 - WaitTime;
-    assert(d < Tolerance);  // within 50ms
+  time_point t0 = Clock::now();
+  std::shared_lock<std::shared_timed_mutex> lk(m, ShortTime);
+  time_point t1 = Clock::now();
+  assert(lk.owns_lock() == false);
+  assert(t1 - t0 >= ShortTime);
 }
 
 int main(int, char**)
 {
-    {
-        m.lock();
-        std::vector<std::thread> v;
-        for (int i = 0; i < 5; ++i)
-            v.push_back(std::thread(f1));
-        std::this_thread::sleep_for(WaitTime);
-        m.unlock();
-        for (auto& t : v)
-            t.join();
-    }
-    {
-        m.lock();
-        std::vector<std::thread> v;
-        for (int i = 0; i < 5; ++i)
-            v.push_back(std::thread(f2));
-        std::this_thread::sleep_for(WaitTime + Tolerance);
-        m.unlock();
-        for (auto& t : v)
-            t.join();
-    }
+  {
+    m.lock();
+    std::vector<std::thread> v;
+    for (unsigned i = 0; i < Threads; ++i)
+      v.push_back(std::thread(f1));
+    while (CountDown > 0)
+      std::this_thread::yield();
+    // Give one more chance for threads to block and wait for the mutex.
+    std::this_thread::yield();
+    std::this_thread::sleep_for(ShortTime);
+    m.unlock();
+    for (auto& t : v)
+      t.join();
+  }
+  {
+    m.lock();
+    std::vector<std::thread> v;
+    for (unsigned i = 0; i < Threads; ++i)
+      v.push_back(std::thread(f2));
+    for (auto& t : v)
+      t.join();
+    m.unlock();
+  }
 
   return 0;
 }