Timer for the C++

[mattchin92]

I am doing tower of hanoi, and need calculate the time for the function. However,i try many type such as time.h or windows.h...Since the function is recursive and very fast to end. hence,the result always be 0 since time start -time end equal 0.So, I am here to ask all of the experts how i can get more precise time value...thanks alot..

[condor]

Please take a look here:

http://www.cplusplus.com/reference/ctime/time/?kw=time

[Stewbond]

Since your in windows, the best-performance timing you can get is with QueryPerformanceCounter();

I don't have Windows here so I can't test it, but this is probably what your code would look like:

#include <windows.h>
#include <iostream>

int main()
{
    LARGE_INTEGER frequency;
    LARGE_INTEGER start;
    LARGE_INTEGER stop;

    QueryPerformanceFrequency(&frequency);
    QueryPerformanceCounter(&start);

    YourFunctionHere();

    QueryPerformanceCounter(&stop);

    double timespent = (double)(stop.QuadPart - start.QuadPart) / (double)frequency.QuadPart;

    std::cout << timespent;

    return 0;
};

If you still have problems timing your function, then try running it many times over in a loop. That'll give you a larger number, then you can divide the time taken by the number of iterations to see how well it performed.

[Stewbond]

Since this is C++, you could probably clean up your main function as well:

#include <windows.h>
class HighResTimer
{
    LARGE_INTEGER start;
    LARGE_INTEGER stop;
    double frequency;
public:
    HighResTimer()
    {
        LARGE_INTEGER freq;
        QueryPerformanceFrequency(&freq);
        frequency = (double)freq.QuadPart;
    }
    void StartTimer()
    {
        QueryPerformanceCounter(&start);
    }
    double StopTimer()
    {
        QueryPerformanceCounter(&stop);
        return ((stop.QuadPart - start.QuadPart)/frequency);
    }
};


int main()
{
    HighResTimer timer;
    timer.StartTimer();
    
    YourFunctionHere();
    
    std::cout << timer.StopTimer();
}

[JLBorges]

> need calculate the time for the function. However,i try many type such as time.h or windows.h...
> Since the function is recursive and very fast to end. hence,the result always be 0.

Even if the result is not zero, a single measurement would tend to be somewhat inaccurate because the clock ticks at discrete intervals. The solution to both problems is: measure the approximate total time taken for a number of executions of the function (say a thousand times) and then compute the average time taken for a single execution.

For instance:

#include <ctime>
#include <cstdlib>
#include <iostream>

int fn()
{
    int r = 0 ;
    for( int i = 0 ; i < 1000 ; ++i ) r += std::rand() % 2 ;
    return r ;
}

int main()
{
    // get an estimate of the processor time used
    auto start = std::clock() ;

    // operation to time
    static volatile int v = 0 ;
    constexpr int N = 1000 ;
    for( int i = 0 ; i < N ; ++i ) v += fn() ;

    const double elapsed = std::clock() - start ;
    std::cout << "approximate processor time for a single call of fn: "
               << (elapsed*1000000) / (CLOCKS_PER_SEC*N)
               << " microseconds\n" ;
}

http://ideone.com/F0nU52