Gustafson's Law

Gustafson's law reframes scaling for growing problems, showing that large machines stay useful when the workload scales with processor count.

A different question

Amdahl's law fixes the problem and asks how much faster it runs. Gustafson's law fixes the run time and asks how much larger a problem can be solved. This matches how scientists actually use big machines: they raise resolution or model size until the run fills the available time.

The statement

If a workload on N processors spends a serial fraction s and a parallel fraction (1 minus s) of its time, the scaled speedup is S(N) = s + N(1 minus s) = N minus s(N minus 1). Speedup grows almost linearly with N because the parallel work expands with the machine while the serial part stays fixed.

Reconciling with Amdahl

The two laws are consistent; they measure different things. Amdahl assumes constant work (strong scaling); Gustafson assumes work grows with processors (weak scaling). A code that scales poorly under Amdahl can still be run efficiently on a huge machine if the problem is scaled up accordingly.

Worked example

def gustafson(s, n):
    return s + n * (1.0 - s)

for n in (8, 64, 1024):
    print(n, round(gustafson(0.05, n), 1))
# 8 -> 7.7, 64 -> 61.0, 1024 -> 972.9
# near-linear scaled speedup

The practical lesson

Exascale machines are justified largely by Gustafson's reasoning: they enable finer meshes, longer time integrations, and larger models rather than merely faster fixed runs. In fusion simulation this means higher-resolution turbulence and fuller device models, which is where added compute is spent.