mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-23 21:13:02 +02:00
54fc055738
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. This is a recommit of r255444 ; trying to workaround a bug in the MSVC 2013 standard library. I think I was hit by: http://connect.microsoft.com/VisualStudio/feedbackdetail/view/791185/std-packaged-task-t-where-t-is-void-or-a-reference-class-are-not-movable Recommit of r255589, trying to please g++ as well. Differential Revision: http://reviews.llvm.org/D15464 From: mehdi_amini <mehdi_amini@91177308-0d34-0410-b5e6-96231b3b80d8> llvm-svn: 255593
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);
|
|
}
|