"Hack computer" from Nand2Tetris registers, any real world examples of similar design?

Question

The "Hack CPU" (Wikipedia/Hack_computer) is a theoretical computer design created by Noam Nisan and Shimon Schocken and described in their book and also used in their Coursera course Nand2Tetris, and in the game https://nandgame.com. Their CPU only has two registers, A and D. Both registers are loaded via the output of the ALU. When loading data from memory to either the A or D register, it has to first pass through the ALU. The A register can also be loaded directly from an instruction, and it also holds the addresses used when accessing memory.

This design surprises me a bit since it seems very slow to have to pass through ALU to load the registers. I am interested in if there is any smart rationale behind the design, and if there are real-world examples of CPUs with similar design? Was the design for example common in the early days of computers? Both questions sort of tell me the same thing: is the design any good, or is it just something more like "educational fiction".

Some more context to their "Hack computer", it uses Harvard architecture.

Answer 1

Yes, most CPUs(*) have an accumulator-based architecture. In fact, most CPUs have the very simplest kind of accumulator-based architecture, the kind used in the "Hack CPU", with an accumulator that can only be loaded from the ALU, and whose output can only go back into the ALU, and one input of the ALU connected only to the accumulator. (The D register is the accumulator of the Nand2Tetris "Hack CPU").

it seems very slow to have to pass through ALU to load the registers.

Some accumulator-based processors do have additional connections that can read out the accumulator directly or write to the accumulator directly or both, bypassing the ALU. But routing through the ALU (for example, by zeroing one of the inputs and performing an OR operation) does not add significant delay to LOAD or STORE. Leaving out those additional connections generally reduces transistor count and area, simplifies wiring, and so reduces cost. (thanks, Paul A. Clayton).

An integer ALU is completely combinational logic, producing outputs very quickly after new inputs are applied -- less than a clock cycle. So loading a value from memory into the accumulator (which requires passing that data through the ALU), or writing the value in the accumulator out to memory (which also requires passing that data through the ALU) is not any slower than the register file (completely bypassing the ALU) used in more recent CPUs. Both architectures can be designed to take a single memory cycle for a LOAD or a STORE. (The register file does makes some other kinds of instructions run faster).

real-world examples of CPUs with similar design?

• As you can see from any PIC microcontroller architecture block diagram, 8-bit PIC microcontrollers have an accumulator called the "W register" connected exactly the same way.
• The 8085 has an accumulator: "the only way to put a value into the accumulator is through the ALU." -- "Ken Shirriff: Reverse-engineering the 8085's ALU", but it has additional connections to to the ALU that bypass the accumulator. (thanks, user52174)
• The Intel MCS-51 architecture ("8051" and "8031") has historically been popular. Although Intel no longer sells chips with this architecture, lots of other chips with this architecture are still in production. The MCS-51 also has only a single accumulator, although the 8051 / 8031 architecture block diagram shows more complicated and flexible connections.
• The PDP-8 architecture has only a single accumulator. (FIXME: link to diagram).
• The MOS 6502 (still in production as the Western Design Center 6502) has only a single accumulator. (FIXME: link to diagram).
• The Hitachi 6301 had two accumulators.

(*) In particular, since 2013 Microchip has been shipping a billion CPU chips every year. Most of them are 8-bit PIC microcontrollers with a traditional accumulator-based architecture.

Chips that include the Western Design Center 6502 ship "over a hundred million units per year".

You may be more familiar with computers that have a register file, with many registers that are all more-or-less equally connected to the ALU. In particular, you may be familiar with the x86 architecture (although many people call all of those ALU-connected registers "accumulators", and sometimes call one of those registers "the accumulator"). Since 2020, the number of x86 architecture CPU chips shipped (combined from all manufacturers) is about 350 million per year, so many people incorrectly think it's the top seller, but other CPU architectures sell even more chips per year.

common in the early days of computers?

As far as I can tell, the accumulator-based architecture is still more common in terms of CPUs shipped per year than any other CPU architecture. (It was also common in the early days of computers).

is the design any good

That's a matter of opinion. Some people can't stand it. Other people love it and say there are still categories where it is "the best". But I would hesitate to call an architecture "bad" when it currently outsells (in terms of CPUs sold per year) all x86 CPUs from all manufacturers combined.