PerfGraph Class Reference

The PerfGraph will hold the master list of all registered performance segments and the head PerfNode. More...

#include <PerfGraph.h>

Inheritance diagram for PerfGraph:

Classes
struct	CumulativeSectionInfo
	Use to hold the cumulative time and memory for each section, which comes from all of the PerfNodes that contribute to said section. More...
class	SectionIncrement
	Use to hold an increment of time and memory for a section This is used in the LivePrint capability. More...

Public Types
enum	DataType {   SELF , CHILDREN , TOTAL , SELF_AVG ,   CHILDREN_AVG , TOTAL_AVG , SELF_PERCENT , CHILDREN_PERCENT ,   TOTAL_PERCENT , SELF_MEMORY , CHILDREN_MEMORY , TOTAL_MEMORY ,   CALLS }
	For retrieving values. More...
using	PerfGraphRegistry = moose::internal::PerfGraphRegistry

Public Member Functions
	PerfGraph (const std::string &root_name, MooseApp &app, const bool live_all, const bool perf_graph_live)
	Create a new PerfGraph.
	~PerfGraph ()
	Destructor.
void	print (const ConsoleStream &console, unsigned int level)
	Print the tree out.
void	printHeaviestBranch (const ConsoleStream &console)
	Print out the heaviest branch through the tree.
void	printHeaviestSections (const ConsoleStream &console, const unsigned int num_sections)
	Print out the heaviest sections that were timed.
bool	active () const
	Whether or not timing is active.
void	setActive (bool active)
	Turn on or off timing.
void	enableLivePrint ()
	Enables Live Print.
void	disableLivePrint ()
	Completely disables Live Print (cannot be restarted)
void	setLivePrintAll (bool active)
	Forces all sections to be output live.
void	setLiveTimeLimit (Real time_limit)
	Set the time limit before a message prints.
void	setLiveMemoryLimit (unsigned int mem_limit)
	Sert the memory limit before a message prints.
Real	sectionData (const DataType type, const std::string &section_name, const bool must_exist=true)
	Gets a PerfGraph result pertaining to a section.
void	update ()
	Updates the time section_time and time for all currently running nodes.
std::size_t	getMaxMemory () const
	Get the maximum memory allocation in MB.
MooseApp &	mooseApp ()
const PerfNode &	rootNode () const
template<typename Functor >
void	treeRecurse (const Functor &act, const unsigned int level=MOOSE_MAX_STACK_SIZE, const bool heaviest=false) const

Static Public Member Functions
static MooseEnum	dataTypeEnum ()
	DataType in a MooseEnum for use in InputParameters in objects that query the PerfGraph with sectionData.

Protected Types
enum	IncrementState { STARTED , PRINTED , FINISHED }
	The execution state of an increment. More...
typedef VariadicTable< std::string, unsigned long int, Real, Real, Real, long int, Real, Real, Real, long int >	FullTable
typedef VariadicTable< std::string, unsigned long int, Real, Real, Real, long int >	HeaviestTable

Protected Member Functions
void	addToExecutionList (const PerfID id, const IncrementState state, const std::chrono::time_point< std::chrono::steady_clock > time, const long int memory)
	Add the information to the execution list.
void	push (const PerfID id)
	Add a Node onto the end of the end of the current callstack.
void	pop ()
	Remove a Node from the end of the current scope.
void	recursivelyUpdate (const PerfNode &current_node)
	Updates the cumulative self/children/total time and memory for each section across all nodes that contribute to said section in _cumulative_section_info.

Protected Attributes
MooseApp &	_moose_app
	The MooseApp.
bool	_live_print_all
	Whether or not to put everything in the perf graph.
bool	_disable_live_print
	Whether or not live print is disabled (cannot be turned on again)
PerfGraphRegistry &	_perf_graph_registry
	The PerfGraphRegistry.
const libMesh::processor_id_type	_pid
	This processor id.
const std::string	_root_name
	Name of the root node.
const PerfID	_root_node_id
	The id for the root node.
const std::unique_ptr< PerfNode >	_root_node
	The root node of the graph.
int	_current_position
	The current node position in the stack.
std::array< PerfNode *, MOOSE_MAX_STACK_SIZE >	_stack
	The full callstack. Currently capped at a depth of 100.
std::array< SectionIncrement, MAX_EXECUTION_LIST_SIZE >	_execution_list
	A circular buffer for holding the execution list, this is read by the printing loop.
std::atomic< unsigned int >	_execution_list_begin
	Where the print thread should start reading the execution list.
std::atomic< unsigned int >	_execution_list_end
	Where the print thread should stop reading the execution list.
std::unordered_map< std::string, CumulativeSectionInfo >	_cumulative_section_info
	The cumulative time and memory for each section.
std::vector< CumulativeSectionInfo * >	_cumulative_section_info_ptrs
	Pointers into _cumulative_section_info indexed on PerfID This is here for convenience and speed so we don't need to iterate over the above map much - and it makes it easier to sort.
