Seyed Masoud Hosseini · Overview · Study log · Weekly summaries · Ideas · Search · Transcript · RSS feed

Digital Design & Computer Architecture · Lecture 9 of 37 · 1:50:31

Lecture 7: Von Neumann Model & Instruction Set Architectures

Study guide

What this lecture covers

This lecture opens the computer-architecture portion of the course after three weeks of digital design. It asks how a computer actually executes a program: what components does it need, how does it represent instructions as bits, and how does it step through them one at a time? The lecture builds from Von Neumann's 1946 model up to concrete instruction encodings in two example instruction set architectures (ISAs), LC-3 and MIPS, and ends by walking through how a single instruction moves through fetch, decode, and execute stages in hardware.

By the end, you can describe the five components of the Von Neumann model, explain memory addressing concepts (address space, addressability, byte vs. word addressing, endianness), read and hand-encode simple LC-3 and MIPS instructions, and trace how the LC-3 microarchitecture executes an ADD or LDR instruction using registers, an ALU, and a finite state machine controller.

Key ideas

Von Neumann model: a computing model with five components — memory, a processing unit, input, output, and a control unit — where memory holds both instructions and data with no inherent distinction between them.
Stored-program and sequential execution: the two defining properties of Von Neumann machines — instructions live in memory as data, and the program counter normally advances sequentially except for control-flow instructions.
Address space and addressability: address space is the number of uniquely addressable locations; addressability is how many bits each address refers to (for example LC-3 is word-addressable with 16-bit words, MIPS is byte-addressable).
Registers as fast temporary storage: a small register file sits next to the ALU so intermediate results don't need slow round-trips to main memory.
Opcode and operand: every instruction encodes what to do (opcode) and what to do it to (operand), with the exact bit layout defined by the ISA specification.
Endianness: big-endian stores the most significant byte at the lowest address, little-endian stores the least significant byte there; it only matters when systems using different conventions communicate.
Instruction processing cycle: fetch, decode, evaluate address, fetch operand, execute, store result — not every instruction uses every phase (for example ADD skips address evaluation).
Control-flow instructions: instructions like jump can load a new value directly into the program counter, letting execution deviate from strict sequential order.

Walkthrough

From digital design to computer architecture (4:50)

The lecture marks the transition from digital design (transistors, gates, sequential circuits, timing) to computer architecture, and introduces the plan: the Von Neumann model today, instruction set architectures using LC-3 and MIPS as running examples, and assembly programming starting the next lecture, before microarchitecture begins the following week.

The Von Neumann model (9:56)

John Von Neumann's 1946 model is introduced as the dominant (though not only) model for general-purpose computing: memory, a processing unit, input, output, and a control unit. Memory stores programs and data indistinguishably as bits; the control unit is what decides, based on context, whether a given memory location is being treated as an instruction or as data.

Memory: addressing and endianness (15:03)

The lecture defines address space (LC-3: 2^16, MIPS: 2^32) and addressability (bit-, byte-, or word-addressable), and works through examples of word-addressable versus byte-addressable memory layouts. It also covers big-endian versus little-endian byte ordering — using Gulliver's Travels' "Big-Endian"/"Little-Endian" egg-breaking factions as the historical reference for the terms — and explains that the convention only matters when systems with different endianness exchange data.

The processing unit and registers (30:13)

Building on the previously designed ALU, the lecture introduces the register file as fast temporary storage close to the ALU, contrasting it with slow, large main memory. LC-3 has 8 general-purpose registers (R0-R7, 3-bit IDs); MIPS has 32 (r0-r31, 5-bit IDs), which makes MIPS registers cheaper to access but its instruction encodings larger. Register allocation — deciding what lives in registers versus memory — is described as a compiler's job in high-level languages, or the assembly programmer's job otherwise.

The control unit and architectural state (37:21)

