Controller class for all DLB timers. More...

#include <dlbtimer.h>

Collaboration diagram for DlbTimerController:

Public Member Functions
void	createDlbTimers (const MInt noTimers, const MBool ignore=false)
	Create the given number of DLB timers. More...

void	enableDlbTimers (const MInt dlbTimerId)
	Enable the given DLB timer. More...

void	enableAllDlbTimers (const MBool *const wasEnabled=nullptr)
	Enable all DLB timers (or those given by the array wasEnabled) More...

void	disableDlbTimers (const MInt dlbTimerId)
	Disable the given DLB timer. More...

void	disableAllDlbTimers (MBool *const wasEnabled=nullptr)
	Disable all (enabled) DLB timers. More...

MBool	dlbTimersEnabled (const MInt dlbTimerId)
	Return if the given DLB timer is enabled. More...

void	startLoadTimer (const MInt dlbTimerId, const MString &name)
	Start the load timer for the given DLB timer id. More...

void	stopLoadTimer (const MInt dlbTimerId, const MString &name)
	Stop the load timer for the given DLB timer id. More...

void	startIdleTimer (const MInt dlbTimerId, const MString &name)
	Start the idle timer for the given DLB timer id. More...

void	stopIdleTimer (const MInt dlbTimerId, const MString &name)
	Stop the idle timer for the given DLB timer id. More...

void	stopLoadStartIdleTimer (const MString &name)
	Stop the currently running load timer and start the corresponding idle timer. More...

void	stopIdleStartLoadTimer (const MString &name)
	Stop the currently running idle timer and start the corresponding load timer. More...

MBool	isTimerRunning () const
	Return if a timer is running. More...

MInt	whichTimerIsRunning () const

MBool	isLoadTimerRunning (const MInt dlbTimerId)

void	reEnableDlbTimer (const MInt dlbTimerId)

void	checkIOTimerStatus (const MString &name) const
	Check the timer status during IO (no timer running and timers not enabled) More...

void	resetRecords ()
	Reset the records of all DLB timers. More...

MFloat	returnLoadRecord (const MInt dlbTimerId, const MInt mode=0)
	Return the load record of a DLB timer. More...

MFloat	returnIdleRecord (const MInt dlbTimerId, const MInt mode=0)
	Return the idle record of a DLB timer. More...

MInt	noDlbTimers () const
	Return the number of DLB timers. More...

MInt	noSubTimers () const
	Return the number of (sub-)timers for each DLB timer. More...

Private Attributes
std::vector< maia::dlbTimer::DlbTimer >	m_dlbTimers {}
	Storage of DLB timers for all solvers/couplers/... More...

MInt	m_runningTimerId = -1
	Id of the currently running DLB load/idle timer. More...

MBool	m_enabled = false
	Current status of all timers; false: all timers disabled; true: at least one timer enabled. More...

MBool	m_ignoreDlbTimers = true
	Global switch in createDlbTimers() to ignore all DLB timers, i.e. they cannot be enabled. More...

Detailed Description

Definition at line 223 of file dlbtimer.h.

Member Function Documentation

◆ checkIOTimerStatus()

void DlbTimerController::checkIOTimerStatus ( const MString & name ) const

inline

Definition at line 448 of file dlbtimer.h.

                                                     {
    TERMM_IF_COND(m_enabled || isTimerRunning(), "Timers still enabled and/or timer running " + name);
  }

◆ createDlbTimers()

void DlbTimerController::createDlbTimers	(	const MInt	noTimers,
		const MBool	ignore = `false`
	)

inline

Definition at line 235 of file dlbtimer.h.

                                                                        {
    if(noDlbTimers() > 0) {
      TERMM(1, "createDlbTimers should only be called once!");
    }
 
    // High-resolution per-process CPU timer
    timespec tp;
    clock_getres(CLOCK_PROCESS_CPUTIME_ID, &tp);
    m_log << "DLB timer: CLOCK PROCESS CPUTIME RESOLUTION " << tp.tv_sec << "s " << tp.tv_nsec << "nsec" << std::endl;
 
    for(MInt i = 0; i < noTimers; i++) {
      const MInt newTimerId = m_dlbTimers.size();
      m_dlbTimers.emplace_back(newTimerId);
    }
 
    m_ignoreDlbTimers = ignore;
  }

