report.h

#ifndef PROFILER_SRC_MOLPRO_PROFILER_TREE_REPORT_H
#define PROFILER_SRC_MOLPRO_PROFILER_TREE_REPORT_H
#ifdef MOLPRO_PROFILER_MPI
#include <mpi.h>
#endif
 
#include <molpro/profiler/Counter.h>
#include <molpro/profiler/Node.h>
#include <molpro/profiler/Profiler.h>
#include <molpro/profiler/SortBy.h>
#include <molpro/profiler/dotgraph.h>
 
#include <list>
#include <memory>
#include <ostream>
#include <string>
#include <vector>
 
namespace molpro {
namespace profiler {
 
void report(const std::shared_ptr<Node<Counter>>& root, const std::string& description, std::ostream& out,
            bool cumulative = true, SortBy sort_by = SortBy::wall);
 
void report(const Profiler& prof, std::ostream& out, bool cumulative = true, SortBy sort_by = SortBy::wall);
 
#ifdef MOLPRO_PROFILER_MPI
void report(const Profiler& prof, std::ostream& out, MPI_Comm communicator, bool cumulative = true,
            SortBy sort_by = SortBy::wall);
void report_root_process(const Profiler& prof, std::ostream& out, MPI_Comm communicator, int root_process,
                         bool cumulative = true, SortBy sort_by = SortBy::wall);
std::string get_dotgraph(const Profiler& prof, MPI_Comm communicator, int root_process, int* hot, int* cool,
                         double threshold, bool get_percentage_time);
#endif
std::string get_dotgraph(const Profiler& prof, int hot[3], int cool[3], double threshold, bool get_percentage_time);
 
namespace detail {
struct TreePath {
  explicit TreePath(std::shared_ptr<Node<Counter>> node, bool cumulative);
 
  static std::list<TreePath> convert_tree_to_paths(const std::shared_ptr<Node<Counter>>& root, bool cumulative,
                                                   SortBy sort_by);
 
private:
  template <class CompareTreePaths>
  static std::list<TreePath> convert_tree_to_paths(const std::shared_ptr<Node<Counter>>& root, TreePath path,
                                                   bool cumulative);
 
public:
  Counter counter;             
  std::list<std::string> path; 
  size_t depth = 0;            
};
 
std::list<std::string> path_to_node(std::shared_ptr<Node<Counter>> node);
 
size_t total_operation_count(const std::shared_ptr<Node<Counter>>& node);
 
template <class AccessParameter>
struct Compare {
  bool operator()(const TreePath& l, const TreePath& r) const {
    bool depth_check = l.depth < r.depth;
    bool parameter_check = AccessParameter{}(l) > AccessParameter{}(r);
    bool result = depth_check ? depth_check : parameter_check;
    if (!result) {
      if (l.depth == r.depth && AccessParameter{}(l) == AccessParameter{}(r)) {
        result = true;
      }
    }
    return result;
  }
};
struct AccessWall {
  double operator()(const TreePath& t) { return t.counter.get_wall().cumulative_time(); }
};
struct AccessCPU {
  double operator()(const TreePath& t) { return t.counter.get_cpu().cumulative_time(); }
};
struct AccessCalls {
  double operator()(const TreePath& t) { return t.counter.get_call_count(); }
};
struct AccessOperations {
  double operator()(const TreePath& t) { return t.counter.get_operation_count(); }
};
struct None {
  double operator()(const TreePath& t) { return 0; }
  double operator()() {return 0;}
};
 
std::string format_path_cumulative(const std::list<std::string>& path);
 
std::string format_path_not_cumulative(const std::list<std::string>& path);
 
inline std::string format_single_path(const std::list<std::string>& path, bool cumulative) {
  if (cumulative)
    return format_path_cumulative(path);
  else
    return format_path_not_cumulative(path);
}
 
template <class CompareTreePaths>
std::map<TreePath, std::shared_ptr<Node<Counter>>, CompareTreePaths> sort_children(
  const std::shared_ptr<Node<Counter>>& root, bool cumulative);
 
void format_paths(std::list<std::string>& path_names, bool append);
 
std::string frequency(size_t n_op, double time);
 
std::string seconds(double time);
 
void write_timing(std::ostream& out, double time, size_t n_op);
 
void write_report(const Node<Counter>& root, const std::string& description, const std::list<TreePath>& paths,
                  std::ostream& out, bool cumulative);
 
#ifdef MOLPRO_PROFILER_MPI
std::shared_ptr<Node<Counter>> synchronised_tree(const std::shared_ptr<Node<Counter>>& node,
                                                 const std::shared_ptr<Node<Counter>>& parent, MPI_Comm comm,
                                                 int root_process);
 
void reduce_all(long long int& operation_count, double& wall_time, double& cpu_time, MPI_Comm comm);
void reduce_root_only(long long int& operation_count, double& wall_time, double& cpu_time, MPI_Comm comm,
                      int root_process);
#endif
 
} // namespace detail
} // namespace profiler
} // namespace molpro
 
#endif // PROFILER_SRC_MOLPRO_PROFILER_TREE_REPORT_H