MyTimer.cpp

Go to the documentation of this file.

#include "MyTimer.h"

#include <iostream>
#include <cassert>
// time manipulation
#include <iomanip>
#include <ctime>


//using namespace std::chrono;

MyTimer::MyTimer() : name("default_timer") {
#ifdef DEBUG_UTIL
        std::cout << "Constructor default MyTimer "<< std::endl;
#endif

        one_timer = OneTimer();
}

MyTimer::MyTimer( std::string str_name ) {
#ifdef DEBUG_UTIL
        std::cout << "Constructor default MyTimer "<< std::endl;
#endif

        name = str_name;
        one_timer = OneTimer();
}

MyTimer::~MyTimer() {
#ifdef DEBUG_UTIL
        std::cout << "Destructor MyTimer "<< std::endl;
#endif
}

void MyTimer::Start() {
#ifdef DEBUG_UTIL
        std::cout << "MyTimer::Start " << std::endl;
#endif

        one_timer.Start();
}

void MyTimer::Stop() {
#ifdef DEBUG_UTIL
        std::cout << "MyTimer::Stop " << std::endl;
#endif

        one_timer.Stop();
}

void MyTimer::Reset( std::string str_name ) {   //= std::string("default_timer") ) {
#ifdef DEBUG_UTIL
        std::cout << "MyTimer::Reset " << str_name << std::endl;
#endif

        one_timer.Reset();
}

double MyTimer::GetTotalTime( std::string str_name )
{
        std::vector<double> times = one_timer.GetAllTimes();
        return times[0];
}

double MyTimer::GetAverageTime( std::string str_name )
{
        std::vector<double> times = one_timer.GetAllTimes();
        return times[1];
}

unsigned int MyTimer::GetNumberCalls( std::string str_name ) {

        return one_timer.GetNumberCalls();
}


void MyTimer::Report() {
#ifdef DEBUG_UTIL
        std::cout << "MyTimer::Report " << std::endl;
#endif

        std::cout << "====================" << std::endl;
        std::cout << "MyTimer Report, all times in seconds" << std::endl;

        std::cout << "\n Name : " << name << std::endl;
        std::cout << " Called " << one_timer.GetNumberCalls() << " times\n " <<std::endl;
        std::vector<double> times = one_timer.GetAllTimes();

        assert ( times.size() == 4);

        // format outpu
        std::cout.precision(6);
        std::cout << std::setw(15) << "Total time" << std::setw(15) << "Average" << std::setw(15) << "Minimum" << std::setw(15) << "Maximum" << std::endl;
        std::cout << std::setw(15) << times[0] << std::setw(15) << std::scientific << times[1]
           << std::setw(15) << std::scientific << times[2] << std::setw(15) << times[3] << std::endl;


        std::cout << "\n====================" << std::endl;
}


MyTimer::OneTimer::OneTimer() {
#ifdef DEBUG_UTIL
        std::cout << "Constructor default OneTimer "<< std::endl;
#endif

        // not necessary for time_point, count set to 0
        start_t = tpoint();
        stop_t = tpoint();

        // set an initial value of 0 ticks
        total_t = duration_dtt(0);
        // need extension to have multiple times
        n_call =0;

        // assertion, total_t set explicitly to 0
        assert ( total_t.count() == 0 );
        // default constructor set to 0
        assert ( start_t.time_since_epoch().count() == 0 );
        assert ( stop_t.time_since_epoch().count() == 0 );
}

MyTimer::OneTimer::~OneTimer() {
#ifdef DEBUG_UTIL
        std::cout << "Destructor OneTimer "<< std::endl;
#endif
        // all on stack

}

