PerfGraphLivePrint Class Reference

This is effectively a functor that runs on a separate thread and watches the state of the call stack to see if things need to be printed about what the application is doing. More...

#include <PerfGraphLivePrint.h>

Inheritance diagram for PerfGraphLivePrint:

Public Member Functions
	PerfGraphLivePrint (PerfGraph &perf_graph, MooseApp &app)
void	start ()
	Start printing.

Protected Attributes
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects.

Private Member Functions
void	printLiveMessage (PerfGraph::SectionIncrement &section_increment)
	Print the live message.
void	printStats (PerfGraph::SectionIncrement &section_increment_start, PerfGraph::SectionIncrement &section_increment_finish)
	Print the stats.
void	printStackUpToLast ()
	Print everything underneath the current top of the stack.
void	inSamePlace ()
	What to do if we're still in the same spot.
void	iterateThroughExecutionList ()
	What to do if there are new things in the execution list.

Private Attributes
const unsigned int	WRAP_LENGTH = 90
	Number of columns before wrapping.
const MooseApp &	_app
	The app performing this print.
PerfGraph &	_perf_graph
	Reference to the PerfGraph to work with.
const moose::internal::PerfGraphRegistry &	_perf_graph_registry
	Reference to the PerfGraphRegistry for convenience.
std::array< PerfGraph::SectionIncrement, MAX_EXECUTION_LIST_SIZE > &	_execution_list
	Convenience reference to the execution_list within the PerfGraph.
std::atomic< bool >	_currently_destructing
	True when we stop printing.
std::atomic< Real > &	_time_limit
	Limit (in seconds) before printing.
std::atomic< unsigned int > &	_mem_limit
	Limit (in MB)
unsigned int	_stack_level
	This is one beyond the last thing on the stack.
std::array< PerfGraph::SectionIncrement, MOOSE_MAX_STACK_SIZE >	_print_thread_stack
	The current stack for what the print thread has seen.
unsigned int	_current_execution_list_end
	The end of the execution list This is (safely) copied from PerfGraph so that it is consistent for an entire iteration.
unsigned int	_current_execution_list_last
	The actual last entry in the list This is useful because it is a circular queue - so this is not just end - 1 (although, often it will be)
unsigned int	_last_execution_list_end
	Where the end of the execution list was during the last call If this == the current_end... then nothing has happened.
PerfGraph::SectionIncrement *	_last_printed_increment
	Which increment was last printed.
unsigned long long int	_last_num_printed
	The output count from the console the last time we printed.
unsigned long long int	_console_num_printed
	The current output count from the console.
bool	_stack_top_print_dots
	Whether or not the top thing on the stack is set to print dots.

Detailed Description

This is effectively a functor that runs on a separate thread and watches the state of the call stack to see if things need to be printed about what the application is doing.

Definition at line 27 of file PerfGraphLivePrint.h.

Constructor & Destructor Documentation

PerfGraphLivePrint()

PerfGraphLivePrint::PerfGraphLivePrint	(	PerfGraph &	perf_graph,
		MooseApp &	app
	)

Definition at line 14 of file PerfGraphLivePrint.C.

  : ConsoleStreamInterface(app),
    _app(app),
    _perf_graph(perf_graph),
    _perf_graph_registry(moose::internal::getPerfGraphRegistry()),
    _execution_list(perf_graph._execution_list),
    _currently_destructing(false),
    _time_limit(perf_graph._live_print_time_limit),
    _mem_limit(perf_graph._live_print_mem_limit),
    _stack_level(0),
    _current_execution_list_end(0),
    _current_execution_list_last(0),
    _last_execution_list_end(0),
    _last_printed_increment(NULL),
    _last_num_printed(0),
    _console_num_printed(0),
    _stack_top_print_dots(true)
{
}

Member Function Documentation

inSamePlace()

void PerfGraphLivePrint::inSamePlace ( )

private

What to do if we're still in the same spot.

Definition at line 210 of file PerfGraphLivePrint.C.

{
  // If someone else printed since, then we need to start over, and set everything on the stack to
  // printed Everything is set to printed because if something printed and we're still in the same
  // place then we need to NOT print out the beginning message
  if (_last_num_printed != _console_num_printed)
  {
    _last_printed_increment = nullptr;
 
    for (unsigned int s = 0; s < _stack_level; s++)
      _print_thread_stack[s]._state = PerfGraph::IncrementState::PRINTED;
 
    return;
  }
 
  // Only print if there is something to print!
  if (_stack_level > 0)
  {
    _stack_top_print_dots =
        _perf_graph_registry.sectionInfo(_print_thread_stack[_stack_level - 1]._id)._print_dots;
 
    printStackUpToLast();
 
    printLiveMessage(_print_thread_stack[_stack_level - 1]);
 
    // Reset this each time
    _stack_top_print_dots = true;
  }
}

