MTimers Class Reference

MTimers manages all MAIA Timers and allows primitive profiling. More...

#include <timer.h>

Collaboration diagram for MTimers:

Classes
struct	Timer

Public Member Functions
MInt	newGroup (const std::string groupName)
	Creates a new timer group and returns its groupId. More...
MInt	newGroupTimer (const std::string timerName, const MInt groupId)
	Creates a new timer and returns its timerId. More...
MInt	newSubTimer (const std::string timerName, const MInt timerId)
	Creates a new timer and returns its timerId. More...
MFloat	returnTimer (const MInt timerId, const MString pos)
	Returns the timer Value. More...
MFloat	returnTimerTime (const MInt timerId)
void	resetTimer (const MInt timerId, const MString pos)
void	recordTimer (const MInt timerId, const MString pos)
void	recordTimerStart (const MInt timerId, const MString pos)
void	recordTimerStop (const MInt timerId, const MString pos)
void	recordTimers (const MString pos)
void	stopAllTimers (const MString pos)
void	stopAllRecordTimers (const MString pos)
void	displayTimer (const MInt timerId)
void	displayTimerNoToggleDisplayed (const MInt timerId)
void	displayAllTimers ()
void	displayAllTimers (const MInt groupId)
void	resetTimers (const MString pos)
void	resetRecord (const MInt timerId, const MFloat timerValue=0.0)
void	resetRecords ()
MInt	isRunning (const MInt timerId) const

Private Member Functions
void	startTimer (const MInt timerId, const MString pos)
void	stopTimer (const MInt timerId, const MString pos)
	Stops the timer and sets its final value. More...
	MTimers ()
	~MTimers ()
	MTimers (MTimers &)
MTimers &	operator= (const MTimers &)
MFloat	time ()
	Returns Wall-Clock time in seconds. More...
void	displayTimer_ (const MInt timerId, const MBool toggleDisplayed=true, const MInt tIndent=0, const MFloat superTime=-1.0)
void	displayTimerHeader_ ()
void	displayTimerGroupHeader_ (const MInt groupId)
MInt	indent (const MInt pIndent) const

Private Attributes
std::vector< std::string >	m_groups
std::vector< Timer >	m_timers

Friends
MTimers &	timers ()

Detailed Description

Usage:

• NEW_TIMER(string name) creates a new timer with name "name" and returns its index (a MInt that you can use to access it).
• RESET_TIMER(MInt timerId): resets timerId.
• START_TIMER(timerId)/STOP_TIMER(timerId) work as expected.
• DISPLAY_TIMER(timerId) writes the timerId name and time to the log.
• DISPLAY_ALL_TIMERS: displays all timers.

Example:

RESET_TIMER; MInt myTimer; myTimer = NEW_TIMER("My timer");

START_TIMER(myTimer); f1(); // Function will be timed. STOP_TIMER(myTimer); f2(); // Function will not be timed. START_TIMER(myTimer); f3(); // Function will be timed. STOP_TIMER(myTimer);

DISPLAY_TIMER(myTimer);

NOTE: MAIA_TIMER_FUNCTION macro enable/disables timing MAIA.

Definition at line 169 of file timer.h.

Constructor & Destructor Documentation

MTimers() [1/2]

MTimers::MTimers ( )

inlineprivate

Definition at line 199 of file timer.h.

            {
#if defined(MAIA_TIMER_FUNCTION)
    m_log << "MTimers: timers enabled." << std::endl;
#endif
#if defined(MAIA_TIMER_DEBUG)
    m_log << "MTimers: timer debug enabled." << std::endl;
#endif
#if defined(MAIA_TIMER_CHECKS)
    m_log << "MTimers: timer checks enabled." << std::endl;
#endif
#if defined(MAIA_ASSERT_TIMER_CHECKS)
    m_log << "MTimers: assert timer checks enabled." << std::endl;
#endif
  }

~MTimers()

MTimers::~MTimers ( )

inlineprivate

Definition at line 213 of file timer.h.

{}

MTimers() [2/2]

MTimers::MTimers ( MTimers &  )

private

Member Function Documentation

displayAllTimers() [1/2]

void MTimers::displayAllTimers ( )

inline

Definition at line 602 of file timer.h.

                                      {
  ASSERT(m_timers.size() > 0, "ERROR: no timers have been created!");
  for(std::size_t groupId = 0, e = m_groups.size(); groupId != e; ++groupId) {
    displayAllTimers(groupId);
  }
}

