Inheritance diagram for Eigen::ThreadPoolTempl< Environment >:

Classes
struct	PerThread

struct	ThreadData

Public Types
typedef RunQueue< Task, 1024 >	Queue

typedef Environment::Task	Task

Public Member Functions
void	Cancel () EIGEN_OVERRIDE

int	CurrentThreadId () const EIGEN_FINAL

int	NumThreads () const EIGEN_FINAL

void	Schedule (std::function< void()> fn) EIGEN_OVERRIDE

void	ScheduleWithHint (std::function< void()> fn, int start, int limit) override

void	SetStealPartitions (const std::vector< std::pair< unsigned, unsigned >> &partitions)

	ThreadPoolTempl (int num_threads, bool allow_spinning, Environment env=Environment())

	ThreadPoolTempl (int num_threads, Environment env=Environment())

	~ThreadPoolTempl ()

Public Member Functions inherited from Eigen::ThreadPoolInterface
virtual	~ThreadPoolInterface ()

Private Types
typedef Environment::EnvThread	Thread

Private Member Functions
void	AssertBounds (int start, int end)

void	ComputeCoprimes (int N, MaxSizeVector< unsigned > *coprimes)

void	DecodePartition (unsigned val, unsigned start, unsigned limit)

unsigned	EncodePartition (unsigned start, unsigned limit)

PerThread *	GetPerThread ()

unsigned	GetStealPartition (int i)

Task	GlobalSteal ()

Task	LocalSteal ()

int	NonEmptyQueueIndex ()

void	SetStealPartition (size_t i, unsigned val)

Task	Steal (unsigned start, unsigned limit)

bool	WaitForWork (EventCount::Waiter waiter, Task t)

void	WorkerLoop (int thread_id)

Static Private Member Functions
static uint64_t	GlobalThreadIdHash ()

static unsigned	Rand (uint64_t *state)

Private Attributes
MaxSizeVector< MaxSizeVector< unsigned > >	all_coprimes_

const bool	allow_spinning_

std::atomic< unsigned >	blocked_

std::atomic< bool >	cancelled_

std::atomic< bool >	done_

EventCount	ec_

Environment	env_

unsigned	global_steal_partition_

std::unique_ptr< Barrier >	init_barrier_

const int	num_threads_

std::unordered_map< uint64_t, std::unique_ptr< PerThread > >	per_thread_map_

EIGEN_MUTEX	per_thread_map_mutex_

std::atomic< bool >	spinning_

MaxSizeVector< ThreadData >	thread_data_

MaxSizeVector< EventCount::Waiter >	waiters_

Static Private Attributes
static const int	kMaxPartitionBits

static const int	kMaxThreads

Detailed Description

template<typename Environment>
class Eigen::ThreadPoolTempl< Environment >

Definition at line 18 of file NonBlockingThreadPool.h.

Member Typedef Documentation

◆ Queue

template<typename Environment >

typedef RunQueue<Task, 1024> Eigen::ThreadPoolTempl< Environment >::Queue

Definition at line 21 of file NonBlockingThreadPool.h.

◆ Task

template<typename Environment >

typedef Environment::Task Eigen::ThreadPoolTempl< Environment >::Task

Definition at line 20 of file NonBlockingThreadPool.h.

◆ Thread

template<typename Environment >

typedef Environment::EnvThread Eigen::ThreadPoolTempl< Environment >::Thread

private

Definition at line 217 of file NonBlockingThreadPool.h.

Constructor & Destructor Documentation

◆ ThreadPoolTempl() [1/2]

template<typename Environment >

Eigen::ThreadPoolTempl< Environment >::ThreadPoolTempl	(	int	num_threads,
		Environment	env = `Environment()`
	)

inline

Definition at line 23 of file NonBlockingThreadPool.h.

24 : ThreadPoolTempl(num_threads, true, env) {}

Eigen::ThreadPoolTempl::ThreadPoolTempl

ThreadPoolTempl(int num_threads, Environment env=Environment())

Definition: NonBlockingThreadPool.h:23

◆ ThreadPoolTempl() [2/2]

template<typename Environment >

Eigen::ThreadPoolTempl< Environment >::ThreadPoolTempl	(	int	num_threads,
		bool	allow_spinning,
		Environment	env = `Environment()`
	)

inline