std::atomic< std::size_t >	_max_memory
	Maximum memory encountered during push and pop.
bool	_active
	Whether or not timing is active.
std::promise< bool >	_done
	The promise to the print thread that will signal when to stop.
bool	_destructing
	Tell the print thread to teardown.
std::mutex	_destructing_mutex
	The mutex to use with a condition_variable predicate to guard _destructing.
std::condition_variable	_finished_section
	The condition_variable to wake the print thread.
std::atomic< Real >	_live_print_time_limit
	The time limit before a message is printed (in seconds)
std::atomic< unsigned int >	_live_print_mem_limit
	The memory limit before a message is printed (in MB)
const std::unique_ptr< PerfGraphLivePrint >	_live_print
	The object that is doing live printing.
std::thread	_print_thread
	The thread for printing sections as they execute.
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects.

Private Member Functions
FullTable	treeTable (const unsigned int level, const bool heaviest=false)
	Helper for building a VariadicTable that represents the tree.
template<typename Functor >
void	treeRecurseInternal (const PerfNode &node, const Functor &act, const unsigned int level, const bool heaviest, unsigned int current_depth) const
void	updateMaxMemory (const std::size_t current_memory)
	Update _max_memory if current_memory > _max_memory.

Friends
class	PerfGuard
class	PerfGraphLivePrint
void	dataStore (std::ostream &, PerfGraph &, void *)
void	dataLoad (std::istream &, PerfGraph &, void *)

Detailed Description

The PerfGraph will hold the master list of all registered performance segments and the head PerfNode.

Definition at line 43 of file PerfGraph.h.

Member Typedef Documentation

FullTable

typedef VariadicTable<std::string, unsigned long int, Real, Real, Real, long int, Real, Real, Real, long int> PerfGraph::FullTable

protected

Definition at line 211 of file PerfGraph.h.

HeaviestTable

typedef VariadicTable<std::string, unsigned long int, Real, Real, Real, long int> PerfGraph::HeaviestTable

protected

Definition at line 213 of file PerfGraph.h.

PerfGraphRegistry

using PerfGraph::PerfGraphRegistry = moose::internal::PerfGraphRegistry

Definition at line 46 of file PerfGraph.h.

Member Enumeration Documentation

DataType

enum PerfGraph::DataType

For retrieving values.

Enumerator
SELF
CHILDREN
TOTAL
SELF_AVG
CHILDREN_AVG
TOTAL_AVG
SELF_PERCENT
CHILDREN_PERCENT
TOTAL_PERCENT
SELF_MEMORY
CHILDREN_MEMORY
TOTAL_MEMORY
CALLS

Definition at line 51 of file PerfGraph.h.

  {
    SELF,
    CHILDREN,
    TOTAL,
    SELF_AVG,
    CHILDREN_AVG,
    TOTAL_AVG,
    SELF_PERCENT,
    CHILDREN_PERCENT,
    TOTAL_PERCENT,
    SELF_MEMORY,
    CHILDREN_MEMORY,
    TOTAL_MEMORY,
    CALLS
  };

IncrementState

enum PerfGraph::IncrementState

protected

The execution state of an increment.

Enumerator
STARTED	Section just started running.
PRINTED	This section has already started printing.
FINISHED	The section is complete.

Definition at line 248 of file PerfGraph.h.

  {
    STARTED,
 
    PRINTED,
 
    FINISHED
  };

Constructor & Destructor Documentation

PerfGraph()

PerfGraph::PerfGraph	(	const std::string &	root_name,
		MooseApp &	app,
		const bool	live_all,
		const bool	perf_graph_live
	)

Create a new PerfGraph.

Parameters

root_name	The name of the root node
app	The MooseApp this PerfGraph is for
live_all	Whether every message should be printed
perf_graph_live	Enable/disable PerfGraphLive (permanently)

Definition at line 28 of file PerfGraph.C.

  : ConsoleStreamInterface(app),
    _moose_app(app),
    _live_print_all(live_all),
    _disable_live_print(!perf_graph_live),
    _perf_graph_registry(moose::internal::getPerfGraphRegistry()),
    _pid(app.comm().rank()),
    _root_name(root_name),
    _root_node_id(_perf_graph_registry.registerSection(root_name, 0)),
    _root_node(std::make_unique<PerfNode>(_root_node_id)),
    _current_position(-1),
    _stack(),
    _execution_list_begin(0),
    _execution_list_end(0),
    _max_memory(0),
    _active(true),
    _destructing(false),
    _live_print_time_limit(5.0),
    _live_print_mem_limit(100),
    _live_print(std::make_unique<PerfGraphLivePrint>(*this, app))
{
  push(_root_node_id);
}

~PerfGraph()

PerfGraph::~PerfGraph

(

)

Destructor.

Definition at line 55 of file PerfGraph.C.

{ disableLivePrint(); }

Member Function Documentation

active()

bool PerfGraph::active ( ) const

inline

Whether or not timing is active.

When not active no timing information will be kept

