The kernel maintains an internal counter called jiffies, which increments once on every timer interrupt. The frequency of these interrupts is defined by the kernel constant HZ.

Analogy: Think of a metronome. Each tick is a jiffy. If you set the metronome to 250 beats per minute (HZ=250), each beat is 4 ms long. The kernel can only notice “time has passed” at tick boundaries — events that happen between ticks are invisible to the scheduler.

Since kernel 2.6.13, you can choose HZ = 100, 250, or 1000 as a kernel compile option (under “Processor type and features → Timer frequency”). Higher HZ means finer timer granularity but more CPU overhead — each interrupt consumes a small amount of CPU time that cannot be used by user processes.

Process time is broken into two components — not just one total number. Understanding the split helps diagnose performance bottlenecks.

From the shell, the time command shows all three values at once:

$ time ./my_program

real    0m4.84s    <-- Wall clock time (includes waiting, sleeping)
user    0m1.03s    <-- User CPU time consumed by the process
sys     0m3.43s    <-- System CPU time (kernel doing work for the process)

# In this case, sys > user suggests lots of file I/O or many system calls.
# Total CPU = user + sys = 4.46s, but real time = 4.84s
# The remaining 0.38s was the process blocked waiting (not using CPU).

times() fills a struct tms with the user and system CPU times of the calling process and its waited-for children. It also returns the elapsed real time as its return value.

#include <sys/times.h>

clock_t times(struct tms *buf);
/* Returns elapsed clock ticks since some arbitrary past point, or (clock_t)-1 on error */

struct tms {
    clock_t tms_utime;   /* User CPU time used by this process */
    clock_t tms_stime;   /* System CPU time used by this process */
    clock_t tms_cutime;  /* User CPU time of waited-for children */
    clock_t tms_cstime;  /* System CPU time of waited-for children */
};

The values in struct tms are in clock ticks. To convert to seconds, divide by sysconf(_SC_CLK_TCK) (which returns 100 on most Linux systems — not the same as CLOCKS_PER_SEC!):

#include <sys/times.h>
#include <unistd.h>
#include <stdio.h>

int main(void)
{
    struct tms t;
    long ticks_per_sec = sysconf(_SC_CLK_TCK);  /* Usually 100 on Linux */

    /* ... do some work ... */
    volatile long sum = 0;
    for (long i = 0; i < 50000000L; i++)
        sum += i;
    /* ... end of work ... */

    if (times(&t) == (clock_t)-1) {
        perror("times");
        return 1;
    }

    printf("User CPU  : %.2f s\n", (double)t.tms_utime / ticks_per_sec);
    printf("System CPU: %.2f s\n", (double)t.tms_stime / ticks_per_sec);
    return 0;
}

Don’t use times() return value for measuring elapsed time reliably. The returned tick count can overflow a clock_t and wrap back to zero on long-running systems. For measuring elapsed wall-clock time, always use gettimeofday() instead.

clock() is the simpler alternative to times(). It returns the total CPU time used (user + system combined), measured in CLOCKS_PER_SEC units.

#include <time.h>

clock_t clock(void);
/* Returns total CPU time in CLOCKS_PER_SEC units, or (clock_t)-1 on error */
/* CLOCKS_PER_SEC is always 1,000,000 (1 million) on POSIX systems */

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

int main(void)
{
    clock_t start = clock();

    /* Work to measure */
    volatile double x = 1.0;
    for (long i = 0; i < 10000000L; i++)
        x = x * 1.000001;

    clock_t end = clock();

    double cpu_seconds = (double)(end - start) / CLOCKS_PER_SEC;
    printf("CPU time used: %.4f seconds\n", cpu_seconds);
    return 0;
}

Key difference: CLOCKS_PER_SEC (used with clock()) is always 1,000,000 regardless of the kernel’s actual clock resolution. sysconf(_SC_CLK_TCK) (used with times()) reflects the kernel’s actual tick rate (USER_HZ). On most Linux systems, USER_HZ = 100, which means times() has 10 ms granularity while clock() reports with finer resolution.