Amdahl's Law: Parallel Speedup Simulator

Workload & Cluster

Worker cores N 8

Parallelizable fraction P 90%

Coordination overhead / core 0.30%

Live Run

Current phase

Serial section

Speedup S(N)

1.00×

Efficiency

100%

Wall-clock time T(N)

100.0 task-s

Theoretical max (N→∞, no overhead)

10.00×

How it works

A job of fixed size takes T(1) = 100 task-seconds on one core. A fraction P of that work can be split evenly across N cores; the rest, fraction (1−P), is inherently sequential (setup, I/O, a single accumulator, whatever can't be split) and always runs on one core alone. This is Amdahl's Law:

T(N) = (1−P)·T(1) + P·T(1)/N + O·N·T(1)
S(N) = T(1) / T(N)
E(N) = S(N) / N   (efficiency per core)

The last term, O·N·T(1), is coordination overhead — the cost of synchronizing and merging results across N workers, which grows with N even though the useful work per core shrinks. It's why real clusters see speedup peak and then fall as more cores are added, instead of climbing forever.

N — how many cores share the parallel fraction of the work.
P — how much of the total job can actually run in parallel; the rest is the hard floor on speedup (with O=0, S(N) can never exceed 1/(1−P) no matter how large N gets).
Overhead / core — synchronization cost per additional core, as a percent of T(1). Push it up and adding cores eventually makes the run slower, not faster.

Watch the grid of cores: only core 0 lights up during the serial section (everyone else idles), all N light up together during the parallel burst, and the amber pulses between cores are the overhead phase — real time nobody is doing useful work, just synchronizing.

Serial (core 0 only) Parallel burst (all N) Coordination overhead

⚠ Couldn't load the 3D engineThree.js failed to load from the CDN. Check your connection and reload.