stopwatch.h

// -*-c++-*-
#ifndef STORMM_BENCHMARK_TEST_H
#define STORMM_BENCHMARK_TEST_H
 
#include <string>
#include <vector>
#include "copyright.h"
#include "Constants/behavior.h"
 
namespace stormm {
namespace testing {
 
using constants::ExceptionResponse;
  
class StopWatch {
public:

  StopWatch(const std::string &title_in = std::string("Timer"));
  
  ~StopWatch() = default;

  StopWatch(const StopWatch &original) = default;
  StopWatch(StopWatch &&original) = default;
  StopWatch& operator=(const StopWatch &original) = default;
  StopWatch& operator=(StopWatch &&original) = default;
  
  double getTimeAtStart() const;

  double getTimeAtLastTest() const;

  double getTimeSinceStart() const;

  double getTimeSinceLastTest() const;

  double getCategoryDuration(int query_index) const;
  double getCategoryDuration(const std::string &query_name) const;

  double getCategoryAverageInterval(int query_index) const;
  double getCategoryAverageInterval(const std::string &query_name) const;

  double getCategoryMinimumTime(int query_index) const;
  double getCategoryMinimumTime(const std::string &query_name) const;

  double getCategoryMaximumTime(int query_index) const;
  double getCategoryMaximumTime(const std::string &query_name) const;

  int getCategorySamples(int query_index) const;
  int getCategorySamples(const std::string &query_name) const;

  std::string getCategoryName(int query_index) const;

  int getCategoryIndex(const std::string &query,
                       ExceptionResponse policy = ExceptionResponse::DIE) const;  
  
  double getTotalDuration() const;
  
  void assignTime(int target, double reference_time);
  void assignTime(int target = 0);
  void assignTime(const std::string &target);
  void assignTime(const std::string &target, double reference_time);

  int addCategory(const std::string &name);

  void printResults(double precision = 1.0e6);

  double2 timeDifferential(const std::string &catg_a, const std::string &catg_b,
                           const std::string &referring_function = std::string("")) const;
 
  double2 timeDifferential(int catg_a, int catg_b,
                           const std::string &referring_function = std::string("")) const;
  
private:
  int category_count;                         
  double initial_time;                        
  double time_at_last_test;                   
  std::vector<double> category_start_times;   
  std::vector<double> category_total_times;   
  std::vector<double> category_squared_times; 
  std::vector<double> category_last_times;    
  std::vector<double> category_min_interval;  
  std::vector<double> category_max_interval;  
  std::vector<int> category_samples;          
  std::vector<std::string> category_names;    
  std::string label;                          

  double translateCurrentTime() const;

  double2 computeDifferential(int catg_a, int catg_b) const;
  
  void validateCategoryIndex(int index, const std::string &referring_function) const;

  int validateCategoryName(const std::string &query, const std::string &referring_function) const;
};
  
} // namespace testing
} // namespace stormm
 
#endif