WatchdogThread Class Reference

Simple class for asynchronous check of time-out. More...

#include <GaudiKernel/WatchdogThread.h>

Collaboration diagram for WatchdogThread:

Public Member Functions
	WatchdogThread (boost::posix_time::time_duration timeout, bool autostart=false)
	Constructor. More...
virtual	~WatchdogThread ()
	Destructor. More...
void	start ()
	Start the watchdog thread. More...
void	stop ()
	Signal the watchdog thread to stop and wait for it. More...
void	ping ()
	Function to call to notify the watchdog thread that we are still alive. More...
void	setTimeout (boost::posix_time::time_duration timeout)
	Change the duration of the time-out. More...
boost::posix_time::time_duration	getTimeout () const
	Get the current time-out value. More...
boost::system_time	getLastPing () const
	Get the time of latest ping. More...

Protected Member Functions
virtual void	action ()
	User implemented function that will be called if the time-out is reached. More...
virtual void	onPing ()
	User implemented function that will be called when ping is called. More...
virtual void	onStart ()
	User implemented function that will be called when starting. More...
virtual void	onStop ()
	User implemented function that will be called when stopping. More...

Private Member Functions
void	i_run ()
	Core function of the secondary thread. More...

Private Attributes
boost::posix_time::time_duration	m_timeout
	Number of seconds allowed between pings. More...
boost::system_time	m_lastPing
	When the last ping was received. More...
std::unique_ptr< boost::thread >	m_thread
	Pointer to the running thread;. More...
bool	m_running
	Flag to mark the thread as running/stopped (avoid possible race conditions). More...
std::mutex	m_lastPingMutex
	Mutex for the access to the m_lastPing data member. More...

Detailed Description

Simple class for asynchronous check of time-out.

The user must provide a callable with the action to be performed when the time-out occurs.

Author

Marco Clemencic

Date

2010-02-23

Definition at line 37 of file WatchdogThread.h.

Constructor & Destructor Documentation

WatchdogThread()

WatchdogThread::WatchdogThread	(	boost::posix_time::time_duration	timeout,
		bool	autostart = false
	)

Constructor.

Definition at line 22 of file WatchdogThread.cpp.

    : m_timeout( std::move( timeout ) ), m_running( false ) {
  // Start the thread immediately if requested.
  if ( autostart ) start();
}

~WatchdogThread()

WatchdogThread::~WatchdogThread ( )

virtual

Destructor.

Definition at line 28 of file WatchdogThread.cpp.

                                {
  // Make sure the thread is stopped before exiting.
  stop();
}

Member Function Documentation

action()

void WatchdogThread::action ( )

protectedvirtual

User implemented function that will be called if the time-out is reached.

Definition at line 88 of file WatchdogThread.cpp.

{}

getLastPing()

boost::system_time WatchdogThread::getLastPing ( ) const

inline

Get the time of latest ping.

Definition at line 69 of file WatchdogThread.h.

                                              {
    auto lock = std::scoped_lock{m_lastPingMutex};
    return m_lastPing;
  }

getTimeout()

boost::posix_time::time_duration WatchdogThread::getTimeout ( ) const

inline

Get the current time-out value.

Definition at line 66 of file WatchdogThread.h.

{ return m_timeout; }

i_run()

void WatchdogThread::i_run ( )

private

Core function of the secondary thread.

Definition at line 57 of file WatchdogThread.cpp.

                           {
  // Copy of the last ping
  boost::system_time lastPing = getLastPing();

  // set initial check time
  boost::system_time nextCheck = lastPing + getTimeout();

  try {
    // enter infinite loop
    while ( m_running ) {
      // Wait until the next check point time is reached.
      // An early exit must be triggered by a call to this->interrupt(), which
      // will produce an exception during the sleep.
      boost::thread::sleep( nextCheck );
      // Check if there was a ping while we were sleeping
      if ( lastPing == getLastPing() ) { // no further accesses
        action();
        // schedule the next check for now + dt (seems a good estimate)
        nextCheck = boost::get_system_time() + getTimeout();
      } else { // there was a ping
        // schedule the next check for last_access + dt
        nextCheck = lastPing = getLastPing();
        nextCheck += getTimeout();
      }
    }
  }
  // Ignore the exception since it is used only to exit from the loop.
  catch ( boost::thread_interrupted& ) {}
}

onPing()

void WatchdogThread::onPing ( )

protectedvirtual

User implemented function that will be called when ping is called.

Definition at line 91 of file WatchdogThread.cpp.

{}

onStart()

void WatchdogThread::onStart ( )

protectedvirtual

User implemented function that will be called when starting.

Definition at line 94 of file WatchdogThread.cpp.

{}

onStop()

void WatchdogThread::onStop ( )

protectedvirtual

User implemented function that will be called when stopping.

Definition at line 97 of file WatchdogThread.cpp.

{}

ping()

void WatchdogThread::ping ( )

inline

Function to call to notify the watchdog thread that we are still alive.

Definition at line 56 of file WatchdogThread.h.

                     {
    auto lock  = std::scoped_lock{m_lastPingMutex};
    m_lastPing = boost::get_system_time();
    onPing();
  }

setTimeout()

void WatchdogThread::setTimeout ( boost::posix_time::time_duration  timeout )

inline

Change the duration of the time-out.

Definition at line 63 of file WatchdogThread.h.

{ m_timeout = timeout; }

start()

void WatchdogThread::start

(

)

Start the watchdog thread.

Definition at line 33 of file WatchdogThread.cpp.

                           {
  if ( !m_thread ) { // can be started only if the thread is not yet started
    m_running = true;
    // call user-defined function
    onStart();
    // Initialize the first "last ping"
    ping();
    // Start a new thread telling it to call the member function i_run()
    m_thread = std::make_unique<boost::thread>( std::mem_fn( &WatchdogThread::i_run ), this );
  }
}

stop()

void WatchdogThread::stop

(

)

Signal the watchdog thread to stop and wait for it.

Definition at line 45 of file WatchdogThread.cpp.

                          {
  if ( m_thread ) {
    m_running = false;           // mark the thread as stopped (interrupt doesn't work if the thread is not sleeping)
    Gaudi::NanoSleep( 1000000 ); // Wait a bit (1ms) to be sure that the interrupt happens during the sleep
    m_thread->interrupt();       // tell the thread to stop (if it is waiting)
    m_thread->join();            // wait for it
    m_thread.reset();            // delete it
    // call user-defined function
    onStop();
  }
}

Member Data Documentation

m_lastPing

boost::system_time WatchdogThread::m_lastPing

private

When the last ping was received.

Definition at line 92 of file WatchdogThread.h.

m_lastPingMutex

std::mutex WatchdogThread::m_lastPingMutex

mutableprivate

Mutex for the access to the m_lastPing data member.

Definition at line 106 of file WatchdogThread.h.

m_running

bool WatchdogThread::m_running

private

Flag to mark the thread as running/stopped (avoid possible race conditions).

Definition at line 98 of file WatchdogThread.h.

m_thread

std::unique_ptr<boost::thread> WatchdogThread::m_thread

private

Pointer to the running thread;.

Definition at line 95 of file WatchdogThread.h.

m_timeout

boost::posix_time::time_duration WatchdogThread::m_timeout

private

Number of seconds allowed between pings.

Definition at line 89 of file WatchdogThread.h.

---

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

• GaudiKernel/GaudiKernel/WatchdogThread.h
• GaudiKernel/src/Lib/WatchdogThread.cpp