Referenced by start().

iterateThroughExecutionList()

void PerfGraphLivePrint::iterateThroughExecutionList ( )

private

What to do if there are new things in the execution list.

Definition at line 241 of file PerfGraphLivePrint.C.

{
  // Current position in the execution list
  auto p = _last_execution_list_end;
 
  while (p != _current_execution_list_end)
  {
    // The ternary here is for wrapping around
    auto next_p = p + 1 < MAX_EXECUTION_LIST_SIZE ? p + 1 : 0;
 
    auto & section_increment = _execution_list[p];
 
    // New section, add to the stack
    if (section_increment._state == PerfGraph::IncrementState::STARTED)
    {
      section_increment._print_stack_level = _stack_level;
 
      // Store this increment in the stack
      _print_thread_stack[_stack_level] = section_increment;
 
      _stack_level++;
    }
    else // This means it's finished need to see if we need to print it
    {
      mooseAssert(_stack_level, "Popping beyond the beginning of the stack!");
 
      // Get the beginning information for this section... it is the thing currently on the top of
      // the stack
      auto & section_increment_start = _print_thread_stack[_stack_level - 1];
 
      auto time_increment =
          std::chrono::duration<double>(section_increment._time - section_increment_start._time)
              .count();
      auto memory_increment = section_increment._memory - section_increment_start._memory;
 
      // If it has already been printed or meets our criteria then print it and finish it
      if (_perf_graph._live_print_all ||
          section_increment_start._state == PerfGraph::IncrementState::PRINTED ||
          time_increment > _time_limit.load(std::memory_order_relaxed) ||
          memory_increment > _mem_limit.load(std::memory_order_relaxed))
      {
        printStackUpToLast();
 
        printStats(section_increment_start, section_increment);
      }
 
      _stack_level--;
    }
 
    p = next_p;
  }
}

Referenced by start().

printLiveMessage()

void PerfGraphLivePrint::printLiveMessage ( PerfGraph::SectionIncrement &  section_increment )

private

Print the live message.

Definition at line 35 of file PerfGraphLivePrint.C.

{
  auto & section_info = _perf_graph_registry.sectionInfo(section_increment._id);
 
  // If we're not printing dots - we shouldn't be printing the message at all
  if (!section_info._print_dots || !_stack_top_print_dots)
  {
    section_increment._state = PerfGraph::IncrementState::PRINTED;
    _last_printed_increment = &section_increment;
    return;
  }
 
  // If the live_message is empty - just print the name
  auto message =
      !section_info._live_message.empty() ? section_info._live_message : section_info._name;
 
  // If this section is just started - but other stuff has printed before we got to print its
  // message, we need to print it anyway because it could be lengthy and print unexplained
  // dots to the console (until the Finished message). "Currently" conveys the message
  // that we did not just start it, but we are doing that right now
  if (_last_num_printed <= _console_num_printed &&
      section_increment._state == PerfGraph::IncrementState::STARTED &&
      section_increment._beginning_num_printed != _console_num_printed)
  {
    message = "Currently " + message;
    // The 10 is for "Currently "
    section_increment._num_dots = 10;
  }
 
  // This line is different - need to finish the last line
  if (_last_printed_increment && _last_printed_increment != &section_increment &&
      _last_printed_increment->_state == PerfGraph::IncrementState::PRINTED &&
      section_info._print_dots)
    _console << '\n';
 
  // Do we need to print dots?
  if (_last_printed_increment && _last_printed_increment == &section_increment &&
      section_increment._state == PerfGraph::IncrementState::PRINTED)
  {
    if (section_info._print_dots)
    {
      _console << ".";
      section_increment._num_dots++;
    }
  }
  // Printed before so print "Still"
  else if (section_increment._state == PerfGraph::IncrementState::PRINTED)
  {
    _console << std::string(2 * section_increment._print_stack_level, ' ') << "Still " << message;
 
    // If we're not printing dots - just finish the line
    if (!section_info._print_dots)
      _console << '\n';
 
    // The 6 is for "Still "
    section_increment._num_dots = 6;
  }
  else // Just print the message
  {
    _console << std::string(2 * section_increment._print_stack_level, ' ') << message;
 
    // If we're not printing dots - just finish the line
    if (!section_info._print_dots)
      _console << '\n';
 
    // Reset the dots since we're printing, except in the "Currently" case
    if (section_increment._state != PerfGraph::IncrementState::STARTED ||
        _last_num_printed > _console_num_printed ||
        section_increment._beginning_num_printed == _console_num_printed)
      section_increment._num_dots = 0;
  }
 
  section_increment._state = PerfGraph::IncrementState::PRINTED;
 
  // Get the message to the screen
  _console << std::flush;
 
  // Keep track of where we printed in the console
  _last_num_printed = section_increment._beginning_num_printed = _console.numPrinted();
 
  _last_printed_increment = &section_increment;
}

