Instruction Set Architecture

An instruction set architecture (ISA) is the vocabulary a processor offers to software: the instructions it can execute, the registers where it keeps working values, and the rules for how memory is read and written.

12 frameworks, from 1945 to today · Computer Architecture · Computer Science

still a working view ended · each leads to its entry below

Overview

An instruction set architecture (ISA) is the vocabulary a processor offers to software: the instructions it can execute, the registers where it keeps working values, and the rules for how memory is read and written1. It is a contract. A program written to an ISA should run on any chip that honors it, whatever the silicon underneath looks like1. That separation — between what the machine promises and how it delivers — is what makes software portable and hardware free to change. The history of ISA is the history of deciding what that contract should say, and of discovering, again and again, that the answer depends on what the machine is for.

Accumulators and the first stored-program machines

The earliest electronic computers had no general registers at all. The EDVAC design, circulated by John von Neumann in 1945, and the machines built from it in the late 1940s and early 1950s, organized computation around a single special register called the accumulator. Arithmetic instructions implicitly took one operand from the accumulator and one from memory, and left the result in the accumulator. A program was a long sequence of load, add, store.

This was a genuine simplification: with one implicit operand, instructions could be short, and the hardware needed only one fast register. The Manchester Baby (1948) and EDSAC (1949) worked this way, as did the IBM 701 (1952). But the accumulator became a bottleneck. Every operation had to pass through one register, and expressions with several terms forced extra loads and stores just to shuffle values in and out. The cost was visible to programmers, who wrote around it by hand.

General registers and the load-store split

The fix was to give the programmer several registers and let instructions name them. General-register architectures appeared in the late 1950s and 1960s. The IBM 709 (1957) had three index registers; the PDP-1 (1959) and especially the IBM System/360 (1964) made a bank of general-purpose registers central. Now an instruction could say "add register 3 to register 7," and intermediate values could live in registers instead of memory.

A sharper distinction emerged alongside: whether arithmetic instructions could reach memory directly. In a load-store architecture, only explicit load and store instructions touch memory; all arithmetic works register-to-register2. The alternative, common in early machines, let an add instruction take a memory operand. Load-store designs made instruction decoding and timing more regular, and they became the norm for the reduced-instruction-set machines of the 1980s. The System/360 is the landmark case of the other choice: a single ISA spanning a whole family of machines from small to large, so that customers could buy a small model and later upgrade without rewriting software. That family concept — one contract, many implementations — is the idea the whole field rests on.

Microprogrammed control and the rise of complexity

Through the 1960s, instruction sets grew. Designers added instructions for decimal arithmetic, string handling, and ever more addressing modes, reasoning that moving work from software into hardware made programs smaller and machines easier to program. The System/360 had a large, varied instruction set for exactly this reason.

Implementing such a set in fixed logic was painful, because each instruction needed its own tangle of gates. The solution, associated with Maurice Wilkes (who described microprogramming in 1951) and brought to production in the 1960s, was microprogrammed control: the processor's behavior was driven by a small internal program — microcode — stored in a control memory. Each machine instruction was broken into a sequence of microinstructions. This made complex instruction sets tractable to build and, crucially, made them changeable: a bug in an instruction could be fixed by patching microcode rather than redesigning silicon. By the 1970s, microprogramming was the standard way to build a processor, and it enabled the wave of complex instruction set computing (CISC) — machines like the DEC VAX (1977) and the Intel 8086 family (1978 onward), whose rich instruction sets aimed to close the gap between high-level languages and hardware.

The RISC argument

By the late 1970s, a counter-argument formed. Studies of compiled programs — notably by John Hennessy's group at Berkeley and by the IBM 801 project under John Cocke — suggested that compilers rarely used the fancy instructions, and that the complex instructions and addressing modes were slowing down the common ones. Microcode took time to sequence, and a large decoder consumed chip area that could have gone to registers and caches.

The reduced instruction set computing (RISC) response, articulated in the early 1980s by Hennessy at Berkeley (the RISC I and II) and by David Patterson at Stanford (MIPS), was to make instructions simple, fixed-length, and few, so that each could be executed in a single cycle and the hardware could be pipelined — overlapping the execution of successive instructions. Simple instructions also made compilers' job clearer: the compiler, not the hardware, would schedule the work. The debate was real and contested. CISC supporters pointed out that smaller code mattered when memory was scarce, and that microcode let a machine offer powerful operations cheaply. RISC supporters pointed to measured performance and simpler, faster silicon. Over the 1980s and 1990s the RISC ideas largely won on performance, and even CISC vendors adopted them internally: modern x86 processors decode their complex instructions into simple internal operations before executing them.

Vector and SIMD: doing many things at once

A separate line of development attacked a different limit: one instruction, one operation. Vector architectures, pioneered by Seymour Cray's machines — the Cray-1 (1976) is the emblem — let a single instruction operate on a whole array of numbers held in vector registers. Scientific code, full of loops over arrays, mapped onto these instructions naturally, and the hardware could pipeline the element-by-element work. The idea faded from general-purpose machines but never died.

