Amdahl's Law: Speedup = 1 / ((1 - p) + p / N)

Performance Engineering

Meaning

Amdahl's Law quantifies the theoretical maximum speedup of a program when a portion of it is parallelized across N processors. It highlights the diminishing returns caused by the serial fraction of the workload. The law is applied when evaluating whether adding more compute resources will meaningfully improve performance.

Primary Function

Performance analysis

Communicative Purpose

Enables estimation of achievable speedup when scaling a workload across multiple processors.

Pattern

calculate speedup → compare with target performance → decide on processor count

Core Structure

Speedup = 1 / ((1 - p) + p / N)

Função primária

Performance analysis

Propósito comunicativo

Enables estimation of achievable speedup when scaling a workload across multiple processors.

Situações de gatilho

Parallel computing: estimating speedup for a fixed workload when adding CPUs Systems design: deciding if a parallelization effort is worthwhile Performance engineering: comparing expected gains against hardware costs

Contextos

High-performance computing, distributed systems, cloud services, scientific simulations

Padrão

calculate speedup → compare with target performance → decide on processor count

Estrutura central

Speedup = 1 / ((1 - p) + p / N)

Colocados típicos

parallelism
scalability
throughput
efficiency
processor count

Substituições comuns

Gustafson's Law – assumes workload scales with processors
giving higher speedup for large N
Karp‑Flatt metric – provides a measured serial fraction from empirical data.

Erros comuns

Treating p as a percentage (0‑100) instead of a fraction (0‑1) → overestimates speedup. Assuming p remains constant as N grows, ignoring overhead → unrealistic predictions. Applying the law to workloads that scale with N, which violates the fixed‑size assumption → underestimates possible gains.

Similar / contraste

Gustafson's Law – focuses on scaled workloads rather than fixed size. Little's Law – relates throughput, latency, and work‑in‑process, not parallel speedup.

Interferências

Coming from JavaScript: using integer division for p and N can truncate values → ensure floating‑point division in Python.

Família do chunk

Amdahl's Law
Gustafson's Law
Karp‑Flatt metric

Nuance

Do not use when the problem size grows with the number of processors; Gustafson's Law is more appropriate. Performance impact: speedup quickly plateaus as N increases if the serial fraction is large. Boundary condition: if p = 0 the speedup is 1 (no gain); if p = 1 the speedup equals N (perfect scaling).

Efeito pragmático

Helps architects and engineers decide whether investing in additional CPUs will deliver meaningful performance improvements, avoiding wasted hardware costs.

Dica de memória

Think of a highway bottleneck: adding more lanes helps only up to the point where the slowest car (the serial part) limits overall traffic flow.

Nota

Amdahl's Law assumes a fixed total workload; it does not account for parallel overhead such as synchronization or communication costs.

Upgrade path

After mastering Amdahl's Law, study Gustafson's Law to handle workloads that scale with processor count.

Frequência: LowFormulaicidade: Fully fixedTipo de construção: formulaPrioridade de aquisição: Comprehension onlyPrioridade de output: BothTag de espaçamento: Medium-term

Examples

def amdahl_speedup(p, N): """Calculate speedup according to Amdahl's Law.""" return 1 / ((1 - p) + p / N) print(amdahl_speedup(0.75, 4)) # → 2.0

import matplotlib.pyplot as plt def amdahl_speedup(p, N): return 1 / ((1 - p) + p / N) p = 0.9 Ns = range(1, 33) speedups = [amdahl_speedup(p, n) for n in Ns] plt.plot(Ns, speedups, marker='o') plt.title("Amdahl's Law Speedup") plt.xlabel('Number of processors (N)') plt.ylabel('Speedup') plt.grid(True) plt.show()

def gustafson_speedup(p, N): return N - (N - 1) * (1 - p) p = 0.8 for N in [2, 4, 8, 16]: print(f"N={N}: Amdahl={amdahl_speedup(p, N):.2f}, Gustafson={gustafson_speedup(p, N):.2f}")