PerfGraph.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
// MOOSE Includes
#include "MooseTypes.h"
#include "PerfNode.h"
#include "IndirectSort.h"
#include "ConsoleStream.h"
#include "ConsoleStreamInterface.h"
#include "MooseError.h"
#include "MemoryUtils.h"
#include "PerfGraphRegistry.h"
 
// System Includes
#include <array>
#include <atomic>
#include <thread>
#include <future>
#include <mutex>
 
// Forward Declarations
class PerfGuard;
class PerfGraphLivePrint;
 
template <class... Ts>
class VariadicTable;
 
#define MOOSE_MAX_STACK_SIZE 100
#define MAX_EXECUTION_LIST_SIZE 10000
 
class PerfGraph : protected ConsoleStreamInterface
{
public:
  using PerfGraphRegistry = moose::internal::PerfGraphRegistry;
 
  enum DataType
  {
    SELF,
    CHILDREN,
    TOTAL,
    SELF_AVG,
    CHILDREN_AVG,
    TOTAL_AVG,
    SELF_PERCENT,
    CHILDREN_PERCENT,
    TOTAL_PERCENT,
    SELF_MEMORY,
    CHILDREN_MEMORY,
    TOTAL_MEMORY,
    CALLS
  };
 
  static MooseEnum dataTypeEnum()
  {
    return MooseEnum(
        "SELF CHILDREN TOTAL SELF_AVG CHILDREN_AVG TOTAL_AVG SELF_PERCENT CHILDREN_PERCENT "
        "TOTAL_PERCENT SELF_MEMORY CHILDREN_MEMORY TOTAL_MEMORY CALLS");
  }
 
  PerfGraph(const std::string & root_name,
            MooseApp & app,
            const bool live_all,
            const bool perf_graph_live);
 
  ~PerfGraph();
 
  void print(const ConsoleStream & console, unsigned int level);
 
  void printHeaviestBranch(const ConsoleStream & console);
 
  void printHeaviestSections(const ConsoleStream & console, const unsigned int num_sections);
 
  bool active() const { return _active; }
 
  void setActive(bool active) { _active = active; }
 
  void enableLivePrint();
 
  void disableLivePrint();
 
  void setLivePrintAll(bool active) { _live_print_all = active; }
 
  void setLiveTimeLimit(Real time_limit)
  {
    _live_print_time_limit.store(time_limit, std::memory_order_relaxed);
  }
 
  void setLiveMemoryLimit(unsigned int mem_limit)
  {
    _live_print_mem_limit.store(mem_limit, std::memory_order_relaxed);
  }
 
  Real
  sectionData(const DataType type, const std::string & section_name, const bool must_exist = true);
 
  void update();
 
  std::size_t getMaxMemory() const { return _max_memory; }
 
  MooseApp & mooseApp() { return _moose_app; }
 
  const PerfNode & rootNode() const { return *_root_node; }
 
  template <typename Functor>
  void treeRecurse(const Functor & act,
                   const unsigned int level = MOOSE_MAX_STACK_SIZE,
                   const bool heaviest = false) const;
 
protected:
  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;
 
  struct CumulativeSectionInfo
  {
    Real _self = 0.;
 
    Real _children = 0.;
 
    Real _total = 0.;
 
    unsigned long int _num_calls = 0;
 
    long int _self_memory = 0;
 
    long int _children_memory = 0;
 
    long int _total_memory = 0;
  };
 
  enum IncrementState
  {
    STARTED,
 
    PRINTED,
 
    FINISHED
  };
 
  class SectionIncrement
  {
  public:
    SectionIncrement()
      : _state(IncrementState::FINISHED),
        _print_stack_level(0),
        _num_dots(0),
        _time(std::chrono::seconds(0)),
        _memory(0),
        _beginning_num_printed(0)
    {
    }
 
    PerfID _id;
 
    IncrementState _state;
 
    unsigned int _print_stack_level;
 
    unsigned int _num_dots;
 
    std::chrono::time_point<std::chrono::steady_clock> _time;
 
    long int _memory;
 
    unsigned long long int _beginning_num_printed;
  };
 
  inline void addToExecutionList(const PerfID id,
                                 const IncrementState state,
                                 const std::chrono::time_point<std::chrono::steady_clock> time,
                                 const long int memory);
 
  void push(const PerfID id);
 
  void pop();
 
  void recursivelyUpdate(const PerfNode & current_node);
 
  MooseApp & _moose_app;
 
  bool _live_print_all;
 
  bool _disable_live_print;
 
  PerfGraphRegistry & _perf_graph_registry;
 
  const libMesh::processor_id_type _pid;
 
  const std::string _root_name;
 
  const PerfID _root_node_id;
 
  const std::unique_ptr<PerfNode> _root_node;
 
  int _current_position;
 
  std::array<PerfNode *, MOOSE_MAX_STACK_SIZE> _stack;
 
  std::array<SectionIncrement, MAX_EXECUTION_LIST_SIZE> _execution_list;
 
  std::atomic<unsigned int> _execution_list_begin;
 
  std::atomic<unsigned int> _execution_list_end;
 
  std::unordered_map<std::string, CumulativeSectionInfo> _cumulative_section_info;
 
  std::vector<CumulativeSectionInfo *> _cumulative_section_info_ptrs;
 
  std::atomic<std::size_t> _max_memory;
 
  bool _active;
 
  std::promise<bool> _done;
 
  bool _destructing;
 
  std::mutex _destructing_mutex;
 
  std::condition_variable _finished_section;
 
  std::atomic<Real> _live_print_time_limit;
 
  std::atomic<unsigned int> _live_print_mem_limit;
 
  const std::unique_ptr<PerfGraphLivePrint> _live_print;
 
  std::thread _print_thread;
 
  // Here so PerfGuard is the only thing that can call push/pop
  friend class PerfGuard;
  friend class PerfGraphLivePrint;
  friend void dataStore(std::ostream &, PerfGraph &, void *);
  friend void dataLoad(std::istream &, PerfGraph &, void *);
 
private:
  FullTable treeTable(const unsigned int level, const bool heaviest = false);
 
  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);
};
 
template <typename Functor>
void
PerfGraph::treeRecurseInternal(const PerfNode & node,
                               const Functor & act,
                               const unsigned int level,
                               const bool heaviest,
                               unsigned int current_depth) const
{
  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);
  }
}
 
template <typename Functor>
void
PerfGraph::treeRecurse(const Functor & act,
                       const unsigned int level /* = MOOSE_MAX_STACK_SIZE */,
                       const bool heaviest /* = false */) const
{
  mooseAssert(_root_node, "Root node does not exist; calling this too early");
  treeRecurseInternal(*_root_node, act, level, heaviest, 0);
}
 
void dataStore(std::ostream & stream, PerfGraph & perf_graph, void * context);
void dataLoad(std::istream & stream, PerfGraph & perf_graph, void * context);