maia::dlbTimer::DlbTimer Class Reference

#include <dlbtimer.h>

Public Member Functions
	DlbTimer (const MInt timerId)
	Constructor, just set the timer id. More...
void	enableDlbTimers ()
void	disableDlbTimers ()
	Temporarily disable timers, e.g. during adaptation. More...
void	reEnableDlbTimer ()
MBool	dlbTimersEnabled () const
	Return if timers are enabled. More...
MBool	isLoadTimerRunning () const
void	startLoadTimer (const MString &name)
	Start the load timer. More...
void	stopLoadTimer (const MString &name)
	Stop the load timer. More...
void	resetLoadRecord ()
	Reset the load record. More...
MFloat	returnLoadRecord (const MInt mode=0) const
	Return the load record. More...
void	startIdleTimer (const MString &name)
	Start the idle timer. More...
void	stopIdleTimer (const MString &name)
	Stop the idle timer. More...
void	resetIdleRecord ()
	Reset the idle record. More...
MFloat	returnIdleRecord (const MInt mode=0) const
	Return the idle record. More...

Static Public Member Functions
static MInt	noTimers ()

Private Member Functions
void	startSolverTimer (const MInt timerId, const MString &name)
	Start the timer with the given id. More...
void	stopSolverTimer (const MInt timerId, const MString &name)
	Stop the timer with the given id. More...
void	resetSolverTimer (const MInt timerId)
	Reset the timer with the given id. More...

Private Attributes
const MInt	m_dlbTimerId = -1
	Unique DLB timer id among all DLB timers. More...
const MInt	m_loadTimerId = 0
	Timer indices. More...
const MInt	m_idleTimerId = 1
MBool	m_dlbTimersEnabled = false
	Stores if the timers are enabled. More...
MFloat	m_timerWallTime [2] = {0.0, 0.0}
	Current time when the timers were started. More...
MFloat	m_timerUserTime [2] = {0.0, 0.0}
MFloat	m_recordedWallTime [2] = {0.0, 0.0}
	Recorded time of the timers. More...
MFloat	m_recordedUserTime [2] = {0.0, 0.0}
MBool	m_timerRunning [2] = {false, false}
	Status of the timers. More...

Detailed Description

Definition at line 32 of file dlbtimer.h.

Constructor & Destructor Documentation

DlbTimer()

maia::dlbTimer::DlbTimer::DlbTimer ( const MInt  timerId )

inline

Definition at line 54 of file dlbtimer.h.

: m_dlbTimerId(timerId) {}

Member Function Documentation

disableDlbTimers()

void maia::dlbTimer::DlbTimer::disableDlbTimers ( )

inline

Definition at line 71 of file dlbtimer.h.

                                 {
    if(!m_dlbTimersEnabled) {
      TERMM(1, "Error: load balancing timers not enabled.");
    }
    m_dlbTimersEnabled = false;
  }

dlbTimersEnabled()

MBool maia::dlbTimer::DlbTimer::dlbTimersEnabled ( ) const

inline

Definition at line 86 of file dlbtimer.h.

{ return m_dlbTimersEnabled; }

enableDlbTimers()

void maia::dlbTimer::DlbTimer::enableDlbTimers ( )

inline

Enable timers for dynamic load balancing, disabled by default since not supported by all solvers/run loops

Definition at line 58 of file dlbtimer.h.

                                {
    if(m_dlbTimersEnabled) {
      TERMM(1, "Error: load balancing timers already enabled.");
    }
    m_dlbTimersEnabled = true;
 
    // Reset timer status
    for(MBool& i : m_timerRunning) {
      i = false;
    }
  }

isLoadTimerRunning()

MBool maia::dlbTimer::DlbTimer::isLoadTimerRunning ( ) const

inline

Definition at line 88 of file dlbtimer.h.

{ return m_timerRunning[m_loadTimerId]; }

noTimers()

static MInt maia::dlbTimer::DlbTimer::noTimers ( )

inlinestatic

Definition at line 156 of file dlbtimer.h.

                         {
    return 2; // Default: load and idle timer
  }

reEnableDlbTimer()

void maia::dlbTimer::DlbTimer::reEnableDlbTimer ( )

inline

