Class that has a threadpool for batch-by-batch multi-threading. More...

#include <BatchThreadPool.h>

Public Member Functions
	BatchThreadPool (size_t num_threads)

	~BatchThreadPool ()

template<class F , class... Args>
std::future< typename std::result_of< F(uint32_t, Args...)>::type >	enqueueJob (F &&f, Args &&...args)

Detailed Description

Class that has a threadpool for batch-by-batch multi-threading.

Definition at line 36 of file BatchThreadPool.h.

Constructor & Destructor Documentation

◆ BatchThreadPool()

onert::backend::trix::BatchThreadPool::BatchThreadPool ( size_t num_threads )

Definition at line 22 of file BatchThreadPool.cc.

                                                   : _num_threads(num_threads), _stop_all(false)
{
  _worker_threads.reserve(_num_threads);
  for (uint32_t thread_num = 0; thread_num < _num_threads; ++thread_num)
  {
    _worker_threads.emplace_back([this, thread_num]() { this->worker(thread_num); });
  }
}

◆ ~BatchThreadPool()

onert::backend::trix::BatchThreadPool::~BatchThreadPool ( )

Definition at line 52 of file BatchThreadPool.cc.

{
  _stop_all = true;
  _cv_job_queue.notify_all();
 
  for (auto &&t : _worker_threads)
  {
    t.join();
  }
}

Member Function Documentation

◆ enqueueJob()

template<class F , class... Args>

std::future< typename std::result_of< F(uint32_t, Args...)>::type > onert::backend::trix::BatchThreadPool::enqueueJob	(	F &&	f,
		Args &&...	args
	)

inline

Template Parameters

F	Type of the function for job
Args	Type of arguments of job

Parameters

f	Function for job
args	Arguments of job

Returns: std::future<typename std::result_of<F(uint32_t, Args...)>::type>

Definition at line 52 of file BatchThreadPool.h.

  {
    if (_stop_all)
    {
      throw std::runtime_error("Stop all threads in BatchThreadPool");
    }
 
    using return_type = typename std::result_of<F(uint32_t, Args...)>::type;
    auto job = std::make_shared<std::packaged_task<return_type(uint32_t)>>(
      std::bind(std::forward<F>(f), std::placeholders::_1, std::forward<Args>(args)...));
    std::future<return_type> job_result_future = job->get_future();
    {
      // Push job in the assigned queue
      std::lock_guard<std::mutex> lock(_m_job_queue);
 
      // Push job
      _job_queue.push([job](uint32_t thread_num) { (*job)(thread_num); });
    }
    _cv_job_queue.notify_one();
 
    return job_result_future;
  }

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