displayAllTimers() [2/2]

void MTimers::displayAllTimers ( const MInt  groupId )

inline

Definition at line 609 of file timer.h.

                                                        {
  ASSERT(m_timers.size() > 0, "ERROR: no timers have been created!");
  ASSERT(static_cast<std::size_t>(groupId) < m_groups.size() && groupId > -1, "ERROR: groupId does not exists");
  for(std::size_t timerId = 0, e = m_timers.size(); timerId != e; ++timerId) {
    m_timers[timerId].displayed = false;
  }
  displayTimerGroupHeader_(groupId);
  displayTimerHeader_();
  for(std::size_t timerId = 0, e = m_timers.size(); timerId != e; ++timerId) {
    if(m_timers[timerId].group == groupId) {
      displayTimer_(timerId);
    }
  }
  for(std::size_t timerId = 0, e = m_timers.size(); timerId != e; ++timerId) {
    m_timers[timerId].displayed = false;
  }
}

displayTimer()

void MTimers::displayTimer ( const MInt  timerId )

inline

Definition at line 627 of file timer.h.

                                                    {
  ASSERT(static_cast<std::size_t>(timerId) < m_timers.size(), "ERROR: timer timerId does not exist");
  displayTimerHeader_();
  displayTimer_(timerId);
}

displayTimer_()

void MTimers::displayTimer_ ( const MInt  timerId, const MBool  toggleDisplayed = true, const MInt  tIndent = 0, const MFloat  superTime = -1.0  )

inlineprivate

Definition at line 528 of file timer.h.

                                                           {
  if(m_timers[timerId].displayed) {
    return;
  }
 
  /* MBool running = false; */
  if(m_timers[timerId].status == Timer::Running) {
    // NOTE: test this if needed, but not used at the moment
    TERMM(1, "Timer is still running");
    /* running = true; */
    /* stopTimer(timerId, AT_); */
  }
  m_log.width(50);
  m_log.setf(std::ios::left);
  std::stringstream indentedName;
 
  // Calculate time relative to the parent timer
  MFloat percentage;
  if(superTime < F0) {
    // If the parent time is less than zero, that means that there is no parent timer
    // and the percentage should be 100%
    percentage = 100.0;
  } else if(approx(superTime, F0, MFloatEps)) {
    // If the parent time is approximately zero, that probably means that the timer was never
    // run - therefore the percentage is set to 0%
    percentage = F0;
  } else {
    // Otherwise calculate the percentage as the fraction of this timer vs. the parent timer times 100%
    percentage = 100.0 * m_timers[timerId].recordedTime / superTime;
  }
 
  indentedName << std::string(tIndent, ' ');
  indentedName << "[" << std::fixed << std::setprecision(1) << std::setw(4) << std::setfill('0') << std::right
               << percentage << std::left << "%] ";
  indentedName << m_timers[timerId].name;
  m_log << indentedName.str() << std::right;
  m_log.precision(6);
  m_log.width(20);
  m_log << m_timers[timerId].recordedTime << std::left << " [sec]";
  // Show output of likwid performance counters if likwid is enabled
#ifdef WITH_LIKWID
  // If the timer wasn't called set the MFLops to 0.00
  m_log << "   ";
  if(approx(m_timers[timerId].recordedTime, F0, MFloatEps)) {
    m_log << "0.00";
  } else {
    m_log << "${timer_" << timerId << "}";
  }
  m_log << " [DP MFlops/s]";
#endif
  if(toggleDisplayed) m_timers[timerId].displayed = true;
  m_log << std::endl;
  for(std::size_t sub = 0, last = m_timers[timerId].subTimers.size(); sub < last; ++sub) {
    const MInt new_indent = indent(tIndent);
    displayTimer_(m_timers[timerId].subTimers[sub], toggleDisplayed, new_indent, m_timers[timerId].recordedTime);
  }
  /* if(running) { */
  /*   startTimer(timerId, AT_); */
  /* } */
}

displayTimerGroupHeader_()

void MTimers::displayTimerGroupHeader_ ( const MInt  groupId )

inlineprivate

Definition at line 592 of file timer.h.

                                                                {
  m_log << "--------------------------------------------------------------------------------" << std::endl;
  m_log.width(50);
  m_log.precision(12);
  m_log.setf(std::ios::left);
  m_log << "Group";
  m_log.width(40);
  m_log << m_groups[groupId] << std::endl;
}

