Amdahls-Law
Amdahl's law is a formula, named after computer architect Gene Amdahl who stated it in 1967, describing the maximum possible speedup from parallelizing part of a task: if a fraction of a program's work cannot be parallelized, that fraction alone puts a hard ceiling on total speedup, no matter how many processors or cores are thrown at the parallel portion. The core insight is uncomfortable but simple — a program that's 95% parallelizable is still fundamentally limited by the 5% that isn't, and adding more cores past a certain point barely moves the needle. How a chip's effective speedup actually gets capped by its serial fraction, as core count climbs, looks like this:
A few things are worth knowing about why Amdahl's law is a ceiling, not a rough guideline:
The formula itself is simple, but what it reveals is that the ceiling on speedup is set entirely by the serial fraction, and adding infinite cores can never push past it. Speedup equals one divided by the serial fraction plus the parallel fraction divided by the number of processors. As the number of processors grows arbitrarily large, that second term shrinks toward zero, which means the maximum possible speedup converges toward one divided by the serial fraction alone — a program that's 10% serial can never speed up more than 10 times, even with an infinite number of cores, because that 10% has to run on one core no matter what the other cores are doing. This is why Amdahl's law is often summarized as "the part you can't parallelize eventually dominates," because past a certain core count, that's literally what happens to the runtime.
A small serial fraction sounds harmless, but its effect on the achievable ceiling is wildly disproportionate, which is exactly why chip architects obsess over shrinking it rather than just adding more cores. A program that's 99% parallelizable — leaving just 1% serial — caps out at a maximum possible speedup of 100 times. A program that's 95% parallelizable, with 5% serial, caps out at only 20 times, despite the parallel fraction only dropping four percentage points. And a program that's 80% parallelizable caps out at just 5 times, no matter how many cores are thrown at it. This nonlinear sensitivity is why real engineering effort in high-core-count chip design goes disproportionately toward eliminating serial bottlenecks — synchronization overhead, shared-resource contention, single-threaded setup and teardown phases — rather than simply adding more parallel execution units, because beyond a certain point more cores stop buying meaningful speedup at all.
Amdahl's law assumes the problem size stays fixed as core count grows, and that assumption is exactly what a related idea, Gustafson's law, challenges — the two aren't contradictory, they're answering different questions. Amdahl's law asks: given a fixed-size problem, how much faster can more cores make it run? Gustafson's law, proposed by John Gustafson in 1988, instead asks: given a fixed amount of time, how much bigger a problem can more cores solve in that same time? In many real workloads — scientific simulations, large-scale data processing, and much of modern AI training — the problem size scales up along with available compute rather than staying fixed, and under that framing, the achievable speedup looks far less pessimistic than Amdahl's law alone suggests. Neither law is simply wrong; they model two genuinely different situations, and conflating them is a common source of confusion when people argue about whether "parallelism has limits" without specifying which question they're actually asking.
Amdahl's law shows up constantly in modern chip design decisions, not as an abstract footnote but as the direct justification for architectural choices that trade raw core count for something else. It's the reason heterogeneous designs pairing a few very fast cores with many slower, more efficient ones can outperform a design with uniformly many identical cores on real workloads — the fast cores chew through the unavoidable serial portions quickly, where adding more parallel cores would have done nothing for that portion anyway. It's also the reason GPU and AI accelerator architects invest heavily in reducing synchronization and memory-access serialization between compute units, since those serial stalls are exactly the kind of bottleneck Amdahl's law says will eventually dominate overall throughput regardless of how many parallel execution lanes a chip packs onto the die.
Read Amdahl's law as a statement about where the real bottleneck lives, not a discouragement from building parallel hardware: the achievable speedup from more cores is capped by whatever fraction of the work still has to run serially, that cap is far more sensitive to small serial fractions than intuition suggests, and the entire practical lesson for chip architects is to spend engineering effort shrinking that serial fraction rather than assuming more cores alone will keep delivering proportional returns.