#include <WorkQueue.h>

Public Types
enum class	State { ONLINE , FINISHING , FORCE_FINISHING }

Public Member Functions
	WorkQueue ()=default
	Create WorkQueue object.

	~WorkQueue ()
	Destroy WorkQueue object.

void	operator() ()
	Thread entry function.

void	enqueue (std::unique_ptr< IFunction > &&fn)
	Push the given Task to the job queue.

void	terminate ()
	Flag as terminating so all the worker threads can terminate.

void	finish ()
	Flag as terminating so all the worker threads can terminate.

uint32_t	numJobsInQueue ()
	Check if it has pending jobs. Even if this returns fals, WorkQueue threads may be still running.

Detailed Description

Definition at line 30 of file WorkQueue.h.

Member Enumeration Documentation

◆ State

enum class onert::exec::WorkQueue::State

strong

Enumerator
ONLINE
FINISHING
FORCE_FINISHING

Definition at line 33 of file WorkQueue.h.

  {
    ONLINE,
    FINISHING,
    FORCE_FINISHING
  };

Constructor & Destructor Documentation

◆ WorkQueue()

onert::exec::WorkQueue::WorkQueue ( )

default

Create WorkQueue object.

◆ ~WorkQueue()

onert::exec::WorkQueue::~WorkQueue ( )

Destroy WorkQueue object.

Definition at line 24 of file WorkQueue.cc.

{
  {
    std::unique_lock<std::mutex> lock(_mu);
    _state = State::FORCE_FINISHING;
  }
  _cv.notify_all();
}

References FORCE_FINISHING.

Member Function Documentation

◆ enqueue()

void onert::exec::WorkQueue::enqueue ( std::unique_ptr< IFunction > && fn )

Push the given Task to the job queue.

Parameters

fn	Function to be executed(a job)

Definition at line 68 of file WorkQueue.cc.

{
  {
    std::unique_lock<std::mutex> lock{_mu};
    _functions.emplace(std::move(fn));
  }
  _cv.notify_one();
}

Referenced by onert::exec::ThreadPool::enqueue().

◆ finish()

void onert::exec::WorkQueue::finish ( )

Flag as terminating so all the worker threads can terminate.

Definition at line 86 of file WorkQueue.cc.

{
  {
    std::unique_lock<std::mutex> lock{_mu};
    _state = State::FINISHING;
  }
  _cv.notify_all();
}

References FINISHING.

Referenced by onert::exec::ThreadPool::finish().

◆ numJobsInQueue()

uint32_t onert::exec::WorkQueue::numJobsInQueue ( )

Check if it has pending jobs. Even if this returns fals, WorkQueue threads may be still running.

Returns: true if the job queue not empty otherwise false

Definition at line 95 of file WorkQueue.cc.

{
  std::unique_lock<std::mutex> lock{_mu};
  return _functions.size();
}

Referenced by onert::exec::ThreadPool::numJobsInQueue().

◆ operator()()

void onert::exec::WorkQueue::operator() ( )

Thread entry function.

Definition at line 33 of file WorkQueue.cc.

{
  while (true)
  {
    std::unique_ptr<IFunction> fn = nullptr;
 
    {
      std::unique_lock<std::mutex> lock{_mu};
      _cv.wait(lock, [this] {
        return (_state == State::FORCE_FINISHING) || (_state == State::FINISHING) ||
               (_state == State::ONLINE && !_functions.empty());
      });
 
      if (_state == State::FORCE_FINISHING)
      {
        assert(_functions.empty() && "Terminating with unfinished jobs");
        return;
      }
      else if (_state == State::FINISHING && _functions.empty())
      {
        return;
      }
      else
      {
        assert(((_state == State::FINISHING) || (_state == State::ONLINE)) && !_functions.empty());
        fn = std::move(_functions.front());
        _functions.pop();
      }
    }
 
    assert(fn);
    fn->run();
  }
}

References FINISHING, FORCE_FINISHING, and ONLINE.

◆ terminate()

void onert::exec::WorkQueue::terminate ( )