Merge pull request #23816 from mikeash/improve-mutex-tests

Author: swift-ci

unittests/runtime/Mutex.cpp

@@ -555,20 +555,21 @@ TEST(StaticReadWriteLockTest, ScopedWriteUnlockThreaded) {
 template <typename RW> void readLockWhileReadLockedThreaded(RW &lock) {
   lock.readLock();
 
-  std::vector<bool> results;
-  results.assign(10, false);
+  std::vector<std::atomic<bool>> results(10);
 
   std::atomic<bool> done(false);
   threadedExecute(10,
                   [&](int index) {
-                    while (!done) {
+                    // Always perform at least one iteration of this loop to
+                    // avoid spurious failures if this thread is slow to run.
+                    do {
                       lock.withReadLock([&] {
                         results[index] = true;
                         std::this_thread::sleep_for(
                             std::chrono::milliseconds(5));
                       });
                       std::this_thread::sleep_for(std::chrono::milliseconds(1));
-                    }
+                    } while (!done);
                   },
                   [&] {
                     std::this_thread::sleep_for(std::chrono::milliseconds(100));
@@ -577,7 +578,7 @@ template <typename RW> void readLockWhileReadLockedThreaded(RW &lock) {
 
   lock.readUnlock();
 
-  for (auto result : results) {
+  for (auto &result : results) {
     ASSERT_TRUE(result);
   }
 }
@@ -595,28 +596,29 @@ TEST(StaticReadWriteLockTest, ReadLockWhileReadLockedThreaded) {
 template <typename RW> void readLockWhileWriteLockedThreaded(RW &lock) {
   lock.writeLock();
 
-  std::vector<int> results;
-  results.assign(10, 0);
+  std::vector<std::atomic<int>> results(10);
 
   std::atomic<bool> done(false);
   threadedExecute(10,
                   [&](int index) {
-                    while (!done) {
+                    // Always perform at least one iteration of this loop to
+                    // avoid spurious failures if this thread is slow to run.
+                    do {
                       lock.withReadLock([&] {
                         results[index] += 1;
                         std::this_thread::sleep_for(
                             std::chrono::milliseconds(5));
                       });
                       std::this_thread::sleep_for(std::chrono::milliseconds(1));
-                    }
+                    } while (!done);
                   },
                   [&] {
                     std::this_thread::sleep_for(std::chrono::milliseconds(100));
                     done = true;
                     lock.writeUnlock();
                   });
 
-  for (auto result : results) {
+  for (auto &result : results) {
     ASSERT_EQ(result, 1);
   }
 }
@@ -636,28 +638,29 @@ template <typename RW> void writeLockWhileReadLockedThreaded(RW &lock) {
 
   const int threadCount = 10;
 
-  std::vector<int> results;
-  results.assign(threadCount, 0);
+  std::vector<std::atomic<int>> results(threadCount);
 
   std::atomic<bool> done(false);
   threadedExecute(threadCount,
                   [&](int index) {
-                    while (!done) {
+                    // Always perform at least one iteration of this loop to
+                    // avoid spurious failures if this thread is slow to run.
+                    do {
                       lock.withWriteLock([&] {
                         results[index] += 1;
                         std::this_thread::sleep_for(
                             std::chrono::milliseconds(5));
                       });
                       std::this_thread::sleep_for(std::chrono::milliseconds(1));
-                    }
+                    } while (!done);
                   },
                   [&] {
                     std::this_thread::sleep_for(std::chrono::milliseconds(100));
                     done = true;
                     lock.readUnlock();
                   });
 
-  for (auto result : results) {
+  for (auto &result : results) {
     ASSERT_EQ(result, 1);
   }
 }
@@ -677,28 +680,29 @@ template <typename RW> void writeLockWhileWriteLockedThreaded(RW &lock) {
 
   const int threadCount = 10;
 
-  std::vector<int> results;
-  results.assign(threadCount, 0);
+  std::vector<std::atomic<int>> results(threadCount);
 
   std::atomic<bool> done(false);
   threadedExecute(threadCount,
                   [&](int index) {
-                    while (!done) {
+                    // Always perform at least one iteration of this loop to
+                    // avoid spurious failures if this thread is slow to run.
+                    do {
                       lock.withWriteLock([&] {
                         results[index] += 1;
                         std::this_thread::sleep_for(
                             std::chrono::milliseconds(5));
                       });
                       std::this_thread::sleep_for(std::chrono::milliseconds(1));
-                    }
+                    } while (!done);
                   },
                   [&] {
                     std::this_thread::sleep_for(std::chrono::milliseconds(100));
                     done = true;
                     lock.writeUnlock();
                   });
 
-  for (auto result : results) {
+  for (auto &result : results) {
     ASSERT_EQ(result, 1);
   }
 }
@@ -719,10 +723,12 @@ template <typename RW> void tryReadLockWhileWriteLockedThreaded(RW &lock) {
   std::atomic<bool> done(false);
   threadedExecute(10,
                   [&](int) {
-                    while (!done) {
+                    // Always perform at least one iteration of this loop to
+                    // avoid spurious failures if this thread is slow to run.
+                    do {
                       ASSERT_FALSE(lock.try_readLock());
                       std::this_thread::sleep_for(std::chrono::milliseconds(1));
-                    }
+                    } while (!done);
                   },
                   [&] {
                     std::this_thread::sleep_for(std::chrono::milliseconds(100));
@@ -747,19 +753,20 @@ template <typename RW> void tryReadLockWhileReadLockedThreaded(RW &lock) {
 
   const int threadCount = 10;
 
-  std::vector<bool> results;
-  results.assign(threadCount, false);
+  std::vector<std::atomic<bool>> results(threadCount);
 
   std::atomic<bool> done(false);
   threadedExecute(threadCount,
                   [&](int index) {
-                    while (!done) {
+                    // Always perform at least one iteration of this loop to
+                    // avoid spurious failures if this thread is slow to run.
+                    do {
                       ASSERT_TRUE(lock.try_readLock());
                       results[index] = true;
                       std::this_thread::sleep_for(std::chrono::milliseconds(5));
                       lock.readUnlock();
                       std::this_thread::sleep_for(std::chrono::milliseconds(1));
-                    }
+                    } while (!done);
                   },
                   [&] {
                     std::this_thread::sleep_for(std::chrono::milliseconds(100));
@@ -768,7 +775,7 @@ template <typename RW> void tryReadLockWhileReadLockedThreaded(RW &lock) {
 
   lock.readUnlock();
 
-  for (auto result : results) {
+  for (auto &result : results) {
     ASSERT_TRUE(result);
   }
 }
@@ -789,10 +796,12 @@ template <typename RW> void tryWriteLockWhileWriteLockedThreaded(RW &lock) {
   std::atomic<bool> done(false);
   threadedExecute(10,
                   [&](int) {
-                    while (!done) {
+                    // Always perform at least one iteration of this loop to
+                    // avoid spurious failures if this thread is slow to run.
+                    do {
                       ASSERT_FALSE(lock.try_writeLock());
                       std::this_thread::sleep_for(std::chrono::milliseconds(1));
-                    }
+                    } while (!done);
                   },
                   [&] {
                     std::this_thread::sleep_for(std::chrono::milliseconds(100));
@@ -818,10 +827,12 @@ template <typename RW> void tryWriteLockWhileReadLockedThreaded(RW &lock) {
   std::atomic<bool> done(false);
   threadedExecute(10,
                   [&](int) {
-                    while (!done) {
+                    // Always perform at least one iteration of this loop to
+                    // avoid spurious failures if this thread is slow to run.
+                    do {
                       ASSERT_FALSE(lock.try_writeLock());
                       std::this_thread::sleep_for(std::chrono::milliseconds(1));
-                    }
+                    } while (!done);
                   },
                   [&] {
                     std::this_thread::sleep_for(std::chrono::milliseconds(100));