Printing time in seconds

Question

I am writing a program and attempting to time the number of seconds that passes when a given block of code runs. Afterwards I would like to print the total time it took to run the block of code in seconds. What I have written is:

time_t start = time(0);
// block of code
double seconds_since_start = difftime(time(0), start);
printf("seconds since start: %2.60f\n", seconds_since_start);

I have printf() printing to 60 decimal precision and all of the times still come out to 0.000000...

Is there an error in my time function? I find it hard to believe that the task I am asking to time would not account for any time in 60 decimal precision.

Answer 1

You can use the date and time utilities available in C++11:

#include <chrono>
#include <iostream>
#include <thread>

int main()
{
    auto start = std::chrono::high_resolution_clock::now();

    std::this_thread::sleep_for(std::chrono::seconds(5));

    auto end = std::chrono::high_resolution_clock::now();

    auto difference = std::chrono::duration_cast<std::chrono::seconds>(end - start).count();

    std::cout << "Seconds since start: " << difference;
}

Answer 2

The return value from time is an integral number of seconds. Casting to a double won't bring back the fractional seconds that have been lost.

You need a more precise clock function, such as gettimeofday (if you want wall-clock time) or times (if you want CPU time).

On Windows, there's timeGetTime, QueryPerformanceCounter (which Castiblanco demonstrates), or GetSystemTimeAsFileTime.

C++ finally got some standard high-resolution clock functions with C++11's <chrono> header, suggested by chris in the comments.

Answer 3

Actually I prefer to do it with milliseconds, because there are tons of function that can return 0 if you use just seconds, for this reason It's better to use milliseconds.

#include <time.h>

double performancecounter_diff(LARGE_INTEGER *a, LARGE_INTEGER *b){
  LARGE_INTEGER freq;
  QueryPerformanceFrequency(&freq);
  return (double)(a->QuadPart - b->QuadPart) / (double)freq.QuadPart;
}


int main()
{

LARGE_INTEGER t_inicio, t_final;
double sec;

QueryPerformanceCounter(&t_inicio);    

// code here, the code that you need to knos the time.

QueryPerformanceCounter(&t_final);

sec = performancecounter_diff(&t_final, &t_inicio);

printf("%.16g millisegudos\n", sec * 1000.0);*/

}

return 0;
}

Answer 4

you can use boost::timer

template<typename T>
double sortTime(std::vector<T>& v, typename sort_struct<T>::func_sort f){
    boost::timer t; // start timing
    f(v);
    return t.elapsed();
}

Answer 5

Something like that should work:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() 
{ 
    clock_t begin, end;
    double time_spent;

    begin = clock();

    //Do stuff

    end = clock();
    time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
    printf("%Lf\n",time_spent);
}