PerfNode.C File Reference

Go to the source code of this file.

Functions
void	dataStore (std::ostream &stream, const std::unique_ptr< PerfNode > &node, void *)
void	dataLoad (std::istream &stream, const std::unique_ptr< PerfNode > &node, void *perf_graph)

Function Documentation

dataLoad()

void dataLoad	(	std::istream &	stream,
		const std::unique_ptr< PerfNode > &	node,
		void *	perf_graph
	)

Definition at line 99 of file PerfNode.C.

{
  std::string name;
  // When we recursively add children, we grab the name before recursing into
  // dataLoad(), so only load the name if we're on the root
  if (node.get() == &static_cast<PerfGraph *>(perf_graph)->rootNode())
    dataLoad(stream, name, nullptr);
 
  std::chrono::steady_clock::duration total_time;
  dataLoad(stream, total_time, nullptr);
  node->_total_time += total_time;
 
  long unsigned int num_calls;
  dataLoad(stream, num_calls, nullptr);
  node->_num_calls += num_calls;
 
  long unsigned int total_memory;
  dataLoad(stream, total_memory, nullptr);
  node->_total_memory += total_memory;
 
  // Recursively add the children
  // If a matching child exists with the same name, the time/calls/memory will be appended
  // to said node. If a node does not exist with the same name, it will be created
  std::size_t num_children;
  dataLoad(stream, num_children, nullptr);
  std::size_t i = 0;
  while (i++ < num_children)
  {
    dataLoad(stream, name, nullptr);
    const auto id = moose::internal::getPerfGraphRegistry().sectionID(name);
    node->getChild(id); // creates the child if it does not exist
 
    const auto & child = node->_children[id];
    dataLoad(stream, child, perf_graph);
  }
}

dataStore()

void dataStore	(	std::ostream &	stream,
		const std::unique_ptr< PerfNode > &	node,
		void *	context
	)

Definition at line 78 of file PerfNode.C.

{
  // We store the name instead of the ID because the ID could change in recover
  std::string name = moose::internal::getPerfGraphRegistry().sectionInfo(node->id())._name;
  dataStore(stream, name, nullptr);
 
  dataStore(stream, node->_total_time, nullptr);
  dataStore(stream, node->_num_calls, nullptr);
  dataStore(stream, node->_total_memory, nullptr);
 
  // Recursively add all of the children
  std::size_t num_children = node->children().size();
  dataStore(stream, num_children, nullptr);
  for (auto & id_child_pair : node->_children)
  {
    const auto & child = id_child_pair.second;
    dataStore(stream, child, nullptr);
  }
}