#include <WorkerThreadPool.hpp>

Collaboration diagram for WorkerThreadPool:

Public Member Functions
	WorkerThreadPool (unsigned const thread_count=std::thread::hardware_concurrency())

	~WorkerThreadPool ()

template<typename FunctionType >
std::future< typename std::invoke_result< FunctionType()>::type >	submit (FunctionType f)

Private Member Functions
void	worker_thread ()

Private Attributes
std::vector< std::thread >	_threads

std::atomic_bool	_done

ThreadSafeQueue< FunctionWrapper >	_work_queue

Constructor & Destructor Documentation

◆ WorkerThreadPool()

WorkerThreadPool::WorkerThreadPool ( unsigned const thread_count = std::thread::hardware_concurrency() )

inline

    :  _done(false)
    {
        try {
            for (unsigned i = 0; i < thread_count; ++i)
                _threads.push_back(std::thread(&WorkerThreadPool::worker_thread, this));
        } catch (...) {
            _done = true;
            throw;
        }
    }

References _done, _threads, and worker_thread().

Here is the call graph for this function:

◆ ~WorkerThreadPool()

WorkerThreadPool::~WorkerThreadPool ( )

inline

    {
        _done = true;
 
        for (unsigned long i = 0; i < _threads.size(); i++)
            if (_threads.at(i).joinable())
                _threads.at(i).join();
    }

References _done, and _threads.

Member Function Documentation

◆ submit()

template<typename FunctionType >

std::future< typename std::invoke_result< FunctionType()>::type > WorkerThreadPool::submit ( FunctionType f )

inline

    {
        typedef typename std::invoke_result<FunctionType()>::type result_type;
 
        std::packaged_task<result_type()> task(std::move(f));
        std::future<result_type> res(task.get_future());
        _work_queue.push(std::move(task));
        return res;
    }

References _work_queue, and ThreadSafeQueue< T >::push().

Here is the call graph for this function:

◆ worker_thread()

void WorkerThreadPool::worker_thread ( )

inlineprivate

    {
        while (!_done) {
            std::shared_ptr<FunctionWrapper> task;
            if ((task = _work_queue.try_pop()))
                task->call();
            else
                std::this_thread::yield();
        }
    }