← Interview Prep

Linux Kernel — Timing Measurements

How the kernel keeps time: clock sources (TSC/HPET) vs clock event devices, HZ/jiffies and the tick, tickless (NOHZ_IDLE/NOHZ_FULL), timer wheel vs hrtimers, REALTIME vs MONOTONIC clocks, and fast clock_gettime via the vDSO.

How the kernel keeps time and drives everything on a schedule — the tick, timers, clock sources, and the clocks your code reads. Original, interview-focused notes; pairs with the network side in PTP & Time Sync.

Separate two ideas: timekeeping (what time is it? — driven by a hardware clock source) and timers/the tick (do something after N ns — driven by a clock event device). And two clocks your code reads: REALTIME (wall-clock, can jump) vs MONOTONIC (never goes backward — use it for intervals).

Clock sources & event devices

Clock sources (free-running counters, read for the current time): TSC (CPU cycle counter — fastest, the usual pick when "constant/nonstop"), HPET, ACPI PM timer, arch timers. See /sys/devices/system/clocksource/…/current_clocksource.
Clock event devices generate interrupts to fire timers and the scheduler tick (local APIC timer, HPET). One-shot or periodic.
The TSC caveat: historically unreliable (varied with frequency scaling, wasn't synced across cores). Modern "invariant TSC" fixes this, which is why it's now the default and what makes fast userspace time (below) possible.

The tick, HZ & jiffies

A periodic timer interrupt — the tick — fires HZ times per second (typically 100/250/1000). Each tick bumps jiffies, the coarse "ticks since boot" counter, and does per-tick work (accounting, scheduler check, timers).
Higher HZ = finer granularity but more overhead. jiffies is coarse (1–10 ms); don't use it for precise timing.
Tickless (NOHZ): NOHZ_IDLE stops the tick on idle CPUs (power saving); NOHZ_FULL stops it on CPUs running a single busy task — critical for HFT/HPC to remove the periodic interrupt jitter. Pairs with isolcpus.

Timers

Kind	Granularity	Use
Timer wheel (`timer_list`)	jiffies (coarse)	Cheap timeouts where ~ms slack is fine (most kernel timeouts).
hrtimers	ns (high-res)	Precise wakeups — `nanosleep`, scheduler, POSIX timers.

hrtimers are stored in a time-ordered tree and fired by the clock-event device, so accuracy doesn't depend on HZ.

The clocks you read

Clock	Behavior
`CLOCK_REALTIME`	Wall-clock (UTC). Can jump (NTP/admin/PTP steps) — don't measure intervals with it.
`CLOCK_MONOTONIC`	Since boot, never decreases (NTP only slews the rate). The right clock for elapsed time.
`CLOCK_MONOTONIC_RAW`	Monotonic, not even NTP-adjusted.
`CLOCK_BOOTTIME`	Monotonic + counts suspend time.
`CLOCK_PROCESS/THREAD_CPUTIME`	CPU time consumed, for profiling.

Fast reads: clock_gettime() on REALTIME/MONOTONIC is served by the vDSO — it reads the TSC in user space with no syscall, so it's cheap enough to call in hot loops. (See System Calls.)

Likely interview questions

REALTIME vs MONOTONIC — which do you use to measure an interval, and why? (MONOTONIC never jumps)
What are jiffies and HZ, and why is jiffies too coarse for precise timing?
Clock source vs clock event device — what does each do? (read time vs fire interrupts)
Why is the TSC preferred now, and what was historically wrong with it? (invariant TSC)
Timer wheel vs hrtimers — when each?
What is NOHZ_FULL and why does trading/HPC want it? (remove tick jitter on isolated CPUs)
Why is clock_gettime cheap? (vDSO reads the TSC without a syscall)

Kernel Internals series. Related: System Calls · PTP & Time Sync.