stop-watch.hpp

 
// Copyright (c) 2010-2013 Tommaso Urli (tommaso.urli@uniud.it; University of
// Udine)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
#ifndef CROCODDYL_CORE_UTILS_STOPWATCH_H_
#define CROCODDYL_CORE_UTILS_STOPWATCH_H_
 
#include <ctime>
#include <iostream>
#include <limits>
#include <map>
#include <sstream>
 
#ifndef WIN32
/* The classes below are exported */
#pragma GCC visibility push(default)
#endif
 
#define START_PROFILER(name) \
  getProfiler().profiler_status() ? getProfiler().start(name) : void()
#define STOP_PROFILER(name) \
  getProfiler().profiler_status() ? getProfiler().stop(name) : void()
 
#define STOP_WATCH_MAX_NAME_LENGTH 60
#define STOP_WATCH_TIME_WIDTH 10
 
namespace crocoddyl {
 
// Generic stopwatch exception class
struct StopwatchException {
 public:
  StopwatchException(std::string error) : error(error) {}
  std::string error;
};
 
enum StopwatchMode {
  NONE = 0,      // Clock is not initialized
  CPU_TIME = 1,  // Clock calculates time ranges using ctime and CLOCKS_PER_SEC
  REAL_TIME = 2  // Clock calculates time by asking the operating system how
                 // much real time passed
};
 
class Stopwatch {
 protected:
  struct PerformanceData;
 
 public:
  struct Watcher {
    Stopwatch &w;
    std::string n;
    PerformanceData *p;
 
    Watcher(Stopwatch &_w, std::string _n, PerformanceData *_p)
        : w(_w), n(_n), p(_p) {}
    inline void start() {
      if (w.profiler_active) _start();
    }
    inline void stop() {
      if (w.profiler_active) _stop();
    }
 
   private:
    void _start();
    void _stop();
  };
 
  Stopwatch(StopwatchMode _mode = NONE);
 
  ~Stopwatch();
 
  void enable_profiler();
 
  void disable_profiler();
 
  inline bool profiler_status() { return profiler_active; }
 
  bool performance_exists(std::string perf_name);
 
  void set_mode(StopwatchMode mode);
 
  Watcher watcher(const std::string &perf_name);
 
  void start(const std::string &perf_name);
 
  void stop(const std::string &perf_name);
 
  void pause(const std::string &perf_name);
 
  void reset(const std::string &perf_name);
 
  void reset_all();
 
  void report(const std::string &perf_name, int precision = 2,
              std::ostream &output = std::cout);
 
  void report_all(int precision = 2, std::ostream &output = std::cout);
 
  long double get_total_time(const std::string &perf_name);
 
  long double get_average_time(const std::string &perf_name);
 
  long double get_min_time(const std::string &perf_name);
 
  long double get_max_time(const std::string &perf_name);
 
  long double get_last_time(const std::string &perf_name);
 
  long double get_time_so_far(const std::string &perf_name);
 
  void turn_off();
 
  void turn_on();
 
  long double take_time();
 
 protected:
  struct PerformanceData {
    PerformanceData()
        : clock_start(0),
          total_time(0),
          min_time(std::numeric_limits<long double>::max()),
          max_time(std::numeric_limits<long double>::min()),
          last_time(0),
          paused(false),
          stops(0) {}
 
    long double clock_start;  
    long double total_time;   
    long double min_time;     
    long double max_time;     
    long double last_time;    
    bool paused;  
    int stops;    
  };
 
  PerformanceData &get_or_create_perf(const std::string &perf_name);
 
  void stop_perf(PerformanceData &perf_info, long double clock_end);
 
  bool active;         
  StopwatchMode mode;  
  std::map<std::string, PerformanceData>
      *records_of;       
  bool profiler_active;  
};
 
Stopwatch &getProfiler();
 
}  // namespace crocoddyl
 
#ifndef WIN32
#pragma GCC visibility pop
#endif
 
#endif