uptime prints three numbers, and most of the engineers reading them are reading something other than what the kernel wrote. Here is the Linux load average explained as the code actually computes it: not a measure of CPU demand, not a percentage, not an average in the arithmetic sense, and not meaningfully comparable to your core count. It is an exponentially damped moving sum of the tasks the kernel counts as working or waiting to work — and on Linux, because of a patch applied in November 1993, that population deliberately includes tasks blocked in uninterruptible sleep on a disk or a network filesystem.
That last clause is the whole article. Every dashboard threshold, every PagerDuty rule of the form load1 > cores, and every capacity conversation that starts with “we’re at load 12 on 8 cores” inherits a definition that one contributor changed on a Friday afternoon in 1993, for a reason he stated plainly at the time and that most of the industry has never read. The change was intentional and argued. It is not a bug, and calling the load average “broken” gets the story exactly backwards. What it is, is a definition divergence — the same three numbers, printed by the same command, meaning two different things depending on which kernel is underneath.

The Metric Is Older Than Unix: TENEX and RFC 546
The load average did not originate in Unix. It came from TENEX, the BBN operating system for the PDP-10, and the earliest widely available description of it is RFC 546, “TENEX Load Averages for July 1973,” by B. Thomas, dated 10 August 1973. Unix inherited the idea, as it inherited hierarchical filesystems and the shell — synthesis and scale reduction rather than invention.
The RFC’s definition is worth quoting exactly, because the parenthetical in it is the hinge on which the next fifty years turn:
“The load average is an average of the number of runable processes over a given time period… an hourly load average of 10 would mean that (for a single CPU system) at any time during that hour one could expect to see 1 process running and 9 others ready to run (i.e., not blocked for I/O) waiting for the CPU.”
Emphasis added, because the original metric explicitly excludes processes blocked for I/O. TENEX’s load average was a pure CPU-demand gauge: one number, one resource, one question — how many things want the processor right now, and how deep is the line? Under that definition, dividing the load average by the CPU count is a defensible back-of-envelope saturation estimate, because the numerator and the denominator describe the same resource.
Unix picked up the metric, and for most of its lineage kept the TENEX semantics. Then Linux changed them.

Friday, 29 October 1993: “Load average broken ?”
The change is traceable to a specific patch by a specific person on a specific day. Brendan Gregg dug the original message out of the archives for “Linux Load Averages: Solving the Mystery” (8 August 2017), still the single best-sourced account of this metric anywhere. The patch was written by Matthias Urlichs, dated Friday, 29 October 1993, under the mail subject “Load average broken ?”, and it shipped in Linux 0.99 patchlevel 14, in November 1993.
Urlichs’ stated rationale was not subtle and not accidental:
“processes which are swapping or waiting on ‘fast’, i.e. noninterruptible, I/O, also consume resources.”
The observation that motivated it is sharper still: under the strict TENEX definition, the load average goes down when you replace a fast swap disk with a slow one. A process waiting on a fast disk gets scheduled back onto the run queue quickly and keeps showing up in the runnable count; a process waiting on a slow disk sits in uninterruptible sleep, invisible to the metric, while the machine gets objectively worse. A number that improves as the hardware degrades is a number nobody should ship.
So Linux widened the population. Alongside running and runnable tasks, the kernel began counting tasks in TASK_UNINTERRUPTIBLE — the D state you see in ps, the state a task enters when it is blocked on something the kernel will not let it be interrupted out of: a block-device read, a page fault against slow storage, an NFS operation on a mount that has stopped answering, certain kernel locks. Whatever else you believe about the load average, this is the fact that governs how you read it: on Linux the number counts CPU demand and uninterruptible-resource demand in a single dimensionless total, and offers no way to separate them.
Two attributions matter here and are routinely mangled. It was Urlichs, not Linus Torvalds — the maintainer applied the patch, he did not author the argument. And the change was a considered widening of scope with a written justification attached, not a regression that nobody noticed. Gregg’s framing is the precise one and worth adopting verbatim: Linux reports system load averages, where other systems report CPU load averages.

