dunedaq::utilities::WorkerThread Class Reference

WorkerThread contains a thread which runs the do_work() function. More...

#include <WorkerThread.hpp>

Public Member Functions
	WorkerThread (std::function< void(std::atomic< bool > &)> do_work)
	WorkerThread Constructor.
void	start_working_thread (const std::string &name="noname")
	Start the working thread (which executes the do_work() function)
void	stop_working_thread ()
	Stop the working thread.
bool	thread_running () const
	Determine if the thread is currently running.
	WorkerThread (const WorkerThread &)=delete
	WorkerThread is not copy-constructible.
WorkerThread &	operator= (const WorkerThread &)=delete
	WorkerThread is not copy-assginable.
	WorkerThread (WorkerThread &&)=delete
	WorkerThread is not move-constructible.
WorkerThread &	operator= (WorkerThread &&)=delete
	WorkerThread is not move-assignable.

Private Attributes
std::atomic< bool >	m_thread_running
std::unique_ptr< std::jthread >	m_working_thread
std::function< void(std::atomic< bool > &)>	m_do_work

Detailed Description

WorkerThread contains a thread which runs the do_work() function.

WorkerThread runs a given function in a std::jthread and allows that work function to be started and stopped via the start_working_thread() and stop_working_thread() methods, respectively. The work function takes a std::atomic<bool>& which indicates whether the thread should continue running, so a typical implementation of a work function is:

void do_work(std::atomic<bool>& running_flag){
  while(running_flag.load()){
   // do something ...
  }
}

If your do_work function is a class member, you will need to wrap it with std::bind or a lambda to bind the implicit 'this' argument, eg

class MyClass {
public:
  MyClass()
    : helper_(std::bind(MyClass::do_work, this, std::placeholders::_1))
  {}
  void do_work(std::atomic<bool>& running_flag) { ... }
  WorkerThread helper_;
};

Definition at line 63 of file WorkerThread.hpp.

Constructor & Destructor Documentation

WorkerThread() [1/3]

dunedaq::utilities::WorkerThread::WorkerThread ( std::function< void(std::atomic< bool > &)> do_work )

explicit

WorkerThread Constructor.

Parameters

do_work

Function to be executed in the thread

This constructor sets the defaults for the thread control variables

Definition at line 20 of file WorkerThread.cpp.

  : m_thread_running(false)
  , m_working_thread(nullptr)
  , m_do_work(do_work)
{
}

WorkerThread() [2/3]

dunedaq::utilities::WorkerThread::WorkerThread ( const WorkerThread & )

delete

WorkerThread is not copy-constructible.

WorkerThread() [3/3]

dunedaq::utilities::WorkerThread::WorkerThread ( WorkerThread && )

delete

WorkerThread is not move-constructible.

Member Function Documentation

operator=() [1/2]

WorkerThread & dunedaq::utilities::WorkerThread::operator= ( const WorkerThread & )

delete

WorkerThread is not copy-assginable.

operator=() [2/2]

WorkerThread & dunedaq::utilities::WorkerThread::operator= ( WorkerThread && )

delete

WorkerThread is not move-assignable.

start_working_thread()

void dunedaq::utilities::WorkerThread::start_working_thread

(

const std::string &

name = "noname"

)

Start the working thread (which executes the do_work() function)

Exceptions

ThreadingIssue

if the thread is already running

Definition at line 28 of file WorkerThread.cpp.

{
  if (thread_running()) {
    throw ThreadingIssue(ERS_HERE,
                         "Attempted to start working thread "
                         "when it is already running!");
  }
  m_thread_running = true;
  m_working_thread = std::make_unique<std::jthread>([&] { m_do_work(std::ref(m_thread_running)); });
  auto handle = m_working_thread->native_handle();
  auto rc = pthread_setname_np(handle, name.c_str());
  if (rc != 0) {
    std::ostringstream s;
    s << "The name " << name << " provided for the thread is too long.";
    ers::warning(ThreadingIssue(ERS_HERE, s.str()));
  }
}

stop_working_thread()

void dunedaq::utilities::WorkerThread::stop_working_thread

(

)

Stop the working thread.

Exceptions

ThreadingIssue	If the thread has not yet been started
ThreadingIssue	If the thread is not in the joinable state
ThreadingIssue	If an exception occurs during thread join

Definition at line 47 of file WorkerThread.cpp.

{
  if (!thread_running()) {
    throw ThreadingIssue(ERS_HERE,
                         "Attempted to stop working thread "
                         "when it is not running!");
  }
  m_thread_running = false;
 
  if (m_working_thread->joinable()) {
    try {
      m_working_thread->join();
    } catch (std::system_error const& e) {
      throw ThreadingIssue(ERS_HERE, std::string("Error while joining thread, ") + e.what());
    }
  } else {
    throw ThreadingIssue(ERS_HERE, "Thread not in joinable state during working thread stop!");
  }
}

thread_running()

bool dunedaq::utilities::WorkerThread::thread_running ( ) const

inline

Determine if the thread is currently running.

Returns

Whether the thread is currently running

Definition at line 91 of file WorkerThread.hpp.

{ return m_thread_running.load(); }

Member Data Documentation

m_do_work

std::function<void(std::atomic<bool>&)> dunedaq::utilities::WorkerThread::m_do_work

private

Definition at line 101 of file WorkerThread.hpp.

m_thread_running

std::atomic<bool> dunedaq::utilities::WorkerThread::m_thread_running

private

Definition at line 99 of file WorkerThread.hpp.

m_working_thread

std::unique_ptr<std::jthread> dunedaq::utilities::WorkerThread::m_working_thread

private

Definition at line 100 of file WorkerThread.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/utilities/include/utilities/WorkerThread.hpp
• /github/workspace/dunedaq/sourcecode/utilities/src/WorkerThread.cpp