unittests/Support/ThreadPool.cpp

   1 //========- unittests/Support/ThreadPools.cpp - ThreadPools.h tests --========//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/Support/ThreadPool.h"
  11
  12 #include "llvm/ADT/STLExtras.h"
  13 #include "llvm/ADT/SmallVector.h"
  14 #include "llvm/ADT/Triple.h"
  15 #include "llvm/Support/Host.h"
  16 #include "llvm/Support/TargetSelect.h"
  17
  18 #include "gtest/gtest.h"
  19
  20 using namespace llvm;
  21
  22 // Fixture for the unittests, allowing to *temporarily* disable the unittests
  23 // on a particular platform
  24 class ThreadPoolTest : public testing::Test {
  25   Triple Host;
  26   SmallVector<Triple::ArchType, 4> UnsupportedArchs;
  27   SmallVector<Triple::OSType, 4> UnsupportedOSs;
  28   SmallVector<Triple::EnvironmentType, 1> UnsupportedEnvironments;
  29 protected:
  30   // This is intended for platform as a temporary "XFAIL"
  31   bool isUnsupportedOSOrEnvironment() {
  32     Triple Host(Triple::normalize(sys::getProcessTriple()));
  33
  34     if (std::find(UnsupportedEnvironments.begin(), UnsupportedEnvironments.end(),
  35                   Host.getEnvironment()) != UnsupportedEnvironments.end())
  36       return true;
  37
  38     if (std::find(UnsupportedOSs.begin(), UnsupportedOSs.end(), Host.getOS())
  39         != UnsupportedOSs.end())
  40       return true;
  41
  42     if (std::find(UnsupportedArchs.begin(), UnsupportedArchs.end(), Host.getArch())
  43         != UnsupportedArchs.end())
  44       return true;
  45
  46     return false;
  47   }
  48
  49   ThreadPoolTest() {
  50     // Add unsupported configuration here, example:
  51     //   UnsupportedArchs.push_back(Triple::x86_64);
  52
  53     // See https://llvm.org/bugs/show_bug.cgi?id=25829
  54     UnsupportedArchs.push_back(Triple::ppc64le);
  55     UnsupportedArchs.push_back(Triple::ppc64);
  56   }
  57
  58   /// Make sure this thread not progress faster than the main thread.
  59   void waitForMainThread() {
  60     while (!MainThreadReady) {
  61       std::unique_lock<std::mutex> LockGuard(WaitMainThreadMutex);
  62       WaitMainThread.wait(LockGuard, [&] { return MainThreadReady; });
  63     }
  64   }
  65
  66   /// Set the readiness of the main thread.
  67   void setMainThreadReadyState(bool Ready) {
  68     std::unique_lock<std::mutex> LockGuard(WaitMainThreadMutex);
  69     MainThreadReady = Ready;
  70     WaitMainThread.notify_all();
  71   }
  72
  73   std::condition_variable WaitMainThread;
  74   std::mutex WaitMainThreadMutex;
  75   bool MainThreadReady;
  76
  77 };
  78
  79 #define CHECK_UNSUPPORTED() \
  80   do { \
  81     if (isUnsupportedOSOrEnvironment()) \
  82       return; \
  83   } while (0); \
  84
  85 TEST_F(ThreadPoolTest, AsyncBarrier) {
  86   CHECK_UNSUPPORTED();
  87   // test that async & barrier work together properly.
  88
  89   std::atomic_int checked_in{0};
  90
  91   setMainThreadReadyState(false);
  92   ThreadPool Pool;
  93   for (size_t i = 0; i < 5; ++i) {
  94     Pool.async([this, &checked_in, i] {
  95       waitForMainThread();
  96       ++checked_in;
  97     });
  98   }
  99   ASSERT_EQ(0, checked_in);
 100   setMainThreadReadyState(true);
 101   Pool.wait();
 102   ASSERT_EQ(5, checked_in);
 103 }
 104
 105 static void TestFunc(std::atomic_int &checked_in, int i) { checked_in += i; }
 106
 107 TEST_F(ThreadPoolTest, AsyncBarrierArgs) {
 108   CHECK_UNSUPPORTED();
 109   // Test that async works with a function requiring multiple parameters.
 110   std::atomic_int checked_in{0};
 111
 112   ThreadPool Pool;
 113   for (size_t i = 0; i < 5; ++i) {
 114     Pool.async(TestFunc, std::ref(checked_in), i);
 115   }
 116   Pool.wait();
 117   ASSERT_EQ(10, checked_in);
 118 }
 119
 120 TEST_F(ThreadPoolTest, Async) {
 121   CHECK_UNSUPPORTED();
 122   ThreadPool Pool;
 123   std::atomic_int i{0};
 124   setMainThreadReadyState(false);
 125   Pool.async([this, &i] {
 126     waitForMainThread();
 127     ++i;
 128   });
 129   Pool.async([&i] { ++i; });
 130   ASSERT_NE(2, i.load());
 131   setMainThreadReadyState(true);
 132   Pool.wait();
 133   ASSERT_EQ(2, i.load());
 134 }
 135
 136 TEST_F(ThreadPoolTest, GetFuture) {
 137   CHECK_UNSUPPORTED();
 138   ThreadPool Pool;
 139   std::atomic_int i{0};
 140   setMainThreadReadyState(false);
 141   Pool.async([this, &i] {
 142     waitForMainThread();
 143     ++i;
 144   });
 145   // Force the future using get()
 146   Pool.async([&i] { ++i; }).get();
 147   ASSERT_NE(2, i.load());
 148   setMainThreadReadyState(true);
 149   Pool.wait();
 150   ASSERT_EQ(2, i.load());
 151 }
 152
 153 TEST_F(ThreadPoolTest, PoolDestruction) {
 154   CHECK_UNSUPPORTED();
 155   // Test that we are waiting on destruction
 156   std::atomic_int checked_in{0};
 157   {
 158     setMainThreadReadyState(false);
 159     ThreadPool Pool;
 160     for (size_t i = 0; i < 5; ++i) {
 161       Pool.async([this, &checked_in, i] {
 162         waitForMainThread();
 163         ++checked_in;
 164       });
 165     }
 166     ASSERT_EQ(0, checked_in);
 167     setMainThreadReadyState(true);
 168   }
 169   ASSERT_EQ(5, checked_in);
 170 }