- Atlas
- Computer Science
- Microarchitecture
Microarchitecture
Microarchitecture is the level of computer design that sits between an instruction set architecture (ISA) — the vocabulary of instructions a program can use — and the silicon that actually executes them.
14 frameworks, from 1950 to today · Computer Architecture · Computer Science
- Hardwired control 1950-1985
- Microcode 1951-1985
- Instruction pipelining 1961-Present
- Dynamic scheduling and scoreboarding 1964-1995
- Out-of-order execution 1964-Present
- Cache hierarchy 1965-Present
- Reduced instruction set computer 1980-Present
- Branch prediction and speculative execution 1985-Present
- Superscalar processor 1990-Present
- Simultaneous multithreading 1995-Present
- Power-aware microarchitecture 2000-Present
- Hardware acceleration 2005-Present
- Multi-core processor 2005-Present
- Domain-specific accelerator microarchitecture 2007-Present
Overview
Microarchitecture is the level of computer design that sits between an instruction set architecture (ISA) — the vocabulary of instructions a program can use — and the silicon that actually executes them1. Where the ISA says what a processor must do, the microarchitecture decides how: which units exist, how instructions flow through them, how many can be in flight at once, and how the machine keeps itself busy while waiting for memory. It is the discipline that turned a processor from a device that executes one instruction at a time into one that juggles hundreds of instructions, several programs, and multiple cores while staying within a power budget. Its history is a story of chasing parallelism that software could not easily express, and of repeatedly discovering that the bottleneck had moved somewhere new.
Microprogrammed control and the discipline of regularity
Early computers of the 1940s and 1950s controlled their hardware directly with logic circuits wired to perform each instruction. As instruction sets grew more elaborate, designers faced a problem: complex instructions meant complex, hard-to-debug control logic2. Maurice Wilkes proposed a solution in 1951: store the control signals as a sequence of microinstructions in a control memory, so that executing one machine instruction means running a small program of microinstructions. This was microprogrammed control, and it made control design regular and changeable — a processor's behavior could be altered by rewriting its microcode rather than rewiring it134.
IBM's System/360 family, announced in 1964, made microprogramming central to a commercial strategy: different models at different price points could share one ISA, with cheaper models using microcode to emulate instructions that costlier models implemented in hardware. The alternative, hardwired control, built each instruction's control signals directly into fixed logic2. Hardwired control was faster but inflexible; microcode was slower but easier to design and extend2. For two decades the trade-off favored microcode in most general-purpose machines, and the microcode of machines like the VAX and the Intel x86 line became a substantial engineering artifact in its own right.
Pipelining: overlapping the stages of execution
A processor that fetches, decodes, executes, and writes back one instruction before starting the next wastes most of its hardware most of the time1. Pipelining fixes this by overlapping those stages, as an assembly line does: while one instruction executes, the next is being decoded and the one after fetched1. The idea appeared in early machines — IBM's Stretch (1961) and the Atlas computer at Manchester (1962) used overlapping execution — and became standard in the 1960s and 1970s.
Pipelining introduced a new class of problem: hazards5. A data hazard occurs when an instruction needs a result the previous one has not yet produced; a control hazard occurs when a branch makes it unclear which instruction to fetch next5. Early pipelines handled data hazards by stalling or by forwarding results directly between stages, and handled branches by delaying the fetch until the branch resolved. The cost of a mispredicted branch — the pipeline flush — became a central quantity in processor design1.
The RISC argument and the load-store discipline
By the late 1970s, instruction sets had grown baroque, and microcoded implementations were struggling to keep pipelines full. In 1980 David Patterson and David Ditzel published an argument for what became known as RISC, the reduced instruction set computer: simple, fixed-length instructions that could be decoded quickly and pipelined efficiently, with memory accessed only through explicit load and store instructions. The Berkeley RISC project and John Hennessy's Stanford MIPS project built working machines around these ideas in the early 1980s, and commercial RISC processors followed.
The RISC philosophy did not merely simplify instructions; it changed what microarchitects could assume. A regular instruction format made it practical to fetch and decode several instructions per cycle, and a load-store design made it easier to schedule memory operations. The debate between RISC and the incumbent complex instruction sets was fierce, but the deeper legacy was methodological: microarchitecture became an empirical discipline, with simulators and benchmark suites used to compare designs before silicon was built.
Caches and the widening memory gap
Processors were getting faster than main memory could feed them16. The cache — a small, fast memory holding recently used data — had been proposed by Wilkes in 1965 and appeared in machines such as the IBM System/360 Model 85 (1968). Through the 1980s and 1990s, cache design became a core part of microarchitecture: multiple levels of cache, separate instruction and data caches, and replacement policies tuned to observed program behavior. The memory hierarchy meant that a processor's performance depended as much on what it could keep close as on how fast it could compute, and cache misses became a dominant source of stalls that later techniques were built to hide1.
Dynamic scheduling, scoreboarding, and out-of-order execution
A pipeline that executes instructions strictly in program order stalls whenever an instruction waits for a slow operation1. Dynamic scheduling lets the hardware reorder execution: an instruction can issue as soon as its operands are ready, even if earlier instructions are still waiting17. The CDC 6600 (1964) used a technique called scoreboarding to track dependencies and allow out-of-order execution, and IBM's System/360 Model 91 (1967) introduced register renaming and a form of out-of-order issue in its floating-point unit, using a structure that anticipated the reorder buffer.
The modern form crystallized in the 1990s. Robert Tomasulo's algorithm, developed for the IBM 360/91, used reservation stations to hold instructions until operands arrived and a common data bus to broadcast results8. The reorder buffer, described in the late 1980s and implemented in processors such as the Intel Pentium Pro (1995), let the machine execute out of order but retire results in program order, preserving the illusion of sequential execution. Register renaming removed false dependencies by giving each new write to a register a fresh physical register19. Together these made it possible to keep many instructions in flight, at the cost of substantial complexity in the hardware that tracks them.
Superscalar issue and the limits of instruction-level parallelism
Pipelining overlaps stages of different instructions; superscalar issue goes further by starting several instructions in the same cycle10. Machines like the IBM Power1 (1990) and the DEC Alpha 21064 (1992) could issue multiple instructions per cycle, and by the mid-1990s four-wide superscalar designs were common. The limit was not the width of the issue logic but the available parallelism in ordinary programs: dependencies between instructions meant that wider machines often sat idle.
Branch prediction and speculative execution were the answer to control hazards1. Instead of waiting to learn whether a branch is taken, the processor predicts and fetches down the predicted path, discarding work if the prediction was wrong111. Two-level adaptive predictors, developed in the early 1990s, used history of past branch outcomes to improve accuracy, and by the late 1990s prediction rates above 95 percent were routine. Speculation let the machine keep its pipeline full across branches, but it also meant that incorrect work was performed and thrown away — and, as became clear much later, that speculative execution could leak information through side channels12.
Simultaneous multithreading and the move to many cores
Even a wide out-of-order machine leaves execution units idle when a single program lacks parallelism. Simultaneous multithreading (SMT) lets one physical core issue instructions from several threads in the same cycle, filling those gaps113. The idea was explored in research machines in the 1990s, notably the Tera computer and the MIT T project, and reached the commercial mainstream with Intel's Hyper-Threading in 2002. SMT improved throughput on workloads with multiple threads but did not raise single-thread performance1.
The larger shift came when clock frequency stopped rising. Around the mid-2000s, power and heat limits — sometimes called the "power wall" — made it impractical to keep increasing single-core speed. The response was chip multiprocessing: putting multiple processor cores on one die114. Commercial dual-core processors appeared in 2005 from both Intel and AMD, and core counts grew steadily thereafter. This was not a new microarchitectural idea so much as a change in what microarchitecture was for: instead of extracting more parallelism from one instruction stream, designers replicated cores and relied on software to use them.
Power, dark silicon, and the end of easy scaling
As transistors shrank, the power density of chips rose faster than cooling could handle, and designers could no longer switch on all the transistors at full speed at once15. The phenomenon was named dark silicon in a 2011 paper by Michael Taylor and colleagues: a growing fraction of a chip's area would have to be powered down or run slowly at any given time. Microarchitecture responded with power-aware design — dynamic voltage and frequency scaling, clock gating, power gating of idle units, and heterogeneous cores that pair high-performance and low-power designs. The ARM big.LITTLE architecture, introduced in 2011, was one commercial expression of this idea.
Domain-specific accelerators
The most recent turn is toward specialization. If general-purpose cores can no longer get much faster, the alternative is to build hardware tailored to particular workloads. Graphics processing units were the first widely deployed accelerators, and their microarchitecture — many simple lanes executing in lockstep — influenced later designs. More recently, machine-learning accelerators such as Google's Tensor Processing Unit (deployed in 2015) built systolic arrays of multiply-accumulate units for neural-network inference, and field-programmable gate arrays and fixed-function blocks for video, cryptography, and networking became standard parts of system-on-chip designs. The microarchitectural question shifted from "how do we make one core faster?" to "which computation deserves its own silicon, and how does it connect to the rest?"
Where microarchitecture stands
Today's processors combine nearly every technique above: superscalar, out-of-order cores with deep pipelines, multi-level caches, sophisticated branch predictors, SMT, and multiple cores on a die, often alongside specialized accelerators. The open questions are shaped by the history: how to keep improving performance when frequency and voltage scaling have stalled; how to design secure speculation after side-channel attacks showed that speculative execution leaks secrets; how to manage power and heat across heterogeneous chips; and how to make accelerators programmable without losing their efficiency. The discipline that began by microcoding control signals now spends much of its effort deciding what not to compute, and where to put the silicon that remains.
References
- Microarchitecture (introduction, Relation to instruction set architecture, Multicycle microarchitecture, Instruction pipelining, Aspects, Branch prediction, Increasing execution speed, Cache, Out-of-order execution, Register renaming, Multiprocessing and multithreading), Wikipedia
- Control unit (Hardwired control unit), Wikipedia
- Microassembler, Wikipedia
- Microcode, Wikipedia
- Hazard (computer architecture), Wikipedia
- Cache hierarchy (Background), Wikipedia
- Out-of-order execution, Wikipedia
- Tomasulo's algorithm, Wikipedia
- Register renaming, Wikipedia
- Superscalar processor, Wikipedia
- Branch predictor, Wikipedia
- SWAPGS (security vulnerability) (introduction, History), Wikipedia
- Simultaneous multithreading, Wikipedia
- Multi-core processor, Wikipedia
- Dark silicon, Wikipedia
The frameworks of Microarchitecture
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1950-1985
Hardwired control
How are control signals generated for each instruction?
- 1951-1985
- 1961-Present
Instruction pipelining
How can several instructions be overlapped in execution?
- 1964-1995
Dynamic scheduling and scoreboarding
How can instructions execute as soon as their operands are ready?
- 1964-Present
Out-of-order execution
How can instructions execute out of program order safely?
- 1965-Present
- 1980-Present
Reduced instruction set computer
What instruction set makes fast pipelines practical?
- 1985-Present
Branch prediction and speculative execution
Which instruction should be fetched after a branch?
- 1990-Present
Superscalar processor
How can several instructions start in the same cycle?
- 1995-Present
Simultaneous multithreading
How can one core keep busy on several programs at once?
- 2000-Present
Power-aware microarchitecture
How can performance be gained within a power budget?
- 2005-Present
Hardware acceleration
When should specialized hardware do a computation instead of a general processor?
- 2005-Present
- 2007-Present
Domain-specific accelerator microarchitecture
How should hardware be tailored to one kind of workload?
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.
Microcode rival of Hardwired control
Hardwired control and Wilkes's microprogrammed control were the two competing ways to generate control signals for the same machines. Wilkes proposed storing control as microinstructions in 1951 precisely because wired logic for complex instruction sets was hard to design and debug, and the trade-off between the two defined control design for decades.
Carried by Maurice Wilkes.
Reduced instruction set computer reacted against Microcode
The RISC argument of Patterson and Ditzel was framed against microcoded complex instruction sets, which they held were slowing pipelines and complicating decode. RISC machines deliberately abandoned microcode for simple fixed-length instructions that could be hardwired and pipelined.
Carried by David Patterson; David Ditzel.
Branch prediction and speculative execution influenced by Instruction pipelining
Branch prediction and speculation exist to solve the control hazard that pipelining introduced: a branch makes it unclear which instruction to fetch next. Predicting the outcome and fetching down the predicted path kept pipelines full, with the misprediction flush as the cost.
Out-of-order execution grew out of Dynamic scheduling and scoreboarding
Out-of-order execution grew directly out of scoreboarding and the IBM System/360 Model 91's dynamic scheduling. Tomasulo's reservation stations and common data bus, and later the reorder buffer and register renaming, refined the dependency-tracking machinery scoreboarding had introduced.
Carried by Robert Tomasulo; IBM System/360 Model 91.
Dynamic scheduling and scoreboarding influenced by Instruction pipelining
Pipelining created the hazard problem that dynamic scheduling was built to solve: in-order pipelines stalled on dependencies and slow operations. Scoreboarding in the CDC 6600 let instructions issue as operands became ready, attacking exactly the stalls that pipelined execution exposed.
Carried by CDC 6600.
Superscalar processor influenced by Instruction pipelining
Superscalar processors extended pipelining from overlapping stages of successive instructions to starting several instructions in the same cycle. The pipelined datapath and its hazard handling were the base on which multiple-issue logic was layered.
Superscalar processor influenced by Out-of-order execution
Superscalar issue combined wide instruction fetch with the out-of-order machinery developed earlier, so that several instructions could start per cycle and execute as operands became ready. Machines such as the Power1 and Alpha 21064 built on dynamic scheduling to keep multiple issue slots busy.
Carried by IBM Power1.
Superscalar processor influenced by Reduced instruction set computer
The regular, fixed-length instruction formats of RISC made it practical to fetch and decode several instructions per cycle, a precondition for superscalar issue. Commercial superscalar processors of the early 1990s were largely RISC designs.
Carried by IBM Power1; DEC Alpha 21064.
Superscalar processor influenced by Branch prediction and speculative execution
Wide superscalar machines needed speculative fetch across branches to keep several issue slots supplied with instructions. Branch prediction, developed earlier, became a necessary companion to multiple-issue designs.
Simultaneous multithreading influenced by Superscalar processor
Simultaneous multithreading was conceived as a way to fill the idle issue slots of wide superscalar machines when a single instruction stream lacked parallelism. Research machines in the 1990s and later Hyper-Threading issued instructions from several threads into the same superscalar core.
Carried by Intel Hyper-Threading.
Multi-core processor influenced by Power-aware microarchitecture
The power wall around the mid-2000s made rising single-core frequency and complexity impractical, and chip multiprocessing was the response. Power-aware design concerns drove the shift to replicating simpler cores rather than widening one.
Hardware acceleration influenced by Cache hierarchy
Accelerators were designed with their own memory hierarchies and data-movement paths, applying cache and memory-hierarchy lessons to keep specialized units fed. The memory wall that caches addressed shaped how accelerators were organized.
Multi-core processor influenced by Superscalar processor
When power limits curbed further widening and clock scaling of superscalar cores, designers replicated cores on one die instead of extracting more instruction-level parallelism. The single-core superscalar design became the building block of chip multiprocessors.
Beyond the field
Where Microarchitecture's ideas came from in other fields, and what they led to there: the strongest 12 of 61 links.
Microcode influenced Complex instruction set computer in Instruction Set Architecture
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.
Microcode influenced Complex instruction set computer in Computer Architecture
Microprogrammed control was the implementation technique that made complex instruction sets practical, and CISC instruction sets were routinely realised in microcode.
Carried by Maurice Wilkes; IBM System/360.
Instruction pipelining led to Pipelining and instruction-level parallelism in Digital Systems
Instruction pipelining, developed from the 1960s onward (IBM Stretch, CDC 6600 scoreboarding), is the base mechanism that the later ILP work generalised into superscalar and out-of-order execution. The 1988-2005 framework treats pipelining as its foundation and extends it with multiple issue and dynamic scheduling.
Carried by Seymour Cray; CDC 6600.
Instruction pipelining led to Instruction-level parallelism in Parallel Computing
Instruction-level parallelism grew directly out of instruction pipelining: once pipelines overlapped stages, designers generalised to issuing and executing multiple instructions per cycle.
Dynamic scheduling and scoreboarding grew out of Pipelining and Instruction-Level Parallelism in Computer Architecture
Dynamic scheduling and scoreboarding grew directly out of pipelining and instruction-level parallelism as the mechanism for handling hazards that simple in-order pipelines could not. Scoreboarding was introduced with the CDC 6600 to let instructions issue out of order while preserving dependences.
Carried by Seymour Cray; CDC 6600.
Out-of-order execution grew out of Pipelining and Instruction-Level Parallelism in Computer Architecture
Out-of-order execution grew directly out of pipelining and instruction-level parallelism as the extension that lets instructions issue and complete in an order different from program order. Scoreboarding and the CDC 6600 were the first step of that development.
Carried by Seymour Cray; Robert Tomasulo.
Cache hierarchy led to Latency-Hiding Techniques in Memory Hierarchy
Latency-hiding techniques such as prefetching and multithreading were developed to cope with the latency gaps of the cache hierarchy. They grew directly out of the cache-hierarchy model.
Cache hierarchy led to Software-Managed and Heterogeneous Memory in Memory Hierarchy
Software-managed and heterogeneous memory is a refinement of the cache hierarchy, adding explicitly managed and non-uniform levels alongside caches. It grew directly out of the cache-hierarchy model.
Cache hierarchy led to Cache Coherence and Memory Consistency in Memory Hierarchy
Coherence protocols govern the cache hierarchy of a multiprocessor, so the coherence framework grew directly out of the cache hierarchy concept. Without multiple cache levels there would be nothing to keep coherent.
Cache hierarchy led to Cache coherence in Memory Hierarchy
Cache coherence grew directly out of cache hierarchy design: once several caches hold copies of the same block, a protocol is needed to keep them consistent. Coherence protocols are the multi-cache extension of the hierarchy.
Reduced instruction set computer reacted against Complex instruction set computer in Instruction Set Architecture
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.
Reduced instruction set computer reacted against Complex instruction set computer in Computer Architecture
RISC was defined by rejecting CISC: the Berkeley and Stanford groups argued that complex instruction sets and microcoded execution were the wrong path, and built simple load-store machines instead. The 1980 Berkeley RISC and 1981 Stanford MIPS papers framed themselves explicitly against the CISC tradition.
Carried by David Patterson; John Hennessy.

Microarchitecture is a planet in Nousfarer
Its city has a tower for each of these 14 frameworks. Land, walk in, and climb one concept at a time.
Land on MicroarchitectureRelated fields
Fields its ideas are linked to
- Computer Architecture 12 links
- Memory Hierarchy 11 links
- Hardware Accelerators 9 links
- Parallel Computing 8 links
- Instruction Set Architecture 7 links
- Digital Systems 5 links
- Computer Systems 4 links
- Embedded Systems 1 link
- Computer Graphics 1 link
- Graphics Rendering 1 link
- Compiler Design 1 link
- Operating Systems 1 link
More in Computer Architecture
- Computer Architecture
- Embedded Systems
- Hardware Accelerators
- Instruction Set Architecture
- Memory Hierarchy
- Parallel Computing
See where Microarchitecture sits on the Map of Human Knowledge