Amdahl’s law, formulated by Gene Amdahl in 1967, answers a simple but sobering question: if I make part of my program faster, how much faster does the whole program get? The answer depends on how big that part is. The untouched remainder still takes the same time, so it quickly dominates.
If 40% of a task becomes 4 times faster, the task as a whole only speeds up 1.43 times. Even if that 40% became infinitely fast, the best you could reach is 1 ÷ 0.6 = 1.67 times. In parallel computing this is why adding more cores gives diminishing returns: with 95% of the code parallel, 8 cores give a speedup of 5.9, and no number of cores can ever beat 20.
The calculator handles one improved part, several parts each with their own speedup, and N identical processors. You can also speed up the sequential part itself (factor O). For parallel work it reports efficiency (speedup per core) and Gustafson’s law, which models the common case where a bigger machine is used to solve a bigger problem in the same time.
How to use the Amdahl’s Law Calculator
- Model
- Share of the task that is improved (p)
- Speedup of that part (s) — 4 means that part now runs 4 times faster.
- Number of processors or cores (N)
- Number of improved parts
- Part 1 – share of the task
- Part 1 – speedup
- Part 2 – share of the task
- Part 2 – speedup
- Part 3 – share of the task
- Part 3 – speedup
- Part 4 – share of the task
- Part 4 – speedup
- Part 5 – share of the task
- Part 5 – speedup
- Speedup of the remaining (sequential) part (O) — Leave at 1 if the rest of the task is unchanged.
- Original execution time
Results update as you type, every field has its own unit menu, and everything is calculated in your browser.
How it works
Choose the model, enter the share of the run time that is improved and how much faster it becomes (or the number of cores), and optionally the original run time. The calculator adds up the new fractional times, inverts the total to get the speedup and divides the original time by it.
Worked example
A 2-minute (120 s) job spends 40% of its time in a routine that you make 4 times faster. The new time fraction is 0.6 + 0.4 ÷ 4 = 0.7, so the speedup is 1 ÷ 0.7 = 1.43× and the job now takes 84 s – 30% less. Even an infinitely fast routine could only reach 1 ÷ 0.6 = 1.67×. Speeding up 60% of a 10-hour job 5 times gives 1 ÷ (0.4 + 0.12) = 1.92×.
Speedup on N cores
| Parallel share | 2 cores | 4 cores | 8 cores | 16 cores | Limit |
|---|---|---|---|---|---|
| 50% | 1.33 | 1.60 | 1.78 | 1.88 | 2 |
| 75% | 1.60 | 2.29 | 2.91 | 3.37 | 4 |
| 90% | 1.82 | 3.08 | 4.71 | 6.40 | 10 |
| 95% | 1.90 | 3.48 | 5.93 | 9.14 | 20 |
| 99% | 1.98 | 3.88 | 7.48 | 13.91 | 100 |
Inputs explained
| Field | What to enter |
|---|---|
| Model | Choose one: One part of the task is sped up, Parallel processing on N processors, Several parts sped up by different factors |
| Share of the task that is improved (p) | In % |
| Speedup of that part (s) | A number. 4 means that part now runs 4 times faster. |
| Number of processors or cores (N) | A number |
| Number of improved parts | Choose one: 2, 3, 4, 5 |
| Part 1 – share of the task | In % |
| Part 1 – speedup | A number |
| Part 2 – share of the task | In % |
| Part 2 – speedup | A number |
| Part 3 – share of the task | In % |
| Part 3 – speedup | A number |
| Part 4 – share of the task | In % |
| Part 4 – speedup | A number |
| Part 5 – share of the task | In % |
| Part 5 – speedup | A number |
| Speedup of the remaining (sequential) part (O) | A number. Leave at 1 if the rest of the task is unchanged. |
| Original execution time | Units: min, s, h, ms |
What each result means
- Overall speedup = 1÷((1 – [Total improved share])÷[Speedup of the remaining (sequential) part (O)] + [Improved time fraction])
- New execution time = [Original execution time]÷[Overall speedup]
- Time saved = [Original execution time] – [New execution time]
- Change in execution time = (1÷[Overall speedup] – 1)×100
- Parallel efficiency (speedup ÷ N) = [Overall speedup]÷[Number of processors or cores (N)]×100
- Gustafson’s scaled speedup = (1 – [Total improved share]) + [Total improved share]×[Number of processors or cores (N)]
Formula
S = 1 ÷ [(1 − p) ÷ O + Σ pᵢ ÷ sᵢ] · S_max = O ÷ (1 − p) · N cores: S = 1 ÷ [(1 − p) + p ÷ N] · Gustafson: S = (1 − p) + p·N
Worked example
Inputs — Model: One part of the task is sped up; Share of the task that is improved (p): 40 %; Speedup of that part (s): 4; Speedup of the remaining (sequential) part (O): 1; Original execution time: 2 min.
Results — Overall speedup = 1.4286 ×; New execution time = 84 s; Time saved = 36 s; Change in execution time = -30 %; Maximum speedup (improved parts infinitely fast) = 1.6667 ×; Check = Shares are consistent.
Key terms
- Speedup (S)
- Original time ÷ new time.
- Parallel fraction (p)
- Share of the original run time that can be improved or parallelised.
- Sequential part
- The share 1 − p that keeps running as before.
- Parallel efficiency
- Speedup ÷ number of processors.
Frequently asked questions
What does Amdahl's law say?
The overall speedup is limited by the part of the task you do not improve: S = 1 ÷ [(1 − p) + p ÷ s].
What is the maximum speedup?
1 ÷ (1 − p). If 90% of a program runs in parallel, no number of processors can make it more than 10 times faster.
How much faster are 8 cores?
With 95% parallel code, 8 cores give 1 ÷ (0.05 + 0.95 ÷ 8) = 5.93×, an efficiency of 74%.
What is the difference between Amdahl's and Gustafson's law?
Amdahl keeps the problem size fixed; Gustafson assumes the parallel part grows with the number of processors, giving S = (1 − p) + p·N.
Why is my real speedup lower than predicted?
Communication, synchronisation, memory bandwidth, cache effects and load imbalance all add overhead that the simple law ignores.
How do I find p for my program?
Profile it: p is the share of the original run time spent in the code you will speed up.