Zum Inhalt springen

Gene Amdahl and the System/360

Zusammenfassung

Gene Amdahl was the chief architect of the IBM System/360 — the single most consequential hardware project in computing history. He designed the architecture that unified IBM’s incompatible product lines into one compatible family, proved that binary compatibility across machines of different speeds was achievable, and created the platform on which enterprise computing has run for six decades. He then left IBM, frustrated by bureaucracy, proved that the architecture he had created could be built cheaper than IBM built it, and gave antitrust lawyers more ammunition than they knew what to do with. Along the way, he stated Amdahl’s Law — the theoretical limit on parallel speedup — in two paragraphs that every parallel computing researcher has been wrestling with since 1967.

From South Dakota to IBM

Gene Myron Amdahl was born on November 16, 1922, in Flandreau, South Dakota, the son of Norwegian immigrants who farmed the plains. He studied physics at South Dakota State College, interrupted by service in the United States Navy during World War II, and returned to complete his degree before pursuing graduate work at the University of Wisconsin-Madison. He completed a PhD in theoretical physics in 1952. His dissertation involved early computer programming, and his experience with the university’s computing equipment — primitive machines that required intimate knowledge of their hardware — convinced him that computing was the right field.

He joined IBM in 1952 as a young engineer at the company’s Poughkeepsie, New York laboratory. IBM in 1952 was not yet the dominant force it would become, but it was building scientific computers that were essential to defense research and government calculation. Amdahl was assigned to work on one of the most important machines of the early decade: the IBM 704.

The 704, introduced in 1954, was the first mass-produced computer to use floating-point hardware — instructions that operated directly on real numbers in scientific notation, rather than requiring programmers to manage decimal scaling manually. The 704 also had index registers, which allowed systematic traversal of arrays without rewriting addresses by hand. It was the machine for which John Backus and his team at IBM developed FORTRAN — the first high-level programming language, which compiled to efficient 704 machine code and made scientific programming accessible to researchers who were not programmers.

Amdahl followed the 704 with a key role in the IBM 7030 Stretch project (1961), IBM’s first transistorized scientific computer and the most powerful computer in the world at its delivery to Los Alamos National Laboratory. Stretch pushed transistor technology to its limits and introduced several architectural innovations — lookahead execution, byte addressing, 64-bit operations — that influenced IBM’s subsequent architecture work. But Stretch failed to meet its contractual performance targets, embarrassing IBM and its architects, and was ultimately delivered at a substantially reduced price. Amdahl was not held responsible for the failure, but the experience of watching an ambitious system fall short of its promises shaped his subsequent caution about overpromising.

The System/360: One Architecture for Everything

By 1961, IBM’s product line had become a serious strategic problem. Over the previous decade, the company had produced a dozen incompatible computer families: the 700 series for scientific computation, the 1400 series for business data processing, the 1620 for scientific work at smaller institutions, the 7090/7094 for advanced scientific computing. Each family had its own instruction set, its own operating system software, its own peripheral devices. A program written for an IBM 1401 could not run on an IBM 7090. A customer who grew out of one machine had to rewrite all their software to move to the next.

This incompatibility was not accidental — it was the product of separate engineering teams working independently — but it was strategically incoherent. IBM was in effect competing against itself. Each upgrade sale required convincing a customer to rewrite their entire software inventory. And competitors were beginning to offer software compatibility as a feature.

Amdahl’s proposal, developed through 1961 and 1962 with a team of architects that also included Fred Brooks, was radical: a single architecture — a precisely defined set of instructions, addressing modes, data types, and register conventions — that would be implemented across a range of machines from the cheapest to the most powerful. Any program written for the cheapest System/360 model would run without modification on the most expensive one. The architecture would be stable; customers would not need to rewrite software when they upgraded hardware.

The technical challenge was implementing this compatibility across a wide range of hardware performance. A fast machine and a slow machine had to run the same instruction set — but the fast machine used completely different hardware. The solution was microprogramming: implementing the instruction set in firmware, as a sequence of simpler micro-operations, so that any hardware capable of executing micro-operations could implement the same architectural behavior. Slow machines implemented each instruction in many micro-operations; fast machines implemented the same instruction in fewer. Both produced identical results.

