mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 11:02:59 +02:00
ae65e281f3
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
101 lines
3.2 KiB
C++
101 lines
3.2 KiB
C++
//===-- llvm/Support/ThreadPool.h - A ThreadPool implementation -*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines a crude C++11 based thread pool.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_SUPPORT_THREAD_POOL_H
|
|
#define LLVM_SUPPORT_THREAD_POOL_H
|
|
|
|
#include "llvm/Config/llvm-config.h"
|
|
#include "llvm/Support/thread.h"
|
|
|
|
#include <future>
|
|
|
|
#include <atomic>
|
|
#include <condition_variable>
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <queue>
|
|
#include <utility>
|
|
|
|
namespace llvm {
|
|
|
|
/// A ThreadPool for asynchronous parallel execution on a defined number of
|
|
/// threads.
|
|
///
|
|
/// The pool keeps a vector of threads alive, waiting on a condition variable
|
|
/// for some work to become available.
|
|
class ThreadPool {
|
|
public:
|
|
using TaskTy = std::function<void()>;
|
|
using PackagedTaskTy = std::packaged_task<void()>;
|
|
|
|
/// Construct a pool with the number of threads found by
|
|
/// hardware_concurrency().
|
|
ThreadPool();
|
|
|
|
/// Construct a pool of \p ThreadCount threads
|
|
ThreadPool(unsigned ThreadCount);
|
|
|
|
/// Blocking destructor: the pool will wait for all the threads to complete.
|
|
~ThreadPool();
|
|
|
|
/// Asynchronous submission of a task to the pool. The returned future can be
|
|
/// used to wait for the task to finish and is *non-blocking* on destruction.
|
|
template <typename Function, typename... Args>
|
|
inline std::shared_future<void> async(Function &&F, Args &&... ArgList) {
|
|
auto Task =
|
|
std::bind(std::forward<Function>(F), std::forward<Args>(ArgList)...);
|
|
return asyncImpl(std::move(Task));
|
|
}
|
|
|
|
/// Asynchronous submission of a task to the pool. The returned future can be
|
|
/// used to wait for the task to finish and is *non-blocking* on destruction.
|
|
template <typename Function>
|
|
inline std::shared_future<void> async(Function &&F) {
|
|
return asyncImpl(std::forward<Function>(F));
|
|
}
|
|
|
|
/// Blocking wait for all the threads to complete and the queue to be empty.
|
|
/// It is an error to try to add new tasks while blocking on this call.
|
|
void wait();
|
|
|
|
private:
|
|
/// Asynchronous submission of a task to the pool. The returned future can be
|
|
/// used to wait for the task to finish and is *non-blocking* on destruction.
|
|
std::shared_future<void> asyncImpl(TaskTy F);
|
|
|
|
/// Threads in flight
|
|
std::vector<llvm::thread> Threads;
|
|
|
|
/// Tasks waiting for execution in the pool.
|
|
std::queue<PackagedTaskTy> Tasks;
|
|
|
|
/// Locking and signaling for accessing the Tasks queue.
|
|
std::mutex QueueLock;
|
|
std::condition_variable QueueCondition;
|
|
|
|
/// Locking and signaling for job completion
|
|
std::mutex CompletionLock;
|
|
std::condition_variable CompletionCondition;
|
|
|
|
/// Keep track of the number of thread actually busy
|
|
std::atomic<unsigned> ActiveThreads;
|
|
|
|
#if LLVM_ENABLE_THREADS // avoids warning for unused variable
|
|
/// Signal for the destruction of the pool, asking thread to exit.
|
|
bool EnableFlag;
|
|
#endif
|
|
};
|
|
}
|
|
|
|
#endif // LLVM_SUPPORT_THREAD_POOL_H
|