A C++17 thread pool class. The user submits tasks to be executed into a queue. Whenever a thread becomes available, it pops a task from the queue and executes it. Each task is automatically assigned a future, which can be used to wait for the task to finish executing and/or obtain its eventual return value.
More...
|
| | thread_pool (const ui32 &_thread_count=std::thread::hardware_concurrency()) |
| | Construct a new thread pool. More...
|
| |
|
| ~thread_pool () |
| | Destruct the thread pool. Waits for all tasks to complete, then destroys all threads. Note that if the variable paused is set to true, then any tasks still in the queue will never be executed.
|
| |
| ui64 | get_tasks_queued () const |
| | Get the number of tasks currently waiting in the queue to be executed by the threads. More...
|
| |
| ui32 | get_tasks_running () const |
| | Get the number of tasks currently being executed by the threads. More...
|
| |
| ui32 | get_tasks_total () const |
| | Get the total number of unfinished tasks - either still in the queue, or running in a thread. More...
|
| |
| ui32 | get_thread_count () const |
| | Get the number of threads in the pool. More...
|
| |
| template<typename T1 , typename T2 , typename F > |
| void | parallelize_loop (const T1 &first_index, const T2 &index_after_last, const F &loop, ui32 num_blocks=0) |
| | Parallelize a loop by splitting it into blocks, submitting each block separately to the thread pool, and waiting for all blocks to finish executing. The user supplies a loop function, which will be called once per block and should iterate over the block's range. More...
|
| |
| template<typename F > |
| void | push_task (const F &task) |
| | Push a function with no arguments or return value into the task queue. More...
|
| |
| template<typename F , typename... A> |
| void | push_task (const F &task, const A &... args) |
| | Push a function with arguments, but no return value, into the task queue. More...
|
| |
| void | reset (const ui32 &_thread_count=std::thread::hardware_concurrency()) |
| | Reset the number of threads in the pool. Waits for all currently running tasks to be completed, then destroys all threads in the pool and creates a new thread pool with the new number of threads. Any tasks that were waiting in the queue before the pool was reset will then be executed by the new threads. If the pool was paused before resetting it, the new pool will be paused as well. More...
|
| |
| template<typename F , typename... A, typename = std::enable_if_t< std::is_void_v<std::invoke_result_t<std::decay_t<F>, std::decay_t<A>...>>>> |
| std::future< bool > | submit (const F &task, const A &... args) |
| | Submit a function with zero or more arguments and no return value into the task queue, and get an std::future<bool> that will be set to true upon completion of the task. More...
|
| |
| template<typename F , typename... A, typename R = std::invoke_result_t<std::decay_t<F>, std::decay_t<A>...>, typename = std::enable_if_t<!std::is_void_v<R>>> |
| std::future< R > | submit (const F &task, const A &... args) |
| | Submit a function with zero or more arguments and a return value into the task queue, and get a future for its eventual returned value. More...
|
| |
|
void | wait_for_tasks () |
| | Wait for tasks to be completed. Normally, this function waits for all tasks, both those that are currently running in the threads and those that are still waiting in the queue. However, if the variable paused is set to true, this function only waits for the currently running tasks (otherwise it would wait forever). To wait for a specific task, use submit() instead, and call the wait() member function of the generated future.
|
| |
A C++17 thread pool class. The user submits tasks to be executed into a queue. Whenever a thread becomes available, it pops a task from the queue and executes it. Each task is automatically assigned a future, which can be used to wait for the task to finish executing and/or obtain its eventual return value.
Definition at line 54 of file thread_pool.hpp.
template<typename T1 , typename T2 , typename F >
| void kvikio::third_party::thread_pool::parallelize_loop |
( |
const T1 & |
first_index, |
|
|
const T2 & |
index_after_last, |
|
|
const F & |
loop, |
|
|
ui32 |
num_blocks = 0 |
|
) |
| |
|
inline |
Parallelize a loop by splitting it into blocks, submitting each block separately to the thread pool, and waiting for all blocks to finish executing. The user supplies a loop function, which will be called once per block and should iterate over the block's range.
- Template Parameters
-
| T1 | The type of the first index in the loop. Should be a signed or unsigned integer. |
| T2 | The type of the index after the last index in the loop. Should be a signed or unsigned integer. If T1 is not the same as T2, a common type will be automatically inferred. |
| F | The type of the function to loop through. |
- Parameters
-
| first_index | The first index in the loop. |
| index_after_last | The index after the last index in the loop. The loop will iterate from first_index to (index_after_last - 1) inclusive. In other words, it will be equivalent to "for
(T i = first_index; i < index_after_last; i++)". Note that if first_index == index_after_last, the function will terminate without doing anything. |
| loop | The function to loop through. Will be called once per block. Should take exactly two arguments: the first index in the block and the index after the last index in the block. loop(start, end) should typically involve a loop of the form "for (T i = start; i < end; i++)". |
| num_blocks | The maximum number of blocks to split the loop into. The default is to use the number of threads in the pool. |
Definition at line 148 of file thread_pool.hpp.
template<typename F , typename... A>
| void kvikio::third_party::thread_pool::push_task |
( |
const F & |
task, |
|
|
const A &... |
args |
|
) |
| |
|
inline |
Push a function with arguments, but no return value, into the task queue.
The function is wrapped inside a lambda in order to hide the arguments, as the tasks in the queue must be of type std::function<void()>, so they cannot have any arguments or return value. If no arguments are provided, the other overload will be used, in order to avoid the (slight) overhead of using a lambda.
- Template Parameters
-
| F | The type of the function. |
| A | The types of the arguments. |
- Parameters
-
| task | The function to push. |
| args | The arguments to pass to the function. |
Definition at line 215 of file thread_pool.hpp.
template<typename F , typename... A, typename = std::enable_if_t< std::is_void_v<std::invoke_result_t<std::decay_t<F>, std::decay_t<A>...>>>>
| std::future<bool> kvikio::third_party::thread_pool::submit |
( |
const F & |
task, |
|
|
const A &... |
args |
|
) |
| |
|
inline |
Submit a function with zero or more arguments and no return value into the task queue, and get an std::future<bool> that will be set to true upon completion of the task.
- Template Parameters
-
| F | The type of the function. |
| A | The types of the zero or more arguments to pass to the function. |
- Parameters
-
| task | The function to submit. |
| args | The zero or more arguments to pass to the function. |
- Returns
- A future to be used later to check if the function has finished its execution.
Definition at line 260 of file thread_pool.hpp.
template<typename F , typename... A, typename R = std::invoke_result_t<std::decay_t<F>, std::decay_t<A>...>, typename = std::enable_if_t<!std::is_void_v<R>>>
| std::future<R> kvikio::third_party::thread_pool::submit |
( |
const F & |
task, |
|
|
const A &... |
args |
|
) |
| |
|
inline |
Submit a function with zero or more arguments and a return value into the task queue, and get a future for its eventual returned value.
- Template Parameters
-
| F | The type of the function. |
| A | The types of the zero or more arguments to pass to the function. |
| R | The return type of the function. |
- Parameters
-
| task | The function to submit. |
| args | The zero or more arguments to pass to the function. |
- Returns
- A future to be used later to obtain the function's returned value, waiting for it to finish its execution if needed.
Definition at line 294 of file thread_pool.hpp.
