Registers are tiny, extremely fast storage locations built directly inside the CPU. Unlike RAM, which is slower and external, registers are read and written in a single clock cycle. Each register has a dedicated role in the fetch-decode-execute cycle, and understanding them is essential for the GCSE systems architecture topic.
Why does the CPU need registers?
The CPU processes instructions at billions of cycles per second, but main memory (RAM) is far slower. If the CPU had to wait for RAM every time it needed a value, it would spend most of its time idle. Registers solve this by keeping the most immediately needed values — the current instruction, the address being accessed, the result of the last calculation — right inside the processor.
Professor Turing's analogy: imagine you are cooking a complex recipe. Your refrigerator (RAM) holds all the ingredients, but you do not run to the fridge for every pinch of salt. Instead, you keep small bowls of frequently used ingredients on your worktop (registers) — immediately to hand, no delay.
What are the key CPU registers?
| Register | Full name | Contents | Role |
|---|---|---|---|
| PC | Program Counter | Address of the next instruction | Keeps track of which instruction executes next |
| MAR | Memory Address Register | Address currently being read or written | Interface between CPU and memory bus |
| MDR | Memory Data Register | Data just read from, or about to be written to, memory | Buffer for memory transfers |
| CIR | Current Instruction Register | The instruction currently being decoded and executed | Holds the instruction while the CPU acts on it |
| ACC | Accumulator | The result of the most recent arithmetic or logic operation | Temporary store for calculations |
Some specifications call the CIR the Instruction Register (IR). These are the same component.
What does the Program Counter (PC) do?
The PC stores the memory address of the next instruction to be executed. After each instruction is fetched, the PC is automatically incremented by the size of one instruction so it points to the following instruction.
This automatic incrementing is how programs flow sequentially. A jump instruction (or branch) overrides the normal increment by loading a specific address into the PC — this is how IF, WHILE, and function calls redirect the flow of a program.
What are the MAR and MDR?
These two registers form the interface between the CPU and main memory, working together every time data is read or written.
Memory Address Register (MAR): holds the address the CPU wants to read from or write to. When the CPU needs to fetch an instruction or read a variable from RAM, it places the relevant address into the MAR. This address is then sent along the address bus to memory.
Memory Data Register (MDR): holds the actual data. On a read, RAM places the requested data on the data bus and the MDR receives it. On a write, the CPU places the data to be stored into the MDR, which then sends it along the data bus to memory at the address held in the MAR.
Think of the MAR as the delivery label (where to go) and the MDR as the package (what to deliver or collect).
What does the CIR (Current Instruction Register) hold?
Once an instruction has been fetched from memory into the MDR, it is copied into the CIR for decoding and execution. The CIR holds the instruction for the entire decode-and-execute phase.
Separating the CIR from the MDR is important: the MDR can then be used to fetch data needed by that instruction while the CIR holds the instruction safely.
How do registers work together in the fetch-decode-execute cycle?
Step-by-step trace of one instruction cycle:
| Phase | Action | Registers involved |
|---|---|---|
| Fetch 1 | Copy PC value into MAR | PC → MAR |
| Fetch 2 | Increment PC (points to next instruction) | PC ← PC + 1 |
| Fetch 3 | Read instruction at MAR address; place in MDR | Memory → MDR |
| Fetch 4 | Copy instruction from MDR into CIR | MDR → CIR |
| Decode | Control unit decodes the instruction in CIR | CIR used |
| Execute | Instruction carried out; ALU stores result in ACC | ACC updated |
After execute, the cycle repeats from Fetch 1, this time with the incremented PC pointing to the next instruction.
Frequently asked questions
Why is the accumulator called the accumulator?
The name comes from early CPU designs where the accumulator literally accumulated the running total of arithmetic operations — each addition was added to whatever was already there. Modern CPUs have many general-purpose registers rather than a single accumulator, but the term persists for the register that receives the result of ALU (Arithmetic Logic Unit) operations. In assembly language programming, many instructions implicitly read from or write to the accumulator.
What is the relationship between the MAR and the address bus?
The address bus is a set of parallel wires connecting the CPU to main memory. The number of wires determines how many different addresses can be specified — an n-bit address bus can address 2ⁿ memory locations. When the CPU places an address in the MAR, that address is transmitted along the address bus to the memory module, which activates the corresponding memory cell. The address bus is unidirectional (CPU to memory only); the data bus is bidirectional (data travels both ways).
Do all CPUs have exactly these five registers?
No. The five registers described here — PC, MAR, MDR, CIR, and ACC — are the ones required for GCSE Computer Science (particularly AQA). Real processors have many additional registers: general-purpose registers (for intermediate calculations), status registers (flags indicating overflow, zero result, etc.), stack pointers, and others. Some modern processors have hundreds of registers managed transparently by the hardware. For GCSE purposes, knowing these five and their roles in the fetch-decode-execute cycle is what the specification requires.
What happens to the PC when a function is called?
When a function is called, the current value of the PC (the address after the call instruction) is saved — typically pushed onto the call stack — and the PC is loaded with the starting address of the function. This redirects execution into the function. When the function returns, the saved address is popped from the stack and loaded back into the PC, resuming execution exactly where the call was made. This mechanism is why you can call a function from anywhere in a program and always return to the right place.
Professor Turing explains CPU registers, the fetch-decode-execute cycle, and all GCSE architecture topics with Socratic questions and diagram walkthroughs at aitutors.me.