Its descendant is SIMD (single instruction, multiple data): instructions that apply the same operation to several packed values at once. Intel's MMX (1997) and SSE (1999) brought this to ordinary PCs, and it is now universal, from x86's AVX to ARM's NEON. The lesson carried forward: when a workload has regular parallelism, widening the instruction to cover several data items at once buys speed without more instructions.

Memory consistency: the rules of the shared well

As machines gained caches and multiple processors, a new question entered the contract: when one processor writes a value, when must another see it? A memory consistency model is the answer — the set of rules a programmer can rely on about the order in which memory operations become visible3. A sequential consistency model, formalized by Leslie Lamport in 1979, says all operations appear in one global order, as if on a single machine. That is easy to reason about but expensive to enforce. Weaker models — total store order, release consistency, and others — relax the rules to let hardware reorder operations for speed, at the cost of requiring programmers to insert explicit synchronization. The choice is a genuine trade-off written into the ISA, and it became central as multicore processors spread in the 2000s.

Open ISAs and the accelerator turn

Two late developments reshaped who controls the contract. The first is open instruction set architecture: ISAs published freely for anyone to implement. The most consequential is RISC-V, begun at Berkeley in 2010, which descends directly from the RISC tradition and lets companies and researchers build processors without licensing a proprietary design4. Its rise reflects a shift in where innovation happens — not only in the largest firms.

The second is the domain-specific accelerator: rather than one general ISA for everything, build specialized instruction sets or coprocessor interfaces for a narrow job5. Graphics processors, digital signal processors, and, in the 2010s, machine-learning accelerators all embody this. The ISA question becomes "what vocabulary does this workload need?" — a return, in a sense, to the CISC instinct that the instruction set should fit the task, but now aimed at narrow domains rather than general programs.

Where the field stands

Today the main approaches coexist rather than compete to extinction. General-purpose processors are RISC-like internally, whether they present a RISC ISA (ARM, RISC-V) or a CISC one (x86) that is decoded into simple operations6. SIMD extensions are standard everywhere. Memory consistency models are explicit parts of every serious ISA. Open ISAs and domain-specific accelerators are the fastest-moving frontiers. The open questions are the old ones in new dress: how much complexity belongs in the contract versus the compiler, how to specify memory behavior precisely enough to program against without over-constraining hardware, and how far specialized vocabularies can go before the portability that made the ISA idea valuable in the first place begins to erode.

References

  1. Instruction set architecture, Wikipedia
  2. Load–store architecture, Wikipedia
  3. Consistency model, Wikipedia
  4. RISC-V, Wikipedia
  5. Hardware acceleration, Wikipedia
  6. Microcode, Wikipedia

The frameworks of Instruction Set Architecture

Each framework is a way of working the field has used: when it held, and the question it answers.

  1. 1945-1960

    Accumulator architecture

    How does a machine compute with one working register?

    Fly to its tower in Nousfarer

  2. 1951-1990

    Microcode

    How can complex instructions be built and changed?

    Fly to its tower in Nousfarer

  3. 1957-Present

    General-register architecture

    How should a processor hold working values?

    Fly to its tower in Nousfarer

  4. 1960-Present

    Load-store architecture

    Which instructions may touch memory directly?

    Fly to its tower in Nousfarer

  5. 1964-Present

    Complex instruction set computer

    Should instructions be rich and powerful?

    Fly to its tower in Nousfarer

  6. 1976-Present

    Vector and SIMD Architecture

    How can one instruction do many operations?

    Fly to its tower in Nousfarer

  7. 1976-1995

    Vector processor

    How can whole arrays be processed at once?

    Fly to its tower in Nousfarer

  8. 1979-Present

    Consistency model

    When must one processor see another's writes?

    Fly to its tower in Nousfarer

  9. 1980-Present
  10. 1990-Present
  11. 1997-Present

    SIMD instruction set extensions

    How can ordinary processors work on packed data?

    Fly to its tower in Nousfarer

  12. 2010-Present

How the ideas connect

Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.

Accumulator architectureMicrocodeGeneral-register architectureLoad-store architectureComplex instruction set computerVector and SIMD ArchitectureVector processorConsistency modelReduced instruction set computerDomain-specific accelerator architect…SIMD instruction set extensionsOpen instruction set architecture

Beyond the field

Where Instruction Set Architecture's ideas came from in other fields, and what they led to there: the strongest 12 of 55 links.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

Instruction Set Architecture is a planet in Nousfarer

Its city has a tower for each of these 12 frameworks. Land, walk in, and climb one concept at a time.

Land on Instruction Set Architecture

Related fields

Fields its ideas are linked to

More in Computer Architecture

See where Instruction Set Architecture sits on the Map of Human Knowledge