The whole machine: wiring three chips together

01Three chips, that is the whole machine

The whole machine is six wires: pc, instruction, addressM, outM, writeM, inM.This is the Harvard architecture from the prologue: ROM32K and Memory are two separate memories with separate address lines, so one cycle can fetch and access memory at the same time.

02Memory: one address space, three devices

Outside it is a memory with a 15-bit address and 16-bit data; inside it splits reads and writes by the top address bits:

On a write, a DMux sends load to the right device; on a read, Mux16 selects it back. RAM16K sees only the low 14 address bits and the screen only the low 13 — so each device sees “its own” address.

03The HDL for Memory

Keyboard has no inputs (it only outputs), and Screen and RAM16K are built-in chips. Everything else is address decoding:

CHIP Memory {
  IN in[16], load, address[15];
  OUT out[16];
  PARTS:
  // address[14]: 0 → RAM, 1 → screen / keyboard
  DMux(in=load, sel=address[14], a=loadRAM, b=loadDevice);

  // address[13]: 0 → screen, 1 → keyboard (read-only, no load)
  Not(in=address[13], out=notA13);
  And(a=loadDevice, b=notA13, out=loadScreen);

  RAM16K(in=in, load=loadRAM, address=address[0..13], out=outRAM);
  Screen(in=in, load=loadScreen, address=address[0..12], out=outScreen);
  Keyboard(out=outKbd);

  // read: pick screen/keyboard first, then RAM vs device
  Mux16(a=outScreen, b=outKbd, sel=address[13], out=outSK);
  Mux16(a=outRAM, b=outSK, sel=address[14], out=out);
}

04Why ROM32K is not implemented

ROM is read-only: give it an address and it returns the 16 bits stored there. The course provides ROM32K as a built-in chip,

ROM32K(address=pc, out=instruction);

with no load and no clock — the program is already installed before the machine runs. Think of it as an array of 32768 rows.

That also explains why Hack cannot modify its own program: ROM is read-only, and program and data live in two places from the start.

05The HDL for Computer

The whole machine is one CHIP that connects the three chips:

CHIP Computer {
  IN reset;
  PARTS:
  ROM32K(address=pc, out=instruction);
  CPU(inM=inM, instruction=instruction, reset=reset,
      outM=outM, writeM=writeM, addressM=addressM, pc=pc);
  Memory(in=outM, load=writeM, address=addressM, out=inM);
}

06One fetch, step by step

There is no bus arbitration, no cache, no pipeline: in one beat the signals travel this chain once, then the next beat starts.

07Boot: what happens after reset

When reset = 1 the CPU sets PC to 0. On the next beat ROM32K returns the instruction at address 0 — the first line of the program.

So “power on and run” is one sentence on Hack: clear PC, then keep executing. No operating system, no loader; the program is the numbers in ROM.

08Hardware done, software enters: how Tetris runs

That is the six-storey tower of computing (five layers of software plus the hardware at the bottom):

No magic, only layer upon layer of abstraction and encapsulation. You are standing on the most solid foundation of that tower — look back at every gate and the picture becomes clear.