3

In computer architecture, Amdahl's law gives the theoretical speedup in latency of the execution of a task at fixed workload that can be expected of a system whose resources are improved.

Slatency is the theoretical speedup in latency of the execution of the whole task;

s is the speedup in latency of the execution of the part of the task that benefits from the improvement of the resources of the system;

p is the percentage of the execution time of the whole task concerning the part that benefits from the improvement of the resources of the system before the improvement.

Slatency = 1/[(1-p) + (p/s)]

It is all theoretical and it had me thinking, when is it inapplicable. And how accurate it is for estimating CPU performance ?

Tony Tannous
  • 14,154
  • 10
  • 50
  • 86

1 Answers1

3

Often when you want to tune some part of a program, you make a microbenchmark to test just that in isolation.

That doesn't always reflect how it will behave when run as part of the full program. (i.e. with other work between executions of the part you're tuning, instead of in a tight loop.)

e.g. if you found sin(x) calculations were expensive and replaced them a lookup table, that might win in a microbenchmark, because a small-enough table stays hot in cache when called back-to-back with no other work in between. Similarly, microbenchmarks measure performance with branch-prediction primed, and with no code-cache pressure (which can make loop unrolling look better than it is).

But that just means your estimate of s is wrong for the function as part of the whole program, not that Amdahl's law is inaccurate. That's just a case of using it wrong.

However, this does lead to a real answer to your question:

Speeding up one part of a program in a way that leads to more cache or TLB misses, branch mispredictions, etc. in other parts of the program does violate Amdahl's law.

Peter Cordes
  • 328,167
  • 45
  • 605
  • 847
  • Thanks mate. Wasn't aware estimating of `s` is so tricky. But it makes sense. – Tony Tannous Nov 25 '16 at 23:03
  • 2
    Well Amdalh's law is a simple mathematical relationship and in that sense it is infallible - but the underlying performance model that it assumes (or that is usually assumed in textbook applications) is too simple: that the program can be partitioned evenly into two parts: one part affected by some "resource improvement" (which could equally be a resource reduction) and another part which is not affected. In an extremely complex system like a modern host, there is usually no such clean division: changes in one part have arbitrary knock-on effects on other parts, as Peter explains above. – BeeOnRope Nov 26 '16 at 19:23