icptimer.h

Go to the documentation of this file.

#ifndef ICP_TIMER_H
#define ICP_TIMER_H

class ICPTimer
{
private:
        std::string m_title;
        struct timeb m_tb;
        SYSTEMTIME m_st;
        Poco::Timestamp m_ts;
        struct timings_t
        {
                FILETIME create;
                FILETIME exit;
                FILETIME kernel;
                FILETIME user;
        };
        timings_t m_thread_times;
        timings_t m_process_times;

        double diffFileTimesInMilliSec(const FILETIME& start, const FILETIME& finish);
        LONGLONG diffFileTimes(const FILETIME& start, const FILETIME& finish);

public:
        ICPTimer(const char* title = NULL);
        ~ICPTimer();
        void start(const char* title = NULL);
        double info(const char* title, std::ostream& os, bool add_nl = true);
};

double ICPTimer::diffFileTimesInMilliSec(const FILETIME& start, const FILETIME& finish)
{
        return diffFileTimes(start, finish) / 1.0e4;
}

LONGLONG ICPTimer::diffFileTimes(const FILETIME& start, const FILETIME& finish)
{
        ULARGE_INTEGER ularge1, ularge2;
        ularge1.LowPart = start.dwLowDateTime;
        ularge1.HighPart = start.dwHighDateTime;
        ularge2.LowPart = finish.dwLowDateTime;
        ularge2.HighPart= finish.dwHighDateTime;
        if (ularge2.QuadPart > ularge1.QuadPart)
        {
                return ularge2.QuadPart - ularge1.QuadPart;
        }
        else
        {
                return -static_cast<LONGLONG>(ularge1.QuadPart - ularge2.QuadPart);
        }
}

ICPTimer::ICPTimer(const char* title)
{
        start(title);
}

ICPTimer::~ICPTimer()
{
}

void ICPTimer::start(const char* title)
{
        if (title != NULL)
        {
                m_title = title;
        }
        m_ts.fromEpochTime(time(NULL));
        GetSystemTime(&m_st);
        ftime(&m_tb);
        if (GetThreadTimes(GetCurrentThread(), &m_thread_times.create, &m_thread_times.exit, &m_thread_times.kernel, &m_thread_times.user) == 0)
        {
                memset(&m_thread_times, 0, sizeof(m_thread_times));
        }
        if (GetProcessTimes(GetCurrentProcess(), &m_process_times.create, &m_process_times.exit, &m_process_times.kernel, &m_process_times.user) == 0)
        {
                memset(&m_process_times, 0, sizeof(m_process_times));
        }
}

double ICPTimer::info(const char* title, std::ostream& os, bool add_nl)
{
        ICPTimer tim_end;
//      double tdiff1ms = ( (tim_end.m_tb.millitm - m_tb.millitm) +
//                                       1000.0 * difftime(tim_end.m_tb.time, m_tb.time) );
//      double tdiff1 = tdiff1ms / 1000.0;
// tdiff2 does not allow for a day change
//      double tdiff2 = 3600.0 * (double)(tim_end.m_st.wHour - m_st.wHour) +
//                            60.0 * (double)(tim_end.m_st.wMinute - m_st.wMinute) +
//                                           (double)(tim_end.m_st.wSecond - m_st.wSecond) + 
//                                           (double)(tim_end.m_st.wMilliseconds - m_st.wMilliseconds) / 1000.0;
        double tdiff3 = m_ts.elapsed() / 1.0e6;
        os << "TIMING (" << m_title << "," << title << "): elasped(" << tdiff3 << 
                                ") thread(kernel=" << diffFileTimesInMilliSec(m_thread_times.kernel, tim_end.m_thread_times.kernel) / 1.0e3 <<
                                ", user=" << diffFileTimesInMilliSec(m_thread_times.user, tim_end.m_thread_times.user) / 1.0e3 <<
                    ") process(kernel=" << diffFileTimesInMilliSec(m_process_times.kernel, tim_end.m_process_times.kernel) / 1.0e3 <<
                    ", user=" << diffFileTimesInMilliSec(m_process_times.user, tim_end.m_process_times.user) / 1.0e3 << (add_nl ? ")\n" : ")");
    return tdiff3;
}

#endif /* ICP_TIMER_H */