mirror of
https://github.com/RPCS3/llvm.git
synced 2025-04-05 14:52:02 +00:00
517dd66ae3
This is a very simple implementation of a thread pool using C++11 thread. It accepts any std::function<void()> for asynchronous execution. Individual task can be synchronize using the returned future, or the client can block on the full queue completion. In case LLVM is configured with Threading disabled, it falls back to sequential execution using std::async with launch:deferred. This is intended to support parallelism for ThinLTO processing in linker plugin, but is generic enough for any other uses. Differential Revision: http://reviews.llvm.org/D15464 From: Mehdi Amini <mehdi.amini@apple.com> git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@255444 91177308-0d34-0410-b5e6-96231b3b80d8
92 lines
2.0 KiB
C++
92 lines
2.0 KiB
C++
//========- unittests/Support/ThreadPools.cpp - ThreadPools.h tests --========//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Support/ThreadPool.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
using namespace llvm;
|
|
using namespace std::chrono;
|
|
|
|
/// Try best to make this thread not progress faster than the main thread
|
|
static void yield() {
|
|
#ifdef LLVM_ENABLE_THREADS
|
|
std::this_thread::yield();
|
|
#endif
|
|
std::this_thread::sleep_for(milliseconds(200));
|
|
#ifdef LLVM_ENABLE_THREADS
|
|
std::this_thread::yield();
|
|
#endif
|
|
}
|
|
|
|
TEST(ThreadPoolTest, AsyncBarrier) {
|
|
// test that async & barrier work together properly.
|
|
|
|
std::atomic_int checked_in{0};
|
|
|
|
ThreadPool Pool;
|
|
for (size_t i = 0; i < 5; ++i) {
|
|
Pool.async([&checked_in, i] {
|
|
yield();
|
|
++checked_in;
|
|
});
|
|
}
|
|
ASSERT_EQ(0, checked_in);
|
|
Pool.wait();
|
|
ASSERT_EQ(5, checked_in);
|
|
}
|
|
|
|
TEST(ThreadPoolTest, Async) {
|
|
ThreadPool Pool;
|
|
std::atomic_int i{0};
|
|
// sleep here just to ensure that the not-equal is correct.
|
|
Pool.async([&i] {
|
|
yield();
|
|
++i;
|
|
});
|
|
Pool.async([&i] { ++i; });
|
|
ASSERT_NE(2, i.load());
|
|
Pool.wait();
|
|
ASSERT_EQ(2, i.load());
|
|
}
|
|
|
|
TEST(ThreadPoolTest, GetFuture) {
|
|
ThreadPool Pool;
|
|
std::atomic_int i{0};
|
|
// sleep here just to ensure that the not-equal is correct.
|
|
Pool.async([&i] {
|
|
yield();
|
|
++i;
|
|
});
|
|
// Force the future using get()
|
|
Pool.async([&i] { ++i; }).get();
|
|
ASSERT_NE(2, i.load());
|
|
Pool.wait();
|
|
ASSERT_EQ(2, i.load());
|
|
}
|
|
|
|
TEST(ThreadPoolTest, PoolDestruction) {
|
|
// Test that we are waiting on destruction
|
|
std::atomic_int checked_in{0};
|
|
|
|
{
|
|
ThreadPool Pool;
|
|
for (size_t i = 0; i < 5; ++i) {
|
|
Pool.async([&checked_in, i] {
|
|
yield();
|
|
++checked_in;
|
|
});
|
|
}
|
|
ASSERT_EQ(0, checked_in);
|
|
}
|
|
ASSERT_EQ(5, checked_in);
|
|
}
|