Timer.cpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 - 2011 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.                                             */
/*------------------------------------------------------------------------*/

#include <math.h>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <functional>
#include <stdexcept>
#include <limits>

#include <sys/times.h>
#include <sys/time.h>
#include <sys/resource.h>

#ifdef __JVN
#include <sys/wait.h>
#endif

#include <stk_util/util/FeatureTest.hpp>

#ifdef SIERRA_INCLUDE_LIBPAPI
#  include <papi.h>
#  if defined(PAPI_VERSION) && (PAPI_VERSION_MAJOR(PAPI_VERSION) != 3)
#    error "Compiling against an unknown PAPI version"
#  endif
#endif

// #include <fenv.h>
#include <math.h>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <functional>
#include <stdexcept>
#include <limits>

#include <stk_util/diag/Writer.hpp>
#include <stk_util/diag/Timer.hpp>
#include <stk_util/diag/PrintTable.hpp>
#include <stk_util/diag/Env.hpp>
#include <stk_util/parallel/MPI.hpp>

#include <stk_util/util/string_case_compare.hpp>

#include <stk_util/diag/WriterExt.hpp>

namespace stk_classic {
namespace diag {

namespace {

MetricsMask s_enabledMetricsMask = METRICS_LAP_COUNT | METRICS_CPU_TIME | METRICS_WALL_TIME;        

template <class T>
typename MetricTraits<T>::Type
value_now() {
  if (MetricTraits<T>::METRIC & getEnabledTimerMetricsMask())
    return MetricTraits<T>::value_now();
  else
    return 0;
}

std::vector<std::string> &
split(
  const std::string &           path,
  char                          separator,
  std::vector<std::string> &    path_vector)
{
  for (std::string::const_iterator it = path.begin(); ; ) {
    std::string::const_iterator it2 = std::find(it, path.end(), separator);
    path_vector.push_back(std::string(it, it2));
    if (it2 == path.end())
      break;
    it = it2 + 1;
  }
  
  return path_vector;
}

} // namespace <empty>


MetricsMask getEnabledTimerMetricsMask()
{
  return s_enabledMetricsMask;
}

void
setEnabledTimerMetricsMask(
  MetricsMask   timer_mask)
{
  s_enabledMetricsMask = timer_mask | METRICS_LAP_COUNT;
}


class TimerImpl
{
  friend class Timer;
  
public:
  static void updateRootTimer(TimerImpl *root_timer);
  
  static Timer createRootTimer(const std::string &name, const TimerSet &timer_set);
    
  static void deleteRootTimer(TimerImpl *root_timer);

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

  static void findTimer(TimerImpl *timer, std::vector<std::string> &path_tail_vector, std::vector<Timer> &found_timers);
  
private:
  static TimerImpl *reg(const std::string &name, TimerMask timer_mask, TimerImpl *parent_timer, const TimerSet &timer_set) {
    return parent_timer->addSubtimer(name, timer_mask, timer_set);
  }

  TimerImpl(const std::string &name, TimerMask timer_mask, TimerImpl *parent_timer, const TimerSet &timer_set);

  ~TimerImpl();
  
  TimerImpl(const TimerImpl &TimerImpl);
  TimerImpl &operator=(const TimerImpl &TimerImpl);
  
#ifdef __INTEL_COMPILER
#pragma warning(push)
#pragma warning(disable: 444)
#endif
  class finder : private std::unary_function<Timer, bool>
  {
  public:
    explicit finder(const std::string &name)
      : m_name(name)
    {}
    
    bool operator()(Timer timer) const {
      return equal_case(timer.getName(), m_name);
    }

  private:
    std::string    m_name;
  };
#ifdef __INTEL_COMPILER
#pragma warning(pop)
#endif

public:
  const std::string &getName() const {
    return m_name;
  }

  TimerMask getTimerMask() const {
    return m_timerMask;
  }

  const TimerSet &getTimerSet() const {
    return m_timerSet;
  }

  bool shouldRecord() const {
    return m_timerSet.shouldRecord(m_timerMask) && s_enabledMetricsMask;
  }

  double getSubtimerLapCount() const {
    return m_subtimerLapCount;
  }

  void setSubtimerLapCount(double value) {
    m_subtimerLapCount = value;
  }

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

