Profiler.h

#ifndef PROFILER_SRC_MOLPRO_PROFILER_PROFILER_H
#define PROFILER_SRC_MOLPRO_PROFILER_PROFILER_H
#ifdef MOLPRO_PROFILER_MPI
// #include <mpi.h>
#endif
#include <molpro/mpi.h>
 
#include <molpro/profiler/SortBy.h>
 
#include <fstream>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace molpro {
namespace profiler {
 
static int hot_default[3] = {255, 0, 0};
static int cool_default[3] = {0, 0, 255};
static std::vector<std::pair<double, double>> default_heat_adjust = {{}};
 
class Counter;
template <class CounterT>
class Node;
 
class Profiler {
protected:
  std::string m_description;       
  std::string m_root_name = "All"; 
  int m_max_depth;         
  int m_current_depth = 0; 
public:
  std::shared_ptr<profiler::Node<profiler::Counter>> root;        
  std::shared_ptr<profiler::Node<profiler::Counter>> active_node; 
  explicit Profiler(std::string description_, bool with_wall = true, bool with_cpu = false);
  Profiler(Profiler&&) = default;
  Profiler& operator=(Profiler&&) = default;
  ~Profiler();
 
  Profiler() = delete;
  Profiler(const Profiler&) = delete;
  Profiler& operator=(const Profiler&) = delete;
 
  const std::string& description() const { return m_description; }
 
  static std::shared_ptr<Profiler> single(const std::string& description_, bool with_wall = true,
                                          bool with_cpu = false);
  static std::shared_ptr<Profiler> single();
  static void erase(const std::string& description);
 
  int get_max_depth() const;
  void set_max_depth(int new_max_depth);
  int get_current_depth() const;
 
  Profiler& start(const std::string& name);
 
  Profiler& stop(const std::string& name = "");
 
  Profiler& stop_all();
 
  profiler::Counter& counter();
 
  // FIXME Why is this even needed?
  Profiler& reset(const std::string& name);
 
  void operator+=(size_t operations);
 
  void operator++();
 
  size_t operator++(int);
 
protected:
  struct Proxy {
    Profiler& prof; 
 
    Proxy(Profiler& prof, const std::string& name) : prof(prof) { prof.start(name); }
    ~Proxy() { prof.stop(); }
 
    Proxy push(const std::string& name) { return Proxy(prof, name); }
 
    void operator+=(size_t operations);
 
    void operator++();
 
    size_t operator++(int);
  };
 
public:
  Proxy push(const std::string& name) { return Proxy(*this, name); }
 
  std::string str(bool cumulative = true, profiler::SortBy sort_by = profiler::SortBy::wall) const;
 
  std::string dotgraph(std::string path, double threshold = 0.01, bool cumulative = true, int hot[3] = hot_default,
                       int cool[3] = cool_default, SortBy sort_by = profiler::SortBy::none,
                       std::vector<std::pair<double, double>> heat_adjust = default_heat_adjust,
                       bool get_percentage_time = false);
 
#ifdef MOLPRO_PROFILER_MPI
  std::string str(MPI_Comm communicator, bool cumulative = true,
                  profiler::SortBy sort_by = profiler::SortBy::wall) const;
 
  std::string dotgraph(std::string path, MPI_Comm communicator, int root_process, double threshold = 0.01,
                       bool cumulative = true, int hot[3] = hot_default, int cool[3] = cool_default,
                       SortBy sort_by = profiler::SortBy::none,
                       std::vector<std::pair<double, double>> heat_adjust = default_heat_adjust,
                       bool get_percentage_time = false);
#endif
 
  friend std::ostream& operator<<(std::ostream& os, const Profiler& obj);
};
 
} // namespace profiler
} // namespace molpro
#endif // PROFILER_SRC_MOLPRO_PROFILER_PROFILER_H