◆ disableAllDlbTimers()

void DlbTimerController::disableAllDlbTimers ( MBool *const wasEnabled = nullptr )

inline

Definition at line 300 of file dlbtimer.h.

                                                              {
    if(m_ignoreDlbTimers) {
      return;
    }
 
    if(m_runningTimerId != -1) {
      TERMM(1, "Cannot disable all DLB timers, timer " + std::to_string(m_runningTimerId) + " still running.");
    }
    for(MInt i = 0; i < noDlbTimers(); i++) {
      const MBool timersEnabled = dlbTimersEnabled(i);
 
      // Store current timer status if requested (pointer != nullptr passed to function)
      if(wasEnabled != nullptr) {
        wasEnabled[i] = timersEnabled;
      }
 
      if(timersEnabled) {
        disableDlbTimers(i);
      }
    }
    m_enabled = false; // All timers are disabled
  }

◆ disableDlbTimers()

void DlbTimerController::disableDlbTimers ( const MInt dlbTimerId )

inline

Definition at line 284 of file dlbtimer.h.

                                               {
    if(m_ignoreDlbTimers) {
      return;
    }
 
    ENSURE_VALID_TIMERID(dlbTimerId, AT_);
    m_dlbTimers[dlbTimerId].disableDlbTimers();
 
    MBool anyEnabled = false;
    for(MInt i = 0; i < noDlbTimers(); i++) {
      anyEnabled |= m_dlbTimers[dlbTimerId].dlbTimersEnabled();
    }
    m_enabled = anyEnabled;
  }

◆ dlbTimersEnabled()

MBool DlbTimerController::dlbTimersEnabled ( const MInt dlbTimerId )

inline

Definition at line 324 of file dlbtimer.h.

                                                {
    if(m_ignoreDlbTimers) {
      return false;
    }
 
    ENSURE_VALID_TIMERID(dlbTimerId, AT_);
    return m_dlbTimers[dlbTimerId].dlbTimersEnabled();
  }

◆ enableAllDlbTimers()

void DlbTimerController::enableAllDlbTimers ( const MBool *const wasEnabled = nullptr )

inline

Definition at line 265 of file dlbtimer.h.

                                                                   {
    if(m_ignoreDlbTimers) {
      return;
    }
 
    for(MInt i = 0; i < noDlbTimers(); i++) {
      // Check if a status array is given and restore previous state
      MBool enableTimers = true;
      if(wasEnabled != nullptr) {
        enableTimers = wasEnabled[i];
      }
 
      if(enableTimers) {
        enableDlbTimers(i);
      }
    }
  }

◆ enableDlbTimers()

void DlbTimerController::enableDlbTimers ( const MInt dlbTimerId )

inline

Definition at line 254 of file dlbtimer.h.

                                              {
    if(m_ignoreDlbTimers) {
      return;
    }
 
    ENSURE_VALID_TIMERID(dlbTimerId, AT_);
    m_dlbTimers[dlbTimerId].enableDlbTimers();
    m_enabled = true; // At least this one timer is enabled
  }

◆ isLoadTimerRunning()

MBool DlbTimerController::isLoadTimerRunning ( const MInt dlbTimerId )

inline

Definition at line 441 of file dlbtimer.h.

                                                  {
    return m_dlbTimers[dlbTimerId].isLoadTimerRunning() && m_runningTimerId == dlbTimerId;
  }

◆ isTimerRunning()

MBool DlbTimerController::isTimerRunning ( ) const

inline

Definition at line 437 of file dlbtimer.h.

437{ return (m_runningTimerId != -1); }

◆ noDlbTimers()

MInt DlbTimerController::noDlbTimers ( ) const

inline

Definition at line 484 of file dlbtimer.h.

484{ return m_dlbTimers.size(); }

◆ noSubTimers()

MInt DlbTimerController::noSubTimers ( ) const