Definition at line 26 of file NonBlockingThreadPool.h.

       : env_(env),
         num_threads_(num_threads),
         allow_spinning_(allow_spinning),
         thread_data_(num_threads),
         all_coprimes_(num_threads),
         waiters_(num_threads),
         global_steal_partition_(EncodePartition(0, 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()

template<typename Environment >

Eigen::ThreadPoolTempl< Environment >::~ThreadPoolTempl ( )

inline

Definition at line 69 of file NonBlockingThreadPool.h.

                      {
     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();
   }

Member Function Documentation

◆ AssertBounds()

template<typename Environment >

void Eigen::ThreadPoolTempl< Environment >::AssertBounds	(	int	start,
		int	end
	)

inlineprivate

Definition at line 187 of file NonBlockingThreadPool.h.

                                         {
     eigen_plain_assert(start >= 0);
     eigen_plain_assert(start < end);  // non-zero sized partition
     eigen_plain_assert(end <= num_threads_);
   }

◆ Cancel()

template<typename Environment >

void Eigen::ThreadPoolTempl< Environment >::Cancel ( )

inlinevirtual

Reimplemented from Eigen::ThreadPoolInterface.

Definition at line 140 of file NonBlockingThreadPool.h.

                                {
     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);
   }

◆ ComputeCoprimes()

template<typename Environment >

void Eigen::ThreadPoolTempl< Environment >::ComputeCoprimes	(	int	N,
		MaxSizeVector< unsigned > *	coprimes
	)

inlineprivate

Definition at line 201 of file NonBlockingThreadPool.h.

                                                                  {
     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);
       }
     }
   }

◆ CurrentThreadId()

template<typename Environment >

int Eigen::ThreadPoolTempl< Environment >::CurrentThreadId ( ) const

inlinevirtual

Implements Eigen::ThreadPoolInterface.

Definition at line 157 of file NonBlockingThreadPool.h.

                                           {
     const PerThread* pt = const_cast<ThreadPoolTempl*>(this)->GetPerThread();
     if (pt->pool == this) {
       return pt->thread_id;
     } else {
       return -1;
     }
   }

◆ DecodePartition()

template<typename Environment >

void Eigen::ThreadPoolTempl< Environment >::DecodePartition	(	unsigned	val,
		unsigned *	start,
		unsigned *	limit
	)

inlineprivate

Definition at line 181 of file NonBlockingThreadPool.h.

                                                                               {
     *limit = val & (kMaxThreads - 1);
     val >>= kMaxPartitionBits;
     *start = val;
   }

◆ EncodePartition()

template<typename Environment >

unsigned Eigen::ThreadPoolTempl< Environment >::EncodePartition	(	unsigned	start,
		unsigned	limit
	)

inlineprivate

Definition at line 177 of file NonBlockingThreadPool.h.

                                                                   {
     return (start << kMaxPartitionBits) | limit;
   }

◆ GetPerThread()

template<typename Environment >

PerThread* Eigen::ThreadPoolTempl< Environment >::GetPerThread ( )

inlineprivate

Definition at line 458 of file NonBlockingThreadPool.h.

                                                 {
 #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
   }

◆ GetStealPartition()

template<typename Environment >

unsigned Eigen::ThreadPoolTempl< Environment >::GetStealPartition ( int i )

inlineprivate

Definition at line 197 of file NonBlockingThreadPool.h.

                                            {
     return thread_data_[i].steal_partition.load(std::memory_order_relaxed);
   }

◆ GlobalSteal()

template<typename Environment >

Task Eigen::ThreadPoolTempl< Environment >::GlobalSteal ( )

inlineprivate

Definition at line 378 of file NonBlockingThreadPool.h.

                      {
     return Steal(0, num_threads_);
   }

◆ GlobalThreadIdHash()

template<typename Environment >

static uint64_t Eigen::ThreadPoolTempl< Environment >::GlobalThreadIdHash ( )

inlinestaticprivate

Definition at line 454 of file NonBlockingThreadPool.h.

                                                            {
     return std::hash<std::thread::id>()(std::this_thread::get_id());
   }

◆ LocalSteal()

template<typename Environment >

Task Eigen::ThreadPoolTempl< Environment >::LocalSteal ( )

inlineprivate

Definition at line 364 of file NonBlockingThreadPool.h.

                     {
     PerThread* pt = GetPerThread();
     unsigned partition = GetStealPartition(pt->thread_id);
     // If thread steal partition is the same as global partition, there is no
     // need to go through the steal loop twice.
     if (global_steal_partition_ == partition) return Task();
     unsigned start, limit;
     DecodePartition(partition, &start, &limit);
     AssertBounds(start, limit);
  
     return Steal(start, limit);
   }

◆ NonEmptyQueueIndex()

template<typename Environment >

int Eigen::ThreadPoolTempl< Environment >::NonEmptyQueueIndex ( )

inlineprivate

