#include <task_thread_pool.hpp>

task_thread_pool::task_thread_pool pool; // num_threads = number of physical cores // or task_thread_pool::task_thread_pool pool{4}; // num_threads = 4

pool.submit_detach( [](int arg) { std::cout << arg; }, 123456 );

std::future<int> future = pool.submit([] { return 1; }); int result = future.get(); // returns 1

pool.wait_for_tasks();

std::vector<int> v = {0, 1, 2, 3, 4, 5}; task_thread_pool::task_thread_pool pool; // parallel for using poolstl::iota_iter; std::for_each(poolstl::par.on(pool), iota_iter<int>(0), iota_iter<int>(v.size()), [](int i) { std::cout << v[i]; // loop body }); // parallel for-each std::for_each(poolstl::par.on(pool), v.cbegin(), v.cend(), [](auto value) { std::cout << value; // loop body });

#include <iostream> // Use #include "task_thread_pool.hpp" for relative path, // and #include <task_thread_pool.hpp> if installed in include path #include "task_thread_pool.hpp" int sum(int a, int b) { return a + b; } int main() { // Create a thread pool. The number of threads is equal to the number of cores in the system, // as given by std::thread::hardware_concurrency(). // You can also specify the number of threads, like so: pool(4), // or resize the thread pool later using pool.set_num_threads(4). task_thread_pool::task_thread_pool pool; //--------------------------------------------- // Submit a task that returns a value. std::future<int> one_future = pool.submit([] { return 1; }); // Use std::future::get() to wait for the task to complete and return the value. std::cout << "Task returned: " << one_future.get() << std::endl; //--------------------------------------------- // Tasks may have arguments: std::future<int> sum_future = pool.submit(&sum, 1, 2); std::cout << "Sum = " << sum_future.get() << std::endl; //--------------------------------------------- // Submit a task that we don't need to track the execution of: pool.submit_detach([](int arg) { std::cout << "The argument is: " << arg << std::endl; }, 42); //--------------------------------------------- // Wait for all tasks to complete: pool.wait_for_tasks(); //--------------------------------------------- // The pool can be paused: pool.pause(); // Submit a task that won't be started until the pool is unpaused. std::future<void> paused_future = pool.submit([] { std::cout << "Paused task executes" << std::endl; }); // prints 1 std::cout << "Number of tasks in the pool: " << pool.get_num_tasks() << std::endl; // Resume executing queued tasks. pool.unpause(); // Wait for the task to finish. paused_future.get(); // prints 0 std::cout << "Number of tasks in the pool: " << pool.get_num_tasks() << std::endl; //--------------------------------------------- // All queued tasks are executed before the pool is destroyed: pool.submit_detach([]{ std::cout << "One last task" << std::endl; }); return 0; }