Computer Organization

Where This Course Goes

A program you run is never the program that executes. Between the source code you type and the transistor that flips, there is a stack of abstractions: instruction encodings, registers, caches, buses, devices. This course walks down that stack, one layer at a time, and shows how each layer is built out of the one below it.

The seven chapters follow the order in which the material actually builds on itself:

1. Computer System Overview — the five classic components, the layered structure of hardware and software, the stored-program principle, and the metrics that let you say whether one machine is faster than another.
2. Data Representation and Operation — number systems, sign-magnitude / one’s complement / two’s complement, character encodings, and the arithmetic and logic circuits that manipulate those bit patterns.
3. Memory Hierarchy — why registers, cache, main memory, and secondary storage are arranged the way they are, and how locality of reference makes the arrangement pay off.
4. Instruction Set — how an instruction is encoded, the addressing modes that tell the CPU where its operands live, and the CISC versus RISC design split.
5. CPU — the datapath and control unit, the single-cycle, multi-cycle, and pipelined execution models, and how modern cores overlap work to raise instruction throughput.
6. Bus System — how address, data, and control lines move information between components, and how bus bandwidth, arbitration, and timing shape the machine.
7. I/O System — devices, controllers, interrupts, and the programmed, interrupt-driven, and DMA modes through which a peripheral reaches the CPU.

Every chapter closes with exercises and reference answers, and a syllabus page collects the assessment objectives for the 408 postgraduate entrance examination.

What You Will Learn

• Read a machine on sight: given any part of a computer — a register, a cache, a bus, a device — say what problem it solves and which layer of the stack it belongs to.
• Reason about representation: convert between binary, octal, decimal, and hexadecimal; produce the sign-magnitude, one’s complement, and two’s complement forms of a signed integer; explain exactly when an addition overflows.
• Walk the instruction cycle: fetch, decode, execute, access memory, write back — and predict which stages dominate the runtime of a given loop.
• Compute performance honestly: work with clock frequency, CPI, instruction counts, MIPS, and Amdahl’s law, and explain why a higher clock frequency does not automatically mean a faster processor.
• Compare architectures on evidence: weigh CISC against RISC on code density, decode complexity, pipeline friendliness, and backwards compatibility, and explain why modern x86-64 chips internally translate to RISC-like micro-operations.

Who This Is For

• Students preparing for the 408 postgraduate entrance examination in computer science, who want the syllabus turned into readable notes instead of a list of exam points.
• Developers and engineers who want to reason about cache misses, branch prediction, memory barriers, and instruction counts rather than treating the processor as a black box.
• Readers who have written a lot of code but never had to explain what the CPU actually did with it.
• Anyone starting from scratch: every term is defined the first time it appears, and no chapter assumes knowledge from a later one.