关于时序测量的困惑

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.