Confusion about Timing Measurements - c

Question

I have been tasked with implementing three different functions get_current_time_seconds1, 2 and 3, and then have to estimate the resolution of the various functions. How would I estimate this?
Which timing function would you suggest to use? What do the compiler options -O0 -lrt mean when I have to compile with gcc -O0 -lrt timing.c -o timing?
#define BILLION 1000000000L
#define LIMIT_I 1000
#define LIMIT_J 1000
double get_current_time_seconds1()
{
/* Get current time using gettimeofday */
time_t t = time(NULL);
struct tm *tm = localtime(&t);
printf("%s\n", asctime(tm));
return (double) tm;
}
double get_current_time_seconds2()
{
struct timespec start,stop;
clock_gettime(CLOCK_REALTIME, &start);
clock_gettime(CLOCK_REALTIME, &stop);
double x = (stop.tv_sec - start.tv_sec) + (stop.tv_nsec - start.tv_nsec);
printf("%lf\n", x);
return (double) x;
}
double get_current_time_seconds3()
{
uint64_t diff;
struct timespec start, end;
clock_gettime(CLOCK_MONOTONIC, &start);
sleep(5);
clock_gettime(CLOCK_MONOTONIC, &end);
diff = BILLION * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;
printf("elapsed time = %llu nanoseconds\n", (long long unsigned int)diff);
return (double) diff;
}

Answer 1

How would I estimate this? Which timing function would you suggest to use?
If you want to get the resolution (precision) of the various timing elements, you can use the clock_getres function, passing in the various CLOCK_ id types, for example:
#include <stdio.h>
#include <time.h>
static void printres(clockid_t id)
{
struct timespec ts;
int rc = clock_getres(id, &ts);
printf("clock id: %d\n", (unsigned int)id);
if (rc != 0) {
printf("Error: %d\n", rc);
return;
}
printf("tv_sec = %lu\ntv_nsec = %lu\n", ts.tv_sec, ts.tv_nsec);
}
int main(int argc, char** argv)
{
printres(CLOCK_REALTIME);
printres(CLOCK_MONOTONIC);
printres(CLOCK_PROCESS_CPUTIME_ID);
printres(CLOCK_THREAD_CPUTIME_ID);
return 0;
}
On my system, tv_nsec for all but CLOCK_THREAD_CPUTIME_ID is 1000, for CLOCK_THREAD_CPUTIME_ID the value for tv_nsec is 1, this means that the precision for the other clock types is 1 millisecond (1000 nanoseconds) while the precision of CLOCK_THREAD_CPUTIME_ID is 1 nanosecond.
For your first function that calls localtime the precision for that would be 1 second as that function calculates the time from the Unix epoch in seconds.
What do the compiler options -O0 -lrt mean when I have to compile with gcc -O0 -lrt timing.c -o timing?
For some compilers like gcc and clang the option -O means to optimize the code when compiling it to the level specified, so -O0 means not to optimize the code at all, this is usually useful when debugging code.
The -l option says to compile against the specified library, so -lrt says to compile using the rt library, or "real time library"; this is necessary on some systems as CLOCK_REALTIME can be defined in that library.
I hope that can help.