Info

Microprogramming — the technique of implementing a complex instruction set by breaking each instruction into simpler micro-operations executed by a simpler underlying hardware machine — was invented by Maurice Wilkes at Cambridge in 1951. The System/360’s achievement was applying it at commercial scale to create the first fully compatible family of computers. The concept of an instruction set architecture (ISA) as a stable interface between hardware and software, allowing hardware to change without forcing software rewrites, is one of the most important abstractions in computing history. It descends directly from the System/360 project.

The IBM System/360 was announced on April 7, 1964, in a coordinated global announcement across eight countries and 165 cities, with approximately 100,000 simultaneous attendees at various events. IBM had committed $5 billion to the project — more than the company’s total annual revenues in 1964, and the largest privately financed industrial project in history to that date. The system offered six initial models ranging in price from roughly $133,000 to $5.5 million. All models ran the same software.

Fred Brooks, who managed the operating system software development for the System/360, later wrote The Mythical Man-Month (1975) partly from the lessons of that software effort — the OS/360 project had consumed more resources and taken longer than any estimate, and had taught Brooks deeply uncomfortable truths about software engineering and the difficulty of managing large programming teams.

The System/360’s Commercial Success

The System/360 succeeded beyond any internal projection. Within a year of announcement, IBM had over $1 billion in System/360 orders outstanding. By 1967, the backlog was $4 billion. Customers who had been considering competitive machines from Burroughs, Honeywell, or Control Data moved to the System/360, buying not just hardware but the implicit promise of software continuity — the ability to upgrade hardware for decades without rewriting software.

The architecture survived not years but decades. The System/360 was extended into the System/370 (1970), which added virtual memory. The 370 became the 303x and 308x families, then the 3090, then the System/390, then the IBM Z series — the modern mainframe line. The fundamental register set, instruction set, and data type definitions of the 1964 System/360 are still present in the IBM Z architecture of 2024, running financial transactions for most of the world’s largest banks. The architecture Amdahl designed has been in continuous production and use for sixty years, which may be longer than any other computer architecture in history.

Amdahl’s Law

In 1967, at the AFIPS Spring Joint Computer Conference in Atlantic City, Amdahl presented a paper of approximately three hundred words — really two paragraphs — containing the observation that became known as Amdahl’s Law.

The observation was a response to advocates of massively parallel computing who argued that connecting many processors would multiply computing power proportionally. Amdahl’s counterargument was that every real program contains some fraction of computation that is inherently sequential — that must be completed before the next step can begin. If even a small fraction of a program is sequential, the sequential fraction imposes a ceiling on the speedup that parallelism can achieve.

If a fraction p of a program can be parallelized and the remaining fraction (1−p) must run sequentially, then the maximum speedup from N processors is:

S(N) = 1 / ((1-p) + p/N)

As N grows toward infinity, the speedup approaches 1/(1-p). A program that is 95% parallelizable achieves at most 20-fold speedup, regardless of how many processors are applied to it. A program that is 99% parallelizable achieves at most 100-fold speedup. The 1% or 5% that cannot be parallelized is the bottleneck, and no amount of additional hardware changes it.

The law was stated as a critique of unrealistic expectations, not as a fundamental physical limit. John Gustafson, in 1988, argued that Amdahl had framed the problem incorrectly: as more processors become available, programmers typically scale up the problem they tackle, not keep the problem size fixed. Under Gustafson’s framing, the speedup scales more favorably. The tension between Amdahl’s and Gustafson’s perspectives has organized much of parallel computing research for fifty years.

Amdahl Corporation: Proving IBM Overcharged

In 1970, Amdahl left IBM after a frustrating experience with the System/370 design, in which his architectural recommendations were overruled by management decisions he considered both technically and commercially wrong. He had spent eighteen years at IBM, had been responsible for one of the company’s most important products, and left with the conviction that IBM was substantially overcharging customers for its hardware.

He founded Amdahl Corporation in Sunnyvale, California, with the intention of building IBM-compatible mainframes — machines that ran IBM’s System/360 instruction set and all System/360 software, but were built with newer technology and more efficient circuit design, delivering better performance at lower cost.

