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/stk_config.h>
#if defined( STK_HAS_MPI )
#include <mpi.h>
#endif
 
#include <stk_util/diag/TimerMetricTraits.hpp>
#include <stk_util/parallel/Parallel.hpp>
#include <stk_util/environment/FormatTime.hpp>
#include <stk_util/diag/Writer_fwd.hpp>
 
#include <stk_util/diag/String.hpp>
#include <stk_util/diag/WriterParser.hpp>
#include <stk_util/diag/Option.hpp>
 
 
 
namespace stk_classic {
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_classic
 
 
namespace sierra {
namespace Diag {
 
typedef stk_classic::diag::Timer Timer;
typedef stk_classic::diag::TimerSet TimerSet;
typedef stk_classic::TimeFormat TimeFormat;
typedef stk_classic::diag::TimeBlock TimeBlock;
typedef stk_classic::diag::TimeBlockSynchronized TimeBlockSynchronized;
 
enum TimerSetMask{
  TIMER_DOMAIN    = 0x00000001,   
  TIMER_REGION    = 0x00000002,   
  TIMER_PROCEDURE = 0x00000004,   
  TIMER_MECHANICS = 0x00000008,   
  TIMER_ALGORITHM = 0x00000010,   
  TIMER_SOLVER    = 0x00000020,   
  TIMER_CONTACT   = 0x00000040,   
  TIMER_MATERIAL  = 0x00000080,   
  TIMER_SEARCH    = 0x00000100,   
  TIMER_TRANSFER  = 0x00000200,   
  TIMER_ADAPTIVITY  = 0x00000400,   
  TIMER_RECOVERY  = 0x00000800,   
  TIMER_PROFILE_1 = 0x00001000,   
  TIMER_PROFILE_2 = 0x00002000,   
  TIMER_PROFILE_3 = 0x00004000,   
  TIMER_PROFILE_4 = 0x00008000,   
  TIMER_APP_1   = 0x00010000,   
  TIMER_APP_2   = 0x00020000,   
  TIMER_APP_3   = 0x00040000,   
  TIMER_APP_4   = 0x00080000,   
  TIMER_ALL   = 0x000FFFFF,   
  TIMER_NONE    = 0x00000000,   
 
  TIMER_FORCE   = 0x00000000    
};
 
 
TimerSet &sierraTimerSet();
 
Timer &sierraTimer();
 
void sierraTimerDestroy();
 
class TimerParser;
 
typedef sierra::OptionMask TimerMask;     
 
enum {
  DEFAULT_TIMER_NAME_MAX_WIDTH = 40     
};
 
TimerParser &theTimerParser();
 
void setEnabledTimerMask(TimerMask timer_mask);
 
TimerMask getEnabledTimerMask();
 
void setTimeFormat(int time_format);
 
void setTimeFormatMillis();
 
int getTimeFormat();
 
void setTimerNameMaxWidth(size_t width);
 
size_t getTimerNameMaxWidth();
 
stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type getCPULapTime(Timer timer);
 
stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type getCPUAccumulatedLapTime(Timer timer);
 
stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type getSierraCPUTime();
stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type getSierraWallTime();
 
 
class TimerParser : public OptionMaskParser
{
public:
  TimerParser();
 
  Mask parse(const char *mask_string) const;
 
  virtual void parseArg(const std::string &name, const std::string &arg) const;  
 
  mutable stk_classic::diag::MetricsMask        m_metricsSetMask;
  mutable stk_classic::diag::MetricsMask        m_metricsMask;
};
 
 
class SierraRootTimer 
{
  public:
    SierraRootTimer();
    virtual ~SierraRootTimer();
    stk_classic::diag::Timer & sierraTimer();
 
  private:
    stk_classic::diag::Timer m_sierraTimer; 
};
 
} // namespace Diag
} // namespace sierra
 
 
#endif // STK_UTIL_DIAG_Timer_hpp