SequencerTimerTool.h

Go to the documentation of this file.

#ifndef SEQUENCERTIMERTOOL_H
#define SEQUENCERTIMERTOOL_H 1

// Include files
// from Gaudi
#include "GaudiAlg/GaudiHistoTool.h"
#include "GaudiAlg/ISequencerTimerTool.h"

// local
#include "TimerForSequencer.h"

class SequencerTimerTool : public GaudiHistoTool, virtual public ISequencerTimerTool
{

public:
  using ISequencerTimerTool::start;
  using ISequencerTimerTool::stop;
  using ISequencerTimerTool::name;

public:
  SequencerTimerTool( const std::string& type, const std::string& name, const IInterface* parent );

  ~SequencerTimerTool() override = default; 

  StatusCode initialize() override;

  StatusCode finalize() override;

  int addTimer( const std::string& name ) override;

  void increaseIndent() override { m_indent += 1; }

  void decreaseIndent() override { m_indent = std::max( m_indent - 1, 0 ); }

  void start( int index ) override { m_timerList[index].start(); }

  double stop( int index ) override { return m_timerList[index].stop(); }

  double lastTime( int index ) override { return m_timerList[index].lastTime(); }

  const std::string& name( int index ) override { return m_timerList[index].name(); }

  int indexByName( const std::string& name ) override;

  bool globalTiming() override { return m_globalTiming; };

  void saveHistograms() override;

private:
  Gaudi::Property<int> m_shots{this, "Shots", 3500000, "number of shots for CPU normalization"};
  Gaudi::Property<bool> m_normalised{this, "Normalised", false, "normalise the time to a nominal PIII"};
  Gaudi::Property<bool> m_globalTiming{this, "GlobalTiming", false};
  Gaudi::Property<std::string::size_type> m_headerSize{this, "NameSize", 30,
                                                       "number of characters to be used in algorithm name column"};

  int m_indent = 0; 
  std::vector<TimerForSequencer> m_timerList;
  double m_normFactor = 0.001; 
  double m_speedRatio = 0;
};
#endif // SEQUENCERTIMERTOOL_H