displayTimerHeader_()

void MTimers::displayTimerHeader_ ( )

inlineprivate

Definition at line 590 of file timer.h.

{}

displayTimerNoToggleDisplayed()

void MTimers::displayTimerNoToggleDisplayed ( const MInt  timerId )

inline

Definition at line 633 of file timer.h.

                                                                     {
  ASSERT(static_cast<std::size_t>(timerId) < m_timers.size(), "ERROR: timer timerId does not exist");
  displayTimerHeader_();
  displayTimer_(timerId, false);
}

indent()

MInt MTimers::indent ( const MInt  pIndent ) const

inlineprivate

Definition at line 252 of file timer.h.

{ return pIndent + 2; };

isRunning()

MInt MTimers::isRunning ( const MInt  timerId ) const

inline

Definition at line 192 of file timer.h.

{ return m_timers[timerId].status == Timer::Running; };

newGroup()

MInt MTimers::newGroup ( const std::string  groupName )

inline

Definition at line 332 of file timer.h.

                                                  {
  m_groups.push_back(name);
#if defined(MAIA_TIMER_DEBUG)
  m_log << "New timer group " << m_groups.size() - 1 << " '" << name << "' " << std::endl;
#endif
  return m_groups.size() - 1;
}

newGroupTimer()

MInt MTimers::newGroupTimer ( const std::string  timerName, const MInt  groupId  )

inline

Definition at line 341 of file timer.h.

                                                                           {
  ASSERT(static_cast<std::size_t>(groupId) < m_groups.size() && groupId > -1,
         "groupId: " << groupId << " does not exists | name: " << name);
  const MInt newTimerId = m_timers.size();
  m_timers.push_back(Timer(name, groupId, newTimerId, -1));
#if defined(MAIA_TIMER_DEBUG)
  m_log << "New group timer " << newTimerId << " '" << name << "' " << groupId << std::endl;
#endif
  return newTimerId;
}

newSubTimer()

MInt MTimers::newSubTimer ( const std::string  timerName, const MInt  timerId  )

inline

Definition at line 353 of file timer.h.

                                                                         {
  if(timerId < 0) {
#if defined(MAIA_TIMER_DEBUG)
    m_log << "cannot create subTimer '" << name << "'" << std::endl;
#endif
    return -1;
  }
 
  ASSERT(static_cast<std::size_t>(timerId) < m_timers.size(),
         "timerId " << timerId << " does not exist when trying to create subtimer with name " << name);
 
  const MInt groupId = m_timers[timerId].group;
  const MInt newTimerId = m_timers.size();
  m_timers.push_back(Timer(name, groupId, newTimerId, timerId));
#if defined(MAIA_TIMER_DEBUG)
  m_log << "New subtimer " << newTimerId << " '" << name << "' " << groupId << " " << timerId << std::endl;
#endif
  m_timers[timerId].subTimers.push_back(newTimerId);
  return newTimerId;
}

operator=()

MTimers & MTimers::operator= ( const MTimers &  )

private

recordTimer()

void MTimers::recordTimer ( const MInt  timerId, const MString  pos  )

inline

Definition at line 298 of file timer.h.

                                                                      {
  m_timers[timerId].recordedTime += returnTimer(timerId, pos);
}

recordTimers()

void MTimers::recordTimers ( const MString  pos )

inline

Definition at line 302 of file timer.h.

                                                   {
  for(std::size_t timerId = 0, e = m_timers.size(); timerId != e; ++timerId) {
    recordTimer(timerId, pos);
  }
}

recordTimerStart()

void MTimers::recordTimerStart ( const MInt  timerId, const MString  pos  )

inline

Definition at line 374 of file timer.h.

                                                                           {
  if(timerId < 0) {
    return;
  }
#ifdef MAIA_SYNCHRONIZE_TIMERS
  MPI_Barrier(MPI_COMM_WORLD);
#endif
  resetTimer(timerId, pos);
  startTimer(timerId, pos);
}

recordTimerStop()

void MTimers::recordTimerStop ( const MInt  timerId, const MString  pos  )

inline

Definition at line 287 of file timer.h.

                                                                          {
  if(timerId < 0) {
    return;
  }
#ifdef MAIA_SYNCHRONIZE_TIMERS
  MPI_Barrier(MPI_COMM_WORLD);
#endif
  stopTimer(timerId, pos);
  recordTimer(timerId, pos);
}

