[libcxx] [test] Make some threading tests more robust

[mstorsjo]

Summary

Increase the timeout tolerance if TEST_HAS_SANITIZERS is set, similarly
to how it's done in a couple other tests.

Use std::this_thread::yield(); instead of busylooping. When multiple
threads are busylooping, it's plausible that not all threads even get
started running before the timeout runs out.

This makes the threading tests succeed if run in Windows runners on
Github Actions.

[Mordante]

LGTM, with a nit. I would have preferred to do D131484 before this one. (I don't think it's worth your time to inverse the order now.)

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

40

Can you add the comment of the other similar tests (See D131484)

[mstorsjo]

In D131483#3713843, @Mordante wrote:

LGTM, with a nit. I would have preferred to do D131484 before this one. (I don't think it's worth your time to inverse the order now.)

I'm totally ok with landing D131484 before this one; I just sent them out in parallel for reviewing.

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

40

Sure (although some of the existing ones also lack the comment, e.g. the third diff here on phab). Also, if landing D131484 and renaming the define to TEST_IS_SLOW, should the comments be reworded slightly (all of them)? Because I was hitting the tolerance when running without sanitizers too...

[mstorsjo]

Rebased the patch on top of D131484, added the same descriptive comment on the new uses of the define too.

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

 std::shared_timed_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef std::chrono::milliseconds ms;
 typedef std::chrono::nanoseconds ns;
 
+
+#if !defined(TEST_HAS_SANITIZERS)
+ms Tolerance = ms(200);
+#else
+ms Tolerance = ms(200 * 5);
+#endif
+
 void f()
 {
     time_point t0 = Clock::now();
     {
         std::shared_lock<std::shared_timed_mutex> lk(m, std::try_to_lock);
         assert(lk.owns_lock() == false);
     }
     {
         std::shared_lock<std::shared_timed_mutex> lk(m, std::try_to_lock);
         assert(lk.owns_lock() == false);
     }
     {
         std::shared_lock<std::shared_timed_mutex> lk(m, std::try_to_lock);
         assert(lk.owns_lock() == false);
     }
     while (true)
     {
         std::shared_lock<std::shared_timed_mutex> lk(m, std::try_to_lock);
         if (lk.owns_lock())
             break;
+        std::this_thread::yield();
     }
     time_point t1 = Clock::now();
     ns d = t1 - t0 - ms(250);
-    assert(d < ms(200));  // within 200ms
+    assert(d < Tolerance);  // within tolerance
 }
 
 int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
     for (int i = 0; i < 5; ++i)
         v.push_back(support::make_test_thread(f));
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     for (auto& t : v)
         t.join();
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp

 std::shared_mutex m;
 
 typedef std::chrono::system_clock Clock;
 typedef Clock::time_point time_point;
 typedef Clock::duration duration;
 typedef std::chrono::milliseconds ms;
 typedef std::chrono::nanoseconds ns;
 
+
+#if !defined(TEST_HAS_SANITIZERS)
+ms Tolerance = ms(200);
+#else
+ms Tolerance = ms(200 * 5);
+#endif
+
 void f()
 {
     time_point t0 = Clock::now();
     assert(!m.try_lock_shared());
     assert(!m.try_lock_shared());
     assert(!m.try_lock_shared());
     while(!m.try_lock_shared())
-        ;
+        std::this_thread::yield();
     time_point t1 = Clock::now();
     m.unlock_shared();
     ns d = t1 - t0 - ms(250);
-    assert(d < ms(200));  // within 200ms
+    assert(d < Tolerance);  // within tolerance
 }
 
 
 int main(int, char**)
 {
     m.lock();
     std::vector<std::thread> v;
     for (int i = 0; i < 5; ++i)
         v.push_back(support::make_test_thread(f));
     std::this_thread::sleep_for(ms(250));
     m.unlock();
     for (auto& t : v)
         t.join();
 
   return 0;
 }

libcxx/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp

 
 void f()
 {
     time_point t0 = Clock::now();
     assert(!m.try_lock_shared());
     assert(!m.try_lock_shared());
     assert(!m.try_lock_shared());
     while(!m.try_lock_shared())
-        ;
+        std::this_thread::yield();
     time_point t1 = Clock::now();
     m.unlock_shared();
     ns d = t1 - t0 - ms(250);
     assert(d < Tolerance);  // within tolerance
 }
 
 int main(int, char**)
 {