AlgorithmTimer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAKERNEL_ALGORITHMTIMER_H
#define ATHENAKERNEL_ALGORITHMTIMER_H
 
// Framework includes
#include "GaudiKernel/ServiceHandle.h"
 
// System includes
#include <time.h>
#include <signal.h>
#ifdef __APPLE__
#include <sys/signal.h>
#include <sys/time.h>
#endif
 
// STL includes
#include <functional>
#include <string>
#include <list>
 
#ifdef __APPLE__
typedef sigval sigval_t;
typedef itimerval timer_t;
#endif //MacOSX
 
namespace Athena {
 
  //forward declarations
  class ScopedTimer;
  
  namespace AlgorithmTimerHandler
  {
    void onAlarmThread(sigval_t sv);
  }
 
  class AlgorithmTimer
  {
    friend void AlgorithmTimerHandler::onAlarmThread(sigval_t sv);
  
  public:
 
    enum AlgorithmTimerConfig
      {
        DEFAULT          = 0x0,    
        USEREALTIME      = 0x1,    
      };
  
    typedef std::function<void()> callbackFct_t;
  
    AlgorithmTimer(unsigned int milliseconds,
                   callbackFct_t callback = NULL,
                   AlgorithmTimerConfig conf = DEFAULT);
  
    ~AlgorithmTimer();
  
    void start() { start(m_timeout); }
  
    void start(unsigned int milliseconds);
 
    void start(ScopedTimer& scope);
  
    unsigned int stop();
  
    unsigned int timeLeft() const;
  
    unsigned int timeout() const { return m_timeout; }
  
    void SetGDBCoreDumpDetails(unsigned int details)
    { m_gdb_details = details; };
  
  protected:
  
    unsigned int     m_timeout;         
    struct sigevent  m_sigevent;        
    timer_t          m_timerid;         
    callbackFct_t    m_onAlarm;         
    std::atomic_bool m_active;          
  
  
  private:
    // Dummies
    AlgorithmTimer();                                 
    AlgorithmTimer(const AlgorithmTimer&);            
    AlgorithmTimer& operator=(const AlgorithmTimer&); 
  
    callbackFct_t abortJob();
  
    unsigned int m_gdb_details;
  };
 
 
  class ScopedTimer {
    friend class AlgorithmTimer;
  public:
    ScopedTimer(unsigned int milliseconds) : m_timeout(milliseconds), m_timer(0) {}
    ~ScopedTimer() { if (m_timer) m_timer->stop(); }
  private:
    unsigned int m_timeout;        
    AlgorithmTimer* m_timer;       
  };
  
} // namespace Athena
 
#endif