timer.hh

Go to the documentation of this file.

// Copyright (c) 2015, LAAS-CNRS
// Authors: Thomas Moulard, Joseph Mirabel
//

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.

#ifndef HPP_UTIL_TIMER_HH
#define HPP_UTIL_TIMER_HH

#include <chrono>
#include <hpp/util/config.hh>
#include <hpp/util/debug.hh>

namespace hpp {
namespace debug {
class HPP_UTIL_DLLAPI Timer {
 public:
 typedef std::chrono::steady_clock clock_type;
 typedef clock_type::time_point time_point;
 typedef std::chrono::duration<double> duration_type;

 explicit Timer(bool autoStart = false);
 Timer(const Timer&);
 Timer& operator=(const Timer&);
 ~Timer();

 const time_point& start();
 const time_point& stop();
 double duration() const;

 const time_point& getStart() const;
 const time_point& getStop() const;

 std::ostream& print(std::ostream&) const;

 private:
 time_point start_;
 time_point end_;
};

#ifdef HPP_ENABLE_BENCHMARK

#define hppStartBenchmark(ID) \
 hppDout(benchmark, #ID << ": start"); \
 ::hpp::debug::Timer _##ID##_timer_(true)

#define hppStopBenchmark(ID) \
 do { \
 _##ID##_timer_.stop(); \
 hppDout(benchmark, #ID << ": stop"); \
 } while (0)

#define hppDisplayBenchmark(ID) \
 hppDout(benchmark, #ID << ": " << _##ID##_timer_.duration());

#define hppBenchmark(data) \
 do { \
 using namespace hpp; \
 using namespace ::hpp::debug; \
 std::stringstream __ss; \
 __ss << data << iendl; \
 logging.benchmark.write(__FILE__, __LINE__, __PRETTY_FUNCTION__, __ss); \
 } while (0)

#else
#define hppStartBenchmark(ID)
#define hppStopBenchmark(ID)
#define hppDisplayBenchmark(ID)
#define hppBenchmark(data)
#endif // HPP_ENABLE_BENCHMARK

class HPP_UTIL_DLLAPI TimeCounter {
 public:
 struct Scope {
 Scope(TimeCounter& t) : tc(t) { t.start(); }
 ~Scope() { tc.stop(); }

 TimeCounter& tc;
 };

 typedef std::chrono::system_clock clock_type;
 typedef clock_type::time_point time_point;
 typedef std::chrono::duration<double> duration_type;

 TimeCounter(const std::string& name);

 void start();
 double stop();
 double last();
 void reset();

 double min() const;
 double max() const;
 double mean() const;
 double totalTime() const;

 std::ostream& print(std::ostream& os) const;

 private:
 std::string n_;
 unsigned long c_;
 duration_type t_, last_, min_, max_;
 time_point s_;
};

std::ostream& operator<<(std::ostream& os, const TimeCounter& tc);

#ifdef HPP_ENABLE_BENCHMARK


#define HPP_DEFINE_TIMECOUNTER(name) \
 ::hpp::debug::TimeCounter _##name##_timecounter_(#name)

#define HPP_SCOPE_TIMECOUNTER(name) \
 ::hpp::debug::TimeCounter::Scope _##name##_scopetimecounter_( \
 _##name##_timecounter_)

#define HPP_START_TIMECOUNTER(name) _##name##_timecounter_.start()
#define HPP_STOP_TIMECOUNTER(name) _##name##_timecounter_.stop()
#define HPP_DISPLAY_LAST_TIMECOUNTER(name) \
 do { \
 using namespace hpp; \
 using namespace ::hpp::debug; \
 std::stringstream __ss; \
 __ss << #name << " last: " << _##name##_timecounter_.last() << iendl; \
 logging.benchmark.write(__FILE__, __LINE__, __PRETTY_FUNCTION__, __ss); \
 } while (0)

#define HPP_DISPLAY_TIMECOUNTER(name) \
 do { \
 using namespace hpp; \
 using namespace ::hpp::debug; \
 std::stringstream __ss; \
 __ss << _##name##_timecounter_ << iendl; \
 logging.benchmark.write(__FILE__, __LINE__, __PRETTY_FUNCTION__, __ss); \
 } while (0)

#define HPP_RESET_TIMECOUNTER(name) _##name##_timecounter_.reset();
#define HPP_STREAM_TIMECOUNTER(os, name) os << _##name##_timecounter_
#else // HPP_ENABLE_BENCHMARK
#define HPP_DEFINE_TIMECOUNTER(name) \
 struct _##name##_EndWithSemiColon_ {}
#define HPP_SCOPE_TIMECOUNTER(name)
#define HPP_START_TIMECOUNTER(name)
#define HPP_STOP_TIMECOUNTER(name)
#define HPP_DISPLAY_LAST_TIMECOUNTER(name)
#define HPP_DISPLAY_TIMECOUNTER(name)
#define HPP_RESET_TIMECOUNTER(name)
#define HPP_STREAM_TIMECOUNTER(os, name) os
#endif // HPP_ENABLE_BENCHMARK

#define HPP_STOP_AND_DISPLAY_TIMECOUNTER(name) \
 HPP_STOP_TIMECOUNTER(name); \
 HPP_DISPLAY_TIMECOUNTER(name)

} // end of namespace debug
} // end of namespace hpp

#endif // HPP_UTIL_TIMER_HH