Definition at line 124 of file PerfGraph.h.

{ return _active; }

Referenced by setActive(), and setLivePrintAll().

addToExecutionList()

void PerfGraph::addToExecutionList ( const PerfID  id, const IncrementState  state, const std::chrono::time_point< std::chrono::steady_clock >  time, const long int  memory  )

inlineprotected

Add the information to the execution list.

Should only be called by push() and pop()

Definition at line 155 of file PerfGraph.C.

{
  auto & section_increment = _execution_list[_execution_list_end];
 
  section_increment._id = id;
  section_increment._state = state;
  section_increment._time = time;
  section_increment._memory = memory;
  section_increment._beginning_num_printed = _console.numPrinted();
 
  // A note about this next section of code:
  // It is only EVER run on the main thread - and therefore there can be
  // no race conditions.  All that is important here is that the print
  // thread always sees a consistent value for _execution_list_end
  auto next_execution_list_end = _execution_list_end + 1;
 
  // Are we at the end of our circular buffer?
  if (next_execution_list_end >= MAX_EXECUTION_LIST_SIZE)
    next_execution_list_end = 0;
 
  // This "release" will synchronize the above memory changes with the
  // "acquire" in the printing thread
  // All of the above memory operations will be seen by the
  // printing thread before the printing thread sees this new value
  _execution_list_end.store(next_execution_list_end, std::memory_order_release);
}

Referenced by pop(), and push().

dataTypeEnum()

static MooseEnum PerfGraph::dataTypeEnum ( )

inlinestatic

DataType in a MooseEnum for use in InputParameters in objects that query the PerfGraph with sectionData.

Definition at line 72 of file PerfGraph.h.

  {
    return MooseEnum(
        "SELF CHILDREN TOTAL SELF_AVG CHILDREN_AVG TOTAL_AVG SELF_PERCENT CHILDREN_PERCENT "
        "TOTAL_PERCENT SELF_MEMORY CHILDREN_MEMORY TOTAL_MEMORY CALLS");
  }

Referenced by PerfGraphData::validParams().

disableLivePrint()

void PerfGraph::disableLivePrint

(

)

Completely disables Live Print (cannot be restarted)

Definition at line 68 of file PerfGraph.C.

{
  if (_pid == 0 && !_disable_live_print)
  {
    {
      // Unlike using atomics for execution_thread_end
      // here we actually lock to ensure that either the print thread
      // immediately sees that we are destructing or is immediately
      // notified with the below notification.  Without doing this
      // it would be possible (but unlikely) for the print thread to
      // hang for 1 second at the end of execution (which would not be
      // good anytime you are running lots of fast calculations back-to-back
      // like during testing or stochastic sampling).
      std::lock_guard<std::mutex> lock(_destructing_mutex);
      _destructing = true;
    }
 
    _finished_section.notify_one();
 
    _print_thread.join();
 
    _disable_live_print = true;
  }
}

Referenced by CommonOutputAction::act(), MooseApp::setupOptions(), and ~PerfGraph().

enableLivePrint()

void PerfGraph::enableLivePrint

(

)

Enables Live Print.

Definition at line 58 of file PerfGraph.C.

{
  if (_pid == 0 && !_disable_live_print)
  {
    // Start the printing thread
    _print_thread = std::thread([this] { this->_live_print->start(); });
  }
}

getMaxMemory()

std::size_t PerfGraph::getMaxMemory ( ) const

inline

Get the maximum memory allocation in MB.

This is thread safe.

Definition at line 183 of file PerfGraph.h.

{ return _max_memory; }

Referenced by updateMaxMemory().

mooseApp()

MooseApp & PerfGraph::mooseApp ( )

inline

Returns

The MooseApp

Definition at line 188 of file PerfGraph.h.

{ return _moose_app; }

pop()

void PerfGraph::pop ( )

protected

Remove a Node from the end of the current scope.

Note: only accessible by using PerfGuard!

Definition at line 236 of file PerfGraph.C.

{
  if (!_active)
    return;
 
  auto current_time = std::chrono::steady_clock::now();
 
  auto & current_node = _stack[_current_position];
 
  MemoryUtils::Stats stats;
  auto memory_success = MemoryUtils::getMemoryStats(stats);
 
  long int current_memory = 0;
 
  if (memory_success)
  {
    const auto memory_mb =
        MemoryUtils::convertBytes(stats._physical_memory, MemoryUtils::MemUnits::Megabytes);
    current_memory = memory_mb;
    updateMaxMemory(memory_mb);
  }
  // If we weren't able to get the memory stats, let's just use the start memory
  else if (_current_position !=
           -1) // If we weren't able to get the memory stats, let's just use the start memory
    current_memory = _stack[_current_position]->startMemory();
 
  current_node->addTimeAndMemory(current_time, current_memory);
 
  _current_position--;
 
  // Add this to the exection list
  if ((_pid == 0 && !_disable_live_print) &&
      (!_perf_graph_registry.readSectionInfo(current_node->id())._live_message.empty() ||
       _live_print_all))
  {
    addToExecutionList(current_node->id(), IncrementState::FINISHED, current_time, current_memory);
 
    // Tell the printing thread that a section has finished
    //
    // Note: no mutex is needed here because we're using an atomic
    // in the predicate of the condition_variable in the thread
    // This is technically correct - but there is a chance of missing a signal
    // For us - that chance is low and doesn't matter (the timeout will just be hit
    // instead). So - I would rather not have an extra lock here in the main thread.
    _finished_section.notify_one();
  }
}