Definition at line 78 of file dlbtimer.h.

                                 {
    if(m_dlbTimersEnabled) {
      TERMM(1, "Error: load balancing timers already enabled.");
    }
    m_dlbTimersEnabled = true;
  }

resetIdleRecord()

void maia::dlbTimer::DlbTimer::resetIdleRecord ( )

inline

Definition at line 143 of file dlbtimer.h.

{ resetSolverTimer(m_idleTimerId); }

resetLoadRecord()

void maia::dlbTimer::DlbTimer::resetLoadRecord ( )

inline

Definition at line 110 of file dlbtimer.h.

{ resetSolverTimer(m_loadTimerId); }

resetSolverTimer()

void maia::dlbTimer::DlbTimer::resetSolverTimer ( const MInt  timerId )

inlineprivate

Definition at line 204 of file dlbtimer.h.

                                            {
    if(m_timerRunning[timerId]) {
      TERMM(1, "error in resetSolverTimer(" + std::to_string(timerId) + "): timer still running, dlbTimerId "
                   + std::to_string(m_dlbTimerId));
    } else {
      m_recordedWallTime[timerId] = 0.0;
      m_recordedUserTime[timerId] = 0.0;
#ifdef MAIA_DEBUG_DLB_TIMER
      m_log << "DLB timer #" << m_dlbTimerId << " resetSolverTimer #" << timerId << std::endl;
#endif
    }
  }

returnIdleRecord()

MFloat maia::dlbTimer::DlbTimer::returnIdleRecord ( const MInt  mode = 0 ) const

inline

Definition at line 146 of file dlbtimer.h.

                                                            {
#ifdef MAIA_DEBUG_DLB_TIMER
    const MFloat diff = m_recordedWallTime[m_idleTimerId] - m_recordedUserTime[m_idleTimerId];
    m_log << "DLB timer #" << m_dlbTimerId << " "
          << " returnIdleRecord: " << m_recordedWallTime[m_idleTimerId] << " user " << m_recordedUserTime[m_idleTimerId]
          << " diff " << diff << std::endl;
#endif
    return (mode == 0) ? m_recordedWallTime[m_idleTimerId] : m_recordedUserTime[m_idleTimerId];
  }

returnLoadRecord()

MFloat maia::dlbTimer::DlbTimer::returnLoadRecord ( const MInt  mode = 0 ) const

inline

Definition at line 113 of file dlbtimer.h.

                                                            {
#ifdef MAIA_DEBUG_DLB_TIMER
    const MFloat diff = m_recordedWallTime[m_loadTimerId] - m_recordedUserTime[m_loadTimerId];
    m_log << "DLB timer #" << m_dlbTimerId << " "
          << " returnLoadRecord: " << m_recordedWallTime[m_loadTimerId] << " user " << m_recordedUserTime[m_loadTimerId]
          << " diff " << diff << std::endl;
#endif
    return (mode == 0) ? m_recordedWallTime[m_loadTimerId] : m_recordedUserTime[m_loadTimerId];
  }

startIdleTimer()

void maia::dlbTimer::DlbTimer::startIdleTimer ( const MString &  name )

inline

Definition at line 124 of file dlbtimer.h.

                                                  {
    if(!m_dlbTimersEnabled) {
      return;
    }
    if(m_timerRunning[m_loadTimerId]) {
      TERMM(1, name + "; Error: cannot start idle timer while load timer still running.");
    }
    startSolverTimer(m_idleTimerId, name);
  }

startLoadTimer()

void maia::dlbTimer::DlbTimer::startLoadTimer ( const MString &  name )

inline

Definition at line 91 of file dlbtimer.h.

                                                  {
    if(!m_dlbTimersEnabled) {
      return;
    }
    if(m_timerRunning[m_idleTimerId]) {
      TERMM(1, name + "; Error: cannot start load timer while idle timer still running.");
    }
    startSolverTimer(m_loadTimerId, name);
  }

startSolverTimer()

void maia::dlbTimer::DlbTimer::startSolverTimer ( const MInt  timerId, const MString &  name  )

inlineprivate

