In 1974, researcher John Cocke and his team at IBM Research began work on designing a controller for a telephone exchange. They wound up creating the first prototype computer employing a reduced instruction set computer (RISC) architecture. The new architecture design enabled computers to run much faster than was previously possible, and is still used in nearly every computational device today.
John Cocke was considered a brilliant man whose deep understanding of computer hardware and software, and the way they interact, made it possible for him to see innovative solutions to problems in many different fields. He was often found walking from office to office at IBM, engaging colleagues in insightful discussions about their current project, even if it was not his specialty. He always seemed to be one step ahead of everyone else, leading them forward in their work by talking through the details. As Harwood Kolsky recalls, “He would sort of go from one room to another, and from one lab to another, you know, spreading ideas and trailing cigarette ashes as he went along.”
His ability to look at things differently led Cocke to the concept of RISC architecture. At the time, the complex instruction set computer (CISC) architecture was the norm, although that name wouldn’t come about for many years. The goal of the CISC design was to complete a task in as few lines of assembly code as possible. Architects would build complex instructions directly into the hardware—a microprocessor would come with a specific instruction set in which each single instruction executed a series of operations. In this design, the compiler had to do very little work to translate a high-level language statement into assembly language.
Cocke and his team reduced the size of the instruction set, eliminating certain instructions that were seldom used. "We knew we wanted a computer with a simple architecture and a set of simple instructions that could be executed in a single machine cycle—making the resulting machine significantly more efficient than possible with other, more complex computer designs," recalled Cocke in 1987.
With the new design, the CPU was only able to execute a limited set of instructions, but it could execute them much faster because the instructions were so simple. Each task, such as fetching an instruction, accessing memory or writing data, could be completed within a single machine cycle, or electronic pulse; with CISC, tasks often required multiple machine cycles, taking at least twice as long to execute a task.
Because each instruction executed in the same amount of time, pipelining was possible. With pipelining, instructions could be set up like an assembly line with multiple instructions executing at the same time. For example, one instruction could be fetched, while another was decoded, while a third was executed and a fourth was writing the result. Each stage processed simultaneously, improving throughput for the entire workload. In addition, external memory was only accessed by load and store instructions; all other instructions were limited to internal registers. This simplified processor design opened the door to faster computation.
“The main idea is not to add any complexity to the machine unless it pays for itself by how frequently you would use it. And so, for example, a machine which was being used in a heavily scientific way, where floating point instructions were important, might make a different set of tradeoffs than another machine where that wasn't important. Similarly, one in which compatibility with other machines was important or in which certain types of networking was important would include different features. But in each case they ought to be done as the result of measurements of relative frequency of use and the penalty that you would pay for the inclusion or non-inclusion of a particular feature.”
“Computer Chronicles: RISC Computers (1986),”October 2, 1986
“With his eclectic intellect and itinerant working style, Mr. Cocke often kept dialogues going with people on different subjects that spanned months, even years. ‘He would start up a conversation with you on some detailed technical subject, plunging right in where he left off the last time he saw you a couple of months earlier,’ recalled Frances Allen, an I.B.M. researcher who collaborated with Mr. Cocke on compiler research. ‘It was one of John's traits that took a little getting used to.’”
“John Cocke, Chip Wizard From I.B.M.'s Research Labs, Dies at 77,” The New York TimesJuly 19, 2002
“They say power corrupts, but nobody told embedded-systems designers. The PowerPC processor family turns 20 years old this year, and it’s come a very long way from its beginnings in the first Power Macintosh in 1990. Today’s PowerPC has done a 180-degree turnaround: it’s no longer in Macs or any other desktop computers, but it’s going strong in embedded applications, especially networking and consumer electronics. PowerPCs are found in everything from spacecraft to Cisco routers to Ford and Jaguar engines to video games, including the “big three” of PlayStation 3, Xbox 360, and Nintendo Wii.”
“PowerPC: Twenty Years of Progress,” EE JournalJuly 27, 2010
Although IBM’s original telephone exchange controller project was terminated, Cocke and his team completed what would be the first prototype computer employing RISC architecture in 1980—dubbed the
Around the time that Cocke and his team were developing the 801, two other groups sponsored by the US Department of Defense Advanced Research Projects Agency (DARPA) were working on similar projects that employed a reduced instruction set. One was a project at the University of California, Berkeley, under the direction of David Patterson and Carlo H. Sequin—who coined the term “RISC.” The other project was led by John L. Hennessy at Stanford University.
Back at IBM, the RT PC didn’t meet with much success, but it did spur further development of the microprocessor. In 1990, IBM released the RISC System/6000, shortened to
Soon after the release of the RS/6000, IBM formed an alliance with Apple and Motorola to develop a single-chip microprocessor family based on the
In the years since the introduction of RISC architecture design, processors have advanced and become more powerful than many would have believed possible. IBM has been there along the way, driving innovation in processor design. Throughout the past 20 years, IBM’s RISC-based processors have been used in servers and routers, automobile engines and jet control systems, and even spacecraft—an IBM POWER processor was used in the onboard computer of NASA’s Mars Pathfinder from 1996 to 1997.
IBM also uses RISC-based processors in all of its supercomputers. The
Today, just about every microprocessor is based on RISC architecture. Billions of ARM RISC-based processors are shipped each year to be used in cell phones and other small devices, and PowerPC processors dominate gaming systems and the automotive area.
For his part, in 1987 John Cocke won the prestigious Turing Award given annually by the Association for Computing Machinery. “In his Turing Award paper, which is really the essence of his quest for high performance … it's quite clear that as early as 1960, he had the very clear idea in his head of what is a very high performance computer,” remembered Abe Peled. “All he had to do was wait for the technology to make it really possible.”
Selected team members who contributed to this Icon of Progress:
- Dr. John Cocke Creator of RISC and former IBM Fellow
- George Radin Managed team of engineers that worked on the IBM 801
- Joel Birnbaum Director of computer sciences; led development of first RISC computer
- Frances Allen Collaborated with John Cocke on compiler research during RISC development