void MyTimer::OneTimer::Start() {
#ifdef DEBUG_UTIL
        std::cout << "OneTimer::Start " << std::endl;
#endif

        // Check correct order of Start() and Stop()
        //assert ( start_t.time_since_epoch().count() == 0 );
        if ( start_t.time_since_epoch().count() != 0 ) {
                std::cout << "Warning in MyTimer::Start(), maybe called 2 times " << std::endl;
                std::cout << "Warning The starting time will not modified " << std::endl;
        }

        // define tme_point
        //std::chrono::system_clock::time_point sys_tp_now = std::chrono::system_clock::now();
        // transform to c style
        //std::time_t now_c = std::chrono::system_clock::to_time_t(sys_tp_now);
        // Convert to struct tm, C style time
        //tm* t = std::localtime(&now_c);
        // Write the time to the console, BUG GCC even 4.8 4.9 ? std::put_time not available
                // should use system call, strftime
                //std::cout << std::put_time(t, "%H:%M:%S"); // << std::endl;
                //char tmp_char[25];
                //strftime(tmp_char,25,"%Y-%m-%d %H:%M:%S",t);
                //std::cout << "tmp_char " << tmp_char << std::endl;


        // increment n_call here or ?
        start_t = std::chrono::steady_clock::now();
        stop_t = tpoint();
#ifndef DEBUG_UTIL
        std::cout  << " start_t.time_since_epoch().count() " << start_t.time_since_epoch().count() << std::endl;
        std::cout  << " stop_t.time_since_epoch().count() "  << stop_t.time_since_epoch().count() << std::endl;
#endif
}

void MyTimer::OneTimer::Stop() {
#ifdef DEBUG_UTIL
        std::cout << "OneTimer::Stop " << std::endl;
#endif

        // Check correct order of Start() and Stop()
        //assert ( stop_t.time_since_epoch().count() == 0 );
        if ( stop_t.time_since_epoch().count() != 0 ) {
                std::cout << "Warning in MyTimer::Stop(), maybe called 2 times " << std::endl;
                std::cout << "Warning Stopping timer is discarded " << std::endl;
                return;
        }

        if ( start_t.time_since_epoch().count() == 0 ) {
                std::cout << "Warning in MyTimer::Stop(), Start() has not been called " << std::endl;
                std::cout << "Warning Stopping timer is discarded " << std::endl;
                return;
        }

        stop_t = std::chrono::steady_clock::now();
        // update time interval
        total_t += stop_t - start_t;
        // update the number of call
        ++n_call;
        // could set start of 0, allow to check if order Start(), Stop() is correct
        start_t = tpoint();

/*
#ifdef DEBUG_UTIL
        std::cout << "stop_t.time_since_epoch().count() " << stop_t.time_since_epoch().count() << std::endl;
        std::cout << "stop_t.time_since_epoch().count() "  << stop_t.time_since_epoch().count() << std::endl;
        std::cout << "stop_t.count() -start_t.count() " << stop_t.time_since_epoch().count() - start_t.time_since_epoch().count() << std::endl;
#endif
*/

        // auto, suggested is an interval, but different ration
        // std::chrono::duration<long int, std::ratio<1l, 1000000000l> >
        //auto tmp = stop_t - start_t;
        //std::cout << "diff_tp.count() " << diff_tp.time_since_epoch().count() << std::endl;
        //std::cout << tmp << std::endl;
        //std::cout << "tmp.count() " << tmp.count() << std::endl;
        //std::cout << "tmp in milliseconds " << duration_tt(tmp).count() << std::endl;
        //std::cout << "tmp in milliseconds " << std::chrono::duration<double, std::milli>(tmp).count() << std::endl;


        //std::cout << start_t;

        // increment n_call here or ?
        //total_t = stop_t.time_since_epoch().count() - start_t.time_since_epoch().count();
        //total_t( stop_t.time_since_epoch().count() - start_t.time_since_epoch().count() );
        //total_t = stop_t.time_since_epoch() -start_t.time_since_epoch();
        //total_t = duration_tt( stop_t -start_t );
        //total_t = duration_tt( stop_t.time_since_epoch() -start_t.time_since_epoch() );
        //std::cout  << " total_t.count() " << total_t.count() << std::endl;
}

void MyTimer::OneTimer::Reset() {
#ifdef DEBUG_UTIL
        std::cout << "OneTimer::Reset " << std::endl;
#endif

        total_t = duration_dtt(0);
        // need extension to have multiple times
        n_call =0;
}

std::vector<double> MyTimer::OneTimer::GetAllTimes() {

        std::vector<double> all_times;

        // return time in seconds by default
        // total time
        //all_times.push_back ( total_t.count() );
        all_times.push_back ( std::chrono::duration<double>(total_t).count() );
        // average
        all_times.push_back ( std::chrono::duration<double>(total_t).count() / n_call );

        // minimum
        all_times.push_back ( 0. );
        // maximum
        all_times.push_back ( 0. );

        return all_times;
}