dispenso::ThreadPool Class Reference

#include <thread_pool.h>

Public Member Functions
DISPENSO_DLL_ACCESS	ThreadPool (size_t n, size_t poolLoadMultiplier=32)
template<class Rep , class Period >
void	setSignalingWake (bool enable, const std::chrono::duration< Rep, Period > &sleepDuration=std::chrono::microseconds(kDefaultSleepLenUs))
DISPENSO_DLL_ACCESS void	resize (ssize_t n)
ssize_t	numThreads () const
template<typename F >
void	schedule (F &&f)
template<typename F >
void	schedule (F &&f, ForceQueuingTag)
template<typename Generator >
void	scheduleBulk (size_t count, Generator &&gen)
DISPENSO_DLL_ACCESS	~ThreadPool ()

Friends
class	ConcurrentTaskSet
class	TaskSet

Detailed Description

The basic executor for dispenso. It provides typical thread pool functionality, plus allows work stealing by related types (e.g. TaskSet, Future, etc...), which prevents deadlock when waiting for pool-recursive tasks.

Definition at line 72 of file thread_pool.h.

Constructor & Destructor Documentation

ThreadPool()

DISPENSO_DLL_ACCESS dispenso::ThreadPool::ThreadPool	(	size_t	n,
		size_t	poolLoadMultiplier = 32 )

Construct a thread pool.

Parameters

n	The number of threads to spawn at construction.
poolLoadMultiplier	A parameter that specifies how overloaded the pool should be before allowing the current thread to self-steal work.

~ThreadPool()

DISPENSO_DLL_ACCESS dispenso::ThreadPool::~ThreadPool

(

)

Destruct the pool. This destructor is blocking until all queued work is completed. It is illegal to call the destructor while any other thread makes calls to the pool (as is generally the case with C++ classes).

Member Function Documentation

numThreads()

ssize_t dispenso::ThreadPool::numThreads ( ) const

inline

Get the number of threads backing the pool. If called concurrently to resize, the number returned may be stale.

Returns

The current number of threads backing the pool.

Definition at line 129 of file thread_pool.h.

resize()

DISPENSO_DLL_ACCESS void dispenso::ThreadPool::resize ( ssize_t n )

inline

Change the number of threads backing the thread pool. This is a blocking and potentially slow operation, and repeatedly resizing is discouraged.

Parameters

n	The number of threads in use after call completion

Definition at line 118 of file thread_pool.h.

schedule() [1/2]

template<typename F >

void dispenso::ThreadPool::schedule ( F && f )

inline

Schedule a functor to be executed. If the pool's load factor is high, execution may happen inline by the calling thread.

Parameters

f	The functor to be executed. f's signature must match void(). Best performance will come from passing lambdas, other concrete functors, or OnceFunction, but std::function or similarly type-erased objects will also work.

Definition at line 315 of file thread_pool.h.

schedule() [2/2]

template<typename F >

void dispenso::ThreadPool::schedule ( F && f, ForceQueuingTag  )

inline

Schedule a functor to be executed. The functor will always be queued and executed by pool threads.

Parameters

f	The functor to be executed. f's signature must match void(). Best performance will come from passing lambdas, other concrete functors, or OnceFunction, but std::function or similarly type-erased objects will also work.

Definition at line 329 of file thread_pool.h.

scheduleBulk()

template<typename Generator >

void dispenso::ThreadPool::scheduleBulk	(	size_t	count,
		Generator &&	gen )

Schedule multiple functors to be executed in bulk. This is more efficient than calling schedule() multiple times when you have many tasks to submit, as it reduces atomic contention and allows for better thread wakeup behavior.

Parameters

count	The number of functors to schedule.
gen	A generator functor that takes an index and returns a functor to execute. gen(i) will be called for i in [0, count) to produce each task.

Note

Work is enqueued in chunks and interleaved with inline execution based on the pool's load factor, preventing both pool thread starvation and excessive queueing overhead.

Definition at line 466 of file thread_pool.h.

setSignalingWake()

template<class Rep , class Period >

void dispenso::ThreadPool::setSignalingWake ( bool enable, const std::chrono::duration< Rep, Period > & sleepDuration = std::chrono::microseconds(kDefaultSleepLenUs) )

inline

Enable or disable signaling wake functionality. If enabled, this will try to ensure that threads are woken up proactively when work has not been available and it becomes available. This function is blocking and potentially very slow. Repeated use is discouraged.

Parameters

enable	If set true, turns on signaling wake. If false, turns it off.
sleepDuration	If enable is true, this is the length of time a thread will wait for a signal before waking up. If enable is false, this is the length of time a thread will sleep between polling.

Note

It is highly recommended to leave signaling wake enabled on Windows platforms, as sleeping/polling tends to perform poorly for intermittent workloads. For Mac/Linux platforms, it is okay to enable signaling wake, particularly if you wish to set a longer expected duration between work. If signaling wake is disabled, ensure sleepDuration is small (e.g. 200us) for best performance. Most users will not need to call this function, as defaults are reasonable.

Definition at line 102 of file thread_pool.h.

Friends And Related Symbol Documentation

ConcurrentTaskSet

friend class ConcurrentTaskSet

friend

Definition at line 292 of file thread_pool.h.

TaskSet

friend class TaskSet

friend

Definition at line 293 of file thread_pool.h.

---

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

• /github/workspace/dispenso/thread_pool.h