Microprocessoren: de evolutie van stored-program computing

In de vroege dagen van computing, erkenden pioniers zoals Alan Turing en John von Neumann dat een werkelijk nuttige machine meer moet doen dan slechts een lijst commando's uitvoeren – het moet in staat zijn om data op te slaan, op te halen, en te wijzigen binnen hetzelfde geheugenpool. Deze inzicht leidde tot het concept van de stored-program computer.

Turing's theoretische machine vertrouwde op een sequentiële-toegang band om zowel programmainstructies als data te houden. Een besturingsschakeling las de band, voerde operaties uit, en herschreef resultaten terug naar de band of bewoog de band om nieuwe data te lezen. Moderne systemen vervangen die band door random-access memory (RAM), wat hetzelfde doel bereikt met veel grotere snelheid en flexibiliteit.

Een nuttige analogie komt van vroege automatische machine-tool controle. Open-lus of numerieke controle (NC) systemen stuurden een draaibank of freesbank door instructies te volgen gecodeerd als gaten in papierband. De machine bewoog blindelings, de band volgend zonder bewustzijn van de werkstuktoestand.

Omdat het apparaat „blind” was voor zijn omgeving, kon het niet compenseren voor veranderingen zoals metaaluitzetting of slijtage van het gereedschap. De programmeur moest ook elke mogelijke instructiereeks anticiperen, aangezien de band read-only was en de machine geen intern geheugen had om zijn toestand bij te houden.

Upgraden naar een eindige-toestandsmachine (FSM) gaf het gereedschap een rudimentair geheugen: door sommige databits terug te voeden in de adreslogica, kon het systeem simpele toestanden onthouden zoals „koelmiddel aan” of „gereedschap in-positie”. Toch bleef dit tekortschieten aan echte flexibiliteit.

De doorbraak kwam met gesloten-lus numerieke controle (CNC), waar het programma nieuwe data naar schrijfbaar geheugen (RAM) kon schrijven. Het controlsysteem kon dan vastleggen wat het had gedaan en zich aanpassen aan sensor-gedetecteerde veranderingen – veel als een timmerman aantekeningen op een kladblok zet voor later referentie.

Computerwetenschappers hebben lang gedroomd van machines die hun eigen code kunnen wijzigen, wat spiegelt hoe de menselijke hersenen synapsen versterken door ervaring. Voor zulke zelf-wijzigende programma's haalbaar te zijn, moet de uitvoerbare code in hetzelfde schrijfbare geheugen resideren dat data opslaat – een concept dat nog steeds aan de voorgrens van onderzoek ligt.

Meeste software volgt nog steeds vaste instructiereeksen, wat alleen een apart data-veld wijzigt. Om het stored-program model echt te ondersteunen, hebben we meer nodig dan een FSM; we hebben een read/write geheugen, een data-verwerkingseenheid, en een gesophisticeerde controller.

Read/write geheugen wordt gemakkelijk geleverd door statische of dynamische RAM-chips – betaalbaar en snel. Logische operaties worden afgehandeld door een Arithmetic Logic Unit (ALU), die rekenkundige en Booleaanse functies kan uitvoeren.

De Control Unit orchestreert databeweging tussen geheugen, de ALU, en externe apparaten. Het gebruikt tri-state buffers om data op bussen te routeren en decoderinglogica om binaire instructiecodes in acties te vertalen.

Voorbeelduit instructies zouden zijn: „Tel de waarde op adres 0010 op bij de waarde op adres 1101”, of „Bereken de pariteit van het byte op adres 0111.” De mapping van binaire codes naar operaties is arbitrair, net als de vroege ASCII-standaard, hoewel instructiesets meestal fabricant-specifiek zijn.

Wanneer read/write geheugen, een ALU, en een Control Unit geïntegreerd zijn – vaak op een enkele chip – vormen ze een processor. Een processor met minimaal extern geheugen is een microprocessor; gekoppeld met bus-controle circuitry, wordt het een Central Processing Unit (CPU).

De CPU's operatie is ingepakt in de fetch/execute cyclus. De program counter houdt het adres van de volgende instructie. De Control Unit leest dat adres in de geheugenadresbus, haalt de instructie uit RAM op, en slaat het op in een tijdelijk register.

Als de instructie operanden vereist, geeft de Control Unit extra geheugentoegangen uit, routet de opgehaalde data naar ALU-registers. De ALU voert dan de gevraagde operatie uit, plaatst het resultaat in de accumulator. Ten slotte incrementeert de program counter, en de cyclus herhaalt zich.

 Microprocessor (CPU)

--------------------------------------
| ** Program counter ** |
| (increments address value sent to |
| external memory chip(s) to fetch |
| the next instruction) |==========> Address bus
| (to RAM memory) |
--------------------------------------
| ** Control Unit ** |<=========> Control Bus
| (decodes instructions read from |
| program in memory, enables flow |
| of data to and from ALU, internal |
| registers, and external devices) |
| (to all devices sharing |
| address and/or data busses; |
| arbitrates all bus communi- |
| cations) |
--------------------------------------
| ** Arithmetic Logic Unit (ALU) ** |
| (performs all mathematical |
| calculations and Boolean |
| functions) |
--------------------------------------
| ** Registers ** |
| (small read/write memories for |
| holding instruction codes, |
| error codes, ALU data, etc; |
| includes the "accumulator") |
|<=========> Data Bus
| (from RAM memory and other |
| external devices) |
--------------------------------------

Zelfs de eenvoudigste operaties vereisen veel micro-stappen. Complexe rekenkunde zoals exponentiatie omvat herhaalde iteraties van basisfuncties. Overweeg de duizenden cycli die een vluchtsimulator's graphics engine moet uitvoeren om het display elk frame te verversen.

De pure snelheid van de fetch/execute cyclus maakt dit haalbaar. Sommige ontwerpen embedden een klein programma – genaamd microcode – in een interne ROM. Microcode behandelt de sub-stappen van complexe operaties, wat de programmeur in staat stelt een enkele high-level instructie uit te geven in plaats van elk detail te schrijven.

Op deze manier bevat een processor een processor: een programma dat draait binnen een programma dat ontwikkeling vereenvoudigt terwijl prestaties behouden blijven.