resetRecord()

void MTimers::resetRecord ( const MInt  timerId, const MFloat  timerValue = 0.0  )

inline

Definition at line 277 of file timer.h.

                                                                            {
  m_timers[timerId].recordedTime = timerValue;
}

resetRecords()

void MTimers::resetRecords ( )

inline

Definition at line 281 of file timer.h.

                                  {
  for(std::size_t timerId = 0, e = m_timers.size(); timerId != e; ++timerId) {
    resetRecord((MInt)timerId);
  }
}

resetTimer()

void MTimers::resetTimer ( const MInt  timerId, const MString  pos  )

inline

Definition at line 308 of file timer.h.

                                                                                      {
#if defined(MAIA_TIMER_CHECKS)
  if(m_timers[timerId].status == Timer::Running) {
    const MString msg = "The timer #" + std::to_string(timerId) + " '" + m_timers[timerId].name
                        + "' can't be reset because it is running! " + pos;
    m_log << msg << std::endl;
    std::cerr << msg << std::endl;
#if defined(MAIA_ASSERT_TIMER_CHECKS)
    TERMM(1, msg);
#endif
  }
#endif
 
  m_timers[timerId].cpuTime = 0.0;
  m_timers[timerId].status = Timer::Stopped;
}

resetTimers()

void MTimers::resetTimers ( const MString  pos )

inline

Definition at line 325 of file timer.h.

                                                  {
  for(std::size_t timerId = 0, e = m_timers.size(); timerId != e; ++timerId) {
    resetTimer(timerId, pos);
  }
}

returnTimer()

MFloat MTimers::returnTimer ( const MInt  timerId, const MString  pos  )

inline