The control unit is described as the "conductor" that sequences instruction execution using the instruction register (holds the current instruction's bits) and the program counter (holds the address of the current or next instruction). Together, memory, registers, and the program counter make up the architectural state visible to the programmer. The lecture previews the full LC-3 Von Neumann datapath diagram, pointing out the ALU, register file, instruction register, program counter, control finite state machine, and the tri-state buffer that gates ALU results onto the processor bus.

Instruction formats and encoding (1:07:34)

Every instruction is built from an opcode (what to do) and operands (what to do it to). The lecture hand-encodes an LC-3 ADD instruction (4-bit opcode, three register fields) and a byte-addressable LDR (load register) instruction using base-plus-offset addressing, then contrasts them with the equivalent MIPS R-type (register-register, with an opcode plus function field) and I-type (immediate) encodings, which use more bits for a larger register file and a 16-bit immediate field.

The instruction processing cycle (1:24:47)

The lecture defines the six possible phases of executing an instruction — fetch, decode, evaluate address, fetch operand, execute, store result — and notes that not every instruction needs every phase (ADD skips address evaluation, LDR skips the ALU execute step). It then walks the LC-3 microarchitecture's finite state machine through fetching an instruction (loading the memory address register from the program counter, reading memory into the memory data register, then into the instruction register), decoding it via a 4-to-16 decoder on the opcode bits, and executing ADD and LDR by routing values through the ALU, register file, and processor bus under specific control signals.

Changing the sequence of execution (1:46:05)

The lecture closes with control instructions, which load a new value into the program counter instead of letting it increment sequentially. It shows LC-3's unconditional jump (JMP, register addressing: PC gets the value in a base register) and MIPS's jump (J-type: opcode plus a 26-bit target combined with the top bits of the incremented PC and multiplied by four for word alignment), noting these are what let programs implement branches, function calls, and returns instead of running strictly instruction-after-instruction.

Before you watch

Be comfortable with the ALU, register, decoder, and finite state machine designs from the digital design portion of the course, since this lecture reuses them directly.
Review binary and hexadecimal number representation, used throughout for instruction encoding.
Recall tri-state buffers and bus-based data movement, used to explain how values move between the ALU, memory, and register file on the processor bus.

Check your understanding

Why does memory contain no inherent distinction between "instructions" and "data," and what determines how a given bit pattern is interpreted?
If a memory is word-addressable with a 16-bit word versus byte-addressable with an 8-bit byte, how does the address needed to reach the same data element change?
Why does a big-endian and little-endian system only run into trouble when they communicate with each other, not when each operates on its own?
Which phases of the instruction processing cycle does an ADD instruction skip, and which does an LDR (load register) instruction skip? Why?
Why do MIPS instructions need more encoding bits for registers than LC-3 instructions, and what tradeoff does that reflect?

Vocabulary

Von Neumann model (noun): A basic computer design with five parts: memory, a processing unit, input, output, and a control unit.
Almost every modern computer follows the Von Neumann model.
stored-program (adjective): Describes a computer where instructions are kept in memory just like data.
A stored-program computer treats instructions and data the same way in memory.
instruction set architecture (ISA) (noun): The set of instructions and rules a processor understands and follows.
LC-3 and MIPS are two example instruction set architectures.
fetch-decode-execute (phrase): The repeating cycle a processor uses to get, understand, and run each instruction.
Every instruction goes through the fetch-decode-execute cycle.
address space (noun): The total number of distinct memory locations a system can address.
LC-3 has an address space of 2 to the 16th locations.
addressability (noun): How many bits of data each single memory address refers to.
LC-3 is word-addressable, while MIPS is byte-addressable.
byte-addressable (adjective): Describes memory where each address points to exactly one byte.
MIPS memory is byte-addressable.
word-addressable (adjective): Describes memory where each address points to one full word, larger than a byte.
LC-3 memory is word-addressable with 16-bit words.
endianness (noun): The order in which a multi-byte number's bytes are stored in memory.
Endianness only matters when systems with different conventions exchange data.
big-endian (adjective): Describes storing the most significant byte of a number at the lowest memory address.
A big-endian system stores the largest byte first.
little-endian (adjective): Describes storing the least significant byte of a number at the lowest memory address.
A little-endian system stores the smallest byte first.
register file (noun): A small group of fast storage locations inside the processor, next to the ALU.
The register file holds values the ALU needs quickly.
ALU (noun): The circuit inside a processor that performs arithmetic and logic operations.
The ALU adds two register values together.
register allocation (noun): Deciding which values are kept in fast registers versus slower main memory.
A compiler performs register allocation for a high-level program.
control unit (noun): The part of a processor that sequences and controls instruction execution.
The control unit decides which signals to activate at each step.
instruction register (noun): A register that holds the bits of the instruction currently being executed.
The fetched instruction is loaded into the instruction register.
program counter (noun): A register that holds the address of the current or next instruction to run.
The program counter normally increases after each instruction.
architectural state (noun): All the memory, register, and program-counter values visible to a programmer.
Memory, registers, and the program counter together form the architectural state.
opcode (noun): The part of an instruction that says what operation to perform.
The opcode tells the processor to add two numbers.
operand (noun): A value or register that an instruction's operation acts on.
The instruction's operand specifies which registers to add.
base-plus-offset addressing (noun): A way of finding a memory address by adding a fixed offset to a base register's value.
The LDR instruction uses base-plus-offset addressing.
R-type instruction (noun): A MIPS instruction format that operates on values already stored in registers.
An R-type instruction combines two register values using an ALU operation.
I-type instruction (noun): A MIPS instruction format that includes a constant value directly inside the instruction.
An I-type instruction carries a 16-bit immediate value.
J-type instruction (noun): A MIPS instruction format used for jumps, containing a large target address field.
The J-type instruction encodes a 26-bit jump target.
immediate (noun): A constant value written directly inside an instruction, instead of read from a register.
The instruction adds an immediate value of five to the register.
control-flow instruction (noun): An instruction that can change the program counter to something other than the next address.
A jump is a control-flow instruction.
conductor (noun): Here, a description of the control unit as the part that directs and times all the other components.
The control unit acts like a conductor sequencing the instruction cycle.
processor bus (noun): A shared set of wires that carries data between the ALU, memory, and registers.
The ALU's result is placed on the processor bus.
decoder (noun): A circuit that converts a coded input, like an opcode, into a single active output signal.
A 4-to-16 decoder identifies which instruction the opcode represents.
sign extension (noun): Extending a small signed number to a larger bit width while keeping its value and sign correct.
The 5-bit immediate uses sign extension before the addition.

From the YouTube description

Digital Design and Computer Architecture, ETH Zürich, Spring 2025 (https://safari.ethz.ch/ddca/spring2025/)

Lecture 7: Von Neumann Model & Instruction Set Architectures
Lecturer: Prof. Onur Mutlu
Date: 13 March 2025

Lecture 7 Slides (pptx): https://safari.ethz.ch/ddca/spring2025/lib/exe/fetch.php?media=onur-ddca-2025-lecture7-vonneumann-isa-afterlecture.pptx
Lecture 7 Slides (pdf): https://safari.ethz.ch/ddca/spring2025/lib/exe/fetch.php?media=onur-ddca-2025-lecture7-vonneumann-isa-afterlecture.pdf

Recommended Reading:
====================
Intelligent Architectures for Intelligent Computing Systems
https://people.inf.ethz.ch/omutlu/pub/intelligent-architectures-for-intelligent-computingsystems-invited_paper_DATE21.pdf

A Modern Primer on Processing in Memory
https://people.inf.ethz.ch/omutlu/pub/ModernPrimerOnPIM_springer-emerging-computing-bookchapter21.pdf

RowHammer: A Retrospective
https://people.inf.ethz.ch/omutlu/pub/RowHammer-Retrospective_ieee_tcad19.pdf

RECOMMENDED LECTURE VIDEOS & PLAYLISTS:
========================================
Computer Architecture Fall 2021 Lectures Playlist:
https://www.youtube.com/watch?v=4yfkM_5EFgo&list=PL5Q2soXY2Zi-Mnk1PxjEIG32HAGILkTOF

Computer Architecture Fall 2022 Lectures Playlist:
https://www.youtube.com/watch?v=BIpPTqHK-Lc&list=PL5Q2soXY2Zi-cAls3cyauNzM7-74Eq31O

Digital Design and Computer Architecture Spring 2022 Livestream Lectures Playlist:
https://www.youtube.com/watch?v=cpXdE3HwvK0&list=PL5Q2soXY2Zi97Ya5DEUpMpO2bbAoaG7c6

Digital Design and Computer Architecture Spring 2021 Livestream Lectures Playlist:
https://www.youtube.com/watch?v=LbC0EZY8yw4&list=PL5Q2soXY2Zi_uej3aY39YB5pfW4SJ7LlN

Featured Lectures:
https://www.youtube.com/watch?v=jVYCchBGNVc&list=PL5Q2soXY2Zi8VrmOTz44l2WupethSdh-M&index=1

Interview with Professor Onur Mutlu:
https://www.youtube.com/watch?v=8ffSEKZhmvo&list=PL5Q2soXY2Zi8VrmOTz44l2WupethSdh-M&index=9

The Story of RowHammer Lecture:
https://www.youtube.com/watch?v=sgd7PHQQ1AI&list=PL5Q2soXY2Zi8D_5MGV6EnXEJHnV2YFBJl&index=39

Accelerating Genome Analysis Lecture:
https://www.youtube.com/watch?v=r7sn41lH-4A&list=PL5Q2soXY2Zi8D_5MGV6EnXEJHnV2YFBJl&index=41

Memory-Centric Computing Systems Tutorial at IEDM 2021:
https://www.youtube.com/watch?v=H3sEaINPBOE&list=PL5Q2soXY2Zi8D_5MGV6EnXEJHnV2YFBJl&index=35

Intelligent Architectures for Intelligent Machines Lecture:
https://www.youtube.com/watch?v=GTieZPY4Wmc&list=PL5Q2soXY2Zi8D_5MGV6EnXEJHnV2YFBJl&index=38

Computer Architecture Fall 2020 Lectures Playlist:
https://www.youtube.com/watch?v=c3mPdZA-Fmc&list=PL5Q2soXY2Zi9xidyIgBxUz7xRPS-wisBN

Digital Design and Computer Architecture Spring 2020 Lectures Playlist:
https://www.youtube.com/watch?v=AJBmIaUneB0&list=PL5Q2soXY2Zi_FRrloMa2fUYWPGiZUBQo2

Public Lectures by Onur Mutlu, Playlist:
https://www.youtube.com/watch?v=kgiZlSOcGFM&list=PL5Q2soXY2Zi8D_5MGV6EnXEJHnV2YFBJl

Computer Architecture at Carnegie Mellon Spring 2015 Lectures Playlist:
https://www.youtube.com/watch?v=zLP_X4wyHbY&list=PL5PHm2jkkXmi5CxxI7b3JCL1TWybTDtKq

Rethinking Memory System Design Lecture @stanfordonline :
https://www.youtube.com/watch?v=F7xZLNMIY1E&list=PL5Q2soXY2Zi8D_5MGV6EnXEJHnV2YFBJl&index=4

← Lecture 6: Timing & Verification II · Lecture 8: Instruction Set Architectures II →