olb::ThreadPool Class Reference

Pool of threads for CPU-based background processing. More...

#include <threadPool.h>

Collaboration diagram for olb::ThreadPool:

Public Member Functions
	ThreadPool ()
void	init (int nThreads, bool verbose)
	Initialization to be called by olbInit.
	~ThreadPool ()
unsigned	size () const
	Returns number of threads.
template<typename F >
void	scheduleAndForget (F &&f)
	Schedule F, tracking neither its return value nor completion.
template<typename F , typename R = std::invoke_result_t<std::decay_t<F>>>
std::future< R >	schedule (F &&f)
	Schedule F and return future of its return value.
void	wait ()
	Blocks until all tasks are completed.
template<typename T >
void	waitFor (std::vector< std::future< T > > &futures)
	Blocks until all tasks producing the given futures are completed.

Detailed Description

Pool of threads for CPU-based background processing.

Not intended for parallelization of performance critical paths but for background processing of e.g. VTK output to reduce blocking of simulation process.

Definition at line 47 of file threadPool.h.

Constructor & Destructor Documentation

ThreadPool()

olb::ThreadPool::ThreadPool ( )

inline

Definition at line 86 of file threadPool.h.

              :
    _mutex{},
    _waiting{false},
    _active{true},
    _taskCount{0},
    _available{},
    _done{},
    _threads{1},
    _queue{},
    _initialized{false}
  { }

~ThreadPool()

olb::ThreadPool::~ThreadPool ( )

inline

Definition at line 115 of file threadPool.h.

  {
    _active = false;
    _available.notify_all();
    for (std::thread& thread : _threads) {
      thread.join();
    }
  }

Member Function Documentation

init()

void olb::ThreadPool::init ( int nThreads, bool verbose )

inline

Initialization to be called by olbInit.

Definition at line 99 of file threadPool.h.

  {
    OLB_PRECONDITION(!_initialized);
    OstreamManager clout(std::cout, "ThreadPool");
    if (nThreads > 1) {
      _threads.resize(nThreads);
    }
    for (unsigned iThread=0; iThread < _threads.size(); ++iThread) {
      _threads[iThread] = std::thread(&ThreadPool::work, this, iThread);
    }
    if (verbose) {
      clout << "Sucessfully initialized, numThreads=" << std::to_string(_threads.size()) << std::endl;
    }
    _initialized = true;
  }

References OLB_PRECONDITION.

Here is the caller graph for this function:

schedule()

template<typename F , typename R = std::invoke_result_t<std::decay_t<F>>>

std::future< R > olb::ThreadPool::schedule ( F && f )

inline

Schedule F and return future of its return value.

Definition at line 145 of file threadPool.h.

  {
    OLB_PRECONDITION(_initialized);
    auto packagedF = std::make_shared<std::packaged_task<R()>>(f);
    {
      const std::scoped_lock lock(_mutex);
      _queue.push([packagedF]() {
        (*packagedF)();
      });
    }
    ++_taskCount;
    _available.notify_one();
    return packagedF->get_future();
  }

References OLB_PRECONDITION.

Here is the caller graph for this function:

scheduleAndForget()

template<typename F >

void olb::ThreadPool::scheduleAndForget ( F && f )

inline

Schedule F, tracking neither its return value nor completion.

Definition at line 132 of file threadPool.h.

  {
    OLB_PRECONDITION(_initialized);
    {
      const std::scoped_lock lock(_mutex);
      _queue.push(f);
    }
    ++_taskCount;
    _available.notify_one();
  }

References OLB_PRECONDITION.

size()

unsigned olb::ThreadPool::size ( ) const

inline

Returns number of threads.

Definition at line 125 of file threadPool.h.

  {
    return _threads.size();
  }

wait()

void olb::ThreadPool::wait ( )

inline

Blocks until all tasks are completed.

Definition at line 161 of file threadPool.h.

  {
    OLB_PRECONDITION(_initialized);
    _waiting = true;
    std::unique_lock lock(_mutex);
    _done.wait(lock, [&]() {
      return _taskCount == 0;
    });
    _waiting = false;
  }

References OLB_PRECONDITION.

waitFor()

template<typename T >

void olb::ThreadPool::waitFor ( std::vector< std::future< T > > & futures )

inline

Blocks until all tasks producing the given futures are completed.

Definition at line 174 of file threadPool.h.

  {
    for (auto& future : futures) {
      future.wait();
    }
  }

Here is the caller graph for this function:

---

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

• src/core/threadPool.h