Referenced by inSamePlace(), and printStackUpToLast().

printStackUpToLast()

void PerfGraphLivePrint::printStackUpToLast ( )

private

Print everything underneath the current top of the stack.

Definition at line 191 of file PerfGraphLivePrint.C.

{
  if (_stack_level < 1)
    return;
 
  // We need to print out everything on the stack before this that hasn't already been printed...
  for (unsigned int s = 0; s < _stack_level - 1; s++)
  {
    auto & section = _print_thread_stack[s];
 
    // Hasn't been printed at all and nothing else has been printed since this started
    if (section._state == PerfGraph::IncrementState::STARTED)
      printLiveMessage(section);
 
    section._state = PerfGraph::IncrementState::PRINTED;
  }
}

Referenced by inSamePlace(), and iterateThroughExecutionList().

printStats()

void PerfGraphLivePrint::printStats ( PerfGraph::SectionIncrement &  section_increment_start, PerfGraph::SectionIncrement &  section_increment_finish  )

private

Print the stats.

Definition at line 119 of file PerfGraphLivePrint.C.

{
  if (_stack_level < 1)
    return;
 
  mooseAssert(_perf_graph_registry.sectionExists(section_increment_start._id),
              "Not found in map: " << section_increment_start._id);
 
  auto & section_info_start = _perf_graph_registry.sectionInfo(section_increment_start._id);
 
  // If the live_message is empty - just print the name
  auto message = !section_info_start._live_message.empty() ? section_info_start._live_message
                                                           : section_info_start._name;
 
  auto time_increment =
      std::chrono::duration<double>(section_increment_finish._time - section_increment_start._time)
          .count();
 
  auto memory_total = section_increment_finish._memory;
 
  auto num_horizontal_chars = message.size() + (2 * section_increment_start._print_stack_level);
 
  // Add multiapps prefix size
  if (!_app.isUltimateMaster())
    num_horizontal_chars += _app.name().size() + 2;
 
  // Do we need to print "Finished"?
  // This happens after something else printed in-between when this increment started and finished
  if (!section_info_start._print_dots ||
      (_last_printed_increment && _last_printed_increment != &section_increment_start) ||
      (section_increment_start._beginning_num_printed !=
       _console_num_printed)) // This means someone _else_ printed
  {
    // If we had printed some dots - we need to finish the line
    if (_last_printed_increment &&
        _last_printed_increment->_state == PerfGraph::IncrementState::PRINTED &&
        _perf_graph_registry.sectionInfo(_last_printed_increment->_id)._print_dots)
      _console << '\n';
 
    _console << std::string(2 * section_increment_start._print_stack_level, ' ') << "Finished "
             << message;
 
    // 9 is for "Finished "
    num_horizontal_chars += 9;
  }
  else
    num_horizontal_chars += section_increment_start._num_dots;
 
  // Actually do the printing
  _console << std::setw(WRAP_LENGTH - num_horizontal_chars);
 
  _console << " [";
  _console << COLOR_YELLOW;
  _console << std::setw(6) << std::fixed << std::setprecision(2) << time_increment << " s";
  _console << COLOR_DEFAULT;
  _console << ']' << " [";
  _console << COLOR_YELLOW << std::setw(5) << std::fixed;
  _console << memory_total;
  _console << " MB";
  _console << COLOR_DEFAULT;
  _console << ']';
 
  // If we're not printing dots - just finish the line
  _console << std::endl;
 
  _last_num_printed = _console.numPrinted();
 
  _last_printed_increment = &section_increment_finish;
}

Referenced by iterateThroughExecutionList().

start()

void PerfGraphLivePrint::start

(

)

Start printing.

Definition at line 295 of file PerfGraphLivePrint.C.