Referenced by PerfGuard::~PerfGuard().

print()

void PerfGraph::print	(	const ConsoleStream &	console,
		unsigned int	level
	)

Print the tree out.

Parameters

console	The output stream to output to
level	The log level, the higher the number the more output you get

Definition at line 416 of file PerfGraph.C.

{
  console << "\nPerformance Graph:\n";
  treeTable(level).print(console);
}

Referenced by PerfGraphOutput::output().

printHeaviestBranch()

void PerfGraph::printHeaviestBranch

(

const ConsoleStream &

console

)

Print out the heaviest branch through the tree.

Parameters

console

The output stream to output to

Definition at line 423 of file PerfGraph.C.

{
  console << "\nHeaviest Branch:\n";
  treeTable(MOOSE_MAX_STACK_SIZE, /* heaviest = */ true).print(console);
}

Referenced by PerfGraphOutput::output().

printHeaviestSections()

void PerfGraph::printHeaviestSections	(	const ConsoleStream &	console,
		const unsigned int	num_sections
	)

Print out the heaviest sections that were timed.

Parameters

console

The output stream to output to

Definition at line 430 of file PerfGraph.C.

{
  update();
 
  console << "\nHeaviest Sections:\n";
 
  // Indirect Sort The Self Time
  std::vector<size_t> sorted;
  Moose::indirectSort(_cumulative_section_info_ptrs.begin(),
                      _cumulative_section_info_ptrs.end(),
                      sorted,
                      [](CumulativeSectionInfo * lhs, CumulativeSectionInfo * rhs)
                      {
                        if (lhs && rhs)
                          return lhs->_self > rhs->_self;
 
                        // If the LHS exists - it's definitely bigger than a non-existant RHS
                        if (lhs)
                          return true;
 
                        // Both don't exist - so it doesn't matter how we sort them
                        return false;
                      });
 
  HeaviestTable vtable({"Section", "Calls", "Self(s)", "Avg.", "%", "Mem(MB)"}, 10);
 
  vtable.setColumnFormat({VariadicTableColumnFormat::AUTO,    // Section; doesn't matter
                          VariadicTableColumnFormat::AUTO,    // Calls
                          VariadicTableColumnFormat::FIXED,   // Time
                          VariadicTableColumnFormat::FIXED,   // Avg.
                          VariadicTableColumnFormat::PERCENT, // Percent
                          VariadicTableColumnFormat::AUTO}    // Memory
  );
 
  vtable.setColumnPrecision({
      1, // Section
      1, // Calls
      3, // Time
      3, // Avg.
      2, // Percent
      1  // Memory
  });
 
  mooseAssert(!_cumulative_section_info_ptrs.empty(),
              "update() must be run before printHeaviestSections()!");
 
  // The total time of the root node
  auto total_root_time = _cumulative_section_info_ptrs[_root_node_id]->_total;
 
  // Now print out the largest ones
  for (unsigned int i = 0; i < num_sections; i++)
  {
    auto id = sorted[i];
 
    if (!_cumulative_section_info_ptrs[id])
      continue;
 
    const auto & entry = *_cumulative_section_info_ptrs[id];
    vtable.addRow(_perf_graph_registry.sectionInfo(id)._name,        // Section
                  entry._num_calls,                                  // Calls
                  entry._self,                                       // Time
                  entry._self / static_cast<Real>(entry._num_calls), // Avg.
                  100. * entry._self / total_root_time,              // Percent
                  entry._self_memory);                               // Memory
  }
 
  vtable.print(console);
}

Referenced by PerfGraphOutput::output().

push()

void PerfGraph::push ( const PerfID  id )

protected

Add a Node onto the end of the end of the current callstack.

Note: only accessible by using PerfGuard!

Definition at line 186 of file PerfGraph.C.

