Inside the CPU (Years 8–11) — Computer Science

The von Neumann architecture, the fetch-decode-execute cycle, and the registers that make it work.

Deep inside every computer — your phone, a games console, the till at a shop — sits a small slab of silicon that does the actual thinking: the CPU, or Central Processing Unit. It has no idea what a game or a spreadsheet is. It only knows how to fetch a tiny instruction, work out what it means, do it, and then reach for the next one — billions of times a second.

Why this matters: Everything a computer does — every pixel drawn, every sum, every text sent — is the CPU repeating one simple loop at blinding speed. Understand that loop and the "magic" of computers turns into something you can actually explain.

The fetch–decode–execute cycle repeats endlessly.

The von Neumann design

One memory holds both instructions and data; the CPU fetches over a shared bus.

Almost every computer follows a blueprint from 1945 called the von Neumann architecture. Its big idea is simple but powerful: program instructions and data are stored together in the same memory. Think of a recipe book left open on the kitchen counter — both the steps to follow and the ingredients list live in one place, and the cook keeps glancing back at it. The CPU is that cook, fetching one line of the recipe at a time.

Inside the CPU: the key parts

The CPU's parts: a Control Unit and ALU served by four key registers.

The CPU is not one blob — it has specialist parts, and many of them are tiny, super-fast stores called registers. A register is like a sticky note in the cook's hand: it holds just one value, right now, ready to use.

Part	Job
Control Unit (CU)	Directs everything; decodes instructions and sends signals
Arithmetic Logic Unit (ALU)	Does the maths (+, −) and logic (AND, comparisons)
Program Counter (PC)	Holds the address of the next instruction
Memory Address Register (MAR)	Holds the address being read from or written to
Memory Data Register (MDR)	Holds the data just fetched from, or going to, memory
Accumulator (ACC)	Holds the result of ALU calculations

The fetch–decode–execute cycle

This is the loop the CPU never stops running:

Worked example — one trip round the cycle:

During fetch the PC is incremented — 20 becomes 21, ready for next time.

1. Fetch: The PC says the next instruction is at address 20. That address copies into the MAR, memory is read, and the instruction lands in the MDR. The PC ticks up to 21.
2. Decode: The Control Unit looks at the instruction and works out it means "ADD the number at address 50".
3. Execute: The value is fetched, the ALU adds it to whatever is in the Accumulator, and the answer stays in the ACC.
Then it starts again at address 21.

Common mistake: The Program Counter does not store the current instruction — it stores the address of the next one. The instruction itself sits in the MDR after being fetched.

Tip: remember the cycle as three words in order — Fetch, Decode, Execute — and picture the cook glancing at the recipe, understanding the step, then doing it. Everything else the CPU does is just this, repeated billions of times a second.