Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
If 10% of a fixed workload remains unimproved, even infinite parallel hardware can make the complete program no more than 10× faster. That is the central insight of Amdahl’s Law: end-to-end performance is limited by the portion of execution that does not benefit from an optimization.
Amdahl’s Law is an upper-bound and prioritization model—not a complete performance forecast. It helps estimate whether additional CPU cores, GPUs, nodes, or engineering effort can produce worthwhile gains, while real systems must also account for communication, synchronization, memory contention, data movement, and load imbalance.
What Amdahl’s Law means
Amdahl’s Law answers a practical question: how much faster can a fixed-size job become when only part of it is improved?
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
It applies to parallelizing software, adding processors, moving work to an accelerator, optimizing a database stage, or improving any other portion of a system. The key is that overall speedup is determined by the weighted combination of improved and unimproved execution time—not by the speed of the improved component alone.
#1 Best Overall
The idea was presented by Gene M. Amdahl at the AFIPS Spring Joint Computer Conference in 1967, in the paper “Validity of the Single Processor Approach to Achieving Large Scale Computing Capabilities.”
Speedup, latency, throughput, and efficiency
Speedup is defined as:
S = Told / Tnew
- Speedup: how much less time the same workload takes.
- Latency: the time required for one request or operation.
- Throughput: the amount of work completed per unit of time.
- Efficiency: how effectively processors are being used:
E(P) = S(P) / P. - Scalability: how performance changes as resources or problem size changes.
A server can improve throughput by processing many independent requests concurrently without achieving the same proportional reduction in the latency of one request. Always identify which performance objective is being measured.
The classic formula and its derivation
Normalize the original execution time to 1. Let:
fbe the fraction of execution time that remains serial or otherwise unimproved.1 − fbe the fraction that can be divided among workers.Pbe the number of processors or equivalent parallel resources.
With perfect partitioning and no parallel overhead, execution time becomes:
T(P) = f + (1 − f) / P
Therefore:
S(P) = 1 / [f + (1 − f) / P]
This is the standard formulation described in the Encyclopedia of Parallel Computing.
The infinite-processor limit
As P approaches infinity, the parallel portion approaches zero:
Smax = 1 / f
| Unimproved fraction | Maximum theoretical speedup |
|---|---|
| 50% | 2× |
| 20% | 5× |
| 10% | 10× |
| 5% | 20× |
| 1% | 100× |
| 0.1% | 1,000× |
For example, if 20% of execution time remains serial, parallelizing the other 80% cannot produce more than 5× speedup, even with unlimited processors. This practical interpretation is also illustrated in Intel’s Amdahl’s Law guidance.
Rank #2
Finite-processor example
Suppose f = 0.10. Then:
S(P) = 1 / [0.10 + 0.90 / P]
| Processors | Speedup | Efficiency |
|---|---|---|
| 1 | 1.00× | 100% |
| 2 | 1.82× | 91% |
| 4 | 3.08× | 77% |
| 8 | 4.71× | 59% |
| 16 | 6.40× | 40% |
| 32 | 7.80× | 24% |
| 64 | 8.77× | 14% |
| ∞ | 10.00× | Approaches 0% |
The first few processors deliver substantial gains. Later processors attack a progressively smaller share of total runtime, so returns diminish.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Generalizing Amdahl’s Law to any optimization
The same reasoning applies when an enhancement affects a fraction p of execution time and makes that portion k times faster:
S = 1 / [(1 − p) + p / k]
Suppose an accelerator improves 60% of runtime by 10×:
S = 1 / [0.4 + 0.6 / 10] = 1 / 0.46 ≈ 2.17×
The accelerator is 10× faster for its own work, but the complete application is only about 2.17× faster. Transfer and setup costs can reduce the gain further; AMD’s Vitis guidance highlights this issue for hardware acceleration.
Target-speedup calculations
To determine the serial fraction required for a target speedup S on P processors:
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →f = [(1 / S) − (1 / P)] / [1 − (1 / P)]
With unlimited processors, achieving at least 20× speedup requires:
f ≤ 1 / 20 = 0.05
So no more than 5% of measured execution time may remain unimproved.
To estimate the processor count needed for a target speedup:
P = (1 − f) / [(1 / S) − f]
This is valid only when S < 1 / f. If the target equals or exceeds the asymptotic limit, no finite processor count can achieve it under the model.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsSerial code is not the same as serial time
The most useful interpretation of f is normally a fraction of measured elapsed time, not a percentage of source-code statements or algorithmic operations.
A logically serial section may execute quickly. Meanwhile, nominally parallel code may spend significant time waiting on:
- Locks and barriers
- Memory bandwidth and cache coherence
- Network communication
- Input/output
- Queueing and scheduling
- Load imbalance
- Accelerator transfers
For that reason, “10% of the program is serial” is often misleading. A more defensible statement is: “For this workload, implementation, machine, and baseline measurement, approximately 10% of elapsed time did not benefit from the tested parallelization.”
The fraction can change with input size, processor count, data distribution, compiler, runtime, storage system, network, and algorithm. Intel recommends measuring rather than guessing when applying the model.
Recommended Free Tools
Amdahl’s Law is an upper bound, not a forecast
The basic formula assumes:
- A fixed problem size
- Perfect division of parallel work
- No communication or synchronization cost
- No scheduling overhead
- No memory, cache, or NUMA penalties
- No load imbalance
- Identical processor effectiveness
- A constant unimproved fraction
Real execution time is better represented as:
T(P) = Ts + Tp / P + Toverhead(P)
The overhead term can include communication, setup, synchronization, imbalance, memory-system effects, idle time, and retries. It may grow with the number of workers, making observed performance worse than the ideal curve. A detailed USENIX discussion develops overhead-aware extensions to the simple model.
Strong scaling versus weak scaling
| Strong scaling | Weak scaling | |
|---|---|---|
| Problem size | Fixed | Grows with resources |
| Question | How quickly can the same job finish? | How much more work can finish in the same time? |
| Closest model | Amdahl’s Law | Gustafson-style analysis |
| Typical goal | Lower latency | Increase capacity |
Classic Amdahl analysis is primarily a strong-scaling model. In scientific computing, a larger machine may be used to solve a larger problem rather than to finish the same problem sooner. Cornell’s parallel-computing material explains this fixed-size versus fixed-runtime distinction.
Amdahl’s Law and Gustafson’s Law
Gustafson’s Law changes the question from “How quickly can a fixed job finish?” to “How much larger a job can be completed in the same amount of time?” A commonly used form is:
SG(P) = P − f(P − 1)
Amdahl and Gustafson are not competing slogans. They describe different workload assumptions:
- Amdahl: fixed workload, reduced execution time, strong scaling.
- Gustafson: fixed execution time, increased workload, weak or scaled-size analysis.
The two formulations can be reconciled when their baselines and measured fractions are stated clearly. See the discussions from Temple University and this mathematical analysis.
Best Value
Where real systems lose scalability
Communication and synchronization
Workers must exchange data, acquire locks, wait at barriers, and combine results. These operations add latency and can become increasingly expensive as the system grows.
Load imbalance
Perfectly equal operation counts do not guarantee equal execution times. Completion is determined by the slowest worker, leaving others idle.
Memory bandwidth and contention
An application can contain abundant parallel work yet stop scaling when workers saturate shared memory bandwidth or compete for cache and interconnect capacity.
I/O and data movement
Faster computation may have little end-to-end effect when reading, writing, preprocessing, marshaling, or transferring data dominates runtime.
Heterogeneous hardware
A GPU, FPGA, or specialized accelerator is not simply a fixed number of homogeneous processors. Benefit depends on kernel suitability, data size, transfer path, precision, memory layout, occupancy, branching, launch overhead, and synchronization.
Changing behavior at scale
Contention can make the effective serial fraction rise as more resources are added. Conversely, larger caches or a changed algorithm can sometimes produce superlinear measured speedup. Such results indicate that the simple assumptions do not fully describe the comparison.
Applications
- Multithreaded CPU programs: estimate whether more cores can reduce batch-job latency.
- Databases: distinguish parallel query execution from serial planning, locking, storage, and coordination.
- Distributed processing: weigh computation against network transfers, shuffles, and aggregation.
- GPU and FPGA acceleration: include host-device transfers and launch or setup time.
- Web services: apply the model carefully when throughput, queueing, and request concurrency matter more than one-request latency.
- Scientific simulation: use Amdahl for fixed-size strong scaling and Gustafson-style reasoning for larger simulations.
- Machine learning: account for input pipelines, synchronization, parameter exchange, and accelerator utilization—not only kernel speed.
- Build systems and media processing: identify dependency chains, serial orchestration, file I/O, and stages that cannot run concurrently.
A practical profiling workflow
- Define the objective. Decide whether the target is latency, throughput, cost per job, energy, or deadline compliance.
- Fix the workload. Record input data, correctness criteria, compiler, software version, hardware, and configuration.
- Measure a baseline. Use wall-clock time and repeat runs sufficiently to account for variability.
- Break down elapsed time. Separate useful computation from waiting, synchronization, I/O, communication, and data movement.
- Estimate candidate benefits. For each proposed improvement, identify the measured time fraction it affects and its plausible local speedup.
- Calculate the ideal bound. Use Amdahl’s formula before spending on hardware or a major rewrite.
- Test multiple resource counts. Compare observed results with the ideal curve and look for changing fractions or growing overhead.
- Include economic and operational costs. Consider hardware, cloud instances, energy, licensing, porting, deployment, reliability, and maintenance.
- Re-measure after changes. Every major algorithmic or hardware change can alter the measured fractions.
When Amdahl’s Law is useful—and when it is not enough
Use it when the workload is fixed, the objective is clear, a candidate optimization affects a known portion of runtime, and a measured baseline is available.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Use additional models or measurements when problem size grows, communication changes materially with scale, workloads are queue-driven, hardware is heterogeneous, memory bandwidth is the bottleneck, or the serial fraction varies substantially with input and processor count.
Possible complements include empirical scaling curves, roofline analysis for compute-versus-memory limits, queueing models for contention and throughput, the Universal Scalability Law, and cost-per-unit-work analysis.
Quick Recap
Decision checklist
- Is the workload fixed or growing?
- Am I optimizing latency, throughput, cost, energy, or capacity?
- What fraction of measured time benefits from the proposed change?
- What is the theoretical maximum speedup?
- What speedup is possible at the planned resource count?
- What communication, synchronization, transfer, or setup overhead will be added?
- Could memory bandwidth, queueing, or load imbalance become the new bottleneck?
- Does the measured fraction remain stable across inputs and scales?
- Is the expected marginal benefit worth the hardware and engineering cost?
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
