timer.hpp

//
//  Timer.h
//
//
 
#ifndef TIMER_HPP
#define TIMER_HPP
 
#include <time.h>
#include <sys/time.h>
 
#ifdef __MACH__
#include <mach/clock.h>
#include <mach/mach.h>
#endif
 
#include "util/cuda_util.hpp"
 
class timer
{
    bool running;
 
    struct timespec tsstart;
 
    clock_t cstart;
 
    // stop time
    struct timespec tsstop;
 
    clock_t cstop;
 
#if defined(__NVCC__) && !defined(CUDA_ON_CPU)
    #ifdef __HIP__
        hipEvent_t start_g, stop_g;
    #else
        cudaEvent_t start_g, stop_g;
    #endif
#endif
 
    // Fill the stop point
    void check()
    {
#if defined(SYNC_BEFORE_TAKE_TIME) && defined(__NVCC__)
        #ifdef __HIP__
        hipDeviceSynchronize();
        #else
        cudaDeviceSynchronize();
        #endif
#endif
 
#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
        clock_serv_t cclock;
        mach_timespec_t mts;
        host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
        clock_get_time(cclock, &mts);
        mach_port_deallocate(mach_task_self(), cclock);
        tsstop.tv_sec = mts.tv_sec;
        tsstop.tv_nsec = mts.tv_nsec;
#else
        clock_gettime(CLOCK_REALTIME, &tsstop);
#endif
        cstop = clock();
    }
 
public:
 
    timer()
    :running(false),cstart(0),cstop(0)
    {
        tsstart = timespec();
        tsstop = timespec();
    }
 
    void start()
    {
        // time is running
        running = true;
 
#if defined(SYNC_BEFORE_TAKE_TIME) && defined(__NVCC__) 
        cudaDeviceSynchronize();
#endif
 
#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
        clock_serv_t cclock;
        mach_timespec_t mts;
        host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
        clock_get_time(cclock, &mts);
        mach_port_deallocate(mach_task_self(), cclock);
        tsstart.tv_sec = mts.tv_sec;
        tsstart.tv_nsec = mts.tv_nsec;
#else
        clock_gettime(CLOCK_REALTIME, &tsstart);
#endif
    
        cstart = clock();
 
    }
 
    void stop()
    {
        if (running == false)   return;
        running = false;
        check();
    }
 
    double getwct()
    {
        if (running == true)
            check();
 
        return ((double)(tsstop.tv_sec - tsstart.tv_sec)) + ((1e-9) * ((double)(tsstop.tv_nsec - tsstart.tv_nsec)));
    }
 
    double getcputime()
    {
        if (running == true)
            check();
 
        return (((double)(cstop - cstart)) / CLOCKS_PER_SEC);
    }
 
    void reset()
    {
        tsstart = tsstop;
        cstart = cstop;
    }
 
    #if defined(__NVCC__) && !defined(CUDA_ON_CPU)
 
    void startGPU()
    {
        #ifdef __HIP__
        hipEventCreate(&start_g);
        hipEventRecord(start_g,0);
        #else
        cudaEventCreate(&start_g);
        cudaEventRecord(start_g,0);
        #endif
    }
 
    void stopGPU()
    {
        #ifdef __HIP__
        hipEventCreate(&stop_g);
        hipEventRecord(stop_g,0);
        hipEventSynchronize(stop_g);
        #else
        cudaEventCreate(&stop_g);
        cudaEventRecord(stop_g,0);
        cudaEventSynchronize(stop_g);
        #endif
    }
 
    double getwctGPU()
    {
        float elapsedTime;
 
        #ifdef __HIP__
        hipEventElapsedTime(&elapsedTime, start_g,stop_g);
        #else
        cudaEventElapsedTime(&elapsedTime, start_g,stop_g);
        #endif
 
        return elapsedTime;
    }
 
    #endif
};
 
#endif