Funding was difficult. IBM’s reputation was so powerful that investors were skeptical that any competitor could credibly challenge it. Amdahl spent most of the first five years seeking capital rather than building computers. The breakthrough came through Fujitsu, the Japanese technology company, which invested in Amdahl Corporation in exchange for access to Amdahl’s advanced manufacturing techniques. The arrangement gave Fujitsu a window into American semiconductor and computer design; it gave Amdahl the capital to finish his machine.

The Amdahl 470V/6 shipped in 1975. It was priced at approximately two-thirds the cost of the comparable IBM System/370 Model 168 and was measured as significantly faster in performance. IBM’s response was immediate: price cuts, new lease terms designed to penalize customers who switched mid-lease, and quiet pressure on customers through IBM salespeople. The antitrust implications were noted by the U.S. Department of Justice, which had already begun antitrust proceedings against IBM in 1969. Amdahl Corporation became one of the principal exhibits in the government’s case.

Info

The IBM antitrust case, United States v. IBM, was filed in 1969 and dragged on until 1982, when the Reagan administration dropped it as “without merit.” The case occupied enormous resources on both sides — IBM deployed hundreds of lawyers and produced millions of pages of documents — and its resolution (or abandonment) left the question of IBM’s competitive practices legally unanswered. Amdahl Corporation’s success in the plug-compatible mainframe market was taken, by those outside IBM, as practical evidence that IBM had indeed been overcharging for computing power.

Amdahl Corporation was profitable through the 1980s, reaching approximately $2 billion in annual revenues at its peak. The strategy depended on IBM maintaining a stable architecture that Amdahl could be compatible with, and on IBM’s pricing remaining high enough to leave a margin for a competitor. Both conditions held through the 1980s.

Trilogy Systems and the Failed Bet on Wafer-Scale Integration

In 1980, Amdahl left his own company to pursue an even more ambitious technical vision: Trilogy Systems. Trilogy’s goal was to build extremely high-performance computers using wafer-scale integration — rather than cutting a silicon wafer into individual chips, build an entire circuit on a single wafer, with multiple redundant copies of each functional unit and on-wafer routing to work around manufacturing defects.

Warnung

Wafer-scale integration had been an engineering dream since the early 1970s. The economics were appealing: a single wafer-scale circuit would eliminate the packaging and interconnect overhead of chip-to-chip connections, potentially enabling much faster systems. The practical problem was yield. Even the best semiconductor processes have some fraction of defective transistors per unit area. On a small chip, you either get a working chip or you discard it; the good chips far outnumber the defective ones. On a wafer-scale device, no circuit the size of a wafer is free of defects, and the complexity of routing around defects reliably enough to produce a functioning system was never solved. Trilogy raised $230 million — one of the largest venture capital rounds of its era — and spent most of it before concluding that the wafer-scale integration approach was not manufacturable. Amdahl returned to Amdahl Corporation in 1984. Trilogy became a cautionary study in the gap between elegant engineering concepts and manufacturing reality.

Legacy

Amdahl died on November 10, 2015, at ninety-two, in Palo Alto. He had spent sixty years building some of the most capable and influential computers of each era — the 704, Stretch, the System/360, the 470 — and had contributed a conceptual tool that every parallel systems designer still uses.

The System/360 architecture he designed continues to run in IBM Z-series mainframes processing the financial infrastructure of the global economy. The instruction set he specified in 1964 runs in machines whose transistors are ten thousand times smaller. The stability of the architecture across six decades is both its achievement and its limitation: the System/360 was designed before virtual memory, before multiprocessing, before the internet, and the successive extensions have not always been elegant. But it has survived, and it works, and the investment customers made in System/360 software has been preserved across generations of hardware.

Amdahl’s Law is taught in every computer architecture course. The debate it triggered — about the limits of parallelism, about how to think about the ratio of serial to parallel work, about whether the right measure is speedup at fixed problem size or throughput at variable problem size — remains live. As computing has moved from single fast processors to massively parallel GPU clusters running machine learning workloads, the question of which fraction of computation is inherently sequential has become practically urgent again, sixty years after Amdahl asked it.

The System/360 project and its role in IBM’s dominance is covered in The Supercomputer Era. The semiconductor context of Amdahl’s career is in The Integrated Circuit Revolution.

📚 Sources