Timer.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/

#ifndef stk_util_diag_Timer_hpp
#define stk_util_diag_Timer_hpp

#include <iosfwd>
#include <vector>
#include <list>
#include <string>

#include <stk_util/diag/TimerMetricTraits.hpp>
#include <stk_util/parallel/Parallel.hpp>
#include <stk_util/util/FormatTime.hpp>
#include <stk_util/diag/Writer_fwd.hpp>


namespace stk {
namespace diag {

class Timer;
class TimerSet;
class TimerImpl;

typedef unsigned TimerMask;        

MetricsMask getEnabledTimerMetricsMask();

void setEnabledTimerMetricsMask(MetricsMask timer_mask);

void updateRootTimer(Timer root_timer);

Timer createRootTimer(const std::string &name, const TimerSet &timer_set);

void deleteRootTimer(Timer timer);

std::vector<Timer> &findTimers(Timer root_timer, const std::string &path_tail, std::vector<Timer> &found_timers);

class TimerSet
{
public:
  explicit TimerSet(TimerMask enabled_timer_mask)
    : m_enabledTimerMask(enabled_timer_mask)
  {}

private:
  TimerSet(const TimerSet &timer_set)
    : m_enabledTimerMask(timer_set.m_enabledTimerMask)
  {}

  TimerSet &operator=(TimerSet &timer_set) {
    m_enabledTimerMask = timer_set.m_enabledTimerMask;

    return *this;
  }

public:
  ~TimerSet()
  {}

  TimerMask getEnabledTimerMask() const {
    return m_enabledTimerMask;
  }

  void setEnabledTimerMask(TimerMask timer_mask) {
    m_enabledTimerMask = timer_mask;
  }

  bool shouldRecord(TimerMask timer_mask) const {
    return (timer_mask == 0 || (m_enabledTimerMask & timer_mask));
  }

private:
  TimerMask    m_enabledTimerMask;  
};


typedef std::list<Timer> TimerList;    

class Timer
{
  friend class TimerImpl;
  friend class TimeBlock;
  friend class TimeBlockSynchronized;
  friend void updateRootTimer(Timer);
  friend Timer createRootTimer(const std::string &, const TimerSet &);
  friend void deleteRootTimer(Timer);
  friend std::vector<Timer> &findTimers(Timer, const std::string &, std::vector<Timer> &);

public:
  template <typename T>
  struct Metric
  {
    Metric()
      : m_lapStart(0),
        m_lapStop(0),
        m_accumulatedLap(0),
        m_checkpoint(0)
    {}

    void reset() {
      m_lapStart = m_lapStop = m_accumulatedLap = m_checkpoint = 0;
    }

    typename MetricTraits<T>::Type addLap() {
      return m_accumulatedLap += m_lapStop - m_lapStart;
    }

    void checkpoint() const {
      m_checkpoint = m_accumulatedLap;
    }

    typename MetricTraits<T>::Type getLap() const {
      return m_lapStop - m_lapStart;
    }

    typename MetricTraits<T>::Type getStart() const {
      return m_lapStart;
    }

    typename MetricTraits<T>::Type getStop() const {
      return m_lapStop;
    }

    typename MetricTraits<T>::Type getAccumulatedLap(bool arg_checkpoint = false) const {
      if (arg_checkpoint)
        return m_accumulatedLap - m_checkpoint;
      else
        return m_accumulatedLap;
    }

    Writer &dump(Writer &dout) const;

    typename MetricTraits<T>::Type    m_lapStart;    
    typename MetricTraits<T>::Type    m_lapStop;    
    typename MetricTraits<T>::Type    m_accumulatedLap;  
    mutable typename MetricTraits<T>::Type      m_checkpoint;    
  };

  Timer(const std::string &name, const Timer parent);

  Timer(const std::string &name, const Timer parent, const TimerSet &timer_set);

  Timer(const std::string &name, TimerMask timer_mask, const Timer parent);

  Timer(const std::string &name, TimerMask timer_mask, const Timer parent, const TimerSet &timer_set);

  explicit Timer(TimerImpl &timer_impl)
    : m_timerImpl(&timer_impl)
  {}

  explicit Timer(TimerImpl *timer_impl)
    : m_timerImpl(timer_impl)
  {}

  Timer(const Timer &timer)
    : m_timerImpl(timer.m_timerImpl)
  {}

  Timer &operator=(const Timer &timer) {
    if (this != &timer)
      m_timerImpl = timer.m_timerImpl;

    return *this;
  }

  virtual ~Timer()
  {}

  const TimerList &getTimerList() const;

  TimerList::iterator begin();
  TimerList::const_iterator begin() const;
  TimerList::iterator end();
  TimerList::const_iterator end() const;

  const std::string &getName() const;


  const TimerSet &getTimerSet() const;

  TimerMask getTimerMask() const;

  bool shouldRecord() const;

  double getSubtimerLapCount() const;

  template <class T>
  const Metric<T> &getMetric() const;

  double accumulateSubtimerLapCounts() const;

  Timer &start();

  Timer &lap();

  Timer &stop();

  void checkpoint() const;

  Writer &dump(Writer& dout) const;

private:
  TimerImpl *    m_timerImpl;      
};



class TimeBlock
{
public:
  explicit TimeBlock(Timer &timer, bool start_timer = true)
    : m_timer(timer),
      m_started(start_timer)
  {
    if (start_timer)
      m_timer.start();
  }

private:
  TimeBlock(const TimeBlock &);
  TimeBlock &operator=(const TimeBlock &);

public:
  ~TimeBlock() {
    try {
      if (m_started)
        m_timer.stop();
    }
    catch (...) {
    }
  }

  void start() {
    m_started = true;
    m_timer.start();
  }

  void lap() {
    m_timer.lap();
  }

  void stop() {
    m_started = false;
    m_timer.stop();
  }

private:
  Timer &               m_timer;  
  bool      m_started;  
};

class TimeBlockSynchronized
{
public:
  TimeBlockSynchronized(Timer &timer, ParallelMachine mpi_comm, bool start_timer = true);

  ~TimeBlockSynchronized();

  void start();

  void stop();

private:
  Timer &      m_timer;  
  ParallelMachine    m_mpiComm;  
  bool      m_started;  
};


template <class T>
inline Writer &operator<<(Writer &dout, const Timer::Metric<T> &timer) {
  return timer.dump(dout);
}

inline Writer &operator<<(Writer &dout, const Timer &timer) {
  return timer.dump(dout);
}

} // namespace diag
} // namespace stk


#endif // stk_util_diag_Timer_hpp