inline

Definition at line 487 of file dlbtimer.h.

487{ return maia::dlbTimer::DlbTimer::noTimers(); }

maia::dlbTimer::DlbTimer::noTimers

static MInt noTimers()

Definition: dlbtimer.h:156

◆ reEnableDlbTimer()

void DlbTimerController::reEnableDlbTimer ( const MInt dlbTimerId )

inline

Definition at line 445 of file dlbtimer.h.

445{ m_dlbTimers[dlbTimerId].reEnableDlbTimer(); }

◆ resetRecords()

void DlbTimerController::resetRecords ( )

inline

Definition at line 453 of file dlbtimer.h.

                      {
    if(m_ignoreDlbTimers) {
      return;
    }
    for(MInt i = 0; i < noDlbTimers(); i++) {
      m_dlbTimers[i].resetLoadRecord();
      m_dlbTimers[i].resetIdleRecord();
    }
  }

◆ returnIdleRecord()

MFloat DlbTimerController::returnIdleRecord	(	const MInt	dlbTimerId,
		const MInt	mode = `0`
	)

inline

Definition at line 474 of file dlbtimer.h.

                                                                             {
    if(m_ignoreDlbTimers) {
      return -1.0;
    }
    ENSURE_VALID_TIMERID(dlbTimerId, name);
    ENSURE_VALID_TIMERMODE(mode, name);
    return m_dlbTimers[dlbTimerId].returnIdleRecord(mode);
  }

◆ returnLoadRecord()

MFloat DlbTimerController::returnLoadRecord	(	const MInt	dlbTimerId,
		const MInt	mode = `0`
	)

inline

Definition at line 464 of file dlbtimer.h.

                                                                             {
    if(m_ignoreDlbTimers) {
      return -1.0;
    }
    ENSURE_VALID_TIMERID(dlbTimerId, name);
    ENSURE_VALID_TIMERMODE(mode, name);
    return m_dlbTimers[dlbTimerId].returnLoadRecord(mode);
  }

◆ startIdleTimer()

void DlbTimerController::startIdleTimer	(	const MInt	dlbTimerId,
		const MString &	name
	)

inline

Definition at line 371 of file dlbtimer.h.

                                                                  {
    if(m_ignoreDlbTimers) {
      return;
    }
    ENSURE_VALID_TIMERID(dlbTimerId, name);
 
    if(!dlbTimersEnabled(dlbTimerId)) {
      return;
    }
 
    // Check that no load/idle timer is currently running
    if(m_runningTimerId != -1) {
      TERMM(1, "Cannot start idle timer " + std::to_string(dlbTimerId) + ", timer " + std::to_string(m_runningTimerId)
                   + " already running.");
    }
 
    m_dlbTimers[dlbTimerId].startIdleTimer(name);
    m_runningTimerId = dlbTimerId;
  }

◆ startLoadTimer()

void DlbTimerController::startLoadTimer	(	const MInt	dlbTimerId,
		const MString &	name
	)

inline

Definition at line 334 of file dlbtimer.h.

                                                                  {
    if(m_ignoreDlbTimers) {
      return;
    }
    ENSURE_VALID_TIMERID(dlbTimerId, name);
 
    if(!dlbTimersEnabled(dlbTimerId)) {
      return;
    }
 
    // Check that no load/idle timer is currently running
    if(m_runningTimerId != -1) {
      TERMM(1, "Cannot start load timer " + std::to_string(dlbTimerId) + ", timer " + std::to_string(m_runningTimerId)
                   + " already running.");
    }
 
    m_dlbTimers[dlbTimerId].startLoadTimer(name);
    m_runningTimerId = dlbTimerId;
  }

◆ stopIdleStartLoadTimer()

void DlbTimerController::stopIdleStartLoadTimer ( const MString & name )

inline

