CODEWITHSUNDEEP
cbenchmarkingclock
lash
lash

Reputation: 756

Measuring processor ticks in C

I wanted to calculate the difference in execution time when executing the same code inside a function. To my surprise, however, sometimes the clock difference is 0 when I use clock()/clock_t for the start and stop timer. Does this mean that clock()/clock_t does not actually return the number of clicks the processor spent on the task?

After a bit of searching, it seemed to me that clock_gettime() would return more fine grained results. And indeed it does, but I instead end up with an abitrary number of nano(?)seconds. It gives a hint of the difference in execution time, but it's hardly accurate as to exactly how many clicks difference it amounts to. What would I have to do to find this out?

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

#define M_PI_DOUBLE (M_PI * 2)

void rotatetest(const float *x, const float *c, float *result) {
    float rotationfraction = *x / *c;
    *result = M_PI_DOUBLE * rotationfraction;
}

int main() {

    int i;
    long test_total = 0;
    int test_count = 1000000;
    struct timespec test_time_begin;
    struct timespec test_time_end;

    float r = 50.f;
    float c = 2 * M_PI * r;
    float x = 3.f;
    float result_inline = 0.f;
    float result_function = 0.f;

    for (i = 0; i < test_count; i++) {
        clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &test_time_begin);
        float rotationfraction = x / c;
        result_inline = M_PI_DOUBLE * rotationfraction;
        clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &test_time_end);
        test_total += test_time_end.tv_nsec - test_time_begin.tv_nsec;
    }

    printf("Inline clocks %li, avg %f (result is %f)\n", test_total, test_total / (float)test_count,result_inline);

    for (i = 0; i < test_count; i++) {
        clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &test_time_begin);
        rotatetest(&x, &c, &result_function);
        clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &test_time_end);
        test_total += test_time_end.tv_nsec - test_time_begin.tv_nsec;
    }

    printf("Function clocks %li, avg %f (result is %f)\n", test_total, test_total / (float)test_count, result_inline);

    return 0;
}

I am using gcc version 4.8.4 on Linux 3.13.0-37-generic (Linux Mint 16)

Upvotes: 1

Views: 10450

Answers (2)

dhke
dhke

Reputation: 15388

First of all: As already mentioned in the comments, clocking a single run of execution one by the other will probably do you no good. If all goes down the hill, the call for getting the time might actually take longer than the actual execution of the operation.

Please clock multiple runs of the operation (including a warm up phase so everything is swapped in) and calculate the average running times.

clock() isn't guaranteed to be monotonic. It also isn't the number of processor clicks (whatever you define this to be) the program has run. The best way to describe the result from clock() is probably "a best effort estimation of the time any one of the CPUs has spent on calculation for the current process". For benchmarking purposes clock() is thus mostly useless.

As per specification:

The clock() function returns the implementation's best approximation to the processor time used by the process since the beginning of an implementation-dependent time related only to the process invocation.

And additionally

To determine the time in seconds, the value returned by clock() should be divided by the value of the macro CLOCKS_PER_SEC.

So, if you call clock() more often than the resolution, you are out of luck.

For profiling/benchmarking, you should --if possible-- use one of the performance clocks that are available on modern hardware. The prime candidates are probably

Edit: The question now references CLOCK_PROCESS_CPUTIME_ID, which is Linux' way of exposing the TSC.

If any (or both) are available depends on the hardware in is also operating system specific.

Upvotes: 2

Sorcrer
Sorcrer

Reputation: 1644

After googling a little bit I can see that clock() function can be used as a standard mechanism to find the tome taken for execution , but be aware that the time will be varying at different time depending upon the load of your processor, You can just use the below code for calculation

clock_t begin, end;
double time_spent;

begin = clock();
/* here, do your time-consuming job */
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;

Upvotes: 0

Related Questions