What the Number Counts, System by System
Three lineages, three populations, one command printing all of them identically.
| System | Task states counted | What the number answers | What it cannot tell you |
|---|---|---|---|
| TENEX (1973), per RFC 546 | Runnable only — running plus ready-to-run, explicitly “not blocked for I/O” | Demand for the CPU | Anything at all about storage or network |
| Traditional Unix and BSD-derived systems (FreeBSD, macOS, the commercial Unixes) | Running plus runnable threads | Demand for the CPU — Gregg’s “CPU load averages” | Whether the machine is also crippled by I/O wait |
| Linux, 0.99pl14 (Nov 1993) onward | Running plus runnable plus TASK_UNINTERRUPTIBLE (D state) | Demand for CPU and uninterruptible resources — Gregg’s “system load averages” | Which of the two is responsible, or in what proportion |
The practical consequence of row three is that the same load figure on a Linux box and a FreeBSD box are not the same measurement, and no amount of dashboard normalization fixes it. A cross-platform fleet with one load1 alert threshold is comparing two different quantities that happen to share a name and a field position in uptime‘s output.
It is also worth being precise about a related metric while we are here, because it is the sibling misread. %iowait is an idle state, not busy time: the CPU is idle while at least one I/O is outstanding. High %iowait frequently just means nothing else happened to be runnable at that moment, and low %iowait is never evidence that storage is healthy.

The Mechanics: A Five-Second Sample and Three Decay Constants
The second misreading is temporal. The load average is not an average, not instantaneous, and not something you can differentiate back into a point-in-time value.
The kernel samples the active task count on a timer — every five seconds plus one tick, which is deliberately not a clean multiple of the tick rate so the sample does not lock in phase with periodic workloads — and feeds each sample into an exponentially damped moving sum. The recurrence is fixed-point integer arithmetic with an 11-bit fractional shift, so the scale factor is 2048, and three constants encode the three decay rates:
| Constant | Value | Decay it encodes | Weight retained per 5-second sample |
|---|---|---|---|
EXP_1 | 1884 | e−5/60 | 1884 ÷ 2048 ≈ 0.9200 |
EXP_5 | 2014 | e−5/300 | 2014 ÷ 2048 ≈ 0.9834 |
EXP_15 | 2037 | e−5/900 | 2037 ÷ 2048 ≈ 0.9946 |
Each update is, in effect, load ← (load × EXP + n × (2048 − EXP)) ÷ 2048, where n is the sampled count of active tasks. Modern kernels fold per-CPU deltas into a global figure rather than walking every run queue on one CPU, which is what keeps the calculation honest on tickless (NO_HZ) systems where an idle CPU’s timer interrupt no longer fires on schedule.
Three things follow, and all three routinely surprise people:
- The “1-minute” figure is not a one-minute window. It is a decay rate whose time constant is 60 seconds. A workload that stopped 30 seconds ago is still contributing about 60% of its peak influence to
load1. The number lags by design. - The figures are not comparable across sampling intervals the way a rate is. You cannot scrape
load1every 10 seconds and reconstruct what the run queue actually did; the damping has already destroyed that information. - The three numbers are only useful relative to each other.
load1well aboveload15means demand is climbing;load1well belowload15means a burst has passed and you are watching it decay. That trend comparison is genuinely the metric’s best remaining use.
Everything the kernel exposes here is in one file. The kernel’s own /proc documentation specifies /proc/loadavg as the three damped figures, then a running/total entity count, then the last PID allocated. That fourth field — the instantaneous runnable count — is strictly more actionable than the three damped ones next to it, and almost nobody graphs it.

Load 40 With Idle CPUs
Put the definition and the mechanics together and the pathological case is not an edge case at all; it is the expected behaviour. A Linux box can sit at load 40 with near-idle processors if forty tasks are parked in D state against a saturated array, a degraded RAID rebuild, or an NFS server that stopped responding. Nothing is wrong with the CPUs. Nothing is wrong with the metric either — it is reporting exactly the population it was redefined in 1993 to report. What is wrong is the inference that a big number implicates the processor.
The same reading is ambiguous in the other direction. Load 40 might equally be forty genuinely runnable threads queued behind eight cores. The number is identical. The remedies are opposite.
| What you observe | What the load average is counting | Where to actually look |
|---|---|---|
High load, %CPU near idle, vmstat‘s b column high | D-state tasks blocked on storage | iostat -xz 1 for await and queue depth; /proc/pressure/io; block-layer latency histograms |
High load, vmstat‘s r column high, CPUs pinned | Genuinely runnable threads queued for CPU | Run-queue latency; /proc/pressure/cpu; IPC via perf to check the cores are doing work, not stalling |
| Load climbing alongside an unresponsive network mount | Tasks stuck in uninterruptible sleep on the filesystem | Mount options and server health; the kernel stack of a D-state task via /proc/PID/stack or wchan |
High load, both r and b low | Decay lag from a burst that has already ended | Wait for load1 to decay; compare against PSI’s 10-second window |
| Load near zero, users reporting slowness | Neither CPU nor uninterruptible demand | Application-layer latency, user-space lock contention, network round trips |
vmstat 1‘s first two columns — r for runnable, b for blocked in uninterruptible sleep — decompose the load average into its two constituents in about one second of typing, and are the fastest possible disambiguation of rows one and two. That they are almost never the first thing anyone runs is a good measure of how much authority the single dimensionless number has accumulated.

