Measure execution time in C++ OpenMP code

I am running a .cpp code (i) in sequential style and (ii) using OpenMP statements. I am trying to see the time difference. For calculating time, I use this:

#include <time.h>
.....
main()
{

  clock_t start, finish;
  start = clock();
  .
  .
  .
  finish = clock();

  processing time = (double(finish-start)/CLOCKS_PER_SEC);

 }

The time is pretty accurate in sequential (above) run of the code. It takes about 8 seconds to run this. When I insert OpenMP statements in the code and thereafter calculate the time I get a reduction in time, but the time displayed is about 8-9 seconds on the console, when actually its just 3-4 seconds in real time!

Here is how my code looks abstractly:

#include <time.h>
.....
main()
{

  clock_t start, finish;
  start = clock();
  .
  .
  #pragma omp parallel for
  for( ... )
     for( ... )
       for (...)
    {           
      ...;      
    }
  .
  .
  finish = clock();

  processing time = (double(finish-start)/CLOCKS_PER_SEC);

 }

When I run the above code, I get the reduction in time but the time displayed is not accurate in terms of real time. It seems to me as though the clock () function is calculating each thread's individual time and adding up them up and displaying them.

Can someone tell the reason for this or suggest me any other timing function to use to measure the time in OpenMP programs?

Thanks.

Solution 1:

It seems to me as though the clock () function is calculating each thread's individual time and adding up them up and displaying them.

This is exactly what clock() does - it measures the CPU time used by the process, which at least on Linux and Mac OS X means the cumulative CPU time of all threads that have ever existed in the process since it was started.

Real-clock (a.k.a. wall-clock) timing of OpenMP applications should be done using the high resolution OpenMP timer call omp_get_wtime() which returns a double value of the number of seconds since an arbitrary point in the past. It is a portable function, e.g. exists in both Unix and Windows OpenMP run-times, unlike gettimeofday() which is Unix-only.

Solution 2:

I've seen clock() reporting CPU time, instead of real time.

You could use

struct timeval start, end;
gettimeofday(&start, NULL);

// benchmark code

gettimeofday(&end, NULL);

delta = ((end.tv_sec  - start.tv_sec) * 1000000u + 
         end.tv_usec - start.tv_usec) / 1.e6;

To time things instead

Solution 3:

You could use the built in omp_get_wtime function in omp library itself. Following is an example code snippet to find out execution time.

#include <stdio.h>
#include <omp.h>

int main(){

    double itime, ftime, exec_time;
    itime = omp_get_wtime();

    // Required code for which execution time needs to be computed
    
    ftime = omp_get_wtime();
    exec_time = ftime - itime;
    printf("\n\nTime taken is %f", exec_time);

}

Solution 4:

Well yes, that's what clock() is supposed to do, tell you how much processor time the program used.

If you want to find elapsed real time, instead of CPU time, use a function that returns wall clock time, such as gettimeofday().

Solution 5:

#include "ctime"

std::time_t start, end;
long delta = 0;
start = std::time(NULL);

// do your code here

end = std::time(NULL);
delta = end - start;

// output delta