How to extend clock() execution time - c

Question

My C program can run more than 3 hours. For the sake of my experiment, I want to calculate the duration time (i.e., execution time) taken by the program until it finishes. I use start = clock(); at the beginning of main(), at the end I do end = clock(), finally subtract end - start the get the execution time. However, as it is said here, clock_t clock(void) is limited to 72 minutes. How can I enforce it to count the whole execution time not only 72 minutes?

Answer 1

The time() function is specified in C89, C99, C11. It has second resolution and usually spans more than 30-bits worth of seconds. It's likely the most portable solution. In fact, I'd never heard of clock() until today. Counting ticks is rarely what you want even if you need high resolution.
If you don't need a portable way to measure CPU/execution time, use procfs. proc/self/stat's stime field and sysconf(_SC_CLK_TCK) should be all you need.

Answer 2

Use gettimeofday() (https://linux.die.net/man/2/gettimeofday). It offers microsecond resolution over a very long period. Record the start time and the end time and calculate the difference.

Answer 3

The standard across all POSIXy systems, including, Linux, is the clock_gettime() POSIX.1 function.
Consider the following example:
#define _POSIX_C_SOURCE 200809L
#include <stdlib.h>
#include <time.h>
/* Clock used by wall_start()/wall_elapsed() */
#ifdef CLOCK_MONOTONIC
#define WALL_CLOCK_ID CLOCK_MONOTONIC
#else
#define WALL_CLOCK_ID CLOCK_REALTIME
#endif
static struct timespec wall_started = { 0 };
static inline void wall_start(void)
{
if (clock_gettime(WALL_CLOCK_ID, &wall_started)) {
wall_started.tv_sec = 0;
wall_started.tv_nsec = 0;
}
}
static inline void wall_elapsed(void)
{
struct timespec t;
if (!clock_gettime(WALL_CLOCK_ID, &t))
return (double)(t.tv_sec - wall_started.tv_sec)
+ (double)(t.tv_nsec - wall_started.tv_nsec) / 1000000000.0;
else
return -1.0;
}
/* Return the number of seconds of CPU time
used by this process (includes all threads)
*/
static inline double cpu_elapsed(void)
{
struct timespec t;
if (!clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &t))
return (double)t.tv_sec
+ (double)t.tv_nsec / 1000000000.0;
return -1.0;
}
If you want to display the time in days, hours, minutes, and seconds, you'll also need a simple function to split the (floating-point) seconds into days, hours, and minutes.
Here is one implementation, which takes pointers to ints for days, hours, and minutes; you can use NULL if you don't want to split that out. The function returns the remaining seconds:
static inline double split_seconds(double secs,
int *days,
int *hours,
int *minutes)
{
/* We split the absolute number of seconds, only. */
if (secs < 0.0)
secs = 0.0;
if (days) {
const int ndays = (int)(secs / 86400.0);
secs -= (double)ndays * 86400.0;
*days = ndays;
}
if (hours) {
const int nhours = (int)(secs / 3600.0);
secs -= (double)nhours * 3600.0;
*hours = nhours;
}
if (minutes) {
const int nminutes = (int)(secs / 60.0);
secs -= (double)nminutes * 60.0;
*minutes = nminutes;
}
return secs;
}
For example, calling split_seconds(3661.25, NULL, &h, NULL) returns 61.25 with h == 1. Calling split_seconds(3661.25, &d, &h, &m) returns 1.25, with d == 0, h == 1, m == 1, corresponding to 0 days, 1 hour, 1 minute, and 1.25 seconds.
The CLOCK_REALTIME clock is the standard wall clock in POSIXy systems, but it is affected by NTP (Network Time Protocol) changes, and the system administrator can directly set it. It is not, however, affected by Daylight Savings Time or anything related to timezones, because it is in UTC, not local time.
The CLOCK_MONOTONIC clock is similar to CLOCK_REALTIME, except that its epoch is unknown (probably set to some time in the past when the machine last booted), and it is not affected by NTP time jumps (but is affected by small incremental changes by NTP, to keep the computer clock synchronized to network time sources), and is not affected by system time changes by the system administrator.
If available, CLOCK_MONOTONIC is considered better for measuring elapsed real-world time than CLOCK_REALTIME; CLOCK_REALTIME is better suited to cases where you compare to an absolute real-world time, or check if a specific date/time has already passed or not.
If you intend to store a timestamp to e.g. a file, you must use CLOCK_REALTIME and not CLOCK_MONOTONIC, because the latter is only meaningful on that same machine, and only until the next boot.
When using CLOCK_REALTIME, remember that it is in UTC, and users normally specify their times and dates in local time; you probably want to use strptime() POSIX.1 function to parse the text (use #define _XOPEN_SOURCE in Linux), and mktime() to generate the time_t you can store to the tv_sec member of a struct timespec structure.