Definition at line 423 of file dlbtimer.h.

                                                   {
    if(!m_enabled) {
      return; // If no timer is enabled there is nothing to do
    }
 
    if(m_runningTimerId < 0) {
      TERMM(1, "Cannot stop idle and start load timer, the running timer is: " + std::to_string(m_runningTimerId));
    }
    const MInt timerId = m_runningTimerId; // m_runningTimerId is reset in stopIdleTimer()
    stopIdleTimer(timerId, name);
    startLoadTimer(timerId, name);
  }

◆ stopIdleTimer()

void DlbTimerController::stopIdleTimer	(	const MInt	dlbTimerId,
		const MString &	name
	)

inline

Definition at line 392 of file dlbtimer.h.

                                                                 {
    if(m_ignoreDlbTimers) {
      return;
    }
    ENSURE_VALID_TIMERID(dlbTimerId, name);
 
    if(!dlbTimersEnabled(dlbTimerId)) {
      return;
    }
 
    ASSERT(dlbTimerId == m_runningTimerId, "timer id does not match the running timer id");
    m_dlbTimers[dlbTimerId].stopIdleTimer(name);
    m_runningTimerId = -1;
  }

◆ stopLoadStartIdleTimer()

void DlbTimerController::stopLoadStartIdleTimer ( const MString & name )

inline

Definition at line 408 of file dlbtimer.h.

                                                   {
    if(!m_enabled) {
      return; // If no timer is enabled there is nothing to do
    }
 
    if(m_runningTimerId < 0) {
      TERMM(1, "Cannot stop load and start idle timer, the running timer is: " + std::to_string(m_runningTimerId) + '/'
                   + name);
    }
    const MInt timerId = m_runningTimerId; // m_runningTimerId is reset in stopLoadTimer()
    stopLoadTimer(timerId, name);
    startIdleTimer(timerId, name);
  }

◆ stopLoadTimer()

void DlbTimerController::stopLoadTimer	(	const MInt	dlbTimerId,
		const MString &	name
	)

inline

Definition at line 355 of file dlbtimer.h.

                                                                 {
    if(m_ignoreDlbTimers) {
      return;
    }
    ENSURE_VALID_TIMERID(dlbTimerId, name);
 
    if(!dlbTimersEnabled(dlbTimerId)) {
      return;
    }
 
    ASSERT(dlbTimerId == m_runningTimerId, "timer id does not match the running timer id");
    m_dlbTimers[dlbTimerId].stopLoadTimer(name);
    m_runningTimerId = -1;
  }

◆ whichTimerIsRunning()

MInt DlbTimerController::whichTimerIsRunning ( ) const

inline

Definition at line 439 of file dlbtimer.h.

439{ return m_runningTimerId; }

Member Data Documentation

◆ m_dlbTimers

std::vector<maia::dlbTimer::DlbTimer> DlbTimerController::m_dlbTimers {}

private

Definition at line 491 of file dlbtimer.h.

◆ m_enabled

MBool DlbTimerController::m_enabled = false

private

Definition at line 495 of file dlbtimer.h.

◆ m_ignoreDlbTimers

MBool DlbTimerController::m_ignoreDlbTimers = true

private

Definition at line 497 of file dlbtimer.h.

◆ m_runningTimerId

MInt DlbTimerController::m_runningTimerId = -1

private

Definition at line 493 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

Public Member Functions

Private Attributes

Detailed Description

Member Function Documentation

◆ checkIOTimerStatus()

◆ createDlbTimers()

◆ disableAllDlbTimers()

◆ disableDlbTimers()

◆ dlbTimersEnabled()

◆ enableAllDlbTimers()

◆ enableDlbTimers()

◆ isLoadTimerRunning()

◆ isTimerRunning()

◆ noDlbTimers()

◆ noSubTimers()

◆ reEnableDlbTimer()

◆ resetRecords()

◆ returnIdleRecord()

◆ returnLoadRecord()

◆ startIdleTimer()

◆ startLoadTimer()

◆ stopIdleStartLoadTimer()

◆ stopIdleTimer()

◆ stopLoadStartIdleTimer()

◆ stopLoadTimer()

◆ whichTimerIsRunning()

Member Data Documentation

◆ m_dlbTimers

◆ m_enabled

◆ m_ignoreDlbTimers

◆ m_runningTimerId