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