omt::ThreadHandoff Class Reference

#include <ThreadHandoff.h>

Classes
class	Functor
class	FunctorBase

Public Member Functions
const ThreadHandoff &	operator= (const ThreadHandoff &)=delete
template<typename F >
void	runAndWait (F &&iF)
void	stopThread ()
	ThreadHandoff (int stackSize)
	ThreadHandoff (const ThreadHandoff &)=delete
	~ThreadHandoff ()

Static Private Member Functions
static void *	threadLoop (void *iArgs)

Private Attributes
bool	m_loopReady {false}
std::mutex	m_mutex
bool	m_stopThread {false}
pthread_t	m_thread
std::condition_variable	m_threadHandoff
FunctorBase *	m_toRun {nullptr}

Detailed Description

Definition at line 33 of file ThreadHandoff.h.

Constructor & Destructor Documentation

ThreadHandoff() [1/2]

ThreadHandoff::ThreadHandoff ( int  stackSize )

explicit

Definition at line 41 of file ThreadHandoff.cc.

References Exception, m_loopReady, m_mutex, m_thread, m_threadHandoff, and threadLoop().

                                          {
  pthread_attr_t attr;
  int erno;
  if (0 != (erno = pthread_attr_init(&attr))) {
    throw cms::Exception("ThreadInitFailed")
        << "Failed to initialize thread attributes (" << erno << ") " << errorMessage(erno);
  }

  if (0 != (erno = pthread_attr_setstacksize(&attr, stackSize))) {
    throw cms::Exception("ThreadStackSizeFailed")
        << "Failed to set stack size " << stackSize << " " << errorMessage(erno);
  }
  std::unique_lock<std::mutex> lk(m_mutex);

  erno = pthread_create(&m_thread, &attr, threadLoop, this);
  if (0 != erno) {
    throw cms::Exception("ThreadCreateFailed") << " failed to create a pthread (" << erno << ") " << errorMessage(erno);
  }
  m_loopReady = false;
  m_threadHandoff.wait(lk, [this]() { return m_loopReady; });
}

~ThreadHandoff()

ThreadHandoff::~ThreadHandoff

(

)

Definition at line 68 of file ThreadHandoff.cc.

References m_stopThread, m_thread, runTheMatrix::ret, and stopThread().

                              {
  if (not m_stopThread) {
    stopThread();
  }
  void* ret;
  pthread_join(m_thread, &ret);
}

ThreadHandoff() [2/2]

omt::ThreadHandoff::ThreadHandoff ( const ThreadHandoff &  )

delete

Member Function Documentation

operator=()

const ThreadHandoff& omt::ThreadHandoff::operator= ( const ThreadHandoff &  )

delete

runAndWait()

template<typename F >

void omt::ThreadHandoff::runAndWait ( F &&  iF )

inline

Definition at line 42 of file ThreadHandoff.h.

References MillePedeFileConverter_cfg::e, f, m_loopReady, m_mutex, m_threadHandoff, m_toRun, and eostools::move().

Referenced by OscarMTProducer::beginRun(), OscarMTProducer::endRun(), OscarMTProducer::produce(), stopThread(), and OscarMTProducer::~OscarMTProducer().

                            {
      Functor<F> f{std::move(iF)};

      std::unique_lock<std::mutex> lck(m_mutex);
      m_loopReady = false;
      m_toRun = &f;

      m_threadHandoff.notify_one();

      m_threadHandoff.wait(lck, [this]() { return m_loopReady; });
      auto e = f.exception();
      if (e) {
        std::rethrow_exception(e);
      }
    }

stopThread()

void omt::ThreadHandoff::stopThread ( )

inline

Definition at line 58 of file ThreadHandoff.h.

References m_stopThread, and runAndWait().

Referenced by ~ThreadHandoff().

                      {
      runAndWait([this]() { m_stopThread = true; });
    }

threadLoop()

void * ThreadHandoff::threadLoop ( void *  iArgs )

staticprivate

Definition at line 99 of file ThreadHandoff.cc.

Referenced by ThreadHandoff().

                                           {
  auto theThis = reinterpret_cast<ThreadHandoff*>(iArgs);

  //need to hold lock until wait to avoid both threads
  // being stuck in wait
  std::unique_lock<std::mutex> lck(theThis->m_mutex);
  theThis->m_loopReady = true;
  theThis->m_threadHandoff.notify_one();

  do {
    theThis->m_toRun = nullptr;
    theThis->m_threadHandoff.wait(lck, [theThis]() { return nullptr != theThis->m_toRun; });
    theThis->m_toRun->execute();
    theThis->m_loopReady = true;
    theThis->m_threadHandoff.notify_one();
  } while (not theThis->m_stopThread);
  theThis->m_loopReady = true;
  return nullptr;
}

Member Data Documentation

m_loopReady

bool omt::ThreadHandoff::m_loopReady {false}

private

Definition at line 94 of file ThreadHandoff.h.

Referenced by runAndWait(), and ThreadHandoff().

m_mutex

std::mutex omt::ThreadHandoff::m_mutex

private

Definition at line 90 of file ThreadHandoff.h.

Referenced by runAndWait(), and ThreadHandoff().

m_stopThread

bool omt::ThreadHandoff::m_stopThread {false}

private

Definition at line 95 of file ThreadHandoff.h.

Referenced by stopThread(), and ~ThreadHandoff().

m_thread

pthread_t omt::ThreadHandoff::m_thread

private

Definition at line 89 of file ThreadHandoff.h.

Referenced by ThreadHandoff(), and ~ThreadHandoff().

m_threadHandoff

std::condition_variable omt::ThreadHandoff::m_threadHandoff

private

Definition at line 91 of file ThreadHandoff.h.

Referenced by runAndWait(), and ThreadHandoff().

m_toRun

FunctorBase* omt::ThreadHandoff::m_toRun {nullptr}

private

Definition at line 93 of file ThreadHandoff.h.

Referenced by runAndWait().