Computer Architecture Drills

The procedures, until they are fast

CS203 teaches each of these once, against one example, and moves on. This is the volume — thirty-three procedures from De Morgan to Amdahl’s law, on RISC-V, with questions generated fresh that never run out. Each stays green only while your recent answers hold.

Start this project See the modules

Modules: 9
Drills: 33
Build steps: 0
Time: ~6h

Walk out able to

Split a cache address, count a pipeline’s stalls, and compute an $\text{AMAT}$ — without stopping to rebuild the rule first.

What you drill

Gates, maps and wrapping

Boolean laws, canonical forms, K-maps, overflow flags.

RV32I, and the machine

Formats, fields, addresses, frames, control words.

Clocks and pipelines

State tables, critical paths, CPI, hazards, prediction.

Memory, near and far

Index and tag, AMAT, page walks, TLB reach, Amdahl.

What you get

Skills that stick

Every project mixes short lessons, focused drills and real build steps, so you finish with working code and the judgement behind it.

You will practise

Boolean laws, K-maps, two’s complement
RV32I formats, addresses and the ABI
Control words, clock periods, pipelines
Caches, page tables and Amdahl’s law

Afterwards you can

Split an address into tag, index, offset
Count the stalls a sequence really costs
Decode an RV32I word field by field
Compute an AMAT across two levels

Modules

Step by step

Each module builds on the last. Read a short lesson, drill it until it's second nature, then put it to work.

1
Read a circuit
~37 min
Push a complement through a gate, read a canonical form, and cover a map minimally.
- LessonWhat this project is for4 min
- DrillShorten it by one law10 min
- DrillCount a canonical form9 min
- DrillCover a Karnaugh map14 min
2
Arithmetic that wraps
~28 min
Read a signed pattern, say what a fixed-width add stores, and tell the two flags apart.
- DrillRead a two’s-complement pattern8 min
- DrillSay what the machine stores10 min
- DrillTell a carry from an overflow10 min
3
Controllers and datapaths
~30 min
Walk a transition table, size a state register, and read simultaneous transfers.
- DrillWalk a state-transition table13 min
- DrillSize a register or a mux8 min
- DrillRead simultaneous transfers9 min
4
The RV32I contract
~40 min
Name a format, decode a field, form an address, and extend a narrow load.
- DrillName the instruction format8 min
- DrillDecode a field from the word12 min
- DrillForm an effective address10 min
- DrillExtend a narrow load10 min
5
Assembly and the ABI
~38 min
Place a value in the right register, size a frame, shift, mask, and lay out a struct.
- DrillPlace a value in a register8 min
- DrillSize and fill a stack frame10 min
- DrillShift and mask8 min
- DrillLay out a struct in memory12 min
6
Building the processor
~34 min
State a control word, turn block delays into a clock period, and price an instruction mix.
- DrillState the control word9 min
- DrillTurn delays into a clock period13 min
- DrillPrice an instruction mix12 min
7
Keeping the pipeline full
~44 min
Count cycles and stalls, find the hazards, and price a branch that guessed wrong.
- DrillCount cycles through a pipeline9 min
- DrillFind the hazards in a sequence14 min
- DrillPrice a mispredicted branch9 min
- DrillTrace a 2-bit predictor12 min
8
The memory hierarchy
~46 min
Split an address, classify a miss, price a write policy, and average an access.
- DrillSplit an address three ways12 min
- DrillClassify a miss9 min
- DrillPrice a write policy12 min
- DrillAverage a memory access13 min
9
Translation, and its limits
~52 min
Split a virtual address, reach of a TLB, what an access does, and Amdahl’s ceiling.
- DrillSplit a virtual address11 min
- DrillWork out a TLB’s reach9 min
- DrillName what an access does10 min
- DrillClassify a dependence10 min
- DrillApply Amdahl’s law12 min