timer.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
/**************************************************************************************************/
 
#ifndef ADOBE_TIMER_HPP
#define ADOBE_TIMER_HPP
 
/**************************************************************************************************/

 
/**************************************************************************************************/
 
#include <adobe/config.hpp>
 
#include <adobe/algorithm/minmax.hpp>
#include <adobe/algorithm/sort.hpp>
#include <adobe/numeric.hpp>
 
#include <boost/operators.hpp>
 
#if ADOBE_PLATFORM_WIN
#ifndef WINDOWS_LEAN_AND_MEAN
#define WINDOWS_LEAN_AND_MEAN
#define ADOBE_UNDEFINE_WINDOWS_LEAN_AND_MEAN 1
#endif
#include <windows.h>
#if ADOBE_UNDEFINE_WINDOWS_LEAN_AND_MEAN
#undef WINDOWS_LEAN_AND_MEAN
#undef ADOBE_UNDEFINE_WINDOWS_LEAN_AND_MEAN
#endif
#endif
 
#include <cassert>
#include <chrono>
#include <iostream>
#include <vector>
 
/**************************************************************************************************/
 
namespace adobe {
 
/**************************************************************************************************/
 
class timer_t : boost::totally_ordered<timer_t> {
    using value_type = std::chrono::time_point<std::chrono::high_resolution_clock>;
 
    typedef std::vector<double> accumulator_type;
 
public:
    typedef accumulator_type::size_type size_type;
 
#ifndef ADOBE_NO_DOCUMENTATION
 
    timer_t() {
        reset();
    }
 
    timer_t(const timer_t& rhs)
        : epoch_m(rhs.epoch_m), split_m(rhs.split_m), time_set_m(rhs.time_set_m)
    {
    }
 
    timer_t& operator=(const timer_t& rhs) {
        epoch_m = rhs.epoch_m;
        split_m = rhs.split_m;
        time_set_m = rhs.time_set_m;
 
        return *this;
    }
 
#endif

 
    inline void reset() { 
        epoch_m = std::chrono::high_resolution_clock::now();
    }

 
    inline void reset_accumulator() { time_set_m.clear(); }

 
    inline double split() {
        const std::chrono::duration<double, std::milli> delta{
            std::chrono::high_resolution_clock::now() - epoch_m};
        return delta.count();
    }

 
    inline void accrue() {
        time_set_m.push_back(split());
        reset();
    }

 
    inline double accrued_min() const { return *adobe::min_element(time_set_m); }

 
    inline double accrued_max() const { return *adobe::max_element(time_set_m); }

 
    inline double accrued_average() const { return empty() ? 0 : accrued_total() / size(); }

 
    inline double accrued_median() const {
        if (empty())
            return 0;
 
        adobe::sort(time_set_m);
 
        return (size() % 2 == 1)
                   ? time_set_m[time_set_m.size() / 2]
                   : (time_set_m[time_set_m.size() / 2] + time_set_m[time_set_m.size() / 2 - 1]) /
                         2;
    }

 
    inline double accrued_total() const { return adobe::accumulate(time_set_m, double(0)); }

 
    inline size_type size() const { return time_set_m.size(); }

 
    inline bool empty() const { return time_set_m.empty(); }

 
    inline void report(const char* decoration, std::ostream& s = std::cout) {
        double time(split());
 
        s << decoration << " took " << time << " milliseconds (" << time / 1e3 << " sec)"
          << std::endl;
 
        reset();
    }
 
private:
#ifndef ADOBE_NO_DOCUMENTATION
    friend bool operator==(const timer_t& x, const timer_t& y);
    friend bool operator<(const timer_t& x, const timer_t& y);
#endif
 
    value_type epoch_m;
    value_type split_m;
    mutable accumulator_type time_set_m;
};
 
/**************************************************************************************************/
 
#ifndef ADOBE_NO_DOCUMENTATION
 
inline bool operator==(const timer_t& /*x*/, const timer_t& /*y*/) { return true; }
 
/**************************************************************************************************/
 
inline bool operator<(const timer_t& /*x*/, const timer_t& /*y*/) { return false; }
 
#endif
 
/**************************************************************************************************/
 
} // namespace adobe
 
/**************************************************************************************************/
 
#endif
 
/**************************************************************************************************/