Arm Community
Arm Community
  • Site
  • User
  • Site
  • Search
  • User
Arm Community blogs
Arm Community blogs
Architectures and Processors blog RISC versus CISC Wars in the PrePC and PC Eras - Part 1
  • Blogs
  • Mentions
  • Sub-Groups
  • Tags
  • Jump...
  • Cancel
More blogs in Arm Community blogs
  • AI blog

  • Announcements

  • Architectures and Processors blog

  • Automotive blog

  • Embedded and Microcontrollers blog

  • Internet of Things (IoT) blog

  • Laptops and Desktops blog

  • Mobile, Graphics, and Gaming blog

  • Operating Systems blog

  • Servers and Cloud Computing blog

  • SoC Design and Simulation blog

  • Tools, Software and IDEs blog

Tell us what you think
Tags
Actions
  • RSS
  • More
  • Cancel
Related blog posts
Related forum threads

RISC versus CISC Wars in the PrePC and PC Eras - Part 1

David Patterson
David Patterson
September 11, 2013
3 minute read time.

This two-part blog gives a historical perspective on the ARM vs. 80x86 instruction set competition for three eras: PrePC (late 1970s/early 1980s), PC (mid 1980s to mid 2000s), and PostPC (late 2000s onward).

Round 1: The Beginning of Reduced vs. Complex Instruction Set Computers
The first round of the RISC-CISC Wars started 30 years ago with the publication of "The Case for the Reduced Instruction Set Computer" [1] and the companion piece "Comments on "The Case for the Reduced Instruction Set Computer"[2]. We argued then that an instruction set made up of simple or reduced instructions using easy-to-decode instruction formats and lots of registers was a better match to integrated circuits and compiler technology than the instructions sets of the 1970s that featured complex instructions and formats. Our counterexamples were the Digital VAX-11/780, the Intel iAPX-432, and the Intel 8086 architectures, which we labeled Complex Instruction Set Computers (CISC).

I recently found an old set of hand-drawn slides from 1981, one of which shows the simple instructions and formats of the Berkeley RISC architecture.


Benchmarking Pipelined Microprocessors versus Microcoded Microprocessors
To implement their more sophisticated operations, CISCs relied on microcode, which is an internal interpreter with its own program memory.  RISC advocates essentially argued that these simpler internal instructions should be exposed to the compiler rather than buried inside an interpreter within a chip.

RISC architects took advantage of the simpler instruction sets to first demonstrate pipelining and later superscalar execution in microprocessors, both of which had been limited to the supercomputer realm. Below are die photos of Berkeley's RISC I and RISC II, which were single-issue, five-stage pipelined, 32-bit microprocessors.


The chart below was scanned from a 1981 slide I used to summarize the Berkeley RISC results, using different cars to indicate complexity. First car wins! (The top three cars were minicomputers. The lack of a flat address space in the 8086, at the time it was hard to find a C compiler and UNIX system to benchmark the 8086.)


It's still amazing to me that there was a time when graduate students could build a prototype chip that was actually faster than what industry could build.

ARM, MIPS, and SPARC successfully demonstrated the benefits of RISC in the marketplace of the 1980s with rapidly increasing performance that kept pace with the rapid increase in transistors from Moore's Law.

Round 2: Intel Responds and Dominates in the PC Era
Although the VAX and 432 succumbed to the RISC pressure, Intel x86 designers rose to the challenge.  Binary compatibility demanded that they keep the complex instructions, so they couldn't abandon microcode. However, as RISC advocates pointed out, the most frequently executed instructions were simple instructions. Intel's solution was to have hardware translate the simple x86 instructions into internal RISC instructions, and then use whatever ideas RISC architects demonstrated with these internal simple instructions: pipelining, superscalar execution, and so on. While Intel paid a "CISC tax" with longer pipelines, extra translation hardware, and the microcode burden of the complex operations:

  • Intel's semiconductor fabrication line was ahead of what RISC companies could use, so the smaller geometries could hide some of the CISC Tax;
  • As Moore's Law led to on-chip integration of floating-point units and caches, over time the CISC Tax became a smaller fraction of the chip;
  • The increasing popularity of the IBM PC combined with distribution of software in binary format made the x86 instruction set increasingly valuable, no matter what the tax.

