Does any computer resemble the model taught in UK secondary education?

Question

In UK secondary education, there's a model called the fetch-execute cycle, which describes how computers work. (See: Isaac CS; Bitesize GCSE, Higher; Teach CS.) As I understand it:

The processor has at least one general-purpose register, usable as a source for arithmetic operations, and a source or target for MOV operations, plus the following special-purpose registers:

• Program counter (PC), holding the address of the next instruction to execute.
• Status register (SR), holding:
  • Flags like overflow, carry, zero, negative (set on an ALU operation)
  • Whether particular interrupts are due to be raised
• Accumulator, where the result of all ALU operations is stored.
• Current instruction register (CIR).
• Memory address register (MAR).
• Memory buffer register (MBR) aka memory data register.

The registers are faster to access than main memory.

Execution can be divided into four three phases: fetch, decode and execute.

• In the fetch phase, the instruction at the PC is fetched, and stored in the CIR. The PC is incremented before the next fetch.
• In the decode stage, the "control unit" decodes the instruction from the CIR, and decides which parts of the processor should handle it.
• In the execute stage, the sequence of register moves, memory accesses and ALU operations required to implement the instruction is executed.
• If interrupt flags are set in the status register, the corresponding ISR (interrupt handler) is called. (It's unspecified how this happens; this phase of the execution model doesn't even get a name.)

There is an ALU that handles arithmetical, bitwise and comparison operations. Memory accesses involve three buses:

• Data bus
• Address bus
• Control bus

The MAR and MBR are buffers for the address bus and data bus respectively: to perform a memory write, the MAR and MBR are set, then their contents are sent over their respective buses, along with a "please write to memory" signal on the control bus. To perform a memory read, the MAR is set, then sent over the address bus with a "please read from memory" on the control bus, and the signals from the data bus are written to the MBR.

Additionally:

• A clock is involved in some part of the processor's execution.
• The addressable memory is RAM (think core or MOSFET, not drum).
• No pipelining¹ or branch delay slots. An instruction is only executed once the previous instruction has finished.
• RAM accesses may be cached.
• There's a halt instruction.

Being an ignorant youth, I've never come across a computer processor I know to be designed this way. Searching for the terminology turned up the IBM 1620, which has an MBR/MDR distinction and – as far as I can tell – a similar memory bus design. (Unfortunately, it lacks the general-purpose registers, and the clearly-defined ALU.) I haven't found much else online; the search results are so swamped with teaching and revision resources that my usual approach fails.

Is there a computer that works like this? If not, which real-life machines are closest to this model?

---

¹: Though you don't always lose marks for writing about pipelining.

Answer 1

Is there a computer that works like this?

Erm, next to all?

FETCH-DECODE-EXECUTE is the basic execution cycle for each and every digital CPU. No matter if a Turing Machine or a Pentium. I suspect the question is rather about the abstract model used in those courses.

As a model-CPU it's simplified to the minimum viable number of elements, but with added items to simplify teaching as well. It forgoes of course any optimiztion that a real world CPU would have right away, like splitting MBR and MDR or only copy needed data items (instruction or address) into registers.

What may add confusion is that it includes registers that are usually not user visible like MAR or MBR. This is done so the internal operation, below the user model, are to be understood - but without going into real implementation (i.e. gates).

If not, which real-life machines are closest to this model?

As said, next to all (simple, synchronous) CPUs work like that.

---

Insert About Teaching vs. Engineering

The key word is 'like that', as what you see in this course is an idealized model tailored for teaching. This means there are not only parts left out or simplified, but also steps/workings/parts added to ease teaching. These elements may not be found in the same way, or at all, in real implementations.

Remember: The target of teaching is not to build something, but to make pupils understand the principles so the can (hopefully) later create their own design.

For example within the FETCH cycle video shows MBR and CIR being hosted in parallel but feed in sequence. This is a simplification, and in fact rather useless, especially in this combination. In a real world the data fetched get put right away into the CIR, as the sequencer knows it's fetching an instruction. In turn when a fetch is not about instruction, but data, the byte read will get moved direct into the MDR.

In fact, the very reason of having two names for the same register, MBR and MDR, shows already that there might be more to it in real life. It's perfect to 'answer' questions about buffering input, buffering output and holding data for operations. In reality MBR and MDR are often different registers

For teaching it's good to have a streamlined understanding of FETCH where data always going first into. It simplifies the understanding of that process by using always the same straight mechanic. Students may later discover that splitting the load up according to state will improve upon. But that's after understanding the simplified workings first.

A similar liberty includes that a single read fetches instruction and address(es) that go with them to later fit a single register (MDR/CIR) holding all of that (and the control unit later on again). This requires a structure long words and short addresses that hasn't been seen since very early machines (e.g. Zuse, Manchester Mark 1) - and even these machines did not store the same value multiple times. They had way better use for their slim number of logic elements than useless duplication.

Long story short: Teaching models are not only different from reality to reduce complexity, but as well expand to improve teaching (*1).

---

But let's take a real world CPU and look for where to find the elements. Hanson's diagram of the 6502 seems like a good start:

(Taken from the cleaned up version on his site)

The Registers of you school CPU are quite visible:

• Program counter (PC):
  • Top Center in Light Blue
• Status register (SR):
  • Bottom Left in Yellow
• Accumulator:
  • Bottom Center in Green
• ALU:
  • Center in Dark Blue
• Current instruction register (CIR):
  • Top Left in Red
• Memory address register (MAR):
  • Right Side in Brown
• Memory buffer register (MBR):
  • TOP Center in Violett