  const TimerList &getTimerList() const {
    return m_subtimerList;
  }
 
  TimerList::iterator begin() {
    return m_subtimerList.begin();
  }
    
  TimerList::const_iterator begin() const {
    return m_subtimerList.begin();
  }
    
  TimerList::iterator end() {
    return m_subtimerList.end();
  }
    
  TimerList::const_iterator end() const {
    return m_subtimerList.end();
  }
    
  void reset();

  void checkpoint() const;

  TimerImpl &start();

  TimerImpl &lap();

  TimerImpl &stop();

  double accumulateSubtimerLapCounts() const;

  Timer getSubtimer(const std::string &name);

public:
  Writer &dump(Writer &dout) const;

private:
  TimerImpl *addSubtimer(const std::string &name, TimerMask timer_mask, const TimerSet &timer_set);

private:
  std::string           m_name;                 
  TimerMask             m_timerMask;            
  TimerImpl *           m_parentTimer;          
  mutable double        m_subtimerLapCount;     
  unsigned              m_lapStartCount;        

  TimerList             m_subtimerList;         

  const TimerSet &              m_timerSet;     
  Timer::Metric<LapCount>       m_lapCount;     
  Timer::Metric<CPUTime>        m_cpuTime;      
  Timer::Metric<WallTime>       m_wallTime;     
  Timer::Metric<MPICount>       m_MPICount;     
  Timer::Metric<MPIByteCount>   m_MPIByteCount; 
  Timer::Metric<HeapAlloc>      m_heapAlloc;    
};


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


void
updateRootTimer(
  Timer                 root_timer)
{
  TimerImpl::updateRootTimer(root_timer.m_timerImpl);
}


Timer
createRootTimer(
  const std::string &   name,
  const TimerSet &      timer_set)
{
  return TimerImpl::createRootTimer(name, timer_set);
}


void
deleteRootTimer(
  Timer                 timer)
{
  TimerImpl::deleteRootTimer(timer.m_timerImpl);
  timer.m_timerImpl = 0;
}


std::vector<Timer> &
findTimers(Timer root_timer, const std::string &path_tail, std::vector<Timer> &found_timers) {
  TimerImpl::findTimers(root_timer.m_timerImpl, path_tail, found_timers);
  return found_timers;
}


TimerImpl::TimerImpl(
  const std::string &  name,
  TimerMask    timer_mask,
  TimerImpl *    parent_timer,
  const TimerSet &      timer_set)
  : m_name(name),
    m_timerMask(timer_mask),
    m_parentTimer(parent_timer),
    m_subtimerLapCount(0.0),
    m_lapStartCount(0),
    m_subtimerList(),
    m_timerSet(timer_set)
{}


TimerImpl::~TimerImpl()
{
  try {  
    for (TimerList::iterator it = m_subtimerList.begin(); it != m_subtimerList.end(); ++it)
      delete (*it).m_timerImpl;
  }
  catch (std::exception &) {
  }  
}


template<>
const Timer::Metric<LapCount> &
TimerImpl::getMetric<LapCount>() const {
  return m_lapCount;
}


template<>
const Timer::Metric<CPUTime> &
TimerImpl::getMetric<CPUTime>() const {
  return m_cpuTime;
}


template<>
const Timer::Metric<WallTime> &
TimerImpl::getMetric<WallTime>() const {
  return m_wallTime;
}


template<>
const Timer::Metric<MPICount> &
TimerImpl::getMetric<MPICount>() const {
  return m_MPICount;
}


template<>
const Timer::Metric<MPIByteCount> &
TimerImpl::getMetric<MPIByteCount>() const {
  return m_MPIByteCount;
}


template<>
const Timer::Metric<HeapAlloc> &
TimerImpl::getMetric<HeapAlloc>() const {
  return m_heapAlloc;
}


void
TimerImpl::reset()
{
  m_lapStartCount = 0;

  m_lapCount.reset();
  m_cpuTime.reset();
  m_wallTime.reset();
  m_MPICount.reset();
  m_MPIByteCount.reset();
  m_heapAlloc.reset();
}


Timer
TimerImpl::getSubtimer(
  const std::string &  name)
{
  TimerList::iterator it = std::find_if(m_subtimerList.begin(), m_subtimerList.end(), finder(name));

  if (it == m_subtimerList.end())
    throw std::runtime_error("Timer not found");
  else
    return *it;
}


TimerImpl *
TimerImpl::addSubtimer(
  const std::string &  name,
  TimerMask          timer_mask,
  const TimerSet &      timer_set)
{
  TimerList::iterator it = std::find_if(m_subtimerList.begin(), m_subtimerList.end(), finder(name));

  if (it == m_subtimerList.end()) {
    TimerImpl *timer_impl = new TimerImpl(name, timer_mask, this, timer_set);
    m_subtimerList.push_back(Timer(timer_impl));
    return timer_impl;
  }
  else
    return (*it).m_timerImpl;
}


TimerImpl &
TimerImpl::start()
{
  if (shouldRecord()) {
    if (m_lapStartCount++ == 0) {
      m_lapCount.m_lapStart = m_lapCount.m_lapStop;

      m_cpuTime.m_lapStop = m_cpuTime.m_lapStart = value_now<CPUTime>();
      m_wallTime.m_lapStop = m_wallTime.m_lapStart = value_now<WallTime>();
      m_MPICount.m_lapStop = m_MPICount.m_lapStart = value_now<MPICount>();
      m_MPIByteCount.m_lapStop = m_MPIByteCount.m_lapStart = value_now<MPIByteCount>();
      m_heapAlloc.m_lapStop = m_heapAlloc.m_lapStart = value_now<HeapAlloc>();
    }
  }

  return *this;
}


TimerImpl &
TimerImpl::lap()
{
  if (shouldRecord()) {
    if (m_lapStartCount > 0) {
      m_cpuTime.m_lapStop = value_now<CPUTime>();
      m_wallTime.m_lapStop = value_now<WallTime>();
      m_MPICount.m_lapStop = value_now<MPICount>();
      m_MPIByteCount.m_lapStop = value_now<MPIByteCount>();
      m_heapAlloc.m_lapStop = value_now<HeapAlloc>();
    }
  }

  return *this;
}


TimerImpl &
TimerImpl::stop()
{
  if (shouldRecord()) {
    if (--m_lapStartCount <= 0) {
      m_lapStartCount = 0;
      m_lapCount.m_lapStop++;

      m_cpuTime.m_lapStop = value_now<CPUTime>();
      m_wallTime.m_lapStop = value_now<WallTime>();
      m_MPICount.m_lapStop = value_now<MPICount>();
      m_MPIByteCount.m_lapStop = value_now<MPIByteCount>();
      m_heapAlloc.m_lapStop = value_now<HeapAlloc>();

      m_lapCount.addLap();
      m_cpuTime.addLap();
      m_wallTime.addLap();
      m_MPICount.addLap();
      m_MPIByteCount.addLap();
      m_heapAlloc.addLap();
    }
  }

  return *this;
}


double
TimerImpl::accumulateSubtimerLapCounts() const
{
  m_subtimerLapCount = m_lapCount.getAccumulatedLap(false);

  for (TimerList::const_iterator it = m_subtimerList.begin(); it != m_subtimerList.end(); ++it)
    (*it).m_timerImpl->accumulateSubtimerLapCounts();

  for (TimerList::const_iterator it = m_subtimerList.begin(); it != m_subtimerList.end(); ++it)
    m_subtimerLapCount += (*it).m_timerImpl->m_subtimerLapCount;

  return m_subtimerLapCount;
}


void
TimerImpl::checkpoint() const
{
  m_lapCount.checkpoint();
  m_cpuTime.checkpoint();
  m_wallTime.checkpoint();
  m_MPICount.checkpoint();
  m_MPIByteCount.checkpoint();
  m_heapAlloc.checkpoint();

  for (TimerList::const_iterator it = m_subtimerList.begin(); it != m_subtimerList.end(); ++it)
    (*it).m_timerImpl->checkpoint();
}


void
TimerImpl::updateRootTimer(TimerImpl *root_timer)
{
  root_timer->m_lapCount.m_lapStop = value_now<LapCount>();
  root_timer->m_cpuTime.m_lapStop = value_now<CPUTime>();
  root_timer->m_wallTime.m_lapStop = value_now<WallTime>();
  root_timer->m_MPICount.m_lapStop = value_now<MPICount>();
  root_timer->m_MPIByteCount.m_lapStop = value_now<MPIByteCount>();
  root_timer->m_heapAlloc.m_lapStop = value_now<HeapAlloc>();

  root_timer->m_lapCount.m_accumulatedLap = root_timer->m_lapCount.m_lapStop - root_timer->m_lapCount.m_lapStart;
  root_timer->m_cpuTime.m_accumulatedLap = root_timer->m_cpuTime.m_lapStop - root_timer->m_cpuTime.m_lapStart;
  root_timer->m_wallTime.m_accumulatedLap = root_timer->m_wallTime.m_lapStop - root_timer->m_wallTime.m_lapStart;
  root_timer->m_MPICount.m_accumulatedLap = root_timer->m_MPICount.m_lapStop - root_timer->m_MPICount.m_lapStart;
  root_timer->m_MPIByteCount.m_accumulatedLap = root_timer->m_MPIByteCount.m_lapStop - root_timer->m_MPIByteCount.m_lapStart;
  root_timer->m_heapAlloc.m_accumulatedLap = root_timer->m_heapAlloc.m_lapStop - root_timer->m_heapAlloc.m_lapStart;
}



Timer
TimerImpl::createRootTimer(
  const std::string &   name,
  const TimerSet &      timer_set)
{
  TimerImpl *timer_impl = new TimerImpl(name, 0, 0, timer_set);
  return Timer(timer_impl);
}


void
TimerImpl::deleteRootTimer(
  TimerImpl *           root_timer)
{
  delete root_timer;
}


void
TimerImpl::findTimer(
  TimerImpl *                   timer,
  std::vector<std::string> &    path_tail_vector,
  std::vector<Timer> &          found_timers)
{
  if (timer->begin() == timer->end()) { // at leaf
    
  }
  else
    for (TimerList::const_iterator it = timer->begin(); it != timer->end(); ++it)
      findTimer((*it).m_timerImpl, path_tail_vector, found_timers);
}


std::vector<Timer> &
TimerImpl::findTimers(
  TimerImpl *                   root_timer,
  const std::string &           path_tail,
  std::vector<Timer> &          found_timers)
{
  std::vector<std::string> path_tail_vector;
  
  findTimer(root_timer, split(path_tail, '.', path_tail_vector), found_timers);

  return found_timers;
}



Writer &
TimerImpl::dump(
  Writer &    dout) const
{
  if (dout.shouldPrint()) {
    dout << "TimerImpl" << push << dendl;
    dout << "m_name, " << m_name << dendl;
    dout << "m_timerMask, " << m_timerMask << dendl;
//    dout << "m_parentTimer, " << c_ptr_name(m_parentTimer) << dendl;
    dout << "m_subtimerLapCount, " << m_subtimerLapCount << dendl;
    dout << "m_lapStartCount, " << m_lapStartCount << dendl;

    dout << "m_lapCount, " << m_lapCount << dendl;
    dout << "m_cpuTime, " << m_cpuTime << dendl;
    dout << "m_wallTime, " << m_wallTime << dendl;
    dout << "m_MPICount, " << m_MPICount << dendl;
    dout << "m_MPIByteCount, " << m_MPIByteCount << dendl;
    dout << "m_heapAlloc, " << m_heapAlloc << dendl;

    dout << "m_subtimerList, " << m_subtimerList << dendl;
    dout << pop;
  }

  return dout;
}


Timer::Timer(const std::string &name, const Timer parent)
  : m_timerImpl(TimerImpl::reg(name, parent.getTimerMask(), parent.m_timerImpl, parent.getTimerSet()))
{}

Timer::Timer(const std::string &name, TimerMask timer_mask, const Timer parent)
  : m_timerImpl(TimerImpl::reg(name, timer_mask, parent.m_timerImpl, parent.getTimerSet()))
{}

Timer::Timer(const std::string &name, const Timer parent, const TimerSet &timer_set)
  : m_timerImpl(TimerImpl::reg(name, parent.getTimerMask(), parent.m_timerImpl, timer_set))
{}

Timer::Timer(const std::string &name, TimerMask timer_mask, const Timer parent, const TimerSet &timer_set)
  : m_timerImpl(TimerImpl::reg(name, timer_mask, parent.m_timerImpl, timer_set))
{}


const std::string &
Timer::getName() const {
  return m_timerImpl->m_name;
}

TimerMask
Timer::getTimerMask() const {
  return m_timerImpl->getTimerMask();
}

const TimerSet &
Timer::getTimerSet() const {
  return m_timerImpl->getTimerSet();
}

double
Timer::getSubtimerLapCount() const {
  return m_timerImpl->getSubtimerLapCount();
}

const TimerList &
Timer::getTimerList() const {
  return m_timerImpl->getTimerList();
}

template<class T>
const Timer::Metric<T> &
Timer::getMetric() const {
  return m_timerImpl->getMetric<T>();
}

template const Timer::Metric<LapCount> &Timer::getMetric<LapCount>() const;
template const Timer::Metric<CPUTime> &Timer::getMetric<CPUTime>() const;
template const Timer::Metric<WallTime> &Timer::getMetric<WallTime>() const;
template const Timer::Metric<MPICount> &Timer::getMetric<MPICount>() const;
template const Timer::Metric<MPIByteCount> &Timer::getMetric<MPIByteCount>() const;
template const Timer::Metric<HeapAlloc> &Timer::getMetric<HeapAlloc>() const;


bool
Timer::shouldRecord() const
{
  return m_timerImpl->shouldRecord();
}

TimerList::iterator
Timer::begin()
{
  return m_timerImpl->begin();
}
    
TimerList::const_iterator
Timer::begin() const
{
  return m_timerImpl->begin();
}
    
TimerList::iterator
Timer::end()
{
  return m_timerImpl->end();
}
    
TimerList::const_iterator
Timer::end() const
{
  return m_timerImpl->end();
}
    
double
Timer::accumulateSubtimerLapCounts() const {
  return m_timerImpl->accumulateSubtimerLapCounts();
}

Timer &
Timer::start() {
  m_timerImpl->start();
  return *this;
}

Timer &
Timer::lap() {
  m_timerImpl->lap();
  return *this;
}

Timer &
Timer::stop() {
  m_timerImpl->stop();
  return *this;
}

void
Timer::checkpoint() const {
  m_timerImpl->checkpoint();
}

Writer &
Timer::dump(Writer& dout) const {
  return m_timerImpl->dump(dout);
}

template <class T>
Writer &
Timer::Metric<T>::dump(
  Writer &    dout) const
{
  if (dout.shouldPrint()) {
    dout << "Timer::Metric<T>" << push << dendl;
    dout << "m_lapStart, " << m_lapStart << dendl;
    dout << "m_lapStop, " << m_lapStop << dendl;
    dout << "m_accumulatedLap, " << m_accumulatedLap << dendl;
    dout << "m_checkpoint, " << m_checkpoint << dendl;
    dout << pop;
  }
  return dout;
}

template Writer &Timer::Metric<LapCount>::dump(Writer &) const;
template Writer &Timer::Metric<CPUTime>::dump(Writer &) const;
template Writer &Timer::Metric<WallTime>::dump(Writer &) const;
template Writer &Timer::Metric<MPICount>::dump(Writer &) const;
template Writer &Timer::Metric<MPIByteCount>::dump(Writer &) const;
template Writer &Timer::Metric<HeapAlloc>::dump(Writer &) const;


TimeBlockSynchronized::TimeBlockSynchronized(
  Timer &    timer,
  MPI_Comm    mpi_comm,
  bool      start_timer)
  : m_timer(timer),
    m_mpiComm(mpi_comm),
    m_started(start_timer)
{
  if (m_timer.m_timerImpl->shouldRecord()) {
#ifdef STK_HAS_MPI
    if (mpi_comm != MPI_COMM_NULL)
      MPI_Barrier(mpi_comm);
#endif

    if (start_timer)
      m_timer.start();
  }
}


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


void
TimeBlockSynchronized::start()
{
  // Place barrier here
  MPI_Barrier(m_mpiComm);
  m_started = true;
  m_timer.start();
}


void
TimeBlockSynchronized::stop()
{
  m_started = false;
  m_timer.stop();
  // Does a barrier need to be here?
  // MPI_Barrier(Env::parallel_comm());
}

} // namespace diag
} // namespace stk_classic