Why “Load ÷ Cores” Is the Wrong Heuristic
The rule everyone knows — load above core count means saturation — is a straight import from the TENEX definition, where it was reasonable. The numerator counted demand for the CPU and the denominator counted supply of the CPU, so the ratio was a real utilization estimate.
On Linux the numerator no longer describes the resource in the denominator. The ratio mixes CPU demand with disk demand, network-filesystem demand and kernel-lock contention, and divides the total by a count of processors that has nothing to do with three of those four. An eight-core machine at load 12 might be 50% over-subscribed on CPU, or completely idle on CPU and 12 tasks deep on a failing disk. The heuristic returns the same verdict for both.
There is a second, quieter problem: the metric is host-wide and unweighted. It does not know about cgroup CPU limits, does not distinguish a thread that will run for 10 microseconds from one that will run for 10 seconds, does not account for scheduler priority or nice, and treats a task blocked on a 200-microsecond NVMe read identically to one blocked on a dead NFS mount. Any one of those would compromise a saturation metric. Together they mean the ratio is not measuring saturation of anything in particular.
None of that makes the load average useless. It makes it a smoke alarm, not a diagnosis: cheap, always on, no configuration, and genuinely informative about change. Watch its trend, use it to decide whether to look closer, and never let it be the last number in an investigation.
Inside a Container, the Number Isn’t Even Yours
There is one more trap, and it catches modern deployments hardest. /proc/loadavg is not namespaced. A process inside a container reads the host’s load average — every task on the machine, including every neighbour’s, including tasks in cgroups the container cannot see and is not accounted for. The same is true of /proc/meminfo and the host CPU count, which is why so much tooling reports nonsense inside containers unless something is actively lying to it.
The per-container answer lives in cgroup v2 under /sys/fs/cgroup, where CPU accounting, throttling counters and — critically — per-cgroup pressure metrics are scoped to the workload you actually deployed. If you are autoscaling or alerting on a load average read from inside a container, you are alerting on your neighbours. This is the same class of leak that makes host-level introspection so misleading in containerized environments generally: the container boundary is a set of namespaces, and any interface that predates those namespaces simply pierces it.

What to Measure Instead: USE, PSI, and Run-Queue Latency
The replacement is not one metric. It is a method plus two or three instruments, and the method matters more than the instruments.
The USE method is Brendan Gregg’s, published as “Thinking Methodically about Performance,” ACM Queue 10(12), December 2012, and in Communications of the ACM, with the working reference maintained at brendangregg.com/usemethod.html. The mantra is: for every resource, check utilization, saturation, and errors. Utilization is “the average time that the resource was busy servicing work”; saturation is “the degree to which the resource has extra work which it can’t service, often queued”; errors is “the count of error events.”
The structural claim is the valuable part, and it is a direct rebuke of load-average-driven operations. USE enumerates resources first and then goes looking for tools. The alternative — what Gregg calls the tools method — enumerates the tools you happen to have and therefore cannot see anything they do not measure. A dashboard assembled from whatever an agent exports is the tools method wearing a suit, and it is exactly how a fleet ends up with load1 as its primary saturation signal: not because anyone chose it, but because it was already there.
Pressure Stall Information (PSI) is the metric the load average should have been. Written by Johannes Weiner and merged in Linux 4.20, it exposes /proc/pressure/cpu, /proc/pressure/memory and /proc/pressure/io, each giving some and full stall percentages over 10-, 60- and 300-second windows. some is the share of time at least one task was stalled on that resource; full is the share of time every runnable task was stalled — a direct read on lost throughput. Crucially, the resource is named in the filename, and PSI is available per-cgroup, which fixes the container problem in the same stroke. Kubernetes documents PSI metrics directly, and it is the correct signal to autoscale and alert on.
Run-queue latency closes the loop for CPU specifically. The question “how long does a runnable thread wait before it gets a processor?” is answerable in microseconds with a scheduler-latency histogram from the eBPF tooling (runqlat and friends), and it is a latency — a unit an SLO can actually be written against. And where you need to confirm that busy cores are doing work rather than stalling on memory, Gregg’s “CPU Utilization Is Wrong” makes the case for pairing %CPU with instructions-per-cycle, never showing it alone.
| Load average | USE, applied per resource | |
|---|---|---|
| Scope | One number for the whole host | One triple per resource |
| Names the resource? | No — CPU, disk, NFS and locks all collapse into it | Yes, by construction |
| Unit | Dimensionless task count | Utilization %, saturation (queue depth or stall time), error count |
| Time behaviour | Exponentially damped, lagging, non-differentiable | Point-in-time, per collection interval |
| Namespaced for containers | No — host-wide | Yes, via cgroup v2 and per-cgroup PSI |
| Answers “is something wrong?” | Weakly, and only via its trend | Yes |
| Answers “what is wrong?” | No | Yes — that is the entire design goal |
| Cost to collect | One file read | Several reads per resource; more setup |
The applied form of all this is Gregg’s Netflix “60-second checklist” (30 November 2015): uptime, dmesg | tail, vmstat 1, mpstat -P ALL 1, pidstat 1, iostat -xz 1, free -m, sar -n DEV 1, sar -n TCP,ETCP 1, top. Note the ordering — errors and saturation before utilization — and note that uptime is still first. The load average earns its place as the opening question. It has never deserved to be the closing answer.