Definition at line 433 of file NonBlockingThreadPool.h.

                            {
     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;
   }

◆ NumThreads()

template<typename Environment >

int Eigen::ThreadPoolTempl< Environment >::NumThreads ( ) const

inlinevirtual

Implements Eigen::ThreadPoolInterface.

Definition at line 155 of file NonBlockingThreadPool.h.

155 { return num_threads_; }

◆ Rand()

template<typename Environment >

static unsigned Eigen::ThreadPoolTempl< Environment >::Rand ( uint64_t * state )

inlinestaticprivate

Definition at line 474 of file NonBlockingThreadPool.h.

                                                             {
     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)));
   }

◆ Schedule()

template<typename Environment >

void Eigen::ThreadPoolTempl< Environment >::Schedule ( std::function< void()> fn )

inlinevirtual

Implements Eigen::ThreadPoolInterface.

Definition at line 103 of file NonBlockingThreadPool.h.

                                                        {
     ScheduleWithHint(std::move(fn), 0, num_threads_);
   }

◆ ScheduleWithHint()

template<typename Environment >

void Eigen::ThreadPoolTempl< Environment >::ScheduleWithHint	(	std::function< void()>	fn,
		int	start,
		int	limit
	)

inlineoverridevirtual

Reimplemented from Eigen::ThreadPoolInterface.

Definition at line 107 of file NonBlockingThreadPool.h.

                                             {
     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.
     }
   }

◆ SetStealPartition()

template<typename Environment >

void Eigen::ThreadPoolTempl< Environment >::SetStealPartition	(	size_t	i,
		unsigned	val
	)

inlineprivate

Definition at line 193 of file NonBlockingThreadPool.h.

                                                         {
     thread_data_[i].steal_partition.store(val, std::memory_order_relaxed);
   }

◆ SetStealPartitions()

template<typename Environment >

void Eigen::ThreadPoolTempl< Environment >::SetStealPartitions ( const std::vector< std::pair< unsigned, unsigned >> & partitions )

inline

Definition at line 90 of file NonBlockingThreadPool.h.

                                                                                     {
     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);
     }
   }

◆ Steal()

template<typename Environment >

Task Eigen::ThreadPoolTempl< Environment >::Steal	(	unsigned	start,
		unsigned	limit
	)

inlineprivate

Definition at line 338 of file NonBlockingThreadPool.h.

                                              {
     PerThread* pt = GetPerThread();
     const size_t size = limit - start;
     unsigned r = Rand(&pt->rand);
     // Reduce r into [0, size) range, this utilizes trick from
     // https://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/
     eigen_plain_assert(all_coprimes_[size - 1].size() < (1<<30));
     unsigned victim = ((uint64_t)r * (uint64_t)size) >> 32;
     unsigned index = ((uint64_t) all_coprimes_[size - 1].size() * (uint64_t)r) >> 32;
     unsigned inc = all_coprimes_[size - 1][index];
  
     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();
   }

◆ WaitForWork()

template<typename Environment >

bool Eigen::ThreadPoolTempl< Environment >::WaitForWork	(	EventCount::Waiter *	waiter,
		Task *	t
	)

inlineprivate

Definition at line 386 of file NonBlockingThreadPool.h.

                                                       {
     eigen_plain_assert(!t->f);
     // We already did best-effort emptiness check in Steal, so prepare for
     // blocking.
     ec_.Prewait();
     // 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;
   }

◆ WorkerLoop()

template<typename Environment >

void Eigen::ThreadPoolTempl< Environment >::WorkerLoop ( int thread_id )

inlineprivate

Definition at line 256 of file NonBlockingThreadPool.h.

                                  {
 #ifndef EIGEN_THREAD_LOCAL
     std::unique_ptr<PerThread> new_pt(new PerThread());
     per_thread_map_mutex_.lock();
     bool insertOK = per_thread_map_.emplace(GlobalThreadIdHash(), std::move(new_pt)).second;
     eigen_plain_assert(insertOK);
     EIGEN_UNUSED_VARIABLE(insertOK);
     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);
         }
       }
     }
   }

Member Data Documentation

◆ all_coprimes_

template<typename Environment >

MaxSizeVector<MaxSizeVector<unsigned> > Eigen::ThreadPoolTempl< Environment >::all_coprimes_

private

Definition at line 241 of file NonBlockingThreadPool.h.

◆ allow_spinning_

template<typename Environment >

const bool Eigen::ThreadPoolTempl< Environment >::allow_spinning_

private

Definition at line 239 of file NonBlockingThreadPool.h.

◆ blocked_

template<typename Environment >

std::atomic<unsigned> Eigen::ThreadPoolTempl< Environment >::blocked_