{
  // Keep going until we're signaled to end
  // Note that _currently_destructing can only be set to true in this thread
  // Which means that by the time we make it back to the top of the loop, either
  // there was nothing to process or everything has been processed.
  while (!_currently_destructing)
  {
    std::unique_lock<std::mutex> lock(_perf_graph._destructing_mutex);
 
    // Wait for five seconds (by default), or until notified that a section is finished
    // For a section to have finished the execution list has to have been appended to
    // This keeps spurious wakeups from happening
    // Note that the `lock` is only protecting _destructing since the execution list uses atomics.
    // It must be atomic in order to keep the main thread from having to lock as it
    // executes.  The only downside to this is that it is possible for this thread to wake,
    // check the condition, miss the notification, then wait.  In our case this is not detrimental,
    // as the only thing that will happen is we will wait 5 more seconds.  This is also very
    // unlikely.
    // One other thing: wait_for() is not guaranteed to wait for 5 seconds.  "Spurious" wakeups
    // can occur - but the predicate here keeps us from doing anything in that case.
    // This will either wait until 5 seconds have passed, the signal is sent, _or_ a spurious
    // wakeup happens to find that there is work to do.
    _perf_graph._finished_section.wait_for(
        lock,
        std::chrono::duration<Real>(_time_limit.load(std::memory_order_relaxed)),
        [this]
        {
          // Get destructing first so that the execution_list will be in sync
          this->_currently_destructing = _perf_graph._destructing;
 
          // The end will be one past the last
          // This "acquire" synchronizes with the "release" in the PerfGraph
          // to ensure that all of the writes to the execution list have been
          // published to this thread for the "end" we're reading
          this->_current_execution_list_end =
              _perf_graph._execution_list_end.load(std::memory_order_acquire);
 
          // Save off the number of things currently printed to the console
          this->_console_num_printed = _console.numPrinted();
 
          // If we are destructing or there is new work to do... allow moving on
          return this->_currently_destructing ||
                 this->_last_execution_list_end != this->_current_execution_list_end;
        });
 
    // If the PerfGraph is destructing and we don't have anything left to print - we need to quit
    // Otherwise, if there are still things to print - do it... afterwards, the loop above
    // will end because _done_future has been set in PerfGraph.
    if (this->_currently_destructing &&
        this->_last_execution_list_end == this->_current_execution_list_end)
      return;
 
    // The last entry in the current execution list for convenience
    _current_execution_list_last = static_cast<long int>(_current_execution_list_end) - 1 >= 0
                                       ? _current_execution_list_end - 1
                                       : MAX_EXECUTION_LIST_SIZE;
 
    // Only happens if nothing has been added
    if (_current_execution_list_end == 0 && _last_execution_list_end == _current_execution_list_end)
      continue;
 
    // Iterate from the last thing printed (begin) to the last thing in the list (end)
    // If the time or memory of any section is above the threshold, print everything in between and
    // update begin
 
    // Are we still sitting in the same place as the last iteration?  If so, we need to print
    // progress and exit
    if (_last_execution_list_end == _current_execution_list_end)
      inSamePlace();
 
    // This means that new stuff has been added to the execution list.  We need to iterate through
    // it, modifying the stack and printing anything that needs printing
    iterateThroughExecutionList();
 
    _last_num_printed = _console.numPrinted();
 
    _last_execution_list_end = _current_execution_list_end;
  }
}

Member Data Documentation

_app

const MooseApp& PerfGraphLivePrint::_app

private

The app performing this print.

Definition at line 66 of file PerfGraphLivePrint.h.

Referenced by printStats().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MaterialOutputAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), FEProblemBase::adaptMesh(), Adaptivity::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeLinearSystemTags(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), TimeStepper::constrainStep(), IterationAdaptiveDT::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), MessageFromInput::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), SidesetAroundSubdomainUpdater::finalize(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), CoarsenBlockGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), Console::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), PerfGraphOutput::output(), ReporterDebugOutput::output(), SolutionInvalidityOutput::output(), VariableResidualNormsDebugOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), WebServerControl::outputMessage(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), PicardSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), FEProblemSolve::solve(), FixedPointSolve::solve(), LinearSystem::solve(), NonlinearSystem::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), EigenProblem::solve(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), MFEMTransient::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_console_num_printed

unsigned long long int PerfGraphLivePrint::_console_num_printed

private

The current output count from the console.

Definition at line 118 of file PerfGraphLivePrint.h.

Referenced by inSamePlace(), printLiveMessage(), and printStats().