Wikipedia's conclusion of Round 2 of the RISC-CISC war is  "While early RISC designs were significantly different than contemporary CISC designs, by 2000 the highest performing CPUs in the RISC line were almost indistinguishable from the highest performing CPUs in the CISC line."

Given the value of x86 software and eventual performance parity, CISC monopolized the desktop in the PC era.

Conclusion
While RISC became commercially successful in Round 1, to its credit Intel responded by leveraging Moore's Law to maintain binary compatibility with PC software and embrace RISC concepts by translating to RISC instructions internally. The CISC tax was a small price to pay for the PC market.

In my next blog, we'll examine RISC-CISC Wars in the current Post-PC Era, which is based on Cloud Computing and Personal Mobile Devices like smart phones and tablets.
_________________________________________________________
[1] D. A. Patterson and D. R. Ditzel, "The Case for the Reduced Instruction Set Computer," ACM SIGARCH Computer Architecture News, 8: 6, 25-33, Oct. 1980.
[2] D. W. Clark and W. D. Strecker, "Comments on "The Case for the Reduced Instruction Set Computer", ibid, 34-38, Oct. 1980.

Anonymous
  • Garmin
    Garmin over 7 years ago

    I am getting this thing from quite a while, there I got extremely decent stuff from your website there and I imparted this to my younger sibling who is particularly similar to this sort of information and researches on them, she also chip away at her ignite when he get any up down she get help with Garmin Customer Service which is exceptionally pleasant web she found.

    • Cancel
    • Up 0 Down
    • Reply
    • More
    • Cancel
  • Tipene Darrow
    Tipene Darrow over 7 years ago

    If a long block of instructions can be executed in parallel, a future generation can execute it faster; if a block is very short, it doesn’t waste any space.

    how to delete aol account

    • Cancel
    • Up 0 Down
    • Reply
    • More
    • Cancel
  • hitachi customer service
    hitachi customer service over 7 years ago

    CISCs is an internal interpreter with its own program memory.  RISC argued these simpler internal instructions that should be exposed to the compiler rather than buried inside an interpreter within a chip. how to fabricate a chip by using CISC Microprocessors war.

    hitachi customer service

    • Cancel
    • Up 0 Down
    • Reply
    • More
    • Cancel
  • David Patterson
    David Patterson over 11 years ago
    Your comment is true about the microprocessors of the PC Era, but not sure it's true for the microprocessors for the PostPC Era. The emphasis on energy efficiency, cost, and multiple cores are leading to a simplification of the underlying architectures, so RISC is returning.
    • Cancel
    • Up 0 Down
    • Reply
    • More
    • Cancel
Architectures and Processors blog
  • Introducing GICv5: Scalable and secure interrupt management for Arm

    Christoffer Dall
    Christoffer Dall
    Introducing Arm GICv5: a scalable, hypervisor-free interrupt controller for modern multi-core systems with improved virtualization and real-time support.
    • April 28, 2025
  • Getting started with AARCHMRS Features.json using Python

    Joh
    Joh
    A high-level introduction to the Arm Architecture Machine Readable Specification (AARCHMRS) Features.json with some examples to interpret and start to work with the available data using Python.
    • April 8, 2025
  • Advancing server manageability on Arm Neoverse Compute Subsystem (CSS) with OpenBMC

    Samer El-Haj-Mahmoud
    Samer El-Haj-Mahmoud
    Arm and 9elements Cyber Security have brought a prototype of OpenBMC to the Arm Neoverse Compute Subsystem (CSS) to advancing server manageability.
    • January 28, 2025