#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::ThreadHandoff ( int stackSize )

explicit

Definition at line 40 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 ( )

Definition at line 67 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);
 }

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

delete

Member Function Documentation

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

delete

template<typename F >

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

inline

Definition at line 42 of file ThreadHandoff.h.

References alignCSCRings::e, validate-o2o-wbm::f, m_loopReady, m_mutex, m_threadHandoff, m_toRun, and eostools::move().

Referenced by OscarMTProducer::beginRun(), OscarMTProducer::endRun(), OscarMTProducer::OscarMTProducer(), 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);
       }
     }

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; });
     }

void * ThreadHandoff::threadLoop ( void * iArgs )

staticprivate

Definition at line 98 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;
 }