The Stored-Program Computer
Anweisungen
The fetch-decode-execute cycle
The fetch-decode-execute cycle
Trace the loop. Every general-purpose computer built since 1948 does exactly this, billions of times a second.
Read the last line twice, because it is the entire idea. There is no tag, no type, no marker distinguishing code from data. The same bits are an instruction if the program counter reaches them and a number if a LOAD reaches them.
That is what makes the machine universal — and it is also the root of an entire class of security failures. If an attacker can get data into a place the program counter will later reach, their data becomes your instructions. Buffer overflows, return-oriented programming and shellcode all live in the gap this design deliberately leaves open.
Modern processors claw some of it back with an execute-disable bit marking regions as data-only — which is, in effect, re-introducing the distinction von Neumann removed, seventy years later, for safety rather than for capability.Flow
Benötigte Werkzeuge:
Desktop ComputerBuild and run a complete machine in software
Build and run a complete machine in software
Benötigte Werkzeuge:
Desktop ComputerWire a program counter and instruction register
Wire a program counter and instruction register
Build the control path in hardware from parts you already have.
- Make a 4-bit binary counter from the flip-flops of the earlier blueprint — that is the program counter.
- Add a register to hold the fetched word — the instruction register.
- Use the top bits of the instruction register to drive a decoder, one output per opcode.
- Wire the decoder outputs to enable the accumulator's load, the adder, and the counter's parallel-load input.
The decoder is the whole control unit: it turns a bit pattern into a set of enable signals, and that is all “executing an instruction” means.
Note the JUMP path especially. A jump is nothing more than loading the program counter from the instruction instead of incrementing it — no special machinery, just a different source for one register.
Reverse-engineering note: a hardwired decoder like this is fast and rigid. Wilkes proposed microprogramming in 1951 — a tiny ROM inside the processor holding a sequence of control patterns for each opcode — which made complex instruction sets practical and let a machine's instruction set be changed without rewiring. Nearly every CISC processor since has been microcoded.Materialien für diesen Schritt:
Logic IC Assortment (74HC Series)1 Set
LED Indicator Set2 Sets
Perfboard / Protoboard2 Stück
Hookup Wire (22 AWG)1 reel
Resistor Kit1 SetBenötigte Werkzeuge:
Soldering Station (Temperature Controlled)
Oscilloscope 2-Channel 100MHz
Function Generator 10MHz
Digital Multimeter (Lab Grade)The bottleneck von Neumann built in
The bottleneck von Neumann built in
The architecture's great strength has a cost that has shaped computing ever since.
- Count memory accesses for one instruction on your simulator: one to fetch it, often one more to fetch its operand.
- Now note that instructions and data share ONE memory and ONE path to it.
- Work out what happens as the processor gets faster and the memory does not.
Code and data compete for the same channel, so the processor spends much of its time waiting for memory. That is the von Neumann bottleneck, and it has grown steadily worse because processor speed improved far faster than memory latency.
Every modern mitigation is an answer to it: caches keep recently used words close; pipelining fetches the next instruction while executing the current one; Harvard architecture gives code and data separate paths, which is why most microcontrollers and every CPU's L1 cache are split into instruction and data halves.
So the split von Neumann removed has quietly returned at the level where speed matters, while the unified view is preserved at the level where flexibility matters. The machine looks von Neumann to the programmer and Harvard to the silicon — which is a fair summary of a great deal of computer architecture.Benötigte Werkzeuge:
Desktop ComputerThe Manchester Baby, and the first program to run
The Manchester Baby, and the first program to run
Put a date on it, because the moment is unusually well defined.
- On 21 June 1948 the Manchester Small-Scale Experimental Machine ran a program stored in its own memory — the first machine to do so.
- The program searched for the highest proper factor of a number, chosen because it was slow and would exercise the machine hard.
- It ran 52 minutes and about 3.5 million operations to find the answer for 2^18.
- The memory was a Williams tube — a cathode-ray tube storing bits as charge spots on the phosphor, and readable as a visible pattern on the screen.
The Baby had 32 words of 32 bits — 128 bytes — and seven instructions. Everything in this batch is present in it: gates, a store, an accumulator, a program counter, and a conditional jump.
The Williams tube deserves its own note, because it is the CRT blueprint from the radio batch used as memory. The charge spot decays in a fraction of a second, so it is continuously read and rewritten — the same destructive-read-and-restore cycle as core memory, and the direct ancestor of DRAM refresh, which every computer still does thousands of times a second today.Benötigte Werkzeuge:
Desktop ComputerMaterialien
5- Platzhalter
- 2 SetsPlatzhalter
- 2 StückPlatzhalter
- 1 reelPlatzhalter
- 1 SetPlatzhalter
Verwandte Blueprints
Diese Blueprints teilen Wissen — Techniken, Materialien oder Prinzipien
CC0 Gemeinfrei
Dieser Blueprint ist unter CC0 veröffentlicht. Sie dürfen dieses Werk für jeden Zweck frei kopieren, ändern, verbreiten und verwenden, ohne um Erlaubnis zu fragen.
Unterstützen Sie den Maker, indem Sie Produkte über seinen Blueprint kaufen, wo er eine Maker-Provision von Anbietern festgelegt, verdient. Oder erstellen Sie eine neue Iteration dieses Blueprints und verbinden Sie ihn in Ihrem eigenen Blueprint, um Einnahmen zu teilen.