thread_pool Class Reference

#include <thread_pool.hpp>

Collaboration diagram for thread_pool:

Public Member Functions
	thread_pool (std::size_t thread_count=std::thread::hardware_concurrency(), int phy_prio=10)
	~thread_pool ()
	thread_pool (thread_pool const &)=delete
	thread_pool (thread_pool &&)=default
thread_pool &	operator= (thread_pool const &)=delete
thread_pool &	operator= (thread_pool &&)=default
template<class Func , class... Args>
auto	push (Func &&fn, Args &&...args)
void	clear ()
void	join ()
std::size_t	thread_count () const
std::size_t	active_count () const

Private Types
using	task_type = std::function< void()>

Private Member Functions
void	thread_loop ()
task_type	next_task ()

Private Attributes
std::atomic< bool >	m_stop { false }
std::atomic< std::size_t >	m_active { 0 }
std::condition_variable	m_notifier
std::mutex	m_mutex
std::vector< std::thread >	m_workers
std::queue< task_type >	m_tasks

Detailed Description

Definition at line 17 of file thread_pool.hpp.

Member Typedef Documentation

task_type

using thread_pool::task_type = std::function<void()>

private

Definition at line 20 of file thread_pool.hpp.

Constructor & Destructor Documentation

thread_pool() [1/3]

thread_pool::thread_pool ( std::size_t  thread_count = std::thread::hardware_concurrency(), int  phy_prio = 10  )

inlineexplicit

Definition at line 23 of file thread_pool.hpp.

    {
        struct sched_param thread_param; 
        thread_param.sched_priority = phy_prio; 
 
        for (std::size_t i{ 0 }; i < thread_count; ++i) {
            spdlog::info("Launching phy thread with realtime scheduling priority {}", thread_param.sched_priority );
            m_workers.emplace_back(std::bind(&thread_pool::thread_loop, this));
            
            int error = pthread_setschedparam( m_workers.back().native_handle(), SCHED_RR, &thread_param );
            if( error )
            {
                spdlog::error("Cannot set phy thread priority to realtime: {}. Thread will run at default priority.", strerror(error));
            }
        }
    }

~thread_pool()

thread_pool::~thread_pool ( )

inline

Definition at line 40 of file thread_pool.hpp.

    {
        if (m_workers.size() > 0) {
            join();
        }
    }

thread_pool() [2/3]

thread_pool::thread_pool ( thread_pool const &  )

delete

thread_pool() [3/3]

thread_pool::thread_pool ( thread_pool &&  )

default

Member Function Documentation

active_count()

std::size_t thread_pool::active_count ( ) const

inline

Definition at line 107 of file thread_pool.hpp.

    {
        return m_active;
    }

clear()

void thread_pool::clear ( )

inline

Definition at line 76 of file thread_pool.hpp.

    {
        std::unique_lock<std::mutex> lock{ m_mutex };
 
        while (!m_tasks.empty()) {
            m_tasks.pop();
        }
    }

join()

void thread_pool::join ( )

inline

Definition at line 86 of file thread_pool.hpp.

    {
        m_stop = true;
        m_notifier.notify_all();
 
        for (auto &thread : m_workers) {
            if (thread.joinable()) {
                thread.join();
            }
        }
 
        m_workers.clear();
    }

next_task()

task_type thread_pool::next_task ( )

inlineprivate

Definition at line 133 of file thread_pool.hpp.

    {
        std::unique_lock<std::mutex> lock{ m_mutex };
 
        m_notifier.wait(lock, [this]() {
            return !m_tasks.empty() || m_stop;
        });
 
        if (m_tasks.empty()) {
            // No pending task
            return {};
        }
 
        auto task{ m_tasks.front() };
        m_tasks.pop();
        return task;
    }

operator=() [1/2]

thread_pool& thread_pool::operator= ( thread_pool &&  )

default

operator=() [2/2]

thread_pool& thread_pool::operator= ( thread_pool const &  )

delete

push()

template<class Func , class... Args>

auto thread_pool::push ( Func &&  fn, Args &&...  args  )

inline

Definition at line 55 of file thread_pool.hpp.

    {
        using return_type = typename std::result_of<Func(Args...)>::type;
 
        auto task{ std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<Func>(fn), std::forward<Args>(args)...)
        ) };
 
        auto future{ task->get_future() };
        std::unique_lock<std::mutex> lock{ m_mutex };
 
        m_tasks.emplace([task]() {
            (*task)();
        });
 
        lock.unlock();
        m_notifier.notify_one();
        return future;
    }

thread_count()

std::size_t thread_pool::thread_count ( ) const

inline

Definition at line 101 of file thread_pool.hpp.

    {
        return m_workers.size();
    }

thread_loop()

void thread_pool::thread_loop ( )

inlineprivate

Definition at line 114 of file thread_pool.hpp.

    {
        while (true) {
            // Wait for a new task
            auto task{ next_task() };
 
            if (task) {
                ++m_active;
                task();
                --m_active;
            }
            else if (m_stop) {
                // No more task + stop required
                break;
            }
        }
    }

Member Data Documentation

m_active

std::atomic<std::size_t> thread_pool::m_active { 0 }

private

Definition at line 152 of file thread_pool.hpp.

m_mutex

std::mutex thread_pool::m_mutex

private

Definition at line 155 of file thread_pool.hpp.

m_notifier

std::condition_variable thread_pool::m_notifier

private

Definition at line 154 of file thread_pool.hpp.

m_stop

std::atomic<bool> thread_pool::m_stop { false }

private

Definition at line 151 of file thread_pool.hpp.

m_tasks

std::queue<task_type> thread_pool::m_tasks

private

Definition at line 158 of file thread_pool.hpp.

m_workers

std::vector<std::thread> thread_pool::m_workers

private

Definition at line 157 of file thread_pool.hpp.

---

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

• include/thread_pool.hpp