Re-reapply "[IR] Move optional data in llvm::Function into a hungoff uselist"
[oota-llvm.git] / 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   std::condition_variable WaitMainThread;
66   std::mutex WaitMainThreadMutex;
67   bool MainThreadReady;
68
69 };
70
71 #define CHECK_UNSUPPORTED() \
72   do { \
73     if (isUnsupportedOSOrEnvironment()) \
74       return; \
75   } while (0); \
76
77 TEST_F(ThreadPoolTest, AsyncBarrier) {
78   CHECK_UNSUPPORTED();
79   // test that async & barrier work together properly.
80
81   std::atomic_int checked_in{0};
82
83   MainThreadReady = false;
84   ThreadPool Pool;
85   for (size_t i = 0; i < 5; ++i) {
86     Pool.async([this, &checked_in, i] {
87       waitForMainThread();
88       ++checked_in;
89     });
90   }
91   ASSERT_EQ(0, checked_in);
92   MainThreadReady = true;
93   WaitMainThread.notify_all();
94   Pool.wait();
95   ASSERT_EQ(5, checked_in);
96 }
97
98 static void TestFunc(std::atomic_int &checked_in, int i) { checked_in += i; }
99
100 TEST_F(ThreadPoolTest, AsyncBarrierArgs) {
101   CHECK_UNSUPPORTED();
102   // Test that async works with a function requiring multiple parameters.
103   std::atomic_int checked_in{0};
104
105   ThreadPool Pool;
106   for (size_t i = 0; i < 5; ++i) {
107     Pool.async(TestFunc, std::ref(checked_in), i);
108   }
109   Pool.wait();
110   ASSERT_EQ(10, checked_in);
111 }
112
113 TEST_F(ThreadPoolTest, Async) {
114   CHECK_UNSUPPORTED();
115   ThreadPool Pool;
116   std::atomic_int i{0};
117   MainThreadReady = false;
118   Pool.async([this, &i] {
119     waitForMainThread();
120     ++i;
121   });
122   Pool.async([&i] { ++i; });
123   ASSERT_NE(2, i.load());
124   MainThreadReady = true;
125   WaitMainThread.notify_all();
126   Pool.wait();
127   ASSERT_EQ(2, i.load());
128 }
129
130 TEST_F(ThreadPoolTest, GetFuture) {
131   CHECK_UNSUPPORTED();
132   ThreadPool Pool;
133   std::atomic_int i{0};
134   MainThreadReady = false;
135   Pool.async([this, &i] {
136     waitForMainThread();
137     ++i;
138   });
139   // Force the future using get()
140   Pool.async([&i] { ++i; }).get();
141   ASSERT_NE(2, i.load());
142   MainThreadReady = true;
143   WaitMainThread.notify_all();
144   Pool.wait();
145   ASSERT_EQ(2, i.load());
146 }
147
148 TEST_F(ThreadPoolTest, PoolDestruction) {
149   CHECK_UNSUPPORTED();
150   // Test that we are waiting on destruction
151   std::atomic_int checked_in{0};
152   {
153     MainThreadReady = false;
154     ThreadPool Pool;
155     for (size_t i = 0; i < 5; ++i) {
156       Pool.async([this, &checked_in, i] {
157         waitForMainThread();
158         ++checked_in;
159       });
160     }
161     ASSERT_EQ(0, checked_in);
162     MainThreadReady = true;
163     WaitMainThread.notify_all();
164   }
165   ASSERT_EQ(5, checked_in);
166 }