[Syntax] ThreadSafeCachingTests: Use a thread pool

Instead of spawning a thread across test iterations (whoops, out of
threads), use a thread pool of size 2. When turning off atomic caching,
this is enough to trigger a race in 5 iterations or fewer for me, so
10000 ought to be enough for most machines.

This should fix hitting the thread limit on Linux.

rdar://problem/30729901

Author: bitjammer

unittests/Syntax/ThreadSafeCachingTests.cpp

@@ -4,18 +4,78 @@
 #include "llvm/ADT/SmallString.h"
 #include "gtest/gtest.h"
 
+#include <future>
 #include <thread>
+#include <queue>
 
 using namespace swift;
 using namespace swift::syntax;
 
-static void getExpressionFrom(ReturnStmtSyntax Return,
-                              uintptr_t *DataPointer) {
+static uintptr_t getExpressionFrom(ReturnStmtSyntax Return) {
   auto Expression = Return.getExpression().getValue();
-  auto Data = Expression.getDataPointer();
-  *DataPointer = reinterpret_cast<uintptr_t>(Data);
+  return reinterpret_cast<uintptr_t>(Expression.getDataPointer());
 }
 
+class Pool {
+  static constexpr size_t NumThreads = 2;
+  using FuncTy = std::function<uintptr_t(ReturnStmtSyntax)>;
+  std::vector<std::thread> Workers;
+  std::queue<std::function<void()>> Tasks;
+  std::mutex QueueLock;
+  std::condition_variable Condition;
+  bool Stop;
+
+public:
+  Pool() : Stop(false) {
+    for(size_t i = 0; i < NumThreads; ++i)
+      Workers.emplace_back([this] {
+        while (true) {
+          std::function<void()> Task;
+          {
+            std::unique_lock<std::mutex> L(QueueLock);
+
+            Condition.wait(L, [this]{
+              return Stop || !Tasks.empty();
+            });
+
+            if(Stop && Tasks.empty()) {
+              return;
+            }
+
+            Task = std::move(Tasks.front());
+            Tasks.pop();
+          }
+
+          Task();
+        }
+      });
+  }
+
+  std::future<uintptr_t> run(FuncTy Func, ReturnStmtSyntax Return) {
+    auto Task = std::make_shared<std::packaged_task<uintptr_t()>>(
+      std::bind(Func, Return));
+
+    auto Future = Task->get_future();
+    {
+      std::unique_lock<std::mutex> L(QueueLock);
+      Tasks.emplace([Task](){ (*Task)(); });
+    }
+    Condition.notify_one();
+    return Future;
+  }
+
+  ~Pool() {
+    {
+      std::lock_guard<std::mutex> L(QueueLock);
+      Stop = true;
+    }
+    Condition.notify_all();
+    for(auto &Worker : Workers) {
+      Worker.join();
+    }
+  }
+};
+
 // Tests that, when multiple threads ask for a child node of the same syntax
 // node:
 // - Only one thread inserts the realized child into the parent
@@ -26,29 +86,22 @@ TEST(ThreadSafeCachingTests, ReturnGetExpression) {
   auto One = SyntaxFactory::makeIntegerLiteralToken("1", {}, {});
   auto MinusOne = SyntaxFactory::makeIntegerLiteralExpr(Minus, One);
 
+  Pool P;
+
   for (unsigned i = 0; i < 10000; ++i) {
-    llvm::SmallString<48> Scratch;
-    llvm::raw_svector_ostream OS(Scratch);
     auto Return = SyntaxFactory::makeReturnStmt(ReturnKW, MinusOne);
 
-    uintptr_t FirstDataPointer;
-    uintptr_t SecondDataPointer;
+    auto Future1 = P.run(getExpressionFrom, Return);
+    auto Future2 = P.run(getExpressionFrom, Return);
 
-    std::thread first(getExpressionFrom, Return, &FirstDataPointer);
-    std::thread second(getExpressionFrom, Return, &SecondDataPointer);
-    first.join();
-    second.join();
+    auto FirstDataPointer = Future1.get();
+    auto SecondDataPointer = Future2.get();
 
     auto DataPointer = reinterpret_cast<uintptr_t>(
       Return.getExpression().getValue().getDataPointer());
 
     ASSERT_EQ(FirstDataPointer, SecondDataPointer);
     ASSERT_EQ(FirstDataPointer, DataPointer);
-
-    if (FirstDataPointer != SecondDataPointer ||
-        FirstDataPointer != DataPointer) {
-      break;
-    }
   }
 }