PerfNode.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

#include "MooseTypes.h"
#include "MemoryUtils.h"

#include <chrono>
#include <map>

class PerfNode
{
public:
  PerfNode(const PerfID id) : _id(id), _total_time(0), _num_calls(0), _total_memory(0) {}

  PerfID id() const { return _id; }

  void setStartTimeAndMemory(const std::chrono::time_point<std::chrono::steady_clock> time,
                             const long int memory)
  {
    _start_time = time;
    _start_memory = memory;
  }

  const std::chrono::time_point<std::chrono::steady_clock> & startTime() const
  {
    return _start_time;
  }

  const long unsigned int & startMemory() const { return _start_memory; }

  void addTimeAndMemory(const std::chrono::time_point<std::chrono::steady_clock> time,
                        const long int memory)
  {
    _total_time += time - _start_time;
    _total_memory += memory - _start_memory;
  }

  void incrementNumCalls() { _num_calls++; }

  void addTimeAndMemory(const std::chrono::steady_clock::duration time) { _total_time += time; }

  PerfNode * getChild(const PerfID id)
  {
    // RHS insertion on purpose
    auto & child_node = _children[id];

    if (!child_node)
      child_node = std::make_unique<PerfNode>(id);

    return child_node.get();
  }

  const std::map<PerfID, std::unique_ptr<PerfNode>> & children() const { return _children; }

  std::chrono::steady_clock::duration selfTime() const;
  Real selfTimeSec() const { return std::chrono::duration<Real>(selfTime()).count(); }
  Real selfTimeAvg() const { return selfTimeSec() / static_cast<Real>(numCalls()); }

  std::chrono::steady_clock::duration totalTime() const;
  Real totalTimeSec() const { return std::chrono::duration<Real>(totalTime()).count(); }
  Real totalTimeAvg() const { return totalTimeSec() / static_cast<Real>(numCalls()); }

  std::chrono::steady_clock::duration childrenTime() const;
  Real childrenTimeSec() const { return std::chrono::duration<Real>(childrenTime()).count(); }

  unsigned long int numCalls() const { return _num_calls; }

  long int selfMemory() const;

  long int childrenMemory() const;

  long int totalMemory() const { return _total_memory; }

private:
  const PerfID _id;

  std::chrono::time_point<std::chrono::steady_clock> _start_time;

  std::chrono::steady_clock::duration _total_time;

  long unsigned int _start_memory;

  long unsigned int _num_calls;

  long unsigned int _total_memory;

  std::map<PerfID, std::unique_ptr<PerfNode>> _children;

  friend void dataStore(std::ostream &, const std::unique_ptr<PerfNode> &, void *);
  friend void dataLoad(std::istream &, const std::unique_ptr<PerfNode> &, void *);
};

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