_current_execution_list_end

unsigned int PerfGraphLivePrint::_current_execution_list_end

private

The end of the execution list This is (safely) copied from PerfGraph so that it is consistent for an entire iteration.

Definition at line 100 of file PerfGraphLivePrint.h.

Referenced by iterateThroughExecutionList(), and start().

_current_execution_list_last

unsigned int PerfGraphLivePrint::_current_execution_list_last

private

The actual last entry in the list This is useful because it is a circular queue - so this is not just end - 1 (although, often it will be)

Definition at line 105 of file PerfGraphLivePrint.h.

Referenced by start().

_currently_destructing

std::atomic<bool> PerfGraphLivePrint::_currently_destructing

private

True when we stop printing.

NOTE: Even though only one thread is supposed to touch this variable, we make it atomic to avoid potential memory leak errors when testing with libtorch. Doing this is not expected to influence the performance considerably.

Definition at line 83 of file PerfGraphLivePrint.h.

Referenced by start().

_execution_list

std::array<PerfGraph::SectionIncrement, MAX_EXECUTION_LIST_SIZE>& PerfGraphLivePrint::_execution_list

private

Convenience reference to the execution_list within the PerfGraph.

Definition at line 75 of file PerfGraphLivePrint.h.

Referenced by iterateThroughExecutionList().

_last_execution_list_end

unsigned int PerfGraphLivePrint::_last_execution_list_end

private

Where the end of the execution list was during the last call If this == the current_end... then nothing has happened.

Definition at line 109 of file PerfGraphLivePrint.h.

Referenced by iterateThroughExecutionList(), and start().

_last_num_printed

unsigned long long int PerfGraphLivePrint::_last_num_printed

private

The output count from the console the last time we printed.

Definition at line 115 of file PerfGraphLivePrint.h.

Referenced by inSamePlace(), printLiveMessage(), printStats(), and start().

_last_printed_increment

PerfGraph::SectionIncrement* PerfGraphLivePrint::_last_printed_increment

private

Which increment was last printed.

Definition at line 112 of file PerfGraphLivePrint.h.

Referenced by inSamePlace(), printLiveMessage(), and printStats().

_mem_limit

std::atomic<unsigned int>& PerfGraphLivePrint::_mem_limit

private

Limit (in MB)

Definition at line 89 of file PerfGraphLivePrint.h.

Referenced by iterateThroughExecutionList().

_perf_graph

PerfGraph& PerfGraphLivePrint::_perf_graph

private

Reference to the PerfGraph to work with.

Definition at line 69 of file PerfGraphLivePrint.h.

Referenced by iterateThroughExecutionList(), and start().

_perf_graph_registry

const moose::internal::PerfGraphRegistry& PerfGraphLivePrint::_perf_graph_registry

private

Reference to the PerfGraphRegistry for convenience.

Definition at line 72 of file PerfGraphLivePrint.h.

Referenced by inSamePlace(), printLiveMessage(), and printStats().

_print_thread_stack

std::array<PerfGraph::SectionIncrement, MOOSE_MAX_STACK_SIZE> PerfGraphLivePrint::_print_thread_stack

private

The current stack for what the print thread has seen.

Definition at line 95 of file PerfGraphLivePrint.h.

Referenced by inSamePlace(), iterateThroughExecutionList(), and printStackUpToLast().

_stack_level

unsigned int PerfGraphLivePrint::_stack_level

private

This is one beyond the last thing on the stack.

Definition at line 92 of file PerfGraphLivePrint.h.

Referenced by inSamePlace(), iterateThroughExecutionList(), printStackUpToLast(), and printStats().

_stack_top_print_dots

bool PerfGraphLivePrint::_stack_top_print_dots

private

Whether or not the top thing on the stack is set to print dots.

Definition at line 121 of file PerfGraphLivePrint.h.

Referenced by inSamePlace(), and printLiveMessage().

_time_limit

std::atomic<Real>& PerfGraphLivePrint::_time_limit

private

Limit (in seconds) before printing.

Definition at line 86 of file PerfGraphLivePrint.h.

Referenced by iterateThroughExecutionList(), and start().

WRAP_LENGTH

const unsigned int PerfGraphLivePrint::WRAP_LENGTH = 90

private

Number of columns before wrapping.

Definition at line 63 of file PerfGraphLivePrint.h.

Referenced by printStats().

---

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

• include/utils/PerfGraphLivePrint.h
• src/utils/PerfGraphLivePrint.C