Analyzing Amdahl’s Law for Speedup Optimization

In this lesson, you will learn how to use Amdahl’s Law to mathematically determine the upper limit of system performance when accelerating specific parts of your code or hardware.

The Bottleneck Reality

Even if you build the fastest hardware in the world, the total execution time is governed by the parts of the process you cannot speed up. Amdahl’s Law states that the potential speedup of a system is limited by the fraction of the execution time that can be improved.

Mathematically, the speedup ($S$) is defined as: $S = \frac{1}{(1 - f) + \frac{f}{k}}$

Where:

• $f$ is the fraction of the execution time that is enhanced.
• $k$ is the speedup factor applied to that specific fraction.

A Concrete Example

Imagine you are optimizing an embedded image processing task. Suppose 80% of your code is parallelizable ($f = 0.8$), while 20% must remain sequential (like initializing hardware peripherals or final data transmission).

If you purchase a new processor that makes the parallel part 10 times faster ($k = 10$), what is your total system speedup?

Fraction (f) = 0.8
Speedup (k) = 10
Sequential portion (1 - f) = 0.2

Speedup = 1 / (0.2 + 0.8/10)
Speedup = 1 / (0.2 + 0.08)
Speedup = 1 / 0.28 ≈ 3.57

Even though your new processor made the main task 10 times faster, your system only runs 3.57 times faster overall. The 20% sequential "tail" prevents you from ever reaching a 10x speedup, no matter how much faster your hardware becomes.

Why This Matters in Architecture

When designing embedded systems, this law warns us against "premature optimization." If you spend weeks tuning a function that only accounts for 5% of execution time, the maximum theoretical speedup is capped regardless of how perfect that optimization is. As an architect, you must identify the largest fractions ($f$) of execution time first—often found by analyzing bottlenecks in the instruction pipeline or memory access patterns—to get the most significant return on your development effort.

Key Takeaway: The maximum speedup of any system is strictly limited by the portion of execution that cannot be improved, meaning your focus should always be on the largest contributors to total execution time.