Measuring Execution Time in C

Measuring the execution time of a program is an essential task in computer science, as it helps developers understand the performance of their code and identify potential bottlenecks. In C, there are several ways to measure execution time, each with its own strengths and weaknesses.

Introduction to Clock Time and Wall Time

Before diving into the various methods for measuring execution time, it’s essential to understand the difference between clock time and wall time. Clock time refers to the amount of time a program spends executing on the CPU, while wall time refers to the actual time elapsed during the program’s execution.

Using the clock() Function

The clock() function is a standard C function that returns the number of clock ticks since the program started executing. To measure the execution time using clock(), you need to record the start and end times, then calculate the difference between them and divide by CLOCKS_PER_SEC.

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

int main() {
    clock_t tic = clock();

    // Your code here

    clock_t toc = clock();

    printf("Elapsed: %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC);

    return 0;
}

The clock() function provides a resolution of around 10 milliseconds on modern systems, but it may be less precise on older hardware.

Using the gettimeofday() Function

Another way to measure execution time is by using the gettimeofday() function, which returns the current time in seconds and microseconds since the Unix epoch (January 1, 1970).

#include <sys/time.h>
#include <stdio.h>

int main() {
    struct timeval tv1, tv2;
    gettimeofday(&tv1, NULL);

    // Your code here

    gettimeofday(&tv2, NULL);

    printf("Total time = %f seconds\n",
           (double)(tv2.tv_usec - tv1.tv_usec) / 1000000 +
           (double)(tv2.tv_sec - tv1.tv_sec));

    return 0;
}

The gettimeofday() function provides a higher resolution than clock(), but it may be affected by system time changes or daylight saving time adjustments.

Using the clock_gettime() Function

For more precise measurements, you can use the clock_gettime() function with the CLOCK_MONOTONIC_RAW clock. This clock is not affected by system time changes and provides a resolution of nanoseconds.

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

int main() {
    struct timespec begin, end;
    clock_gettime(CLOCK_MONOTONIC_RAW, &begin);

    // Your code here

    clock_gettime(CLOCK_MONOTONIC_RAW, &end);

    printf("Total time = %f seconds\n",
           (end.tv_nsec - begin.tv_nsec) / 1000000000.0 +
           (end.tv_sec - begin.tv_sec));

    return 0;
}

Choosing the Right Method

When choosing a method for measuring execution time, consider the following factors:

• Precision: If you need high-resolution measurements, use clock_gettime() with CLOCK_MONOTONIC_RAW.
• Portability: If you need to measure execution time on multiple platforms, use clock().
• System time changes: If you’re concerned about system time changes affecting your measurements, use clock_gettime() with CLOCK_MONOTONIC_RAW.

In conclusion, measuring execution time in C can be achieved using various methods, each with its own strengths and weaknesses. By understanding the differences between clock time and wall time and choosing the right method for your needs, you can accurately measure the performance of your code.