#ifdef SIERRA_INCLUDE_LIBPAPI
class PAPIRuntimeError : public std::runtime_error
{
public:
  PAPIRuntimeError(const char *message, int status)
    : std::runtime_error(message),
      m_status(status)
  {}

  virtual const char *what() const throw() {
    static std::string message;
    static char papi_message[PAPI_MAX_STR_LEN];

    PAPI_perror(m_status, papi_message, sizeof(papi_message));

    message = std::runtime_error::what();
    message += papi_message;

    return message.c_str();
  }

private:
  int m_status;
};
#endif


namespace sierra {
namespace Diag {

namespace {

size_t
s_timerNameMaxWidth = DEFAULT_TIMER_NAME_MAX_WIDTH;   

} // namespace


// 
// SierraRootTimer member functions:
// 
SierraRootTimer::SierraRootTimer()
  : m_sierraTimer(stk_classic::diag::createRootTimer("Sierra", sierraTimerSet()))
{ }


SierraRootTimer::~SierraRootTimer()
{
  stk_classic::diag::deleteRootTimer(m_sierraTimer);
}


stk_classic::diag::Timer & SierraRootTimer::sierraTimer()
{
  return m_sierraTimer;
}


TimerSet &
sierraTimerSet()
{
  static TimerSet s_sierraTimerSet(TIMER_PROCEDURE | TIMER_REGION);

  return s_sierraTimerSet;
}


boost::shared_ptr<SierraRootTimer> sierraRootTimer()
{
  static boost::shared_ptr<SierraRootTimer> s_sierraRootTimer(new SierraRootTimer());
  if ( ! s_sierraRootTimer ) {
    s_sierraRootTimer.reset(new SierraRootTimer());
  }
  return s_sierraRootTimer;
}


Timer &
sierraTimer()
{
  return sierraRootTimer()->sierraTimer();
}

void
sierraTimerDestroy()
{
  sierraRootTimer().reset();
}


void
setEnabledTimerMask(
  TimerMask     timer_mask)
{
  sierraTimerSet().setEnabledTimerMask(timer_mask);
}


TimerMask
getEnabledTimerMask()
{
  return sierraTimerSet().getEnabledTimerMask();
}


void
setTimeFormat(int time_format) {
  stk_classic::diag::setTimerTimeFormat(time_format);
}


void
setTimeFormatMillis()
{
  if ((getTimeFormat() & stk_classic::TIMEFORMAT_STYLE_MASK ) == stk_classic::TIMEFORMAT_HMS) {
    if (getSierraWallTime() > 3600.0)
      setTimeFormat(getTimeFormat() & ~stk_classic::TIMEFORMAT_MILLIS);
    else
      setTimeFormat(getTimeFormat() | stk_classic::TIMEFORMAT_MILLIS);
  }
  else if ((getTimeFormat() & stk_classic::TIMEFORMAT_STYLE_MASK ) == stk_classic::TIMEFORMAT_SECONDS) {
    if (getSierraWallTime() > 1000.0)
      setTimeFormat(getTimeFormat() & ~stk_classic::TIMEFORMAT_MILLIS);
    else
      setTimeFormat(getTimeFormat() | stk_classic::TIMEFORMAT_MILLIS);
  }
}


int
getTimeFormat()
{
  return stk_classic::diag::getTimerTimeFormat();
}


void
setTimerNameMaxWidth(
  size_t        width)
{
  s_timerNameMaxWidth = width;
}


size_t
getTimerNameMaxWidth()
{
  return s_timerNameMaxWidth;
}


stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type
getSierraCPUTime()
{
  return sierraTimer().getMetric<stk_classic::diag::CPUTime>().getAccumulatedLap(false);
}


stk_classic::diag::MetricTraits<stk_classic::diag::WallTime>::Type
getSierraWallTime()
{
  return sierraTimer().getMetric<stk_classic::diag::WallTime>().getAccumulatedLap(false);
}


stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type
getCPULapTime(Timer timer) {
  return timer.getMetric<stk_classic::diag::CPUTime>().getLap();
}

stk_classic::diag::MetricTraits<stk_classic::diag::CPUTime>::Type
getCPUAccumulatedLapTime(Timer timer) {
  return timer.getMetric<stk_classic::diag::CPUTime>().getAccumulatedLap(false);
}


TimerParser &
theTimerParser()
{
  static TimerParser parser;

  return parser;
}


TimerParser::TimerParser()
  : sierra::OptionMaskParser()
{
  mask("cpu", 0, "Display CPU times");
  mask("wall", 0, "Display wall times");

  mask("hms", 0, "Display times in HH:MM:SS format");
  mask("seconds", 0, "Display times in seconds");

  
//   mask("table", TIMER_TABLE, "Format output as a table");
//   mask("xml", TIMER_XML, "Format output as an XML file");

  mask("all", TIMER_ALL, "Enable all metrics");
  mask("none", TIMER_NONE, "Disable all timers");

  mask("domain", TIMER_DOMAIN, "Enable metrics on the domain");
  mask("region", TIMER_REGION, "Enable metrics on regions");
  mask("procedure", TIMER_PROCEDURE, "Enable metrics on procedures");
  mask("mechanics", TIMER_MECHANICS, "Enable metrics on mechanics");
  mask("algorithm", TIMER_ALGORITHM, "Enable metrics on algorithms");
  mask("solver", TIMER_SOLVER, "Enable metrics on solvers");
  mask("contact", TIMER_CONTACT, "Enable metrics on contact");
  mask("material", TIMER_MATERIAL, "Enable metrics on materials");
  mask("search", TIMER_SEARCH, "Enable metrics on searches");
  mask("transfer", TIMER_TRANSFER, "Enable metrics on user functions");
  mask("adaptivity", TIMER_ADAPTIVITY, "Enable metrics on adaptivity");
  mask("recovery", TIMER_RECOVERY, "Enable metrics on encore recovery");
  mask("profile1", TIMER_PROFILE_1, "Enable app defined profiling metrics");
  mask("profile2", TIMER_PROFILE_2, "Enable app defined profiling metrics");
  mask("profile3", TIMER_PROFILE_3, "Enable app defined profiling metrics");
  mask("profile4", TIMER_PROFILE_4, "Enable app defined profiling metrics");
  mask("app1", TIMER_APP_1, "Enable app defined metrics");
  mask("app2", TIMER_APP_2, "Enable app defined metrics");
  mask("app3", TIMER_APP_3, "Enable app defined metrics");
  mask("app4", TIMER_APP_4, "Enable app defined metrics");
}


OptionMaskParser::Mask
TimerParser::parse(
  const char *          mask) const
{
  m_metricsSetMask = 0;
  m_metricsMask = 0;
  m_optionMask = getEnabledTimerMask();
  
  m_optionMask = OptionMaskParser::parse(mask);

//   if ((m_optionMask & TIMER_FORMAT) == 0)
//     m_optionMask |= TIMER_TABLE;

  setEnabledTimerMask(m_optionMask);
  
  if (m_metricsSetMask != 0)
    stk_classic::diag::setEnabledTimerMetricsMask(m_metricsMask);
    
  return m_optionMask;
}


void
TimerParser::parseArg(
  const std::string &   name,
  const std::string &   arg) const
{
  if (name == "cpu") {
    m_metricsMask |= stk_classic::diag::METRICS_CPU_TIME;
    m_metricsSetMask |= stk_classic::diag::METRICS_CPU_TIME;
  }
  else if (name == "wall") {
    m_metricsMask |= stk_classic::diag::METRICS_WALL_TIME;
    m_metricsSetMask |= stk_classic::diag::METRICS_WALL_TIME;
  }
  else if (name == "heap") {
    m_metricsMask |= stk_classic::diag::METRICS_HEAP_ALLOC;
    m_metricsSetMask |= stk_classic::diag::METRICS_HEAP_ALLOC;
  }
  else if (name == "none") {
    m_optionMask = 0;
    m_metricsSetMask = stk_classic::diag::METRICS_WALL_TIME | stk_classic::diag::METRICS_CPU_TIME;
  }

  else if (name == "hms") {
    Diag::setTimeFormat(stk_classic::TIMEFORMAT_HMS);
  }
  else if (name == "seconds") {
    Diag::setTimeFormat(stk_classic::TIMEFORMAT_SECONDS);
  }

  else
    OptionMaskParser::parseArg(name, arg);
}

} // namespace Diag
} // namespace sierra