{
  if (!_active)
    return;
 
  PerfNode * new_node = nullptr;
 
  if (id == _root_node_id)
    new_node = _root_node.get();
  else
    new_node = _stack[_current_position]->getChild(id);
 
  MemoryUtils::Stats stats;
  auto memory_success = MemoryUtils::getMemoryStats(stats);
 
  long int start_memory = 0;
 
  if (memory_success)
  {
    const auto memory_mb =
        MemoryUtils::convertBytes(stats._physical_memory, MemoryUtils::MemUnits::Megabytes);
    start_memory = memory_mb;
    updateMaxMemory(memory_mb);
  }
  // If we weren't able to get the memory stats, let's just use the parent's
  else if (_current_position != -1)
    start_memory = _stack[_current_position]->startMemory();
 
  // Set the start time
  auto current_time = std::chrono::steady_clock::now();
 
  new_node->setStartTimeAndMemory(current_time, start_memory);
 
  // Increment the number of calls
  new_node->incrementNumCalls();
 
  _current_position++;
 
  if (_current_position >= MOOSE_MAX_STACK_SIZE)
    mooseError("PerfGraph is out of stack space!");
 
  _stack[_current_position] = new_node;
 
  // Add this to the execution list unless the message is empty - but pre-emted by live_print_all
  if ((_pid == 0 && !_disable_live_print) &&
      (!_perf_graph_registry.readSectionInfo(id)._live_message.empty() || _live_print_all))
    addToExecutionList(id, IncrementState::STARTED, current_time, start_memory);
}

Referenced by PerfGraph(), and PerfGuard::PerfGuard().

recursivelyUpdate()

void PerfGraph::recursivelyUpdate ( const PerfNode &  current_node )

protected

Updates the cumulative self/children/total time and memory for each section across all nodes that contribute to said section in _cumulative_section_info.

Note: requires that the contents in each CumulativeSectionInfo in _cumulative_section_info be initially resized and zeroed

Parameters

current_node

The current node to work on

Definition at line 332 of file PerfGraph.C.

{
  const auto & section_name = _perf_graph_registry.readSectionInfo(current_node.id())._name;
 
  // RHS insertion on purpose
  auto & section_time = _cumulative_section_info[section_name];
 
  section_time._self += current_node.selfTimeSec();
  section_time._children += current_node.childrenTimeSec();
  section_time._total += current_node.totalTimeSec();
  section_time._num_calls += current_node.numCalls();
 
  section_time._self_memory += current_node.selfMemory();
  section_time._children_memory += current_node.childrenMemory();
  section_time._total_memory += current_node.totalMemory();
 
  for (auto & child_it : current_node.children())
    recursivelyUpdate(*child_it.second);
}

Referenced by recursivelyUpdate(), and update().

rootNode()

const PerfNode & PerfGraph::rootNode ( ) const

inline

Returns

A constant reference to the root node

Definition at line 193 of file PerfGraph.h.

{ return *_root_node; }

sectionData()

Real PerfGraph::sectionData	(	const DataType	type,
		const std::string &	section_name,
		const bool	must_exist = true
	)

Gets a PerfGraph result pertaining to a section.

Parameters

type	The result type to retrieve
section_name	The name of the section
must_exist	Whether not the section must exist; if false and the section does not exist, returns 0, if true and the section does not exist, exit with an error

Definition at line 94 of file PerfGraph.C.

{
  update();
 
  const auto section_it =
      _cumulative_section_info.find(section_name == "Root" ? _root_name : section_name);
 
  if (section_it == _cumulative_section_info.end())
  {
    if (!must_exist ||                                   // isn't required to exist
        _perf_graph_registry.sectionExists(section_name) // or, is required to exist and it does
    )
      return 0;
 
    mooseError("Unknown PerfGraph section name \"",
               section_name,
               "\" in PerfGraph::sectionData().\nIf you are attempting to retrieve the root use "
               "\"Root\".");
  }
 
  const CumulativeSectionInfo & section_info = section_it->second;
 
  if (type == CALLS)
    return section_info._num_calls;
 
  const auto app_time = _cumulative_section_info_ptrs[_root_node_id]->_total;
 
  switch (type)
  {
    case SELF:
      return section_info._self;
    case CHILDREN:
      return section_info._children;
    case TOTAL:
      return section_info._total;
    case SELF_AVG:
      return section_info._self / static_cast<Real>(section_info._num_calls);
    case CHILDREN_AVG:
      return section_info._children / static_cast<Real>(section_info._num_calls);
    case TOTAL_AVG:
      return section_info._total / static_cast<Real>(section_info._num_calls);
    case SELF_PERCENT:
      return 100. * (section_info._self / app_time);
    case CHILDREN_PERCENT:
      return 100. * (section_info._children / app_time);
    case TOTAL_PERCENT:
      return 100. * (section_info._total / app_time);
    case SELF_MEMORY:
      return section_info._self_memory;
    case CHILDREN_MEMORY:
      return section_info._children_memory;
    case TOTAL_MEMORY:
      return section_info._total_memory;
    default:
      ::mooseError("Unknown DataType");
  }
}

Referenced by PerfGraphData::finalize().

setActive()

void PerfGraph::setActive ( bool  active )

inline

Turn on or off timing.

Definition at line 129 of file PerfGraph.h.

{ _active = active; }

Referenced by CommonOutputAction::act(), and MooseApp::setupOptions().

setLiveMemoryLimit()

void PerfGraph::setLiveMemoryLimit ( unsigned int  mem_limit )

inline

Sert the memory limit before a message prints.

Definition at line 157 of file PerfGraph.h.

  {
    _live_print_mem_limit.store(mem_limit, std::memory_order_relaxed);
  }

