Fixed threads that run indexed work with the caller, for work repeated per batch. More...

#include <worker_pool.hpp>

Public Member Functions
	worker_pool (size_t workers)

	worker_pool (worker_pool const &)=delete

worker_pool &	operator= (worker_pool const &)=delete

	~worker_pool ()

template<typename Work >
void	for_each (size_t count, Work &&work)
	Runs `work(index)` for every index below `count`; one call at a time.

Detailed Description

Fixed threads that run indexed work with the caller, for work repeated per batch.

Spawning and joining threads for every batch cost the thread submitting batches more time than the reads it spread over them.

Definition at line 17 of file worker_pool.hpp.

Constructor & Destructor Documentation

◆ worker_pool() [1/2]

cuddl::detail::worker_pool::worker_pool ( size_t workers )

inlineexplicit

Definition at line 19 of file worker_pool.hpp.

                                         {
        auto const helpers = workers > 0 ? workers - 1 : 0;
        threads_.reserve(helpers);
        for (size_t thread = 0; thread < helpers; ++thread) {
            threads_.emplace_back([this] { serve(); });
        }
    }

◆ worker_pool() [2/2]

cuddl::detail::worker_pool::worker_pool ( worker_pool const & )

delete

◆ ~worker_pool()

cuddl::detail::worker_pool::~worker_pool ( )

inline

Definition at line 28 of file worker_pool.hpp.

                   {
        {
            std::lock_guard lock(mutex_);
            stop_ = true;
        }
        start_.notify_all();
        for (auto& thread : threads_) thread.join();
    }

Member Function Documentation

◆ for_each()

template<typename Work >

void cuddl::detail::worker_pool::for_each	(	size_t	count,
		Work &&	work
	)

inline

Runs work(index) for every index below count; one call at a time.

Definition at line 39 of file worker_pool.hpp.

                                             {
        if (count == 0) return;
        auto run = [&](size_t index) {
            work(index);
        };
        {
            std::lock_guard lock(mutex_);
            job_ = run;
            count_ = count;
            next_ = 0;
            active_ = threads_.size();
            ++generation_;
        }
        start_.notify_all();
        drain();
        std::unique_lock lock(mutex_);
        done_.wait(lock, [&] { return active_ == 0; });
        job_ = nullptr;
    }

◆ operator=()

worker_pool & cuddl::detail::worker_pool::operator= ( worker_pool const & )