PerfGraph.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 "MooseError.h"

// System Includes
#include <array>

// Forward Declarations
class PerfGuard;

template <class... Ts>
class VariadicTable;

#define MAX_STACK_SIZE 100

class PerfGraph
{
public:
  enum TimeType : char
  {
    SELF,
    CHILDREN,
    TOTAL,
    SELF_AVG,
    CHILDREN_AVG,
    TOTAL_AVG,
    SELF_PERCENT,
    CHILDREN_PERCENT,
    TOTAL_PERCENT
  };

  PerfGraph(const std::string & root_name);

  ~PerfGraph() = default;

  PerfID registerSection(const std::string & section_name, unsigned int level);

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

  void printHeaviestBranch(const ConsoleStream & console);

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

  const std::string & sectionName(const PerfID id) const;

  bool active() const { return _active; }

  void setActive(bool active) { _active = active; }

  unsigned long int getNumCalls(const std::string & section_name);

  Real getTime(const TimeType type, const std::string & section_name);

  const Real & getSelfTime(const std::string & section_name)
  {
    return _section_time[section_name]._self;
  }

  const Real & getChildrenTime(const std::string & section_name)
  {
    return _section_time[section_name]._children;
  }

  const Real & getTotalTime(const std::string & section_name)
  {
    return _section_time[section_name]._total;
  }

  void updateTiming();

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

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

  struct SectionTime
  {
    Real _self = 0.;
    Real _children = 0.;
    Real _total = 0.;
    unsigned long int _num_calls = 0;
  };

  void push(const PerfID id);

  void pop();

  void recursivelyPrintGraph(PerfNode * current_node,
                             FullTable & vtable,
                             unsigned int level,
                             unsigned int current_depth = 0);

  void recursivelyPrintHeaviestGraph(PerfNode * current_node,
                                     FullTable & vtable,
                                     unsigned int current_depth = 0);

  void recursivelyFillTime(PerfNode * current_node);

  void printHeaviestSections(const ConsoleStream & console);

  static const std::string ROOT_NAME;

  const std::string _root_name;

  std::unique_ptr<PerfNode> _root_node;

  unsigned int _current_position;

  std::array<PerfNode *, MAX_STACK_SIZE> _stack;

  std::map<std::string, PerfID> _section_name_to_id;

  std::map<PerfID, std::string> _id_to_section_name;

  std::map<PerfID, unsigned int> _id_to_level;

  std::map<std::string, SectionTime> _section_time;

  std::vector<SectionTime *> _section_time_ptrs;

  bool _active;

  // Here so PerfGuard is the only thing that can call push/pop
  friend class PerfGuard;
};