Referenced by CommonOutputAction::act().

setLivePrintAll()

void PerfGraph::setLivePrintAll ( bool  active )

inline

Forces all sections to be output live.

Definition at line 144 of file PerfGraph.h.

{ _live_print_all = active; }

setLiveTimeLimit()

void PerfGraph::setLiveTimeLimit ( Real  time_limit )

inline

Set the time limit before a message prints.

Definition at line 149 of file PerfGraph.h.

  {
    _live_print_time_limit.store(time_limit, std::memory_order_relaxed);
  }

Referenced by CommonOutputAction::act().

treeRecurse()

template<typename Functor >

void PerfGraph::treeRecurse	(	const Functor &	act,
		const unsigned int	level = MOOSE_MAX_STACK_SIZE,
		const bool	heaviest = false
	)		const

Definition at line 488 of file PerfGraph.h.

{
  mooseAssert(_root_node, "Root node does not exist; calling this too early");
  treeRecurseInternal(*_root_node, act, level, heaviest, 0);
}

Referenced by treeTable().

treeRecurseInternal()

template<typename Functor >

void PerfGraph::treeRecurseInternal ( const PerfNode &  node, const Functor &  act, const unsigned int  level, const bool  heaviest, unsigned int  current_depth  ) const

private

Definition at line 450 of file PerfGraph.h.

{
  mooseAssert(_perf_graph_registry.sectionExists(node.id()), "Unable to find section name!");
 
  const auto & current_section_info = _perf_graph_registry.readSectionInfo(node.id());
  if (current_section_info._level <= level)
  {
    mooseAssert(!_cumulative_section_info_ptrs.empty(), "update() must be run before treeRecurse!");
    act(node, current_section_info, current_depth++);
  }
 
  if (heaviest)
  {
    const PerfNode * heaviest_child = nullptr;
    for (const auto & child_it : node.children())
    {
      const auto & current_child = *child_it.second;
 
      if (!heaviest_child || (current_child.totalTime() > heaviest_child->totalTime()))
        heaviest_child = &current_child;
    }
 
    if (heaviest_child)
      treeRecurseInternal(*heaviest_child, act, level, true, current_depth);
  }
  else
  {
    for (const auto & child_it : node.children())
      treeRecurseInternal(*child_it.second, act, level, false, current_depth);
  }
}

Referenced by treeRecurse(), and treeRecurseInternal().

treeTable()

PerfGraph::FullTable PerfGraph::treeTable ( const unsigned int  level, const bool  heaviest = false  )

private

Helper for building a VariadicTable that represents the tree.

Parameters

level	The level to print out below (<=)
heaviest	Show only the heaviest branch

Definition at line 353 of file PerfGraph.C.

{
  update();
 
  FullTable vtable({"Section",
                    "Calls",
                    "Self(s)",
                    "Avg(s)",
                    "%",
                    "Mem(MB)",
                    "Total(s)",
                    "Avg(s)",
                    "%",
                    "Mem(MB)"},
                   10);
 
  vtable.setColumnFormat({
      VariadicTableColumnFormat::AUTO,    // Section Name
      VariadicTableColumnFormat::AUTO,    // Calls
      VariadicTableColumnFormat::FIXED,   // Self
      VariadicTableColumnFormat::FIXED,   // Avg.
      VariadicTableColumnFormat::PERCENT, // %
      VariadicTableColumnFormat::AUTO,    // Memory
      VariadicTableColumnFormat::FIXED,   // Total
      VariadicTableColumnFormat::FIXED,   // Avg.
      VariadicTableColumnFormat::PERCENT, // %
      VariadicTableColumnFormat::AUTO,    // Memory
  });
 
  vtable.setColumnPrecision({
      1, // Section Name
      0, // Calls
      3, // Self
      3, // Avg.
      2, // %
      0, // Memory
      3, // Total
      3, // Avg.
      2, // %
      0, // Memory
  });
 
  auto act = [this, &vtable](const PerfNode & node,
                             const moose::internal::PerfGraphSectionInfo & section_info,
                             const unsigned int depth)
  {
    vtable.addRow(std::string(depth * 2, ' ') + section_info._name,        // Section Name
                  node.numCalls(),                                         // Calls
                  node.selfTimeSec(),                                      // Self
                  node.selfTimeAvg(),                                      // Avg.
                  100. * node.selfTimeSec() / _root_node->totalTimeSec(),  // %
                  node.selfMemory(),                                       // Memory
                  node.totalTimeSec(),                                     // Total
                  node.totalTimeAvg(),                                     // Avg.
                  100. * node.totalTimeSec() / _root_node->totalTimeSec(), // %
                  node.totalMemory());                                     // Memory
  };
  treeRecurse(act, level, heaviest);
 
  return vtable;
}

Referenced by print(), and printHeaviestBranch().

update()

void PerfGraph::update

(

)

Updates the time section_time and time for all currently running nodes.

Definition at line 285 of file PerfGraph.C.

