- Atlas
- Computer Science
- Instruction Set Architecture
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
- Accumulator architecture 1945-1960
- Microcode 1951-1990
- General-register architecture 1957-Present
- Load-store architecture 1960-Present
- Complex instruction set computer 1964-Present
- Vector and SIMD Architecture 1976-Present
- Vector processor 1976-1995
- Consistency model 1979-Present
- Reduced instruction set computer 1980-Present
- Domain-specific accelerator architecture 1990-Present
- SIMD instruction set extensions 1997-Present
- Open instruction set architecture 2010-Present
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
- Instruction set architecture, Wikipedia
- Load–store architecture, Wikipedia
- Consistency model, Wikipedia
- RISC-V, Wikipedia
- Hardware acceleration, Wikipedia
- 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.
- 1945-1960
Accumulator architecture
How does a machine compute with one working register?
- 1951-1990
- 1957-Present
General-register architecture
How should a processor hold working values?
- 1960-Present
- 1964-Present
Complex instruction set computer
Should instructions be rich and powerful?
- 1976-Present
Vector and SIMD Architecture
How can one instruction do many operations?
- 1976-1995
- 1979-Present
- 1980-Present
- 1990-Present
Domain-specific accelerator architecture
What vocabulary does one workload need?
- 1997-Present
SIMD instruction set extensions
How can ordinary processors work on packed data?
- 2010-Present
Open instruction set architecture
Who should be free to build a processor?
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.
General-register architecture replaced Accumulator architecture
The accumulator's single implicit register bottlenecked multi-term expressions, and general-register designs like the IBM System/360 (1964) let instructions name any of several registers, replacing the accumulator as the working model.
Carried by IBM System/360 (1964).
Complex instruction set computer influenced by Microcode
Microprogrammed control made rich, varied instruction sets tractable to implement, enabling the CISC wave; the System/360's large instruction set was realized in microcode, and later VAX and x86 designs followed the same route.
Carried by IBM System/360 (1964); DEC VAX (1977).
Reduced instruction set computer grew out of Load-store architecture
The load-store split became a defining feature of RISC ISAs: MIPS and the Berkeley RISC designs allowed only explicit loads and stores to touch memory, making single-cycle pipelined execution feasible.
Carried by David Patterson; John Hennessy.
Reduced instruction set computer reacted against Complex instruction set computer
RISC arose as a direct attack on CISC: studies of compiled code showed complex instructions and addressing modes were rarely used and slowed the common cases, so RISC advocates argued for few, simple, fixed-length instructions instead.
Carried by John Hennessy; David Patterson; John Cocke.
SIMD instruction set extensions grew out of Vector and SIMD Architecture
SIMD instruction set extensions are the direct descendant of vector/SIMD architecture: Intel's MMX (1997) and SSE (1999) brought packed-data instructions to ordinary PCs, following the same one-instruction-many-data principle.
Carried by Intel MMX (1997); Intel SSE (1999).
Open instruction set architecture grew out of Reduced instruction set computer
RISC-V was begun at Berkeley in 2010 as an open ISA built directly on the RISC tradition, reusing the reduced, load-store, register-based design principles of the earlier RISC machines.
Carried by RISC-V (2010).
Reduced instruction set computer grew out of General-register architecture
RISC machines kept the general-register model but simplified it: fixed-length instructions operating on registers, with the compiler scheduling work, grew out of the register-based designs of the 1960s.
Carried by John Hennessy; David Patterson.
SIMD instruction set extensions grew out of Vector processor
Vector processors demonstrated that regular array workloads map onto wide instructions; SIMD extensions carried that lesson into scalar ISAs as short packed registers when full vector machines faded.
Carried by Intel MMX (1997).
Domain-specific accelerator architecture influenced by Vector and SIMD Architecture
Graphics and signal-processing accelerators built on the SIMD principle of applying one operation to many data items, carrying packed-parallel execution into specialized instruction sets.
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.
Microcode influenced Complex instruction set computer in Computer Architecture
Microcode made complex instruction sets economically feasible, since CISC instructions were implemented as microprograms; the IBM System/360 used microprogrammed control throughout.
Carried by Maurice Wilkes; IBM System/360.
General-register architecture influenced Register allocation and instruction scheduling in Compiler Design
Register allocation exists as a compiler problem because general-register architectures replaced accumulator machines, forcing compilers to map many virtual values onto a small fixed set of registers. Graph-colouring allocation and later scheduling work are defined against that register file.
Carried by John Cocke; Gregory Chaitin.
Complex instruction set computer provoked Reduced instruction set computer in Microarchitecture
RISC arose as a direct attack on the complex instruction set approach, arguing that compiler-generated simple instructions outperformed microcoded complex ones. The Berkeley RISC project and the Stanford MIPS project were the vehicles of that rejection.
Carried by David Patterson; John Hennessy.
Complex instruction set computer influenced by Microcode in Microarchitecture
CISC microarchitectures relied on microcoded control stores to expand complex instructions into elementary operations. The microprogramming technique made the rich CISC instruction sets practical.
Carried by Maurice Wilkes.
Complex instruction set computer influenced by Microcode in Computer Architecture
CISC instruction sets were implemented largely through microcode, with complex instructions expanded into microinstruction sequences in a control store. The microprogramming technique made the rich CISC instruction sets practical.
Carried by Maurice Wilkes.
Complex instruction set computer provoked Reduced instruction set computer in Computer Architecture
RISC was defined in opposition to the complex instruction set computers of the 1960s and 1970s, arguing that large microcoded instruction sets were the wrong direction. The Berkeley and Stanford RISC projects framed their designs as a rejection of CISC complexity.
Carried by David Patterson; John L. Hennessy.
Complex instruction set computer provoked Reduced instruction set computer in Computer Systems
RISC defined itself in opposition to the complex instruction set computer tradition, arguing that compiler-generated simple instructions outperform microcoded complex ones.
Carried by David Patterson; David Ditzel.
Vector processor influenced Vectorized and compiled execution in Query Processing
Vectorized execution in databases is directly modeled on SIMD vector instruction sets, processing tuples in batches to exploit wide registers and reduce interpretation overhead. The X100 work framed its execution model in terms of vector instructions.
Carried by Marcin Zukowski; Peter Boncz.
Consistency model influenced Cache Coherence and Memory Consistency in Memory Hierarchy
Consistency models such as sequential consistency were formulated in the late 1970s for shared-memory multiprocessors and were then taken up by the cache-coherence and memory-consistency work of the 1980s. The coherence framework adopted the consistency-model vocabulary and questions.
Carried by Leslie Lamport.
Reduced instruction set computer reacted against Complex instruction set computer in Computer Architecture
RISC arose as a direct rejection of CISC complexity, arguing that complex instructions and microcode were unnecessary and harmful. Patterson and Ditzel's case for RISC was framed against the prevailing complex instruction set designs.
Carried by David Patterson; David Ditzel.
Domain-specific accelerator architecture led to Hardware acceleration in Microarchitecture
Hardware acceleration grew directly out of domain-specific accelerator architecture: the later movement generalized the practice of building specialized units for particular workloads into a broad design strategy. The earlier accelerator designs supplied the template.
SIMD instruction set extensions grew out of SIMD architectures in Parallel Computing
SIMD instruction set extensions are the direct descendant of SIMD architectures, bringing the data-parallel execution model into general-purpose processors as instruction-level extensions. The array-processor idea was reincarnated as packed registers and vector instructions.

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 ArchitectureRelated fields
Fields its ideas are linked to
- Computer Architecture 17 links
- Computer Systems 9 links
- Microarchitecture 7 links
- Compiler Design 7 links
- Digital Systems 4 links
- Hardware Accelerators 3 links
- Distributed Algorithms 2 links
- Memory Hierarchy 2 links
- Parallel Computing 1 link
- Query Processing 1 link
- Language Design 1 link
- Programming Languages 1 link
More in Computer Architecture
- Computer Architecture
- Embedded Systems
- Hardware Accelerators
- Memory Hierarchy
- Microarchitecture
- Parallel Computing
See where Instruction Set Architecture sits on the Map of Human Knowledge