The Transferable Lesson: A Metric Means What Its Implementation Says
Strip away the Unix archaeology and one rule remains, and it applies to any number your organization has ever put on a wall:
A metric’s meaning is set by its implementation history, not by its name. “Load average” sounds self-describing. It is not an average, and after October 1993 on Linux it is not a load in the sense anyone using the word in 1973 meant. Two systems can print identical values from identically named fields and be measuring different populations, and nothing in the interface will tell you.
The corollary is the operationally expensive one. When a definition changes underneath a metric, every dashboard, alert, runbook, capacity model and SLO built on it silently changes meaning too — without a version bump, without a deprecation notice, and without a single query needing to be edited. Urlichs’ patch did not break anything that day. It quietly re-pointed every future consumer of that number at a different question, and the industry spent the next three decades interpreting the answer as though it were still the old one. That is the same failure mode as a JSON field whose semantics were widened in a minor release, or an internal event whose emission point moved one layer up the stack: the schema validates, the graph keeps drawing, and the meaning has moved.
Two defensive rules fall directly out of this, and they are worth applying to your own telemetry today:
- Prefer metrics whose name states the resource and the unit.
io.pressure.some.avg10cannot be misread the wayload1can.%CPU,%iowaitand the load average all collapse several distinct physical phenomena into one dimensionless number; IPC, PSI’ssome/fullpercentages, off-CPU time by stack, and USE’s per-resource triples do not. This is the same discipline that separates a well-designed engineering metric from one that invites gaming. - A widely adopted metric can never be fixed — only replaced. It accumulates consumers far faster than it accumulates readers of its definition, so by the time the ambiguity is understood, changing it would break more than it repairs. The only workable move is to ship the better metric beside it and migrate consumers deliberately. That is precisely what PSI is: nobody removed
/proc/loadavg, and nobody ever will.
Both rules generalize well past kernels. Any number that survives long enough to be depended on will eventually mean something other than what its name implies — and the systems that stay debuggable are the ones where somebody wrote down which implementation the meaning came from.