{
  // First update all of the currently running nodes
  auto now = std::chrono::steady_clock::now();
 
  MemoryUtils::Stats stats;
  MemoryUtils::getMemoryStats(stats);
  auto now_memory =
      MemoryUtils::convertBytes(stats._physical_memory, MemoryUtils::MemUnits::Megabytes);
 
  for (int i = 0; i <= _current_position; i++)
  {
    auto node = _stack[i];
    node->addTimeAndMemory(now, now_memory);
    node->setStartTimeAndMemory(now, now_memory);
  }
 
  // Zero out the entries
  for (auto & section_time_it : _cumulative_section_info)
  {
    auto & section_time = section_time_it.second;
 
    section_time._num_calls = 0;
    section_time._self = 0.;
    section_time._children = 0.;
    section_time._total = 0.;
    section_time._self_memory = 0;
    section_time._children_memory = 0;
    section_time._total_memory = 0.;
  }
 
  recursivelyUpdate(*_root_node);
 
  // Update vector pointing to section times
  // Note: we are doing this _after_ recursively filling
  // because new entries may have been created
  _cumulative_section_info_ptrs.resize(_perf_graph_registry.numSections());
 
  for (auto & section_time_it : _cumulative_section_info)
  {
    auto id = _perf_graph_registry.sectionID(section_time_it.first);
 
    _cumulative_section_info_ptrs[id] = &section_time_it.second;
  }
}

Referenced by printHeaviestSections(), sectionData(), and treeTable().

updateMaxMemory()

void PerfGraph::updateMaxMemory ( const std::size_t  current_memory )

private

Update _max_memory if current_memory > _max_memory.

Definition at line 500 of file PerfGraph.C.

{
  // We shouldn't need to lock _max_memory in-between getting
  // it and setting it as this should only ever be set outside
  // of threads. _max_memory is an atomic so that getting it
  // is thread safe.
  if (current_memory > getMaxMemory())
    _max_memory = current_memory;
}

Referenced by pop(), and push().

Friends And Related Symbol Documentation

dataLoad

void dataLoad ( std::istream &  stream, PerfGraph &  perf_graph, void *  context  )

friend

Definition at line 525 of file PerfGraph.C.

{
  // Load in all of the recovered sections and register those that do not exist yet
  std::vector<moose::internal::PerfGraphSectionInfo> recovered_section_info;
  dataLoad(stream, recovered_section_info, nullptr);
  for (const auto & info : recovered_section_info)
  {
    if (info._live_message.size())
      perf_graph._perf_graph_registry.registerSection(
          info._name, info._level, info._live_message, info._print_dots);
    else
      perf_graph._perf_graph_registry.registerSection(info._name, info._level);
  }
 
  // Update the current node time/memory/calls before loading the nodes as the load
  // will append information to current nodes that exist
  perf_graph.update();
 
  // Recursively load all of the nodes; this will append information to matching nodes
  // and will create new nodes for section paths that do not exist
  dataLoad(stream, perf_graph._root_node, &perf_graph);
}

dataStore

void dataStore ( std::ostream &  stream, PerfGraph &  perf_graph, void *  context  )

friend

Definition at line 511 of file PerfGraph.C.

{
  // We need to store the registry id -> section info map so that we can add
  // registered sections that may not be added yet during recover
  dataStore(stream, perf_graph._perf_graph_registry._id_to_item, nullptr);
 
  // Update before serializing the nodes so that the time/memory/calls are correct
  perf_graph.update();
 
  // Recursively serialize all of the nodes
  dataStore(stream, perf_graph._root_node, nullptr);
}

PerfGraphLivePrint

friend class PerfGraphLivePrint

friend

Definition at line 422 of file PerfGraph.h.

PerfGuard

friend class PerfGuard

friend

Definition at line 421 of file PerfGraph.h.

Member Data Documentation

_active

bool PerfGraph::_active

protected

Whether or not timing is active.

Definition at line 394 of file PerfGraph.h.

Referenced by active(), pop(), push(), and setActive().

