What is Amdahl's Law?

Amdahl's Law is a fundamental principle in computer science that describes the theoretical maximum speedup achievable when improving part of a system. It demonstrates that the overall performance improvement is limited by the portion of the system that cannot be enhanced.

Consider this analogy: Three friends must travel to a party separately but arrive together to enter. One drives a car, another takes the bus, and the third walks. No matter how fast the car and bus arrive, they must wait for the slowest person (the walker). To improve overall arrival time, focus must be on helping the walker, not making the car faster.

Amdahl's Law Formula

The mathematical expression for Amdahl's Law is:

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

Where:

• Speedup = Maximum theoretical performance improvement

• p = Fraction of the system that can be improved (0 ? p ? 1)

• s = Speedup factor applied to the improvable portion

• (1 - p) = Fraction that remains unimproved (the bottleneck)

Examples

Example 1: 30% Improvable Portion

If 30% of a system can be improved and that portion runs twice as fast:

p = 0.30, s = 2
Speedup = 1 / ((1 - 0.30) + (0.30 / 2))
        = 1 / (0.70 + 0.15)
        = 1 / 0.85
        = 1.18×

Example 2: 70% Improvable Portion

If 70% of a system can be improved with the same 2× speedup:

p = 0.70, s = 2
Speedup = 1 / ((1 - 0.70) + (0.70 / 2))
        = 1 / (0.30 + 0.35)
        = 1 / 0.65
        = 1.54×

Key Implications

• Sequential bottleneck − The non-parallelizable portion (1-p) limits maximum speedup regardless of how many processors are added.

• Diminishing returns − As more processors are added, the performance improvement becomes smaller.

• Focus optimization − Greatest improvements come from optimizing the largest sequential portions first.

Applications in Parallel Computing

Amdahl's Law is crucial in multicore programming and parallel system design:

Conclusion

Amdahl's Law reveals that system performance is fundamentally limited by sequential portions that cannot be parallelized. Understanding this principle helps developers identify bottlenecks and make informed decisions about where to invest optimization efforts for maximum impact.