❓ Frequently Asked Questions
Is a load average of 8 on an 8-core Linux server fine?
The number alone cannot answer that, and on Linux the ratio is not the right question to ask. Load 8 could be eight runnable threads exactly filling eight cores, or zero CPU demand and eight tasks stuck in uninterruptible sleep on a failing disk. Run vmstat 1 and read the r and b columns: r is the runnable population, b is the uninterruptible-sleep population, and the split between them tells you which situation you are in. On a traditional Unix or BSD-derived system, where the load average counts only runnable threads, “load ≈ cores” is a defensible rough gauge — that difference is the entire point of the 1993 divergence.
Why does my Linux load average spike while CPU usage stays low?
Because Linux counts TASK_UNINTERRUPTIBLE (D state) tasks in the load average alongside runnable ones. Tasks blocked on a slow block device, a saturated storage array, a page fault against slow storage, an unresponsive NFS mount, or certain kernel locks all inflate the load average without consuming any CPU. Check /proc/pressure/io, iostat -xz 1, and the b column of vmstat — and remember that %iowait is an idle state, so a low %iowait does not clear storage of suspicion.
What is the actual difference between the 1-, 5-, and 15-minute figures?
They are three exponentially damped moving sums of the same five-second samples, differing only in decay constant: EXP_1 = 1884, EXP_5 = 2014, EXP_15 = 2037, each divided by a fixed-point scale of 2048. They are not fixed windows — the “1-minute” figure is a decay whose time constant is 60 seconds, so a workload that ended 30 seconds ago is still contributing meaningfully to it. Their most reliable use is relative: load1 above load15 means demand is rising; load1 below load15 means a burst is decaying.
Does the load average work correctly inside a container?
No. /proc/loadavg is not namespaced, so a containerized process reads the entire host’s load average, including every task belonging to every other workload on that machine. Autoscaling or alerting on it from inside a container means reacting to your neighbours’ behaviour. Use per-cgroup PSI under /sys/fs/cgroup instead, which is scoped to the workload you actually deployed.
What should I alert on instead of the load average?
Per-resource saturation with the resource named: PSI’s some and full stall percentages from /proc/pressure/{cpu,memory,io} (or the per-cgroup equivalents), run-queue latency for CPU, device latency and queue depth for storage, and error counts everywhere. Structure the whole set with the USE method — utilization, saturation and errors for every resource — so the enumeration starts from resources rather than from whichever metrics your agent happens to export. Keep the load average as a cheap always-on trend signal that tells you to look closer.
Did Linus Torvalds change the load average definition?
No. The patch was written by Matthias Urlichs, dated Friday, 29 October 1993, under the subject line “Load average broken ?”, and shipped in Linux 0.99 patchlevel 14 in November 1993. Torvalds applied it as maintainer; the argument for counting uninterruptible tasks was Urlichs’, and he stated it explicitly: processes waiting on noninterruptible I/O “also consume resources.”
📚 Further Reading
- What Is a Container? The Idea That Powers Modern Software (and AI) — why
/procinterfaces that predate namespaces leak host state into containers, and where the real per-workload limits live. - Observing Distributed Workflows: How to Tell a Saga Is Healthy — the same “which signal actually answers the question” problem, one layer up, in a distributed system.
- DORA Metrics for AI Coding Agents: Stop the Gaming — what happens to a metric when its consumers outnumber the people who have read its definition.
- Ping, Jitter, and Packet Loss — another case where one headline number hides several independent physical phenomena.
- Why Is My Computer So Slow? Diagnosing and Fixing Common Issues — the same diagnostic discipline applied at the desktop scale.
📚 Recommended Resources
Disclosure: some links below are Amazon affiliate links. If you buy through them, I earn a small commission — at no extra cost to you — which helps keep this site running.
Systems Performance: Enterprise and the Cloud (2nd ed.)
Brendan Gregg · Book
The reference behind most of this article. Gregg is the person who traced the load average back to Urlichs’ 1993 patch and to RFC 546, and he is also the author of the USE method the closing sections recommend in its place. The book gives utilization/saturation/errors the full treatment across CPU, memory, disk, filesystems and network — including the per-resource checklists that turn “load is high” into an actual diagnosis. If you buy one book on the strength of this piece, buy this one.
BPF Performance Tools
Brendan Gregg · Book
The practical companion, and the right next step once you accept that the load average cannot tell you which resource is saturated. This is the book for run-queue latency, off-CPU analysis, and block-device latency histograms — the eBPF-based measurements that answer the questions /proc/loadavg structurally cannot. It documents runqlat, biolatency and the rest of the bcc/bpftrace toolkit, tool by tool, with the kernel context for each.
The Linux Programming Interface
Michael Kerrisk · Book
For the layer beneath the metric: process states, scheduling, signals, and the semantics of uninterruptible sleep that make TASK_UNINTERRUPTIBLE a distinct thing worth counting in the first place. Kerrisk maintains the Linux man-pages project, and this is the most careful available account of what the kernel is actually doing when a task enters D state and stops being interruptible.
Before any of the above, if you want the scheduling and virtual-memory fundamentals that make run-queue behaviour intuitive rather than mysterious, Operating Systems: Three Easy Pieces by Remzi and Andrea Arpaci-Dusseau is free in full at ostep.org — the scheduling chapters cover run queues, multi-level feedback and I/O-blocked processes directly, and cost nothing. Read it there; there is no Amazon listing worth linking.