Computer Architecture
What the processor is doing between one instruction and the next
For anyone who can read C and has met the operating system's view of memory, and now wants the layer beneath it: how an instruction is encoded, how the hardware executes several at once, and why the same algorithm can be an order of magnitude faster depending on how it touches memory. This course assumes a working Unix-like shell and, from the C course onwards, a C compiler and make. If you do not have those yet — or have never opened a terminal — the Setting Up course installs and verifies all of it first, and nothing here repeats that material.
Course preview
What you will be able to do
- Decode a real machine instruction into its fields by hand
- Explain what a pipeline overlaps and what stops it
- Reason about a branch's cost in terms of prediction rather than instructions
- Explain a cache miss in terms of the access pattern that caused it
- Rewrite a loop so it runs measurably faster without changing what it computes
- Read a memory specification and say what it does and does not tell you
Before you join
Course roadmap
English is available for every learning step.
This is the full learning route. Lessons build on earlier work; required checkpoints are the points where the route asks you to demonstrate it.
- 01
The contract between hardware and software
Lesson · 16 min
- 02
Two philosophies, and what actually survived
Lesson · 17 min
Builds on: The contract between hardware and software
- 03
How an instruction becomes bits
Lesson · 18 min
Builds on: The contract between hardware and software
- 04
Reading RISC-V instruction formats
Lesson · 19 min
Builds on: How an instruction becomes bits
- 05
How an instruction names its data
Lesson · 17 min
Builds on: Reading RISC-V instruction formats
- 06
Only two instructions touch memory
Lesson · 17 min
Builds on: Reading RISC-V instruction formats
- 07
Decode a real function call by hand
Required checkpoint · 20 min
Builds on: Only two instructions touch memory
- 08
The path one instruction takes through the hardware
Lesson · 19 min
Builds on: Only two instructions touch memory
- 09
What tells each part what to do
Lesson · 18 min
Builds on: The path one instruction takes through the hardware
- 10
Cycles per instruction, and why it matters
Lesson · 18 min
Builds on: The path one instruction takes through the hardware
- 11
Overlapping instructions to finish more
Lesson · 19 min
Builds on: Cycles per instruction, and why it matters
- 12
Two different questions about speed
Lesson · 17 min
Builds on: Overlapping instructions to finish more
- 13
When an instruction needs a result that is not ready
Lesson · 19 min
Builds on: Overlapping instructions to finish more
- 14
The one hazard forwarding cannot remove
Lesson · 17 min
Builds on: When an instruction needs a result that is not ready
- 15
Capstone: measuring what a wrong guess costs
Required checkpoint · 21 min
Builds on: When an instruction needs a result that is not ready
- 16
Why the same program is fast on small data and slow on large
Lesson · 18 min
Builds on: Two different questions about speed
- 17
Where a block is allowed to live
Lesson · 19 min
Builds on: Why the same program is fast on small data and slow on large
- 18
What happens on a hit, a miss, and a write
Lesson · 18 min
Builds on: Where a block is allowed to live
- 19
Capstone: making the same work run fifty times faster
Required checkpoint · 22 min
Builds on: What happens on a hit, a miss, and a write
- 20
What memory actually is, and why it is slow
Lesson · 17 min
Builds on: What happens on a hit, a miss, and a write
- 21
Why memory got wider but not closer
Lesson · 15 min
Builds on: What memory actually is, and why it is slow
- 22
When memory is the shared resource
Lesson · 17 min
Builds on: What memory actually is, and why it is slow
Learn with an account when access opens
Your CYBERSKILLS account will keep progress and checkpoint results together. Until then, this syllabus is here to help you choose the route that fits your goal.
Browse course previews