Validity of the Single Processor Approach to Achieving Large Scale Computing Capabilities
The part of a job that cannot be divided sets a ceiling on the whole job, and a decade of trying had not made that part smaller.
Read the original ↗Three pages from a 1967 conference panel, arguing against a machine architecture, containing no equation, no speedup function and no variable called p - and cited ever since for a formula that appears nowhere in it. The argument is right, the ceiling is real, and almost everything a modern reader believes about the paper comes from somewhere else.
Included with a plan
This discussion is included with a plan. The first three lessons of every track are free, with their boards and videos. A plan unlocks every lesson, board, video, lab and paper for one price.
Related on chalk
The same idea as a board, lab, video or lesson.
- BoardConcurrency and the Hardwarethe ceiling drawn, with the board's own 10% serial means 10x at most
- BoardProcesses Threads and the Kernelwhere the serial part hides - the scheduler, the barrier, the one lock everybody queues for
- BoardThe CPUthe single fast processor the paper was arguing for, and the physics that stopped it getting faster
- BoardThe Order Slip Railthe same curve from the other side: what utilisation does to waiting, which is the coordination term Amdahl has no room for
- BoardComplexity and Big-Othe growth-rate reflex the law is applied with, and the reason a ceiling is a different claim from a complexity class
- LabThe parallel ceilingthe formula the paper does not contain, computed - and the coherency term that turns the curve over
- LabHow cost growswhy an optimisation is capped by the share of the runtime it touches
- LabThe order slip railqueueing at high utilisation, which is what an added core actually runs into
- VideoTime and space complexity: counting without countinggrowth rates, and the discipline of pricing a speedup before attempting it
- VideoQueues: the order slip rail and the cliffthe wait at 95% busy - the cost of coordination, before anyone calls it that
- LessonConcurrency & the HardwareUses the board Concurrency and the Hardware
- LessonWaiting without spinningUses the board Concurrency and the Hardware
- LessonContainer 01: Fork and ExecUses the board Processes Threads and the Kernel
- LessonContainer 02: UTS and PID NamespacesUses the board Processes Threads and the Kernel
- LessonContainer 04: /proc and /devUses the board Processes Threads and the Kernel
- LessonProcesses, Threads & the KernelUses the board Processes Threads and the Kernel
- LessonThe address book every process carriesUses the board Processes Threads and the Kernel
- LessonWhose turn, and who decidesUses the board Processes Threads and the Kernel
- LessonThe program that starts programsUses the board Processes Threads and the Kernel
- LessonThe CPU (fetch-decode-execute, the ISA, assembly)Uses the board The CPU
- LessonBuild a stack machineUses the board The CPU
- LessonThe order slip rail (queues & the utilization cliff)Uses the board The Order Slip Rail
- LessonThe stall that turns people away (load shedding and admission control)Uses the board The Order Slip Rail
- LessonThe stall, built: rush hour (load testing, p99 and the knee in Go)Uses the board The Order Slip Rail
- LessonComplexity & Big-OUses the board Complexity and Big-O
Further reading
Read the original for the full argument and its evidence.
- The paper ↗AFIPS Spring Joint Computer Conference, April 1967, pages 483 to 485. Three pages. Read it for what it argues rather than for the formula, which is not in it.
- Reevaluating Amdahl's Law ↗Gustafson, CACM 31(5), 1988. One page, and the necessary companion: the problem grows with the machine, so measure scaled speedup. Not a refutation - a different question, asked better.
- A General Theory of Computational Scalability Based on Rational Functions ↗Gunther's derivation of the Universal Scalability Law. Amdahl plus a coherency term, which is what makes the curve turn back down instead of flattening. Fit it against your own data before quoting anyone a core count.