scope_timer.h

Go to the documentation of this file.

 
#ifndef SCOPE_TIMER_H
#define SCOPE_TIMER_H
 
#include <rclcpp/rclcpp.hpp>
#include <chrono>
#include <fstream>
#include <mutex>
/* #include <ctime> */
 
namespace mrs_lib
{
 
/*//{ ScopeTimerLogger class */
 
class ScopeTimerLogger {
 
public:
  ScopeTimerLogger(const rclcpp::Node::SharedPtr& node, const std::string& logfile, const bool enable_logging = true, const int log_precision = 10);
 
  ~ScopeTimerLogger();
 
  bool shouldLog() {
    return _should_log_;
  }
 
  bool loggingEnabled() {
    return _logging_enabled_;
  }
 
  std::string getLogFilepath() {
    return _log_filepath_;
  }
 
  using chrono_tp = std::chrono::time_point<std::chrono::steady_clock>;
 
  void log(const std::string& scope, const chrono_tp& time_start, const chrono_tp& time_end);
 
  void log(const std::string& scope, const std::string& label_from, const std::string& label_to, const chrono_tp& time_start, const chrono_tp& time_end);
 
private:
  bool                    _logging_enabled_ = false;
  bool                    _should_log_      = false;
  std::string             _log_filepath_;
  std::ofstream           _logstream_;
  std::mutex              _mutex_logstream_;
  rclcpp::Node::SharedPtr node_;
};
 
/*//}*/
 
class ScopeTimer {
public:
  /* time_point() helper struct //{ */
  struct time_point
  {
    using chrono_tp = std::chrono::time_point<std::chrono::steady_clock>;
 
  public:
    time_point(const rclcpp::Node::SharedPtr& node, const std::string& label) : chrono_time(std::chrono::steady_clock::now()), label(label) {
      ros_time = node->get_clock()->now();
    }
 
    time_point(const rclcpp::Node::SharedPtr& node, const std::string& label, const rclcpp::Time& ros_time) : ros_time(ros_time), label(label) {
 
      // helper types to make the code slightly more readable
      using float_seconds   = std::chrono::duration<float>;
      using chrono_duration = std::chrono::steady_clock::duration;
 
      // prepare ros and chrono current times to minimize their difference
      const auto ros_now = node->get_clock()->now();
 
      const auto chrono_now = std::chrono::steady_clock::now();
 
      // calculate how old is ros_time
      const auto ros_dt = ros_now - ros_time;
 
      // cast ros_dt to chrono type
      const auto chrono_dt = std::chrono::duration_cast<chrono_duration>(float_seconds(ros_dt.seconds()));
 
      // calculate ros_time in chrono time and set it to chrono_time
      chrono_time = chrono_now - chrono_dt;
    }
 
    rclcpp::Time ros_time;
    chrono_tp    chrono_time;
    std::string  label;
  };
  //}
 
public:
  ScopeTimer(const rclcpp::Node::SharedPtr& node, const std::string& label, const rclcpp::Duration& throttle_period = rclcpp::Duration(0, 0),
             const bool enable = true, const std::shared_ptr<ScopeTimerLogger> scope_timer_logger = nullptr);
 
  ScopeTimer(const rclcpp::Node::SharedPtr& node, const std::string& label, const time_point& tp0,
             const rclcpp::Duration& throttle_period = rclcpp::Duration(0, 0), const bool enable = true,
             const std::shared_ptr<ScopeTimerLogger> scope_timer_logger = nullptr);
 
  ScopeTimer(const rclcpp::Node::SharedPtr& node, const std::string& label, const std::shared_ptr<ScopeTimerLogger> scope_timer_logger,
             const bool enable = true);
 
  void checkpoint(const std::string& label);
 
  float getLifetime();
 
  ~ScopeTimer();
 
private:
  rclcpp::Node::SharedPtr node_;
 
  std::string             _timer_label_;
  bool                    _enable_print_or_log;
  rclcpp::Duration        _throttle_period_;
  std::vector<time_point> checkpoints;
 
  std::shared_ptr<ScopeTimerLogger> _logger_ = nullptr;
 
  static std::unordered_map<std::string, rclcpp::Time> last_print_times;
};
 
}  // namespace mrs_lib
 
#endif