Definition at line 164 of file dlbtimer.h.

                                                                 {
    if(m_timerRunning[timerId]) {
      TERMM(1, name + "; error in startSolverTimer(" + std::to_string(timerId) + "): timer already running, dlbTimerId "
                   + std::to_string(m_dlbTimerId));
    } else {
      m_timerWallTime[timerId] = MPI_Wtime();
      m_timerUserTime[timerId] = cpuTime();
 
      m_timerRunning[timerId] = true;
#ifdef MAIA_DEBUG_DLB_TIMER
      m_log << "DLB timer #" << m_dlbTimerId << " startSolverTimer #" << timerId << " at time "
            << m_timerWallTime[timerId] << " from " << name << std::endl;
#endif
    }
  }

stopIdleTimer()

void maia::dlbTimer::DlbTimer::stopIdleTimer ( const MString &  name )

inline

Definition at line 135 of file dlbtimer.h.

                                                 {
    if(!m_dlbTimersEnabled) {
      return;
    }
    stopSolverTimer(m_idleTimerId, name);
  }

stopLoadTimer()

void maia::dlbTimer::DlbTimer::stopLoadTimer ( const MString &  name )

inline

Definition at line 102 of file dlbtimer.h.

                                                 {
    if(!m_dlbTimersEnabled) {
      return;
    }
    stopSolverTimer(m_loadTimerId, name);
  }

stopSolverTimer()

void maia::dlbTimer::DlbTimer::stopSolverTimer ( const MInt  timerId, const MString &  name  )

inlineprivate

Definition at line 181 of file dlbtimer.h.

                                                                {
    if(!m_timerRunning[timerId]) {
      TERMM(1, name + "; error in stopSolverTimer(" + std::to_string(timerId) + "): timer not running, dlbTimerId "
                   + std::to_string(m_dlbTimerId) + " DLB status is " + std::to_string(dlbTimersEnabled()));
    } else {
      const MFloat t_stop = MPI_Wtime();
      const MFloat t_diff = t_stop - m_timerWallTime[timerId];
      m_recordedWallTime[timerId] += t_diff;
 
      const MFloat t_user = cpuTime();
      const MFloat t_user_diff = t_user - m_timerUserTime[timerId];
      m_recordedUserTime[timerId] += t_user_diff;
 
      m_timerRunning[timerId] = false;
#ifdef MAIA_DEBUG_DLB_TIMER
      m_log << "DLB timer #" << m_dlbTimerId << " stopSolverTimer #" << timerId << " at time "
            << m_timerWallTime[timerId] << " with t_diff " << t_diff << " user time diff " << t_user_diff << " from "
            << name << std::endl;
#endif
    }
  }

Member Data Documentation

m_dlbTimerId

const MInt maia::dlbTimer::DlbTimer::m_dlbTimerId = -1

private

Definition at line 35 of file dlbtimer.h.

m_dlbTimersEnabled

MBool maia::dlbTimer::DlbTimer::m_dlbTimersEnabled = false

private

Definition at line 42 of file dlbtimer.h.

m_idleTimerId

const MInt maia::dlbTimer::DlbTimer::m_idleTimerId = 1

private

Definition at line 39 of file dlbtimer.h.

m_loadTimerId

const MInt maia::dlbTimer::DlbTimer::m_loadTimerId = 0

private

Definition at line 38 of file dlbtimer.h.

m_recordedUserTime

MFloat maia::dlbTimer::DlbTimer::m_recordedUserTime[2] = {0.0, 0.0}

private

Definition at line 48 of file dlbtimer.h.

m_recordedWallTime

MFloat maia::dlbTimer::DlbTimer::m_recordedWallTime[2] = {0.0, 0.0}

private

Definition at line 47 of file dlbtimer.h.

m_timerRunning

MBool maia::dlbTimer::DlbTimer::m_timerRunning[2] = {false, false}

private

Definition at line 50 of file dlbtimer.h.

m_timerUserTime

MFloat maia::dlbTimer::DlbTimer::m_timerUserTime[2] = {0.0, 0.0}

private

Definition at line 45 of file dlbtimer.h.

m_timerWallTime

MFloat maia::dlbTimer::DlbTimer::m_timerWallTime[2] = {0.0, 0.0}

private

Definition at line 44 of file dlbtimer.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/dlbtimer.h