Question

Could somebody please explain how to make a countdown timer using clock_gettime, under Linux. I know you can use the clock() function to get cpu time, and multiply it by CLOCKS_PER_SEC to get actual time, but I’m told the clock() function is not well suited for this.

So far I have attempted this (a billion is to pause for one second)

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

#define BILLION 1000000000

int main()
{
 struct timespec rawtime;
 clock_gettime(CLOCK_MONOTONIC_RAW, &rawtime);
 unsigned long int current =  ( rawtime.tv_sec + rawtime.tv_nsec );
 unsigned long int end =  (( rawtime.tv_sec + rawtime.tv_nsec ) + BILLION );
 while ( current < end )
 {
  clock_gettime(CLOCK_MONOTONIC_RAW, &rawtime);
  current =  ( rawtime.tv_sec + rawtime.tv_nsec );
 }

 return 0;
}

I know this wouldn’t be very useful on its own, but once I’ve found out how to time correctly I can use this in my projects. I know that sleep() can be used for this purpose, but I want to code the timer myself so that I can better integrate it in my projects – such as the possibility of it returning the time left, as opposed to pausing the whole program.

Answer 1

Please, do not do that. You’re burning CPU power for nothing in a busy loop.

Why not use the nanosleep() function instead? It’s perfectly suited to the use case you outlined. Or, if you want an easier interface, perhaps something like

#define _POSIX_C_SOURCE 200809L
#include <time.h>
#include <errno.h>

/* Sleep for the specified number of seconds,
 * and return the time left over.
*/
double dsleep(const double seconds)
{
    struct timespec  req, rem;

    /* No sleep? */
    if (seconds <= 0.0)
        return 0.0;

    /* Convert to seconds and nanoseconds. */
    req.tv_sec = (time_t)seconds;
    req.tv_nsec = (long)((seconds - (double)req.tv_sec) * 1000000000.0);

    /* Take care of any rounding errors. */
    if (req.tv_nsec < 0L)
        req.tv_nsec = 0L;
    else
    if (req.tv_nsec > 999999999L)
        req.tv_nsec = 999999999L;

    /* Do the nanosleep. */
    if (nanosleep(&req, &rem) != -1)
        return 0.0;

    /* Error? */
    if (errno != EINTR)
        return 0.0;

    /* Return remainder. */
    return (double)rem.tv_sec + (double)rem.tv_nsec / 1000000000.0;
}

The difference is that using this one the CPU is free to do something else, rather than spin like a crazed squirrel on speed.