Due being a strict 8 bit CPU, the 6502 needs to organize 16 bit parts (PC, MAR) as two 8 bit units. For the context of teaching they are one register. Likewise are secondary parts of registers, like the PC incrementer or the data hold registers for the ALU. These are marked here with thin lines.

Left unmarked are what the 6502 provides over such a minimal model:

• Index Registers (X, Y; Lower Right side) and
• Stack Pointer (S; Center)

The remaining boxes represent items that are usually left out of such models to reduce complexity.

• Buffers and alike units to manage the busses. That are, together with the thin line marked secondary parts, what your teacher implies when saying things like 'Now the MBR is loaded into the ALU'.

• Decode and Sequentialize of execution. The huge area to the left. It contains all logic to make the CPU tick, turn a Byte in the CIR into a sequence of steps to perform what that byte asks for.

Regarding the often cited 'Pipelining' of the 6502: There is none.

At least not in the sense of today's understanding of a pipeline with instructions going thru various stages of execution. It's more like a expedited read ahead (hence the name prefetch register) issued while the last execution cycle is still performed. This works as for many instructions (think of ADD), the last cycle is an internal to perform the operation, thus the bus is free to do a read ahead.

Removing this from the CPU wouldn't change much of the CPU, except making many instructions one clock slower. It's an optimisation that comes (almost) for free by arranging the data pathes the right way.

---

The same can be done with next to any other CPU. Including the most recent units - although, it might be hard to pin these basic elements within the ocean of optimization :))

---

*1 - And to support quick demise/answer of questions of students to advanced for that course.

Answer 2

Microchip PIC family of microcontrollers very closely resembles this model. They are widely used in embedded systems, you probably have several in your home. A block diagram of the architecture can be found in e.g. PIC16F84 datasheet and more information on the core in a separate document.

Detailed comparison

The processor has at least one general-purpose register, usable as a source for arithmetic operations, and a source or target for MOV operations

PICs have exactly one general-purpose register, the W register.

Program counter (PC), Status register (SR)

Yes.

Accumulator, where the result of all ALU operations is stored.

Same as W register.

Current instruction register (CIR).

Yes.

Memory address register (MAR).

Called FSR (file select register).

Memory buffer register (MBR) aka memory data register.

Same as W register.

The registers are faster to access than main memory.

Access to main RAM take a whole 4-clock instruction cycle, W register access happens in single clock cycle.

Execution can be divided into three phases: fetch, decode and execute.

PICs use four phases:

1. Load instruction, increment PC, start next instruction fetch.
2. Memory / operand read
3. Execute ALU operations
4. Memory / result write

There is an ALU that handles arithmetical, bitwise and comparison operations.

Yes.

Memory accesses involve three buses: Data bus, Address bus, Control bus

Yes, though control signals haven't been marked on the block diagram.

A clock is involved in some part of the processor's execution.

Clock is divided into the four phases, non-branch instructions always take 4 clock cycles.

The addressable memory is RAM (think core or MOSFET, not drum).

There is addressable RAM and flash memory.

No pipelining1 or branch delay slots. An instruction is only executed once the previous instruction has finished.

The instruction fetches from flash are pipelined by a single stage (the fetch is started during previous instruction execution). There are no branch delay slots, but branches take 2 instruction cycles (8 clock cycles).

RAM accesses may be cached.

They are not.

There's a halt instruction.

There is a SLEEP instruction, which can be woken from by hardware pins.

Answer 3

It is an extremely common approach for discrete CPUs (CPUs implemented with discrete logic elements, both with integrated circuits and previous technologies), and also in early single-chip CPUs.

Some examples (this is not a complete list):

• DEC PDP-8. As you can see in the block diagram on page 2 of the User's Handbook, there is a memory address register (MAR), a memory buffer register (MBR), a program counter (PC), an instruction register, and an accumulator.

  There is no dedicated status register, but the "link" register which here is considered close to the accumulator would be part of the status register.

  The MAR and MBR registers are displayed on the front panel and can be changed via switches, in that way it is possible to trace the execution, and inspect and modify memory. (That also was a common approach).

  The execution phases (page 4) have an additional defer state (for indirect addressing) on top of fetch and execute, and decoding is implicit, there is no dedicated phase for it.

• If you look at the block diagram of the 6502 CPU, you'll see two ABH and ABL latches (these correspond to MAR) and DOR/DL pair (corresponding to MBR). There is an Instruction Register (IR) and a PC (PCH and PCL) and a status register (P).

  Execution phases are a bit more complex, but the first phase is instruction fetch (which is actually in parallel with the last phase of the previous instruction), followed by a decode phase, followed by various execution phases.

(There are a lot more similar architectures)

So you can see variations of this were widespread, and from a teaching perspective, it makes sense to distill common elements and present those, as in your textbooks.

Answer 4

The old IBM1130 comes close. Here's the console, which displays much of the CPU state:

INSTRUCTION ADDRESS is your PC.

INTERRUPT LEVELS + CONDITION REGISTER are your SR.

OPERATION REGISTER + OPERATION FLAGS + INDEX REGISTER are your CIR.

STORAGE ADDRESS, STORAGE BUFFER, and ACCUMULATOR should be obvious.

It has an extra ARITHMETIC FACTOR separate from the STORAGE BUFFER. I believe this is because core memory must be rewritten after each read, while multiply and divide involve multiple additions and subtractions with modified operands, so keeping these separate is handy.

The ACCUMULATOR EXTENSION supports multiple precision arithmetic, an added feature beyond your model.