private

Definition at line 244 of file NonBlockingThreadPool.h.

◆ cancelled_

template<typename Environment >

std::atomic<bool> Eigen::ThreadPoolTempl< Environment >::cancelled_

private

Definition at line 247 of file NonBlockingThreadPool.h.

◆ done_

template<typename Environment >

std::atomic<bool> Eigen::ThreadPoolTempl< Environment >::done_

private

Definition at line 246 of file NonBlockingThreadPool.h.

◆ ec_

template<typename Environment >

EventCount Eigen::ThreadPoolTempl< Environment >::ec_

private

Definition at line 248 of file NonBlockingThreadPool.h.

◆ env_

template<typename Environment >

Environment Eigen::ThreadPoolTempl< Environment >::env_

private

Definition at line 237 of file NonBlockingThreadPool.h.

◆ global_steal_partition_

template<typename Environment >

unsigned Eigen::ThreadPoolTempl< Environment >::global_steal_partition_

private

Definition at line 243 of file NonBlockingThreadPool.h.

◆ init_barrier_

template<typename Environment >

std::unique_ptr<Barrier> Eigen::ThreadPoolTempl< Environment >::init_barrier_

private

Definition at line 250 of file NonBlockingThreadPool.h.

◆ kMaxPartitionBits

template<typename Environment >

const int Eigen::ThreadPoolTempl< Environment >::kMaxPartitionBits

staticprivate

Definition at line 174 of file NonBlockingThreadPool.h.

◆ kMaxThreads

template<typename Environment >

const int Eigen::ThreadPoolTempl< Environment >::kMaxThreads

staticprivate

Definition at line 175 of file NonBlockingThreadPool.h.

◆ num_threads_

template<typename Environment >

const int Eigen::ThreadPoolTempl< Environment >::num_threads_

private

Definition at line 238 of file NonBlockingThreadPool.h.

◆ per_thread_map_

template<typename Environment >

std::unordered_map<uint64_t, std::unique_ptr<PerThread> > Eigen::ThreadPoolTempl< Environment >::per_thread_map_

private

Definition at line 252 of file NonBlockingThreadPool.h.

◆ per_thread_map_mutex_

template<typename Environment >

EIGEN_MUTEX Eigen::ThreadPoolTempl< Environment >::per_thread_map_mutex_

private

Definition at line 251 of file NonBlockingThreadPool.h.

◆ spinning_

template<typename Environment >

std::atomic<bool> Eigen::ThreadPoolTempl< Environment >::spinning_

private

Definition at line 245 of file NonBlockingThreadPool.h.

◆ thread_data_

template<typename Environment >

MaxSizeVector<ThreadData> Eigen::ThreadPoolTempl< Environment >::thread_data_

private

Definition at line 240 of file NonBlockingThreadPool.h.

◆ waiters_

template<typename Environment >

MaxSizeVector<EventCount::Waiter> Eigen::ThreadPoolTempl< Environment >::waiters_

private

Definition at line 242 of file NonBlockingThreadPool.h.

The documentation for this class was generated from the following file:

NonBlockingThreadPool.h

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

template<typename Environment> class Eigen::ThreadPoolTempl< Environment >

Member Typedef Documentation

◆ Queue

◆ Task

◆ Thread

Constructor & Destructor Documentation

◆ ThreadPoolTempl() [1/2]

◆ ThreadPoolTempl() [2/2]

◆ ~ThreadPoolTempl()

Member Function Documentation

◆ AssertBounds()

◆ Cancel()

◆ ComputeCoprimes()

◆ CurrentThreadId()

◆ DecodePartition()

◆ EncodePartition()

◆ GetPerThread()

◆ GetStealPartition()

◆ GlobalSteal()

◆ GlobalThreadIdHash()

◆ LocalSteal()

◆ NonEmptyQueueIndex()

◆ NumThreads()

◆ Rand()

◆ Schedule()

◆ ScheduleWithHint()

◆ SetStealPartition()

◆ SetStealPartitions()

◆ Steal()

◆ WaitForWork()

◆ WorkerLoop()

Member Data Documentation

◆ all_coprimes_

◆ allow_spinning_

◆ blocked_

◆ cancelled_

◆ done_

◆ ec_

◆ env_

◆ global_steal_partition_

◆ init_barrier_

◆ kMaxPartitionBits

◆ kMaxThreads

◆ num_threads_

◆ per_thread_map_

◆ per_thread_map_mutex_

◆ spinning_

◆ thread_data_

◆ waiters_

template<typename Environment>
class Eigen::ThreadPoolTempl< Environment >