DetectorBank/thread__pool_8h_source.html

 #ifndef _THREAD_POOL_H_
 #define _THREAD_POOL_H_

 #include <memory>
 #include <thread>
 #include <mutex>
 #include <condition_variable>
 #include <functional>
 #include <stdexcept>

 class ThreadPool {
 public:
     typedef std::function<void(void*)> delegate_t;

 protected:
     enum state {waiting, running, dying, dead};

     std::unique_ptr<std::thread[]> workers;

     std::unique_ptr<enum state[]> states;

     std::unique_ptr<std::exception_ptr[]> exceptions;

     void** params;

     delegate_t delegate;

     std::mutex m;
     std::condition_variable cv;
     std::size_t remain;
     void wait_raise(std::unique_lock<std::mutex>& lk, const std::size_t to_check);

     void dispatcher(int id);

 public:
     const std::size_t threads;
     ThreadPool(std::size_t numThreads = 0);
     ~ThreadPool();
     void manifold(delegate_t delegate,
                   void** params,
                   std::size_t jobs);
 };

 #endif
ThreadPool::threads
const std::size_t threads
Number of threads in pool.
Definition: thread_pool.h:90

ThreadPool::cv
std::condition_variable cv
Condition variable through which to notify workers that jobs are available.
Definition: thread_pool.h:66

ThreadPool::states
std::unique_ptr< enum state[]> states
State variables for each thread.
Definition: thread_pool.h:49

ThreadPool::delegate_t
std::function< void(void *)> delegate_t
The type of the delegate function each thread will run.
Definition: thread_pool.h:39

ThreadPool::remain
std::size_t remain
Count of the number of workers still to complete their job packets.
Definition: thread_pool.h:71

ThreadPool::manifold
void manifold(delegate_t delegate, void **params, std::size_t jobs)
Execute a function in each of the threads, passing each one its own paramater set.

ThreadPool::~ThreadPool
~ThreadPool()
Destroy the thread pool.

ThreadPool::m
std::mutex m
Mutex to control access to job packets.
Definition: thread_pool.h:61

ThreadPool::wait_raise
void wait_raise(std::unique_lock< std::mutex > &lk, const std::size_t to_check)
Convenience function: waits for a lock then deals with any exceptions propagated from the threads...

ThreadPool
A utility class to permit a single function to be run on multiple datasets concurrently.
Definition: thread_pool.h:36

ThreadPool::dispatcher
void dispatcher(int id)
Dispatch jobs to the given delegate.

ThreadPool::ThreadPool
ThreadPool(std::size_t numThreads=0)
Construct a thread pool.

ThreadPool::state
state
thread state descriptor
Definition: thread_pool.h:43

ThreadPool::params
void ** params
Parameters for each thread, passed to the runJobs function.
Definition: thread_pool.h:55

ThreadPool::delegate
delegate_t delegate
The work the workers are supposed to perform.
Definition: thread_pool.h:58

ThreadPool::workers
std::unique_ptr< std::thread[]> workers
Worker threads.
Definition: thread_pool.h:46

ThreadPool::exceptions
std::unique_ptr< std::exception_ptr[]> exceptions
exception_ptrs for each thread
Definition: thread_pool.h:52