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