mirror of
https://gitlab.com/libeigen/eigen.git
synced 2025-07-30 00:32:01 +08:00
6560692c67
The current algorithm requires threads to commit/cancel waiting in order they called Prewait. Spinning caused by that serialization can consume lots of CPU time on some workloads. Restructure the algorithm to not require that serialization and remove spin waits from Commit/CancelWait. Note: this reduces max number of threads from 2^16 to 2^14 to leave more space for ABA counter (which is now 22 bits). Implementation details are explained in comments.
476 lines
16 KiB
C++
476 lines
16 KiB
C++
// This file is part of Eigen, a lightweight C++ template library
|
|
// for linear algebra.
|
|
//
|
|
// Copyright (C) 2016 Dmitry Vyukov <dvyukov@google.com>
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla
|
|
// Public License v. 2.0. If a copy of the MPL was not distributed
|
|
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
#ifndef EIGEN_CXX11_THREADPOOL_NONBLOCKING_THREAD_POOL_H
|
|
#define EIGEN_CXX11_THREADPOOL_NONBLOCKING_THREAD_POOL_H
|
|
|
|
namespace Eigen {
|
|
|
|
template <typename Environment>
|
|
class ThreadPoolTempl : public Eigen::ThreadPoolInterface {
|
|
public:
|
|
typedef typename Environment::Task Task;
|
|
typedef RunQueue<Task, 1024> Queue;
|
|
|
|
ThreadPoolTempl(int num_threads, Environment env = Environment())
|
|
: ThreadPoolTempl(num_threads, true, env) {}
|
|
|
|
ThreadPoolTempl(int num_threads, bool allow_spinning,
|
|
Environment env = Environment())
|
|
: env_(env),
|
|
num_threads_(num_threads),
|
|
allow_spinning_(allow_spinning),
|
|
thread_data_(num_threads),
|
|
all_coprimes_(num_threads),
|
|
waiters_(num_threads),
|
|
blocked_(0),
|
|
spinning_(0),
|
|
done_(false),
|
|
cancelled_(false),
|
|
ec_(waiters_) {
|
|
waiters_.resize(num_threads_);
|
|
// Calculate coprimes of all numbers [1, num_threads].
|
|
// Coprimes are used for random walks over all threads in Steal
|
|
// and NonEmptyQueueIndex. Iteration is based on the fact that if we take
|
|
// a random starting thread index t and calculate num_threads - 1 subsequent
|
|
// indices as (t + coprime) % num_threads, we will cover all threads without
|
|
// repetitions (effectively getting a presudo-random permutation of thread
|
|
// indices).
|
|
eigen_plain_assert(num_threads_ < kMaxThreads);
|
|
for (int i = 1; i <= num_threads_; ++i) {
|
|
all_coprimes_.emplace_back(i);
|
|
ComputeCoprimes(i, &all_coprimes_.back());
|
|
}
|
|
#ifndef EIGEN_THREAD_LOCAL
|
|
init_barrier_.reset(new Barrier(num_threads_));
|
|
#endif
|
|
thread_data_.resize(num_threads_);
|
|
for (int i = 0; i < num_threads_; i++) {
|
|
SetStealPartition(i, EncodePartition(0, num_threads_));
|
|
thread_data_[i].thread.reset(
|
|
env_.CreateThread([this, i]() { WorkerLoop(i); }));
|
|
}
|
|
#ifndef EIGEN_THREAD_LOCAL
|
|
// Wait for workers to initialize per_thread_map_. Otherwise we might race
|
|
// with them in Schedule or CurrentThreadId.
|
|
init_barrier_->Wait();
|
|
#endif
|
|
}
|
|
|
|
~ThreadPoolTempl() {
|
|
done_ = true;
|
|
|
|
// Now if all threads block without work, they will start exiting.
|
|
// But note that threads can continue to work arbitrary long,
|
|
// block, submit new work, unblock and otherwise live full life.
|
|
if (!cancelled_) {
|
|
ec_.Notify(true);
|
|
} else {
|
|
// Since we were cancelled, there might be entries in the queues.
|
|
// Empty them to prevent their destructor from asserting.
|
|
for (size_t i = 0; i < thread_data_.size(); i++) {
|
|
thread_data_[i].queue.Flush();
|
|
}
|
|
}
|
|
// Join threads explicitly (by destroying) to avoid destruction order within
|
|
// this class.
|
|
for (size_t i = 0; i < thread_data_.size(); ++i)
|
|
thread_data_[i].thread.reset();
|
|
}
|
|
|
|
void SetStealPartitions(const std::vector<std::pair<unsigned, unsigned>>& partitions) {
|
|
eigen_plain_assert(partitions.size() == static_cast<std::size_t>(num_threads_));
|
|
|
|
// Pass this information to each thread queue.
|
|
for (int i = 0; i < num_threads_; i++) {
|
|
const auto& pair = partitions[i];
|
|
unsigned start = pair.first, end = pair.second;
|
|
AssertBounds(start, end);
|
|
unsigned val = EncodePartition(start, end);
|
|
SetStealPartition(i, val);
|
|
}
|
|
}
|
|
|
|
void Schedule(std::function<void()> fn) EIGEN_OVERRIDE {
|
|
ScheduleWithHint(std::move(fn), 0, num_threads_);
|
|
}
|
|
|
|
void ScheduleWithHint(std::function<void()> fn, int start,
|
|
int limit) override {
|
|
Task t = env_.CreateTask(std::move(fn));
|
|
PerThread* pt = GetPerThread();
|
|
if (pt->pool == this) {
|
|
// Worker thread of this pool, push onto the thread's queue.
|
|
Queue& q = thread_data_[pt->thread_id].queue;
|
|
t = q.PushFront(std::move(t));
|
|
} else {
|
|
// A free-standing thread (or worker of another pool), push onto a random
|
|
// queue.
|
|
eigen_plain_assert(start < limit);
|
|
eigen_plain_assert(limit <= num_threads_);
|
|
int num_queues = limit - start;
|
|
int rnd = Rand(&pt->rand) % num_queues;
|
|
eigen_plain_assert(start + rnd < limit);
|
|
Queue& q = thread_data_[start + rnd].queue;
|
|
t = q.PushBack(std::move(t));
|
|
}
|
|
// Note: below we touch this after making w available to worker threads.
|
|
// Strictly speaking, this can lead to a racy-use-after-free. Consider that
|
|
// Schedule is called from a thread that is neither main thread nor a worker
|
|
// thread of this pool. Then, execution of w directly or indirectly
|
|
// completes overall computations, which in turn leads to destruction of
|
|
// this. We expect that such scenario is prevented by program, that is,
|
|
// this is kept alive while any threads can potentially be in Schedule.
|
|
if (!t.f) {
|
|
ec_.Notify(false);
|
|
} else {
|
|
env_.ExecuteTask(t); // Push failed, execute directly.
|
|
}
|
|
}
|
|
|
|
void Cancel() EIGEN_OVERRIDE {
|
|
cancelled_ = true;
|
|
done_ = true;
|
|
|
|
// Let each thread know it's been cancelled.
|
|
#ifdef EIGEN_THREAD_ENV_SUPPORTS_CANCELLATION
|
|
for (size_t i = 0; i < thread_data_.size(); i++) {
|
|
thread_data_[i].thread->OnCancel();
|
|
}
|
|
#endif
|
|
|
|
// Wake up the threads without work to let them exit on their own.
|
|
ec_.Notify(true);
|
|
}
|
|
|
|
int NumThreads() const EIGEN_FINAL { return num_threads_; }
|
|
|
|
int CurrentThreadId() const EIGEN_FINAL {
|
|
const PerThread* pt = const_cast<ThreadPoolTempl*>(this)->GetPerThread();
|
|
if (pt->pool == this) {
|
|
return pt->thread_id;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
private:
|
|
// Create a single atomic<int> that encodes start and limit information for
|
|
// each thread.
|
|
// We expect num_threads_ < 65536, so we can store them in a single
|
|
// std::atomic<unsigned>.
|
|
// Exposed publicly as static functions so that external callers can reuse
|
|
// this encode/decode logic for maintaining their own thread-safe copies of
|
|
// scheduling and steal domain(s).
|
|
static const int kMaxPartitionBits = 16;
|
|
static const int kMaxThreads = 1 << kMaxPartitionBits;
|
|
|
|
inline unsigned EncodePartition(unsigned start, unsigned limit) {
|
|
return (start << kMaxPartitionBits) | limit;
|
|
}
|
|
|
|
inline void DecodePartition(unsigned val, unsigned* start, unsigned* limit) {
|
|
*limit = val & (kMaxThreads - 1);
|
|
val >>= kMaxPartitionBits;
|
|
*start = val;
|
|
}
|
|
|
|
void AssertBounds(int start, int end) {
|
|
eigen_plain_assert(start >= 0);
|
|
eigen_plain_assert(start < end); // non-zero sized partition
|
|
eigen_plain_assert(end <= num_threads_);
|
|
}
|
|
|
|
inline void SetStealPartition(size_t i, unsigned val) {
|
|
thread_data_[i].steal_partition.store(val, std::memory_order_relaxed);
|
|
}
|
|
|
|
inline unsigned GetStealPartition(int i) {
|
|
return thread_data_[i].steal_partition.load(std::memory_order_relaxed);
|
|
}
|
|
|
|
void ComputeCoprimes(int N, MaxSizeVector<unsigned>* coprimes) {
|
|
for (int i = 1; i <= N; i++) {
|
|
unsigned a = i;
|
|
unsigned b = N;
|
|
// If GCD(a, b) == 1, then a and b are coprimes.
|
|
while (b != 0) {
|
|
unsigned tmp = a;
|
|
a = b;
|
|
b = tmp % b;
|
|
}
|
|
if (a == 1) {
|
|
coprimes->push_back(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
typedef typename Environment::EnvThread Thread;
|
|
|
|
struct PerThread {
|
|
constexpr PerThread() : pool(NULL), rand(0), thread_id(-1) {}
|
|
ThreadPoolTempl* pool; // Parent pool, or null for normal threads.
|
|
uint64_t rand; // Random generator state.
|
|
int thread_id; // Worker thread index in pool.
|
|
#ifndef EIGEN_THREAD_LOCAL
|
|
// Prevent false sharing.
|
|
char pad_[128];
|
|
#endif
|
|
};
|
|
|
|
struct ThreadData {
|
|
constexpr ThreadData() : thread(), steal_partition(0), queue() {}
|
|
std::unique_ptr<Thread> thread;
|
|
std::atomic<unsigned> steal_partition;
|
|
Queue queue;
|
|
};
|
|
|
|
Environment env_;
|
|
const int num_threads_;
|
|
const bool allow_spinning_;
|
|
MaxSizeVector<ThreadData> thread_data_;
|
|
MaxSizeVector<MaxSizeVector<unsigned>> all_coprimes_;
|
|
MaxSizeVector<EventCount::Waiter> waiters_;
|
|
std::atomic<unsigned> blocked_;
|
|
std::atomic<bool> spinning_;
|
|
std::atomic<bool> done_;
|
|
std::atomic<bool> cancelled_;
|
|
EventCount ec_;
|
|
#ifndef EIGEN_THREAD_LOCAL
|
|
std::unique_ptr<Barrier> init_barrier_;
|
|
std::mutex per_thread_map_mutex_; // Protects per_thread_map_.
|
|
std::unordered_map<uint64_t, std::unique_ptr<PerThread>> per_thread_map_;
|
|
#endif
|
|
|
|
// Main worker thread loop.
|
|
void WorkerLoop(int thread_id) {
|
|
#ifndef EIGEN_THREAD_LOCAL
|
|
std::unique_ptr<PerThread> new_pt(new PerThread());
|
|
per_thread_map_mutex_.lock();
|
|
eigen_plain_assert(per_thread_map_.emplace(GlobalThreadIdHash(), std::move(new_pt)).second);
|
|
per_thread_map_mutex_.unlock();
|
|
init_barrier_->Notify();
|
|
init_barrier_->Wait();
|
|
#endif
|
|
PerThread* pt = GetPerThread();
|
|
pt->pool = this;
|
|
pt->rand = GlobalThreadIdHash();
|
|
pt->thread_id = thread_id;
|
|
Queue& q = thread_data_[thread_id].queue;
|
|
EventCount::Waiter* waiter = &waiters_[thread_id];
|
|
// TODO(dvyukov,rmlarsen): The time spent in NonEmptyQueueIndex() is
|
|
// proportional to num_threads_ and we assume that new work is scheduled at
|
|
// a constant rate, so we set spin_count to 5000 / num_threads_. The
|
|
// constant was picked based on a fair dice roll, tune it.
|
|
const int spin_count =
|
|
allow_spinning_ && num_threads_ > 0 ? 5000 / num_threads_ : 0;
|
|
if (num_threads_ == 1) {
|
|
// For num_threads_ == 1 there is no point in going through the expensive
|
|
// steal loop. Moreover, since NonEmptyQueueIndex() calls PopBack() on the
|
|
// victim queues it might reverse the order in which ops are executed
|
|
// compared to the order in which they are scheduled, which tends to be
|
|
// counter-productive for the types of I/O workloads the single thread
|
|
// pools tend to be used for.
|
|
while (!cancelled_) {
|
|
Task t = q.PopFront();
|
|
for (int i = 0; i < spin_count && !t.f; i++) {
|
|
if (!cancelled_.load(std::memory_order_relaxed)) {
|
|
t = q.PopFront();
|
|
}
|
|
}
|
|
if (!t.f) {
|
|
if (!WaitForWork(waiter, &t)) {
|
|
return;
|
|
}
|
|
}
|
|
if (t.f) {
|
|
env_.ExecuteTask(t);
|
|
}
|
|
}
|
|
} else {
|
|
while (!cancelled_) {
|
|
Task t = q.PopFront();
|
|
if (!t.f) {
|
|
t = LocalSteal();
|
|
if (!t.f) {
|
|
t = GlobalSteal();
|
|
if (!t.f) {
|
|
// Leave one thread spinning. This reduces latency.
|
|
if (allow_spinning_ && !spinning_ && !spinning_.exchange(true)) {
|
|
for (int i = 0; i < spin_count && !t.f; i++) {
|
|
if (!cancelled_.load(std::memory_order_relaxed)) {
|
|
t = GlobalSteal();
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
spinning_ = false;
|
|
}
|
|
if (!t.f) {
|
|
if (!WaitForWork(waiter, &t)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (t.f) {
|
|
env_.ExecuteTask(t);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Steal tries to steal work from other worker threads in the range [start,
|
|
// limit) in best-effort manner.
|
|
Task Steal(unsigned start, unsigned limit) {
|
|
PerThread* pt = GetPerThread();
|
|
const size_t size = limit - start;
|
|
unsigned r = Rand(&pt->rand);
|
|
unsigned victim = r % size;
|
|
unsigned inc = all_coprimes_[size - 1][r % all_coprimes_[size - 1].size()];
|
|
|
|
for (unsigned i = 0; i < size; i++) {
|
|
eigen_plain_assert(start + victim < limit);
|
|
Task t = thread_data_[start + victim].queue.PopBack();
|
|
if (t.f) {
|
|
return t;
|
|
}
|
|
victim += inc;
|
|
if (victim >= size) {
|
|
victim -= size;
|
|
}
|
|
}
|
|
return Task();
|
|
}
|
|
|
|
// Steals work within threads belonging to the partition.
|
|
Task LocalSteal() {
|
|
PerThread* pt = GetPerThread();
|
|
unsigned partition = GetStealPartition(pt->thread_id);
|
|
unsigned start, limit;
|
|
DecodePartition(partition, &start, &limit);
|
|
AssertBounds(start, limit);
|
|
|
|
return Steal(start, limit);
|
|
}
|
|
|
|
// Steals work from any other thread in the pool.
|
|
Task GlobalSteal() {
|
|
return Steal(0, num_threads_);
|
|
}
|
|
|
|
|
|
// WaitForWork blocks until new work is available (returns true), or if it is
|
|
// time to exit (returns false). Can optionally return a task to execute in t
|
|
// (in such case t.f != nullptr on return).
|
|
bool WaitForWork(EventCount::Waiter* waiter, Task* t) {
|
|
eigen_plain_assert(!t->f);
|
|
// We already did best-effort emptiness check in Steal, so prepare for
|
|
// blocking.
|
|
if (!ec_.Prewait()) return true;
|
|
// Now do a reliable emptiness check.
|
|
int victim = NonEmptyQueueIndex();
|
|
if (victim != -1) {
|
|
ec_.CancelWait();
|
|
if (cancelled_) {
|
|
return false;
|
|
} else {
|
|
*t = thread_data_[victim].queue.PopBack();
|
|
return true;
|
|
}
|
|
}
|
|
// Number of blocked threads is used as termination condition.
|
|
// If we are shutting down and all worker threads blocked without work,
|
|
// that's we are done.
|
|
blocked_++;
|
|
// TODO is blocked_ required to be unsigned?
|
|
if (done_ && blocked_ == static_cast<unsigned>(num_threads_)) {
|
|
ec_.CancelWait();
|
|
// Almost done, but need to re-check queues.
|
|
// Consider that all queues are empty and all worker threads are preempted
|
|
// right after incrementing blocked_ above. Now a free-standing thread
|
|
// submits work and calls destructor (which sets done_). If we don't
|
|
// re-check queues, we will exit leaving the work unexecuted.
|
|
if (NonEmptyQueueIndex() != -1) {
|
|
// Note: we must not pop from queues before we decrement blocked_,
|
|
// otherwise the following scenario is possible. Consider that instead
|
|
// of checking for emptiness we popped the only element from queues.
|
|
// Now other worker threads can start exiting, which is bad if the
|
|
// work item submits other work. So we just check emptiness here,
|
|
// which ensures that all worker threads exit at the same time.
|
|
blocked_--;
|
|
return true;
|
|
}
|
|
// Reached stable termination state.
|
|
ec_.Notify(true);
|
|
return false;
|
|
}
|
|
ec_.CommitWait(waiter);
|
|
blocked_--;
|
|
return true;
|
|
}
|
|
|
|
int NonEmptyQueueIndex() {
|
|
PerThread* pt = GetPerThread();
|
|
// We intentionally design NonEmptyQueueIndex to steal work from
|
|
// anywhere in the queue so threads don't block in WaitForWork() forever
|
|
// when all threads in their partition go to sleep. Steal is still local.
|
|
const size_t size = thread_data_.size();
|
|
unsigned r = Rand(&pt->rand);
|
|
unsigned inc = all_coprimes_[size - 1][r % all_coprimes_[size - 1].size()];
|
|
unsigned victim = r % size;
|
|
for (unsigned i = 0; i < size; i++) {
|
|
if (!thread_data_[victim].queue.Empty()) {
|
|
return victim;
|
|
}
|
|
victim += inc;
|
|
if (victim >= size) {
|
|
victim -= size;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static EIGEN_STRONG_INLINE uint64_t GlobalThreadIdHash() {
|
|
return std::hash<std::thread::id>()(std::this_thread::get_id());
|
|
}
|
|
|
|
EIGEN_STRONG_INLINE PerThread* GetPerThread() {
|
|
#ifndef EIGEN_THREAD_LOCAL
|
|
static PerThread dummy;
|
|
auto it = per_thread_map_.find(GlobalThreadIdHash());
|
|
if (it == per_thread_map_.end()) {
|
|
return &dummy;
|
|
} else {
|
|
return it->second.get();
|
|
}
|
|
#else
|
|
EIGEN_THREAD_LOCAL PerThread per_thread_;
|
|
PerThread* pt = &per_thread_;
|
|
return pt;
|
|
#endif
|
|
}
|
|
|
|
static EIGEN_STRONG_INLINE unsigned Rand(uint64_t* state) {
|
|
uint64_t current = *state;
|
|
// Update the internal state
|
|
*state = current * 6364136223846793005ULL + 0xda3e39cb94b95bdbULL;
|
|
// Generate the random output (using the PCG-XSH-RS scheme)
|
|
return static_cast<unsigned>((current ^ (current >> 22)) >>
|
|
(22 + (current >> 61)));
|
|
}
|
|
};
|
|
|
|
typedef ThreadPoolTempl<StlThreadEnvironment> ThreadPool;
|
|
|
|
} // namespace Eigen
|
|
|
|
#endif // EIGEN_CXX11_THREADPOOL_NONBLOCKING_THREAD_POOL_H
|