_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(), 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(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::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(), PerfGraphLivePrint::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().

_cumulative_section_info

std::unordered_map<std::string, CumulativeSectionInfo> PerfGraph::_cumulative_section_info

protected

The cumulative time and memory for each section.

This is updated on update() Note that this is total cumulative time/memory across every place that section is in the graph

I'm making this a map so that we can give out references to the values The three values are: self, children The map is on std::string because we might need to be able to retrieve timing values in a "late binding" situation before the section has been registered.

Definition at line 382 of file PerfGraph.h.

Referenced by recursivelyUpdate(), sectionData(), and update().

_cumulative_section_info_ptrs

std::vector<CumulativeSectionInfo *> PerfGraph::_cumulative_section_info_ptrs

protected

Pointers into _cumulative_section_info indexed on PerfID This is here for convenience and speed so we don't need to iterate over the above map much - and it makes it easier to sort.

Definition at line 388 of file PerfGraph.h.

Referenced by printHeaviestSections(), sectionData(), treeRecurseInternal(), and update().

_current_position

int PerfGraph::_current_position

protected

The current node position in the stack.

Definition at line 359 of file PerfGraph.h.

Referenced by pop(), push(), and update().

_destructing

bool PerfGraph::_destructing

protected

Tell the print thread to teardown.

Definition at line 400 of file PerfGraph.h.

Referenced by disableLivePrint().

_destructing_mutex

std::mutex PerfGraph::_destructing_mutex

protected

The mutex to use with a condition_variable predicate to guard _destructing.

Definition at line 403 of file PerfGraph.h.

Referenced by disableLivePrint(), and PerfGraphLivePrint::start().

_disable_live_print

bool PerfGraph::_disable_live_print

protected

Whether or not live print is disabled (cannot be turned on again)

Definition at line 341 of file PerfGraph.h.

Referenced by disableLivePrint(), enableLivePrint(), pop(), and push().

_done

std::promise<bool> PerfGraph::_done

protected

The promise to the print thread that will signal when to stop.

Definition at line 397 of file PerfGraph.h.

_execution_list

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

protected

A circular buffer for holding the execution list, this is read by the printing loop.

Definition at line 365 of file PerfGraph.h.

Referenced by addToExecutionList().

_execution_list_begin

std::atomic<unsigned int> PerfGraph::_execution_list_begin

protected

Where the print thread should start reading the execution list.

Definition at line 368 of file PerfGraph.h.

_execution_list_end

std::atomic<unsigned int> PerfGraph::_execution_list_end

protected

Where the print thread should stop reading the execution list.

Definition at line 371 of file PerfGraph.h.

Referenced by addToExecutionList().

_finished_section

std::condition_variable PerfGraph::_finished_section

protected

The condition_variable to wake the print thread.

Definition at line 406 of file PerfGraph.h.

Referenced by disableLivePrint(), pop(), and PerfGraphLivePrint::start().

_live_print

const std::unique_ptr<PerfGraphLivePrint> PerfGraph::_live_print

protected

The object that is doing live printing.

Definition at line 415 of file PerfGraph.h.

Referenced by enableLivePrint().

_live_print_all

bool PerfGraph::_live_print_all

protected

Whether or not to put everything in the perf graph.

Definition at line 338 of file PerfGraph.h.

Referenced by PerfGraphLivePrint::iterateThroughExecutionList(), pop(), push(), and setLivePrintAll().

_live_print_mem_limit

std::atomic<unsigned int> PerfGraph::_live_print_mem_limit

protected

The memory limit before a message is printed (in MB)

Definition at line 412 of file PerfGraph.h.

Referenced by setLiveMemoryLimit().

_live_print_time_limit

std::atomic<Real> PerfGraph::_live_print_time_limit

protected

The time limit before a message is printed (in seconds)

Definition at line 409 of file PerfGraph.h.

Referenced by setLiveTimeLimit().

_max_memory

std::atomic<std::size_t> PerfGraph::_max_memory

protected

Maximum memory encountered during push and pop.

Definition at line 391 of file PerfGraph.h.

Referenced by getMaxMemory(), and updateMaxMemory().

_moose_app

MooseApp& PerfGraph::_moose_app

protected

The MooseApp.

Definition at line 335 of file PerfGraph.h.

Referenced by mooseApp().

_perf_graph_registry

PerfGraphRegistry& PerfGraph::_perf_graph_registry

protected

The PerfGraphRegistry.

Definition at line 344 of file PerfGraph.h.

Referenced by pop(), printHeaviestSections(), push(), recursivelyUpdate(), sectionData(), treeRecurseInternal(), and update().

_pid

const libMesh::processor_id_type PerfGraph::_pid

protected

This processor id.

Definition at line 347 of file PerfGraph.h.

Referenced by disableLivePrint(), enableLivePrint(), pop(), and push().

_print_thread

std::thread PerfGraph::_print_thread

protected

The thread for printing sections as they execute.

Definition at line 418 of file PerfGraph.h.

Referenced by disableLivePrint(), and enableLivePrint().

_root_name

const std::string PerfGraph::_root_name

protected

Name of the root node.

Definition at line 350 of file PerfGraph.h.

Referenced by sectionData().

_root_node

const std::unique_ptr<PerfNode> PerfGraph::_root_node

protected

The root node of the graph.

Definition at line 356 of file PerfGraph.h.

Referenced by push(), rootNode(), treeRecurse(), treeTable(), and update().

_root_node_id

const PerfID PerfGraph::_root_node_id

protected

The id for the root node.

Definition at line 353 of file PerfGraph.h.

Referenced by PerfGraph(), printHeaviestSections(), push(), and sectionData().

_stack

std::array<PerfNode *, MOOSE_MAX_STACK_SIZE> PerfGraph::_stack

protected

The full callstack. Currently capped at a depth of 100.

Definition at line 362 of file PerfGraph.h.

Referenced by pop(), push(), and update().

---

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

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