spdlog::details::thread_pool Class Reference

#include <thread_pool.h>

Public Types
using	item_type = async_msg
using	q_type = details::mpmc_blocking_queue< item_type >

Public Member Functions
	thread_pool (size_t q_max_items, size_t threads_n)
	~thread_pool ()
	thread_pool (const thread_pool &)=delete
thread_pool &	operator= (thread_pool &&)=delete
void	post_log (async_logger_ptr &&worker_ptr, details::log_msg &msg, async_overflow_policy overflow_policy)
void	post_flush (async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
size_t	overrun_counter ()

Private Member Functions
void	post_async_msg_ (async_msg &&new_msg, async_overflow_policy overflow_policy)
void	worker_loop_ ()
bool	process_next_msg_ ()

Private Attributes
q_type	q_
std::vector< std::thread >	threads_

Detailed Description

Definition at line 118 of file thread_pool.h.

Member Typedef Documentation

using spdlog::details::thread_pool::item_type = async_msg

Definition at line 121 of file thread_pool.h.

using spdlog::details::thread_pool::q_type = details::mpmc_blocking_queue<item_type>

Definition at line 122 of file thread_pool.h.

Constructor & Destructor Documentation

spdlog::details::thread_pool::thread_pool ( size_t  q_max_items, size_t  threads_n  )

inline

Definition at line 124 of file thread_pool.h.

        : q_(q_max_items)
    {
        // std::cout << "thread_pool()  q_size_bytes: " << q_size_bytes <<
        // "\tthreads_n: " << threads_n << std::endl;
        if (threads_n == 0 || threads_n > 1000)
        {
            throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
                            "range is 1-1000)");
        }
        for (size_t i = 0; i < threads_n; i++)
        {
            threads_.emplace_back(&thread_pool::worker_loop_, this);
        }
    }

spdlog::details::thread_pool::~thread_pool ( )

inline

Definition at line 141 of file thread_pool.h.

    {
        try
        {
            for (size_t i = 0; i < threads_.size(); i++)
            {
                post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
            }

            for (auto &t : threads_)
            {
                t.join();
            }
        }
        catch (...)
        {
        }
    }

spdlog::details::thread_pool::thread_pool ( const thread_pool &  )

delete

Member Function Documentation

thread_pool& spdlog::details::thread_pool::operator= ( thread_pool &&  )

delete

size_t spdlog::details::thread_pool::overrun_counter ( )

inline

Definition at line 174 of file thread_pool.h.

    {
        return q_.overrun_counter();
    }

void spdlog::details::thread_pool::post_async_msg_ ( async_msg &&  new_msg, async_overflow_policy  overflow_policy  )

inlineprivate

Definition at line 184 of file thread_pool.h.

    {
        if (overflow_policy == async_overflow_policy::block)
        {
            q_.enqueue(std::move(new_msg));
        }
        else
        {
            q_.enqueue_nowait(std::move(new_msg));
        }
    }

void spdlog::details::thread_pool::post_flush ( async_logger_ptr &&  worker_ptr, async_overflow_policy  overflow_policy  )

inline

Definition at line 169 of file thread_pool.h.

    {
        post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
    }

void spdlog::details::thread_pool::post_log ( async_logger_ptr &&  worker_ptr, details::log_msg &  msg, async_overflow_policy  overflow_policy  )

inline

Definition at line 163 of file thread_pool.h.

    {
        async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
        post_async_msg_(std::move(async_m), overflow_policy);
    }

bool spdlog::details::thread_pool::process_next_msg_ ( )

inlineprivate

Definition at line 204 of file thread_pool.h.

    {
        async_msg incoming_async_msg;
        bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
        if (!dequeued)
        {
            return true;
        }

        switch (incoming_async_msg.msg_type)
        {
        case async_msg_type::log:
        {
            auto msg = incoming_async_msg.to_log_msg();
            incoming_async_msg.worker_ptr->backend_log_(msg);
            return true;
        }
        case async_msg_type::flush:
        {
            incoming_async_msg.worker_ptr->backend_flush_();
            return true;
        }

        case async_msg_type::terminate:
        {
            return false;
        }
        }
        assert(false && "Unexpected async_msg_type");
        return true;
    }

void spdlog::details::thread_pool::worker_loop_ ( )

inlineprivate

Definition at line 196 of file thread_pool.h.

    {
        while (process_next_msg_()) {};
    }

Member Data Documentation

q_type spdlog::details::thread_pool::q_

private

Definition at line 180 of file thread_pool.h.

std::vector<std::thread> spdlog::details::thread_pool::threads_

private

Definition at line 182 of file thread_pool.h.

---

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

• wire-cell-build/util/inc/spdlog/details/thread_pool.h