dunedaq::utilities::ReusableThread Class Reference

#include <ReusableThread.hpp>

Public Member Functions
	ReusableThread (int threadid=0)
	~ReusableThread ()
	ReusableThread (const ReusableThread &)=delete
	ReusableThread is not copy-constructible.
ReusableThread &	operator= (const ReusableThread &)=delete
	ReusableThread is not copy-assginable.
	ReusableThread (ReusableThread &&)=delete
	ReusableThread is not move-constructible.
ReusableThread &	operator= (ReusableThread &&)=delete
	ReusableThread is not move-assignable.
void	set_thread_id (int tid)
int	get_thread_id () const
void	set_name (const std::string &name, int tid)
void	set_pin (int cpuid)
bool	get_readiness () const
template<typename Function, typename... Args>
bool	set_work (Function &&f, Args &&... args)

Private Member Functions
void	thread_worker ()

Private Attributes
int	m_thread_id
std::atomic< bool >	m_task_executed
std::atomic< bool >	m_task_assigned
std::atomic< bool >	m_thread_quit
std::atomic< bool >	m_worker_done
std::atomic< bool >	m_named
std::function< void()>	m_task
std::mutex	m_mtx
std::condition_variable	m_cv
std::thread	m_thread

Detailed Description

Definition at line 24 of file ReusableThread.hpp.

Constructor & Destructor Documentation

ReusableThread() [1/3]

dunedaq::utilities::ReusableThread::ReusableThread ( int threadid = 0 )

explicit

Definition at line 17 of file ReusableThread.cpp.

  : m_thread_id(threadid)
  , m_task_executed(true)
  , m_task_assigned(false)
  , m_thread_quit(false)
  , m_worker_done(false)
  , m_thread(&ReusableThread::thread_worker, this)
{
}

~ReusableThread()

dunedaq::utilities::ReusableThread::~ReusableThread

(

)

Definition at line 27 of file ReusableThread.cpp.

{
  while (m_task_assigned) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
  }
  m_thread_quit = true;
  while (!m_worker_done) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
    m_cv.notify_all();
  }
  m_thread.join();
}

ReusableThread() [2/3]

dunedaq::utilities::ReusableThread::ReusableThread ( const ReusableThread & )

delete

ReusableThread is not copy-constructible.

ReusableThread() [3/3]

dunedaq::utilities::ReusableThread::ReusableThread ( ReusableThread && )

delete

ReusableThread is not move-constructible.

Member Function Documentation

get_readiness()

bool dunedaq::utilities::ReusableThread::get_readiness ( ) const

inline

Definition at line 49 of file ReusableThread.hpp.

{ return m_task_executed; }

get_thread_id()

int dunedaq::utilities::ReusableThread::get_thread_id ( ) const

inline

Definition at line 40 of file ReusableThread.hpp.

{ return m_thread_id; }

operator=() [1/2]

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

delete

ReusableThread is not copy-assginable.

operator=() [2/2]

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

delete

ReusableThread is not move-assignable.

set_name()

void dunedaq::utilities::ReusableThread::set_name	(	const std::string &	name,
		int	tid )

Definition at line 41 of file ReusableThread.cpp.

{
  set_thread_id(tid);
  char tname[16];                                  // NOLINT
  snprintf(tname, 16, "%s-%d", name.c_str(), tid); // NOLINT
  auto handle = m_thread.native_handle();
  pthread_setname_np(handle, tname);
 
  m_named = true;
}

set_pin()

void dunedaq::utilities::ReusableThread::set_pin

(

int

cpuid

)

Definition at line 53 of file ReusableThread.cpp.

{
  // Require that the thread has been named
  if (!m_named) {
    ers::warning(ThreadingIssue(ERS_HERE, "May not set CPU affinity for un-named thread"));
  }
 
  auto handle = m_thread.native_handle();
  cpu_set_t cpuset;
  CPU_ZERO(&cpuset);
  CPU_SET(cpuid, &cpuset);
  int rc = pthread_setaffinity_np(handle, sizeof(cpu_set_t), &cpuset);
 
  if (rc != 0) {
    ers::warning(ThreadingIssue(ERS_HERE, "Error calling pthread_setaffinity_np: " + std::to_string(rc)));
  }
}

set_thread_id()

void dunedaq::utilities::ReusableThread::set_thread_id ( int tid )

inline

Definition at line 37 of file ReusableThread.hpp.

{ m_thread_id = tid; }

set_work()

template<typename Function, typename... Args>

bool dunedaq::utilities::ReusableThread::set_work ( Function && f, Args &&... args )

inline

Definition at line 53 of file ReusableThread.hpp.

  {
    if (!m_task_assigned && m_task_executed.exchange(false)) {
      m_task = std::bind(f, args...); // NOLINT
      m_task_assigned = true;
      m_cv.notify_all();
      return true;
    }
    return false;
  }

thread_worker()

void dunedaq::utilities::ReusableThread::thread_worker ( )

private

Definition at line 72 of file ReusableThread.cpp.

{
  std::unique_lock<std::mutex> lock(m_mtx);
 
  while (!m_thread_quit) {
    if (!m_task_executed && m_task_assigned) {
      m_task();
      m_task_executed = true;
      m_task_assigned = false;
    } else {
      m_cv.wait(lock);
    }
  }
 
  m_worker_done = true;
}

Member Data Documentation

m_cv

std::condition_variable dunedaq::utilities::ReusableThread::m_cv

private

Definition at line 76 of file ReusableThread.hpp.

m_mtx

std::mutex dunedaq::utilities::ReusableThread::m_mtx

private

Definition at line 75 of file ReusableThread.hpp.

m_named

std::atomic<bool> dunedaq::utilities::ReusableThread::m_named

private

Definition at line 71 of file ReusableThread.hpp.

m_task

std::function<void()> dunedaq::utilities::ReusableThread::m_task

private

Definition at line 72 of file ReusableThread.hpp.

m_task_assigned

std::atomic<bool> dunedaq::utilities::ReusableThread::m_task_assigned

private

Definition at line 68 of file ReusableThread.hpp.

m_task_executed

std::atomic<bool> dunedaq::utilities::ReusableThread::m_task_executed

private

Definition at line 67 of file ReusableThread.hpp.

m_thread

std::thread dunedaq::utilities::ReusableThread::m_thread

private

Definition at line 77 of file ReusableThread.hpp.

m_thread_id

int dunedaq::utilities::ReusableThread::m_thread_id

private

Definition at line 66 of file ReusableThread.hpp.

m_thread_quit

std::atomic<bool> dunedaq::utilities::ReusableThread::m_thread_quit

private

Definition at line 69 of file ReusableThread.hpp.

m_worker_done

std::atomic<bool> dunedaq::utilities::ReusableThread::m_worker_done

private

Definition at line 70 of file ReusableThread.hpp.

---

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

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