Definition at line 423 of file timer.h.

                                                                                         {
  if(timerId < 0) {
    TERMM(1, "Invalid timer id");
    return 0.0;
  }
 
#if defined(MAIA_TIMER_CHECKS)
  if(m_timers[timerId].status != Timer::Stopped) {
    const MString msg = "The timer #" + std::to_string(timerId) + " '" + m_timers[timerId].name
                        + "' needs to be stopped before returnTimer() is called! " + pos;
    m_log << msg << std::endl;
    std::cerr << msg << std::endl;
#if defined(MAIA_ASSERT_TIMER_CHECKS)
    TERMM(1, msg);
#endif
  }
#endif
 
#if MAIA_TIMERS_AVERAGE_OVER_DOMAINS
  const MFloat t = m_timers[timerId].cpuTime;
  MFloat tmp_rcv = 0.0;
  MPI_Reduce(&t, &tmp_rcv, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
  return tmp_rcv / globalNoDomains();
#else
  return m_timers[timerId].cpuTime;
#endif
}

returnTimerTime()

MFloat MTimers::returnTimerTime ( const MInt  timerId )

inline

Definition at line 452 of file timer.h.

{ return m_timers[timerId].recordedTime; }

startTimer()

void MTimers::startTimer ( const MInt  timerId, const MString  pos  )

inlineprivate

Definition at line 385 of file timer.h.

                                                                                      {
  ASSERT(m_timers[timerId].status != Timer::Running,
         "The timer " << m_timers[timerId].name << " with id: " << timerId
                      << " can't be started because it is already running! " << pos);
 
#if defined(MAIA_TIMER_CHECKS)
  const MInt parent = m_timers[timerId].parent;
  if(parent != -1) {
    if(m_timers[parent].status != Timer::Running) {
      const MString msg = "The timer #" + std::to_string(timerId) + " '" + m_timers[timerId].name
                          + "' can't be started because its parent timer #" + std::to_string(parent) + " '"
                          + m_timers[parent].name + "' is not running! " + pos;
      m_log << msg << std::endl;
      std::cerr << msg << std::endl;
#if defined(MAIA_ASSERT_TIMER_CHECKS)
      TERMM(1, msg);
#endif
    }
  }
#endif
 
#if defined(MAIA_TIMER_DEBUG)
  m_log << "start timer #" + std::to_string(timerId) + " '" + m_timers[timerId].name + "' " << pos << std::endl;
#endif
 
  const MFloat t = time();
  m_timers[timerId].oldCpuTime = m_timers[timerId].cpuTime;
  m_timers[timerId].cpuTime = t;
  m_timers[timerId].status = Timer::Running;
 
  // Enable likwid counter if likwid is enabled
#ifdef WITH_LIKWID
  LIKWID_MARKER_START(std::to_string(timerId).c_str());
#endif
}

stopAllRecordTimers()

void MTimers::stopAllRecordTimers ( const MString  pos )

inline

Definition at line 514 of file timer.h.

                                                          {
  // for(std::size_t i = 0, e = m_timers.size(); i != e; ++i) {
  for(MInt i = m_timers.size() - 1; i >= 0; i--) {
    if(m_timers[i].status == Timer::Running) {
#ifdef MAIA_SYNCHRONIZE_TIMERS
      MPI_Barrier(MPI_COMM_WORLD);
#endif
      stopTimer(i, pos);
      recordTimer(i, pos);
    }
  }
}

stopAllTimers()

void MTimers::stopAllTimers ( const MString  pos )

inline

Definition at line 505 of file timer.h.

                                                    {
  for(std::size_t i = 0, e = m_timers.size(); i != e; ++i) {
    if(m_timers[i].status == Timer::Running) {
      stopTimer(i, pos);
    }
  }
}

stopTimer()

void MTimers::stopTimer ( const MInt  timerId, const MString  pos  )

inlineprivate

Definition at line 455 of file timer.h.

                                                                                     {
  if(timerId < 0) {
#if defined(MAIA_TIMER_DEBUG)
    m_log << "cannot stop timer " << timerId << " " << pos << std::endl;
#endif
    return;
  }
 
  if(m_timers[timerId].status == Timer::Running) {
    const MFloat t = time();
    m_timers[timerId].cpuTime = t - m_timers[timerId].cpuTime + m_timers[timerId].oldCpuTime;
    m_timers[timerId].status = Timer::Stopped;
 
#if defined(MAIA_TIMER_CHECKS)
    for(auto subTimerId : m_timers[timerId].subTimers) {
      if(m_timers[subTimerId].status == Timer::Running) {
        const MString msg = "The timer #" + std::to_string(timerId) + " '" + m_timers[timerId].name
                            + "' can't be stopped because its sub-timer #" + std::to_string(subTimerId) + " '"
                            + m_timers[subTimerId].name + "' is still running! " + pos;
        m_log << msg << std::endl;
        std::cerr << msg << std::endl;
#if defined(MAIA_ASSERT_TIMER_CHECKS)
        TERMM(1, msg);
#endif
      }
    }
#endif
 
#if defined(MAIA_TIMER_DEBUG)
    m_log << "stop timer #" + std::to_string(timerId) + " '" + m_timers[timerId].name + "' " << pos << std::endl;
#endif
 
    // Stop likwid counter if likwid is enabled
#ifdef WITH_LIKWID
    LIKWID_MARKER_STOP(std::to_string(timerId).c_str());
#endif
  } else {
#if defined(MAIA_TIMER_CHECKS)
    const MString msg = "The timer '" + m_timers[timerId].name + "' can't be stopped because it is not running! " + pos;
    m_log << msg << std::endl;
    std::cerr << msg << std::endl;
#if defined(MAIA_ASSERT_TIMER_CHECKS)
    TERMM(1, msg);
#endif
#endif
  }
}

time()

MFloat MTimers::time ( )

inlineprivate

Timers are not portable. We should use the C++ <chrono> library instead. The factors convert the cpu time to seconds

Definition at line 258 of file timer.h.

                            {
#ifdef MAIA_MPI_TIMER
  return MPI_Wtime();
#else
#if _POSIX_TIMERS > 0
  timespec t;
  clock_gettime(CLOCK_REALTIME, &t);
  return static_cast<MFloat>(t.tv_sec) + static_cast<MFloat>(t.tv_nsec / 1000000000.0);
#else
  struct timeval t;
  gettimeofday(&t, nullptr);
  return static_cast<MFloat>(t.tv_sec) + static_cast<MFloat>(t.tv_usec / 1000000.0);
#endif
#endif
}

Friends And Related Function Documentation

timers

MTimers & timers ( )

friend

Definition at line 19 of file timer.cpp.

                  {
  static MTimers timers;
  return timers;
}

Member Data Documentation

m_groups

std::vector<std::string> MTimers::m_groups

private

Definition at line 242 of file timer.h.

m_timers

std::vector<Timer> MTimers::m_timers

private

Definition at line 243 of file timer.h.

---

The documentation for this class was generated from the following file:

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/UTIL/timer.h