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);