[ homepagina zonder frames ]   [ homepagina met frames ]
Naar de [ vorige logische pagina in deze reeks ]    Naar de [ volgende logische pagina in deze reeks ]

Laatst aangepast op 10 februari 2004

«MICROPRO.HTM»

 
 
 
Deze pagina's zijn alleen bedoeld om enkele elementaire bouwstenen, principes en begrippen i.v.m. de werking van microprocessoren te verduidelijken. Het is zeker niet de bedoeling om alle fijne kneepjes en weetjes van de processortechnieken uit de doeken te doen (alsof we die al zouden kennen).
 
 
 
Aanvankelijk waren computers samengesteld uit duizenden losse elektronische componenten die via ontelbare draden manueel met elkaar correct verbonden moesten worden (een beetje vergelijkbaar met de schakelpaneeltjes die men in sommige secundaire scholen voor het vak T.O. als didactisch middel gebruikt).
 
Vóór de tijd van de halfgeleiders (transistoren e.d.m.) moest men zelfs beroep doen op "lampen" of "radiobuizen" om de eenvoudigste vormen van elektronische informatieverwerking mogelijk te maken.
 
Al bij al een dure aangelegenheid wat betreft de kostprijs van al die aparte onderdelen, de tijd om al die onderdelen correct te verbinden, de enorme fysieke ruimte die men nodig had voor dergelijke schakelingen en de koeling die men moest voorzien om het geheel niet te laten verbranden. Eén radiobuis was toch al snel zo'n 10 cm hoog en had een diameter van 2 cm.
Daarnaast hadden de radiobuizen geen al te lange levensduur en waren ze minder betrouwbaar dan de later ontworpen transistoren.
 
De eerste stappen in de miniaturisering van de computers kwam er bij de invoering van halfgeleiders. Deze zijn gemakkelijk duizend maal kleiner dan de overeenkomstige radiobuizen, verbuiken veel minder energie en zijn ook nog eens stukken goedkoper bij de aanmaak.
 
Men kon nu ook meerdere van die kleinere halfgeleiders zo dicht op mekaar monteren dat er behoorlijk grote schakelingen op één plaat (een "bord" van bijvoorbeeld 20 bij 30 cm groot) mogelijk waren (fysiek klein genoeg en veel minder interne opwarming, dus mogelijkheid om de verschillende componenten zonder veel problemen dichter bij elkaar te plaatsen).
Dit leidde tot het ontstaan van een geïntegreerde schakeling, IC of Integrated Circuit.
 
Een volgende stap in het efficiënter produceren van schakelingen was het drukken van de verbindingen tussen de halfgeleiders (de "banen") via een zeefdrukprocédé. Vandaar ook de namen "bedrukte schakeling" of "printed circuits".
 
Een volgende stap was het fotografisch etsen van halgeleiderschakelingen zelf op één silicium-"wafer" (ongeveer ter grootte van 1 bij 2 cm); d.i. het ontstaan van de eerste chip. Hierbij zijn de halfgeleiders zelf honderden keren kleiner dan de aansluitpunten waarmee de chip met de buitenwereld moet communiceren. Door deze volgende stap in de miniaturisatie kon men nog veel meer transistoren in één geheel samenbrengen. Men sprak destijds van LSI's en VLSI's (Large Scale Integrated circuits en Very Large Scale Integrated circuits).
 
Dergelijke chips namen steeds grotere functies van een volledige computer over maar men had nog steeds meerdere chips van verschillende types nodig om een programma te kunnen laten werken.
 
Eén van de eerste chips die zelf alleen alle logica van een programma kon afhandelen was de INTEL 4004 (1974). Veel verschillende bewerkingen kon deze chip nog niet aan maar het was een "zelfstandige processor" in miniformaat. Vandaar de term "micro-processor".
 
Dat deel van de computer waarin feitelijk de programma's uitgevoerd worden, waarin de berekeningen en de programmabeslissingen genomen worden noemt men ook de C.P.U. of Central Processing Unit (in algemeen Nederlands: de C.V.E. of Centrale Verwerkings- Eenheid). Voor een pc die gebouwd is rond één microprocessor geldt dus dat de microprocessor in dat geval de CPU van het systeem is.
 
In grotere computersystemen kan de CPU zelf uit meerdere chips bestaan, of wordt het rekenwerk verdeeld onder meerdere gelijkaardige microprocessoren.
 
Sommige krachtige "workstations", mini-computers of sommmige netwerkservers werken met twee, vier tot acht microprocessoren. Bij Supercomputers wordt het rekenwerk uitgevoerd door uit grote reeksen processoren (64, 128 enz.).
 
Om twee of meer processoren te laten samenwerken als één CPU moet men een speciaal daartoe ontworpen Operating System gebruiken. Overstappen van een systeem van één microprocessor naar meerdere is dus niet zo simpel als vlug eventjes een latje geheugenchips op het moederbord inpluggen zoals bij het uitbreiden van het RAM-geheugen. Het operating systeem en de toepassingssoftware moeten daartoe geoptimaliseerd zijn.
 
Een microprocessor die niet met één specifieke toepassing voor ogen ontwikkeld is, maar veeleer een uitgebreide waaier van taken moet aankunnen, noemt men ook een General purpose microprocessor, zoals de cpu's van pc's; dit in tegenstelling tot de Dedicated microprocessors die wel voor zeer specifieke opdrachten ontwikkeld worden (bijvoorbeeld, de processoren van de huidige grafische kaarten of geluidskaarten).
 
 
Een microprocessor is één geïntegreerde schakeling op één chip (van duizenden transistors of miljoenen transistoren en andere elektronische logische halfgeleidercomponenten) die als geheel in staat is om zelfstandig alle logische en rekenkundige bewerkingen van één of meerdere programma's uit te voeren.
 
 
 
De mogelijkheden van microprocessoren nemen nog steeds toe waardoor microprocessoren in ongelofelijk veel machines en toepassingen ingeschakeld worden. Enkele ontwikkelingslijnen kon je al afleiden uit het voorgaande (we hernemen ze voor de volledigheid nog even) en enkele andere tendenzen zullen we hier voor het eerst bespreken.
 
 
 
Als gevolg van een combinatie van verschillende factoren is men er toe gekomen om steeds meer halfgeleidercomponenten op dezelfde oppervlakte te kunnen integreren. Hierbij spelen volgende factoren een rol:
In dit verband lees je vaak over de breedte van de smalste verbinding binnenin de processor. Deze wordt uitgedrukt in microns. Bij de 8080 processor was dit nog 6 microns, in sommige versies van de Pentium 4 werkt men met slechts 0,13 micron.
 
In de nabije toekomst zal men door middel van Röntgen-stralen en ingewikkelde schaduwtechnieken nog fijnere datapaden in chips kunnen realiseren.
 
 
 
Alnaargelang men meer componenten op eenzelfde oppervlakte kon integreren is men ook steeds meer geheugenplaatsen in de processorchips zelf gaan inbouwen. Zowel het aantal registers (= speciale werk- en rekengeheugens (zie verder)) als de hoeveelheid level 1 cache RAM-geheugen is steeds verder gaan toenemen.
 
Meer geheugen in de processor betekent hoofdzakelijk tijdwinst voor de uitvoering van programma's omdat de inhoud van het geheugen dat in de processor zelf aanwezig is, ettelijke malen sneller ter beschikking is voor de processor dan de gegevens die van buitenaf (L2 cache-geheugen, gewone RAM, harde schijf etc.) moeten gehaald worden.
 
Oorspronkelijk was er van level 1 cache-geheugen niet eens sprake, terwijl sommige pentium 4 processoren momenteel aparte L1 cache geheugens hebben voor data en programmacode. Bijvoorbeeld 8 kB L1 cache geheugen specifiek voor data en daarnaast nog eens 12 kB L1 cache geheugen, specifiek voor de uit te voeren programmacode.
AMD's Athlon processor heeft bv. 128 KB level 1 cache geheugen (maar het is wel iets minders snel dan het kleinere L1 geheugen van de Pentium 4).
 
 
 
Een ander gevolg van het gebruik van minder energieverbruikende halfgeleidermaterialen is dat men de chip-oppervlakte zelf ook nog kan vergroten zonder dat deze oververhit (samen met grotere afkoelvinnen of extra koelventilatortjes die rechtstreeks op de processor worden gemonteerd).
 
Ook deze factor leidde er toe dat één chip nog veel meer transistoren kon bevatten, waardoor die chip dan ook weer complexere of meer verschillende programma-instructies hardwarematig aankon (zie volgend punt). De huidige Pentium 4-reeks heeft ongeveer 42 miljoen transistoren aan boord, en men droomt nu reeds luidop van processoren met 1 miljard transistoren er in.
 
 
 
Meer componenten in één chip geeft inderdaad de mogelijkheid om de chip:
In elk van bovenstaande gevallen zegt men dat de instructieset (= de totale verzameling van de verschillende machinetaalinstructies die een processor aan kan) toeneemt.
 
Dit houdt in dat een voorheen complexe berekening (vb. een vermenigvuldiging van twee drijvende kommagetallen) die misschien wel in twintig deelstapjes moest uitgevoerd worden op processor niveau, nu kan uitgevoerd worden in bijvoorbeeld slechts drie stappen (of processorcycli). Pure tijdswinst dus.
 
Aanvankelijk was het zelfs zo dat men met het oog op rekenintensieve programma's de mogelijkheid had om een aparte co-processor of rekenprocessor mee te installeren naast de basis CPU.
Naarmate men meer transistoren in één chip kon steken heeft men bv. vanaf de Intel 80486 alle functionaliteit van een mathematische co-processor volledig in de 80486 CPU geïntegreerd.
 
Andere gelijkaardige verbeteringen waren bijvoorbeeld het toevoegen van Intel's MMX technologie vanaf 1997 in de Pentium-II-reeks. Hierdoor werden nog eens 57 nieuwe, voornamelijk multimedia processorinstructies (Multi Media eXtensions die hoofdzakelijk bestonden uit wiskundige matrix-bewerkingen die veel voorkomen in multimedia-toepassingen; daarom ook wel eens als Matrix Math eXtensions aangeduid), aan de bestaande instructieset toegevoegd. Op hetzelfde ogenblik werden 8 speciale registers met een bitlengte van 64 bits opgenomen in de processor, precies om het uitvoeren van die instructies gemakkelijk mogelijk te maken. Hiervoor werden ook nieuwe "datatypes" of "operanden" aan de instructieset toegevoegd. In het geval van MMX ging het hierbij over groepen van integers.
 
AMD heeft ondertussen ook de MMX instructies opgenomen in hun processoren en probeerden zelf "haantje de voorste" te spelen met hun 3DNow! instructieset die ze vanaf 1998 in sommige van hun nieuwste processoren inbouwen (het betreft hier ook voornamelijk instructies die bedoeld zijn om multimediatoepassingen sneller te laten werken, meer in 't bijzonder voor 3D-toepassingen die ditmaal ook kunnen werken met floating point getallen).
 
Bovengenoemde instructie-uitbreidingen zijn bijna allemaal van het type SIMD, Single Instruction Multiple Data, wat zoveel wil zeggen dat men slechts één instructie aan de processor geeft, maar dat deze ene instructie tegelijkertijd op verschillende gegevens kan uitgevoerd worden. Een vorm van elementaire parallelle verwerking in één processor.
 
Intel reageerde hierop door een eigen versie van 3D-instructies in te bouwen vanaf de Pentium 3 (1999), met name de SSE uitbreiding van de instructieset (Streaming Single instruction multiple data Extensions). Dit waren opnieuw 70 extra microprocessorinstructies, waarvan deze keer 50 instructies ook toepasbaar op floating point getallen. Hiertoe werden opnieuw acht nieuwe registers aan de processor toegevoegd, deze keer registers van 128 bits breed, die op die manier elk vier floating point getallen konden bevatten.
 
Op die manier gaat het spelletje tussen de twee grote processorfabrikanten steeds verder (3DNow! professional en SSE-2 zijn ook reeds op de markt, Intel kondigt reeds een SSE-3 reeks aan).
 
Voor de gewone kantoorgebruiker maken al die multimedia en 3D-optimalisaties niet zoveel uit. Gebruikers van streaming audio en video, of 3D-gamers halen het meeste voordeel uit dergelijke uitbreidingen van de instructiesets (ten minste als de programma's die ze op dergelijke pc's draaien ook voor die hardware geoptimalseerd zijn!).
 
In de literatuur spreekt men wel eens over CISC-processoren of Complex Instruction Set Computer processors wanneer men de uitgebreide instructie-set wil benadrukken (zie verder voor de RISC-processoren).
 
 
 
Precies omdat de halfgeleidercomponenten fysiek dichter bij mekaar komen te liggen en omdat men minder energie nodig heeft om deze kleine halfgeleiders te doen schakelen kan men ook de schakelfrequentie van de halfgeleiders opdrijven. Dit komt neer op het verhogen van de klokfrequentie, dit is het aantal klokcycli per seconde. Normaliter neemt men aan dat op één klokcyclus er ook één basisbewerking van de processor kan uitgevoerd worden (bv. een gegeven in een register plaatsen, een optelling maken van twee natuurlijke getallen, een vergelijking maken van twee geheugeninhouden). Let echter op: het uitvoeren van een ingewikkelde instructie, bv. het delen van een drijvende kommagetal door een ander drijvend komma-getal kan meerdere klokcycli vergen!
 
Hoe hoger echter de klokfrequentie waarop een processor kan werken, hoe sneller hij een deel van een programma kan uitvoeren - zolang de processor zelf dan maar niet te lang moet wachten op "trage" output of input-kanalen: dit zijn de zogenaamde wait-states gedurende dewelke de processor eigenlijk alleen maar staat de wachten en niets anders zinnigs kan doen.
 
De klokfrequentie van een processor wordt uitgedrukt in MHz (MegaHertz) en staat voor 1 miljoen tikken per seconde. De kloksnelheid van de 8088 was in 1979 ongeveer 5 MHz, terwijl momenteel (begin 2003) er reeds een Pentium 4 model door Intel aangeboden wordt dat kan werken op 3 GHz.
 
 
 
Met de databreedte van de A.L.U. bedoelen we de bitlengte van de rekenregisters van de A.L.U. De 4004 van Intel kon bijvoorbeeld slechts binaire getallen van vier bits lang in één keer bewerken. Dit wil in feite zeggen dat een optelling van twee getallen die elk 8 bits lang zijn, ten minste opgesplitst zal moeten worden in 2 bewerkingen van vier bits lang. Processoren met een interne databreedte van 8, 16 of 32 bits kunnen deze bewerking in één keer afhandelen.
Vanaf de 80386 hebben de Intel-processoren allemaal een interne databreedte van 32 bits.
 
Opgelet: alhoewel het in de praktijk vaak zo is, is de interne databreedte of databreedte van de A.L.U. niet noodzakelijk dezelfde als de breedte van de databus van het moederbord waarmee de processor zijn gegevens deelt met het RAM-geheugen en andere computeronderdelen. Zo had de 8088 processor een interne databreedte van 16 bits, terwijl voor de communicatie met de andere onderdelen van de pc er gewerkt werd met een databus van slechts 8 bits breed. Omgekeerd zien we nu dat Pentium-processoren intern nog werken op een breedte van 32 bit terwijl ze kunnen samenwerken met een moederbord met een databus van 64 bit!
 
Sedert de invoering van de MMX, 3DNow! en SSE instructies zien we ook dat eenzelfde processor, instructies van verschillende lengte kan verwerken. Zo werkt de pentium 4 vaak op registers van 32 bit breed, maar sommige Single Instruction Multiple Data instructies worden uitgevoerd op registers die 128 bit breed zijn.
 
Hoe dan ook, een grotere interne databreedte van de processor betekent dat hij voor bewerkingen op langere reeksen gegevens duidelijk sneller zal werken dan de processor die deze data eerst in stukjes moet hakken en de bewerkingen brokje per brokje moet uitvoeren en nadien het resultaat weer aan mekaar moet plakken.
 
 
 
Oorspronkelijk kon een microprocessor slechts aan één instructie tegelijk werken. Dit hield onder andere in dat wanneer de processor bezig was met een optelling uit te voeren, er op dat ogenblik geen gegevens vanuit de processor naar het geheugen gestuurd werden of omgekeerd. Nochtans zou het mogelijk geweest zijn dat het resultaat van die optelling nadien nog eens vermenigvuldigd moest worden met de waarde van een derde variabele. Van de oude microprocessoren zegt men dat ze slechts één "execution unit" hadden.
 
Als nu de processor het aan zou kunnen om terwijl hij de optelling doet, ondertussen ook nog eens de derde variabele uit het geheugen op te ophalen, dan kon de vermenigvuldiging sneller aanvatten. Dit is effectief wat men sinds een tiental jaar in veel microprocessoren inbouwt: de mogelijkheid om via parallel werkende "pipelines" of "kanalen" of "execution units" reeds voorbereidend werk te doen voor de instructies die volgen op de instructie waar de processor op het ogenblik reeds mee bezig is. Meer nog, men probeert instructies die volledig los staan van elkaar geheel parallel uit te voeren.
 
In verband met de efficiëntie van deze techniek spelen een drietal factoren een grote rol:
  1. het aantal "pipelines" of "execution units" die naast elkaar tegelijkertijd kunnen werken;
     
  2. hoeveel stappen ver (diep) men kan gaan in elk van deze pipelines met het afwerken van de instructie (louter alleen voorbereiden, of ook reeds berekenen of zelfs wegschrijven van reeds berekende gegevens);
     
  3. de afhankelijkheid van de uitvoering van de volgende instructies op basis van de uitkomst van de vorige instructie(s).
De twee eerste factoren spreken voor zich.
De effectiviteit van de twee eerste factoren kan echter behoorlijk afgezwakt worden wanneer de eerste instructie bijvoorbeeld een "spronginstructie" is, in de zin van IF A > B THEN ... ELSE ... Hier weten we zeker dat slechts één van de twee mogelijke instructiereeksen (THEN of ELSE) afgehandeld zullen moeten worden. Alleen weet je pas na de vergelijking van A en B welke reeks effectief zal uitgevoerd moeten worden en was al het voorbereidend werk voor de andere tak zinloos.
 
Ook in het geval waar het resultaat van de voorgaande bewerking moet gebruikt worden om een volgende bewerking mee te doen, kan je alleen tijdwinst bekomen in de voorbereidingsfase.
 
Wanneer er in een reeks instructies bv. meerdere sommaties te maken zijn van variabelen die verder niets met elkaar te maken hebben dan kunnen deze in principe volledig parallel aan mekaar doorgevoerd worden. Daarom gaat men momenteel in processoren systemen inbouwen die vooraf de eerstvolgende instructies op hun "onafhankelijkheidswaarde" van elkaar beoordelen om precies die instructies bij voorkeur eerst aan te vatten.
 
Het ontwerpen van dergelijke processoren is zeker geen sinecure en soms vraag je je af of we dergelijke complexiteiten wel nodig hebben.
 
Gemiddeld haalt men echter zeker tijdwinst uit deze techniek (ook al worden er feitelijk een groot aantal instructies "voor niets" voorbereid door de processor).
 
Bij Intel tradt de eerste vorm van pipelining op in de 80486 maar zonder verder optimalisatie. Nu (2003) kan de Pentium 4 processor 126 machine-instructies "vooruit" kijken om de meest optimale parallelverwerking te bekomen.
 
 
 
Alle bovenstaande fenomenen hebben er toe geleid dat de huidige processoren veel sneller hetzelfde werk kunnen verzetten dan hun elektronische voorouders. Zoals uit het bovenstaande kan afgeleid worden is de kloksnelheid waarop een processor kan werken zeer belangrijk maar lang niet de enige factor die de verwerkingssnelheid van een processor bepaalt (laat staan de verwerkingssnelhied van de volledige pc).
 
Eén manier om de verwerkingssnelheid van de processor weer te geven is het aantal instructies dat een processor "gemiddeld" kan afwerken per seconde, uitgedrukt in MIPS, Miljoen Instructies Per Seconde. Dit is slechts een "ruwe" schatting van het rekenvermogen van de processor omdat alles afhangt van hoeveel verschillende instructies men test, de soorten instructies die men allemaal test en welke weging men aan de uitvoering van de verschillende instructies geeft.
 
Een 80286 processor haalde in 1982 met een kloksnelheid van 6 MHz een verwerkingssnelheid van 1 MIPS. Een Pentium 4 van 2003 haalde met een kloksnelheid van 2,2 GHz 4 143 MIPS.
 
 
 
Ogenschijnlijk in tegenstelling met de bedoeling van de CISC-processor is men rond 1990 begonnen met het ontwerpen van RISC-processoren =  Reduced Instruction Set Processors. Het achterliggende idee hierbij is om vooral de meest gebruikte instructies hardwarematig maximaal te optimaliseren voor een zeer snelle uitvoering en te proberen om weinig gebruikte instructies te vervangen door enkele reeksen van de geoptimaliseerde basisinstructies. De software voor de RISC processor zal dus voor sommige "zeldzamere" instructies meer klokcycli nodig hebben dan een CISC-processor maar zal daarentegen voor de veel gebruikte instructies veel sneller kunnen werken.
 
In die zin renderen de RISC processoren zeer goed in omgevingen waar vaak dezelfde basisinstructies opnieuw uitgevoerd moeten worden zoals bijvoorbeeld in grafische werkstations of in fileservers. In die zin geven minder basisinstructies in combinatie met een gespecialiseerd processorontwerp toch aanleiding tot meer Mips.
 
Voor een pc waar alleen maar wat tekstverwerking op gebeurt is het onderscheid tussen CISC- en RISC-processoren veel minder belangrijk omdat de pc toch meer staat te wachten op input van de auteur dan dat de processor echt moet werken.
 
 
 
Microprocessoren zijn in vergelijking met de rest van de computeronderdelen enorm toegenomen in kracht en snelheid. Zodanig dat de microprocessor van een pc vaak niets om handen heeft omdat hij moet wachten op toevoer van data, afkomstig van tragere inputbronnen (hetzij vanaf een diskette, harde schijf, info afkomstig van het internet of gewoon wachten op het intypen van een toets op het klavier). M.a.w. de motor staat steeds vol gas te draaien, maar het koppelingspedaal is vaak ingedrukt. Ondertussen verbuikt de processor wel energie en ontwikkelt hij alleen maar warmte.
 
Intel en AMD hebben hierin een mogelijkheid gezien om het gebruikscomfort van draagbare computers te vergroten. Als men er in slaagt om de processor automatisch op een lagere snelheid te laten draaien wanneer dat aangewezen is (bv. op de helft van de maximale snelheid) en hem terug op volle kracht te laten draaien als het nodig is, dan verbruikt de processor ook veel minder energie en kan de pc langer gebruikt worden met eenzelfde batterijlading. Dit zou de gebruiksautonomie van een draagbare pc voor toepassingen zoals tekstverwerking met 25 % kunnen vergroten.
 
De eerste ontwikkelingen op dit vlak waren nogal rudimentair: de draagbare pc draait op volle snelheid wanneer de netvoeding aangesloten is, en valt steevast terug op 2/3 van de maximum snelheid als de netvoeding losgekoppeld is. Momenteel werkt men aan veel dynamischer ontwerpen waarbij een schakeling permanent de processorbelasting meet en in een honderste van een seconde de snelheid kan aanpassen, zonder dat de gebruiker er iets van merkt.
 
Uiteraard wordt deze techniek nu volop ontwikkeld voor de processoren die specifiek voor draagbare pc's ontworpen worden. Het is echter de algemene verwachting dat men deze techniek ook zal inbouwen in de processoren voor desktop modelllen.
 
 
 
Een microprocessor bestaat uit halfgeleidercomponenten (transistoren, AND-, OR-, NAND-, NOR-, XOR- en andere poorten, flip-flops, reeksen flip-flops, grote en kleine geheugenplaatsen met vaak specifieke mogelijkheden en functies) en allerlei verbindingen hiertussen. Hierin kunnen we zeker "logische" gehelen onderscheiden met elk zijn eigen typische functie. Bekijken we enkele onderdelen even van naderbij.
 
 
 
De geheugens die in een microprocessor ingebouwd zijn, werken bijzonder snel, het is te zeggen, gegevens die je er naar toe stuurt zijn tegen de volgende klokpuls reeds voor verdere bewerking beschikbaar. Deze geheugens werken dus aan hetzelfde tempo (of toch bijna) als de processor zelf. Geheugen dat extern aan de processor is, werkt vaak veel trager dan de processor (vandaar de nood aan cache-geheugens).
 
 
 
In zijn eenvoudigste vorm is een flip-flop geheugenelement een opslagruimte voor één bit (voldoende om een logische vlag in op te slaan). Dit geheugen-element (opgebouwd rond een R.S.-flipflop schakeling met schrijf- en lees-controle (ook wel een Delay-flip-flop genoemd)) heeft vier aansluitingen:
Een flip-flop geheugenelement zal dus de waarde van het inputkanaal op het ogenblik van het laatste write-signaal "opsparen" tot er via een nieuwe schrijfpuls een nieuwe waarde vanop het inputkanaal wordt opgeslaan. De "opgeslagen" waarde wordt pas op het outputkanaal gezet wanneer het geheugenelement daarom verzocht wordt via een read-signaal.
 
De input- en outputsignalen zijn in feite DATA-signalen.
De read- en writesignalen zijn CONTROLE-signalen.
 
Wanneer in de A.L.U. van een microprocessor een binaire optelling wordt gemaakt van 2 getallen dan wordt de eventuele "overflow" doorgegeven aan een bepaald "test"-register waarmee de mogelijkheid gecreëerd wordt om na te gaan of er al dan niet overflow opgetreden is. Dat testregister hoeft maar 1 bit groot te zijn. Een simpel flip-flop geheugen-element kan de klus hier dus klaren.
 
 
 
De meeste registers in een CPU zijn reeksen flip-flop geheugen-elementen waardoor we ineens de inhoud van reeksen van 8, 16, 32, 64 of 128 bits kunnen opslaan.
 
Er zijn ook speciaal ontworpen registers die niet alleen gegevens kunnen ontvangen en teruggeven, maar er vaak ondertussen ook nog bijzonder snel een veel gebruikte bewerking kunnen op doen.
 
 
 
Sommige registers zijn speciaal zo gebouwd dat als er een binair getal in opgeslaan is, ze dit getal zeer snel met één eenheid kunnen verhogen. Dergelijke registers worden dan ook vaak gewoon TELLERS genoemd omdat ze per telpuls die ze ontvangen meteen de waarde met 1 éénheid verhogen.
 
 
 
Een ander type register is de ACCUMULATOR of kortweg ACCU. In dit type register kan je een getal opslaan en er nadien nog een tweede naar toe sturen en als resultaat hiervan zit de som van beide getallen in dit register. Om er nadien weer een volledig nieuwe optelling in te maken moet je de inhoud ervan eerst weer resetten.
 
Oorspronkelijk werd de naam ACCU gebruikt voor het register waar alleen het resultaat van een optelling van de inhoud van twee andere registers werd in opgeslaan.
 
In moderne microprocesoren zijn vaak meerdere van beide types ACCU's aanwezig.
 
 
 
Bepaalde registers krijgen alnaargelang de functie die ze vervullen ook dikwijls een specifieke naam. Zo heb je ADRESREGISTERS waarin uiteraard geheugenadressen in opgeslaan en/of berekend kunnen worden.
 
Sommige adresregisters zijn zo gebouwd zodat er snel het adres van een bepaalde instructie of variabele mee kan berekend worden op basis van een ander adres en een zekere "verplaatsing" (displacement) binnen die geheugenruimte.
 
 
 
Nog een specifiek type van register zijn de SCHUIF-registers die de bitstring die er in opgeslaan is, op bevel van schuifpulsen, één voor één, telkens één positie naar links of rechts kunnen doen opschuiven. Zo kan je bv. exact de waarde van de vierde bit in een byte ophalen.
 
Aan de kant waar er vrije bitplaatsen beschikbaar komen kan je er ook weer bit per bit nieuwe waarden inschrijven.
 
 
 
Een bijzondere uitvoering van het schuifregister is de KIEZER die uit  n  ingangsbits, op basis van een ingestelde waarde in een ander register, in één keer precies die bit doorgeeft die overeenkomt met de ingestelde keuze.
 
 
 
Nog een speciaal benoemd register is de STACKPOINTER. De stackpointer is een register dat gebruikt wordt om de top-positie van een stapelgeheugen bij te houden.
 
Visuele voorstelling van de werking van een stapelgeheugen
 
Een stapelgeheugen of stackmemory is een vorm van LIFO geheugen (Last In First Out). Hierbij gaat men de gegevens als het ware één voor één bovenop elkaar stapelen, om ze er nadien weer één voor één af te halen. Het laatste opgestapelde element wordt dan ook weer als eerste uitgelezen. Men zal dus nooit willekeurig een element midden uit de stapel uitlezen vooraleer alle bovenliggende gegevens uitgelezen zijn!
 
Het principe van een stapelgeheugen of stackmemory is dus als volgt:

Waarom heeft een cpu nood aan een geheugensysteem (buffer) dat werkt volgens het LIFO-principe?
 
Het uitvoeren van een computerprogramma bestaat meestal uit het sequentieel afhandelen van machine-instructies in de volgorde waarin ze in het programma opgenomen zijn.
 
Telkens wanneer tijdens de gewone afhandeling van een programma een subroutine wordt aangeroepen dan stopt in feite het "lineaire" parcours van het programma en wordt er gesprongen naar het beginadres van de betreffende subroutine.
 
Nu is het van cruciaal belang dat bij het beëindigen van die subroutine het programma weer verdergaat met de instructie die volgt op de instructie die de subroutine aanriep. Zeker als je weet dat eenzelfde subroutine vanop meerdere plaatsen uit hetzelfde programma kan opgeroepen worden. De stackpointer verwijst hierbij naar de geheugenplaats waarin het geheugenadres van de eerstvolgende uit te voeren instructie opgeslaan is.
 
Aangezien je vanuit een subroutine echter opnieuw een andere subroutine kan oproepen, enzoverder enzovoort moet je dus een LIFO-systeem voorzien om steeds terug te kunnen keren naar de dieper liggende programmacode.
 
Verder kan de "normale" uitvoering van een programma ook tijdelijk onderbroken worden voor de afwerking van allerlei "interrupts" (voorbeeld een "hardware-interrupt", een dringende vraag van een randapparaat om de aandacht van de processor). Ook in dit geval moet tijdelijk opgeslaan worden wat de volgende uit te voeren instructie zal zijn, zodra de processor de hardware-interrupt heeft afgehandeld.
 
Ook "geneste" programmaloops vergen het gebruik van de stack om nog te weten vanwaar men vertrokken was.
 
 
Toemaatje: hoe kan je een geheugenbuffer maken die werkt volgens het FIFO systeem?
 
Een buffer die werkt volgens het FIFO systeem (First In First Out) heb je nodig wanneer je aan de ene kant sneller gegevens binnen krijgt dan je ze aan de andere kant kan verwerken. Je hebt dat vast zelf al eens meegemaakt. Een "trage pc" waar je verschillende programma's tegelijk op draait en liefst ondertussen ook nog een printopdracht laat uitvoeren en dan nog even zeer snel op het klavier tokkelen. Je merkt dat de pc niet echt kan volgen maar na zekere tijd komen toch alle ingetypte letters in de juiste volgorde op scherm. Tenzij je heel erg doordramt en dan begint je pc plots te piepen bij elke toetsaanslag. Zijn invoerbuffer is vol! De pc kon niet tijdig genoeg de binnenkomende gegevens verwerken.
 
In principe zijn de buffers van de pc wel voldoende groot om een plotste toename van inkomende gegevens tijdelijk te "bufferen". Een FIFO-buffer wordt daarom ook wel eens een WACHTLIJN genoemd. Fifo-buffers worden ook vaak gebruikt bij seriële en asynchrone datacommunicatie. Hierdoor kan het verzendende toestel reeds een bepaalde hoeveelheid data doorsturen, ook al kan het ontvangende toestel die gegevens nog niet meteen verwerken. Van zodra het ontvangende toestel wel aandacht kan geven aan de ontvangen en gebufferde data, kan deze meteen een hele hoop data verwerken.
 
Eén en ander is misschien gemakkelijk te volgen op de bijhorende visuele voorstelling.
 
Visuele voorstelling van de werking van een FIFO-geheugen-buffer
 
 
Om dit te realiseren heb je ook weer een aaneengesloten gereserveerde bufferruimte in het geheugen nodig + twee pointers; één om aan te geven tot waar er nog niet verwerkte gegevens in de buffer staan en één voor aan te geven tot waar de gegevens in de buffer reeds verwerkt zijn.
 
Wanneer de bovengrens van de buffer vol is moeten de gegevens weer vanaf de ondergrens aangevuld worden. Op die manier werkt men schijnbaar in een kringloop.
 
Er onstaat een probleem wanneer, bij wijze van spreken, de pointer met de nog niet verwerkte gegevens de pointer met de reeds verwerkte gegevens inhaalt.
 
 
Een heel bijzondere vorm van schakelgeheugens zijn de tri-state buffers. Deze geheugens kunnen als output per bit ofwel een "0"-waarde, een "1"-waarde als een "doet er niet toe"-waarde hebben. De "doet er niet toe"-waarde houdt eigenlijk in dat op dat ogenblik, met de output van dat register geen rekening gehouden moet worden. Het is alsof de output van de tri-state buffer op dat ogenblik "losgekoppeld" is van de outputlijnen waarmee hij verbonden is.
 
Dit is op zich geen echte afwijking van het binaire systeem maar wel een handigheidje om bijvoorbeeld uit de mogelijke outputs van verschillende registers alleen de output van één welbepaalde buffer op een bus te kunnen plaatsen.
 
Een tri-state buffer zal zijn output slechts op de bus plaatsen wanneer hij een output enable signaal ontvangt. Van alle buffers die hun output op dezelfde bus plaatsen mag er op hetzelfde ogenblik steeds slechts één buffer output enabled zijn (anders krijg je een onvoorspelbare mengeling van gegevens en bestaat het risico op interne kortsluitingen)!
 
Eén en ander is misschien gemakkelijker te volgen op onderstaande visuele voorstelling waarbij de output van slechts twee tri-state buffers doorgegeven wordt naar één databusje. Zowel de twee tri-state buffers als de ontvangende databus en het ontvangende gewone register hebben in onderstaand voorbeeld allen een bitbreedte van 4 bits (in de realiteit kan dit van één tot "n"-aantal bits gaan).
 
Visuele voorstelling van de samenwerking van 2 tri-state buffers
 
 
Met tri-state buffers kan men dus door het output-enable signaal selectief aan te zetten voor één van de buffers, "kiezen" uit een reeks buffers die hun output in principe allemaal naar dezelfde databus sturen.
 
Tri-state buffers worden ook vaak gebruikt voor het bouwen van multiplexers.
 
 
De A.L.U. of Arithmetic and Logical Unit (in algemeen Nederlands noemt men dit de Rekeneenheid) is één van de twee belangrijkste grote functionele gehelen die we in een CPU kunnen onderscheiden.
 
Het is het geheel van speciale registers en schakelingen waarin allerlei wiskundige en logische bewerkingen in uitgevoerd kunnen worden.
 
Dit gaat (afhankelijk van de soort microprocessor) van eenvoudige optellingen van twee natuurlijke getallen tot het delen van twee zeer grote drijvende kommagetallen. Ook het vergelijken van twee bits, twee getallen of bitstrings tot 32 bits lang behoort tot de standaardbewerkingen die de ALU aankan.
 
De ALU of rekeneenheid krijgt de gegevens waarmee of waarop de bewerkingen moeten uitgevoerd worden (=de operanden) doorgespeeld vanuit het RAM-geheugen; momenteel veel meer vanuit het L1-cache geheugen dat in de processor zelf is ingebouwd. Operanden kunnen ook rechtstreeks in een bepaald rekenregister zitten als het resultaat van een vorige bewerking.
 
Voor sommige bewerkingen in de ALU is slechts één operand nodig, voor andere bewerkingen twee of zelfs nog meer in geval van complexe bewerkingen.
 
In het geval van een bewerking op één operand (bv. inverteren van een bitstring om het two's-complement te kunnen bepalen, of het opschuiven van bits etc.) wordt de operand vaak in een speciaal daarvoor bestemd register gestopt (vb. de ACCU). Gestuurd door de Control Unit (zie verder) wordt in dat betreffende register dan de gewenste bewerking uitgevoerd. Wanneer de bewerking uitgevoerd is bevat het register het resultaat, d.w.z. de oorspronkelijke inhoud van het register is "overschreven" door het resultaat. Men zegt van dergelijke rekenregisters dat ze tegelijkertijd de "source" als de "destination" zijn van de één-operandbewerking.
 
In het geval van twee-operand bewerkingen zit de ene operand in een specifiek source-register terwijl de tweede operand bv. meteen in de ACCU opgeslaan wordt. Na de bewerking bevat de ACCU dan het resultaat van de twee-operand bewerking. Enz.
 
Het resultaat van sommige bewerkingen moet uiteindelijk terug naar het Level-1-cache geheugen of het gewone RAM-geheugen of bv. de harde schijf overgedragen worden. Daartoe moet het resultaat op de interne of extern databus geplaatst worden (de interne databus is de databus binnenin de microprocessor waarmee gegevens tussen de verschillende registers van de microprocessor uitgewisseld kunnen worden).
 
 
 
De C.U. of Control Unit (in algemeen Nederlands: de besturingseenheid) is ook een onmisbaar functioneel geheel in de CPU. Zoals de naam al impliceert is de CU verantwoordelijk voor het besturen en controleren van de processor zelf, dit houdt o.a. in:
Om al die taken te kunnen waarnemen beschikt ook de CU over enkele specifieke registers.
 
 
 
Een microprocessor kan uiteindelijk alleen maar de taken aan waarvoor hij gebouwd is. Deze taken zijn de programma-instructies. De volledige verzameling instructies die een microprocessor aankan noemen we de instructieset (zie hoger).
 
Afhankelijk van zijn type bestaat zo'n instructie uit één of meerdere verschillende delen. Een direct gevolg hiervan is dat niet alle instructies dezelfde lengte hebben. Sommige instructies zijn bv. slechts twee bytes lang, andere zijn misschien vier of zelfs 8 bytes lang.
 
Het eerste deel van een instructie is echter steeds even lang en is een soort identificatiecode van de instructie: de operatie-code of kortweg opcode genoemd.
 
Wanneer een instructie in het instructieregister geplaatst wordt dan kan het instructieregister op basis van de opcode reeds verschillende zaken opmaken, zoals:
Als het een instructie betreft die als operanden de waarde van variabelen nodig heeft dan volgen op de opcode de geheugenadressen waarin de variablen opgeslaan zijn die naar de ALU gestuurd moeten worden (en/of de geheugenadressen waar de resultaten naar toe geschreven moeten worden).
 
Op die manier moet de CU in staat zijn de juiste gegevens uit het geheugen naar de juiste registers in de ALU te sturen. Omgekeerd moet de CU dan ook in staat zijn om de resultaten van de bewerkingen naar de juiste geheugenadressen te sturen.
 
In feite wordt de instructie die in het instructie-register geplaatst wordt, daardoor ook meteen geanalyseerd en geïnterpreteerd. In de Engelstalige literatuur spreekt men dan ook vaak over de "instruction decoder" wanneer men het over het instructie-register heeft.
 
 
 
Een uitvoerbaar computerprogramma is een geheel van (machinetaal-)instructies en data waarmee en waarop de instructies uitgevoerd worden. De instructies moeten in een welbepaalde volgorde uitgevoerd worden. De instructies zijn opgeslaan in elkaar opvolgende geheugencellen. Niet alle instructies hebben echter dezelfde lengte (zie hierboven). Sommige instructies beslaan meer dan één geheugencel. Als "adres van een instructie" in een uitvoerbaar programma wordt in feite het adres van de geheugencel waarin het eerste deel van de instructie staat, bedoeld.
 
De variabelen die in het programma gebruikt zullen worden en eventueel de waarden waarmee ze oorspronkelijk opgevuld zijn, bv. initialisatie waarden, worden tijdens het laden van het programma ook in het werkgeheugen gestockeerd.
 
Na het laden van een uitvoerbaar programma wordt bij het uitvoeren ervan steeds begonnen met de uitvoering van de eerste instructie, nogal logisch he! De eerste instructie van een bepaald type uitvoerbaar programma (bv. .COM of .EXE) staat steeds op een vast geheugenadres. Daarom is het geen enkel probleem om de eerste instructie terug te vinden. Van dan af echter moet er een speciaal mechanisme in werking treden om het beginadres van de volgende instructie te kennen.
 
De Instructie-teller of Program-Counter is een speciaal adresregister waarin het geheugenadres van de eerstvolgende uit te voeren instructie komt te staan. Het principe hierbij is dat men vertrekt van het geheugenadres van de instructie die momenteel uitgevoerd wordt (dus in het opdrachtenregister zit). De opdrachtenregister vindt uit welk type instructie dit is en hoe lang ze is (zie hoger). Die informatie wordt doorgespeeld aan de program-counter. Wanneer nu het geheugenadres van de huidige instructie vermeerderd wordt met het aantal geheugencellen dat de huidige instructie lang is, dan weet men perfect het startadres van de volgende uit te voeren instructie. Bij het uitvoeren van de volgende instructie wordt dan opnieuw op dezelfde wijze het beginadres van de daaropvolgende instructie berekend enz.
 
 
 
Een programma verloopt natuurlijk niet steeds lineair, de éne instructie na de andere. In veel gevallen moet een programma op basis van het resultaat van een bewerking deze, een andere, of zelfs geen (reeks) instructies uitvoeren. Een typisch voorbeeld hiervan zijn de IF THEN instructies. Dit betekent dat soms een reeks instructies overgeslaan moet worden. Hoe weet de microprocessor dan wat het beginadres van de volgende instructie is?
 
Voorwaardelijke spronginstructies (dus op basis van een vergelijking zoals IF A > B) behoren ook tot een bepaald type instructies en hebben dus zelf een bepaalde lengte en vooral ook enkele zeer bijzondere operanden, bijvoorbeeld het beginadres van de instructie waarnaar gesprongen moet worden ingeval dat bv. de ELSE clausule uitgevoerd moet worden. In dergelijke gevallen wordt dan dit adres opgeslaan in een tweede of alternatieve instructie-teller. Afhankelijk van de uistlag van de IF THEN voorwaarde zal dus ofwel verdergegaan worden met het normaal berekende beginadres van de volgende instructie, dan wel met het beginadres dat in de alternatieve program-counter opgeslagen zit.
 
 
 
Nemen we weer even het geval van een eenvoudige IF THEN instructie. In een uitvoerbaar programma vertaalt dit zich in een reeks instructies die moeten uitgevoerd worden als de IF voorwaarde voldaan is (de IF-tak), meteen gevolgd door een reeks instructies die moeten uitgevoerd worden wanneer niet aan de IF voorwaarde voldaan is (de ELSE-tak).
 
In het geval dat aan de IF voorwaarde voldaan is begint de microprocessor meteen met deze reeks instructies maar dan moet aan het einde van de IF-tak gesprongen worden OVER de instructies die de THEN-tak uitmaken (zoniet dan zouden zowel de IF als de ELSE clausule uitgevoerd worden). Met andere woorden, in het uitvoerbaar programma moet hier een onvoorwaardelijke sprongopdracht opgenomen worden die er voor zorgt dat na het uitvoeren van de IF-tak het programma verder gaat met de eerste instructie die volgt op de ELSE-tak.
 
Dit is technisch gezien een eenvoudige klus voor de microprocessor. Wanneer het opdrachten-register aan de opcode merkt dat er een onvoorwaardelijke sprong-opdracht uitgevoerd moet worden dan wordt het geheugenadres dat als operand meegegeven is in de spronginstructie gewoon aan de opdrachten-teller doorgegeven. In dit geval moet de opdrachten-teller niet eens rekenen; gewoon een adres overnemen.
 
 
 
Bij het oproepen van een subroutine wordt er in feite een sprong gemaakt naar de eerste instructie van die subroutine. De laatste machine-instructie van een subroutine is de opdracht om de subroutine te beëindigen, m.a.w. om verder te gaan met de instructie die volgt op de spronginstrcutie die de subroutine opriep.
 
Zoals we eerder reeds aanhaalden hebben we hier het probleem dat je vanop verschillende plaatsen in een programma dezelfde subroutine kan aanroepen, m.a.w. de subroutine zelf "weet" niet vanwaar ze opgeroepen is, dus ook niet naar waar het heen (beter nog: terug) moet na het beëindigen van de subroutine.
 
Dit probleem lost men op door de combinatie van twee technieken:
  1. bij het oproepen van een subroutine wordt bij het uitvoeren van de sprong-opdracht naar het begin van de subroutine ook het beginadres van de daaropvolgende instructie berekend en doorgegeven aan de stack (de stack-pointer wordt met één eenheid verhoogd en in de geheugencel waarnaar de nieuwe stack-pointer naar verwijst, wordt het beginadres van de instructie opgeslaan die zal moeten uitgevoerd worden na het einde van de subroutine);
     
  2. de laatste opdracht van een subroutine houdt in dat de program-counter niet een nieuw adres berekend, maar dat er het adres in overgebracht wordt die via de stack kan opgehaald worden.
Daar deze stack werkt volgens het LIFO-principe wordt het ook meteen mogelijk dat er vanuit een subroutine nog een andere subroutine opgeroepen wordt, enzv. en dat men toch iedere keer weer netjes terugkomt vanwaar men vertrokken is.
 
 
 
Nu we de functie van de belangrijkste bouwstenen van een CPU overlopen hebben en we ondertussen de werking van verschillende systemen toegelicht hebben, kunnen we een samenvattend beeld geven van hoe een microprocessor een programma uitvoert.
 
Een programma moet eerst onder de vorm van machinetaal-instructies in het werkgeheugen opgeslaan worden (via de externe databus kan het programma bijvoorbeeld van de harde schijf naar het gewone RAM-geheugen gekopieerd worden).
 
Het eerste blok met instructies wordt naar de Control Unit van de processor overgebracht.
 
Daardoor wordt uiteraard ook de allereerst uit te voeren instructie in het opdrachtenregister van de CU overgebracht en daar geanalyseerd (de eerste instructie van een bepaald type programma staat steeds op een vast adres, dus dit adres zal in feite de eerste inhoud van de program-counter zijn).
 
Op basis van het analysewerk van het opdrachtenregister worden de nodige gegevens uit het werkgeheugen opgehaald en in de juiste registers van de ALU overgebracht (via een samenwerking van de externe en interne databussen, van de adresbus en de interne controlebus).
 
Tegelijkertijd wordt in de program-counter reeds het beginadres van de volgende instructie berekend.
 
De juiste bewerking wordt in de ALU uitgevoerd en de resultaten daarvan zijn beschikbaar in de "destination"-registers van de desbtreffende bewerkingen (voorbeeld: de ACCU).
 
De volgende instructie wordt aan de hand van de nieuwe waarde in de program-counter opgehaald en in het opdrachtenregister overgebracht en de volgende opdrachtcyclus kan herbeginnen.
 
In een aantal bijzondere gevallen wordt het beginadres van de volgende instructie niet berekend door de program-counter maar wordt er beroep gedaan op de alternatieve programcounter, of op het geheugenadres dat doorgegeven wordt in een onvoorwaardelijke sprongopdracht, of gaat men het adres van de volgende instructie afhalen van de stack.
 
 
Toemaatje
 
In de literatuur noemt men de volledige afhandeling van één machine-instructie wel eens een von Neumann-Controle-cyclus naar de wetenschapper die dit verwerkingssysteem het eerste voorstelde. De voorbereidingsfase van zo'n cyclus, gedurende dewelke alle elementen die nodig zijn om de instructie uit te voeren worden opgehaald en in de juiste registers worden overgebracht noemt men dan de fetch-cyclus, terwijl het uitvoeren van de berekening of het terug stockeren van de resultaten in het geheugen de execute-cyclus genoemd wordt.
 
 
 
 
Naar de [homepage (zonder frames)].   Naar de [homepagina (met frames)].
Naar de [ vorige logische pagina in deze reeks ]    Naar de [ volgende logische pagina in deze reeks ]
 
Deze pagina bevindt zich op een WWW-server van de [Hogeschool Gent]. Voor commentaar, vragen of suggesties i.v.m. deze pagina ben je steeds welkom bij [Lucas De Cocker], lector mediakunde, K.L. Ledeganckstraat 8, B-9000 Gent. [E-mail = Lucas.DeCocker@hogent.be]
 
Het gebruik van dit document is onderworpen aan de wetten op het auteursrecht ©. Wens je deze inhoud (of delen ervan) te kopiëren of op een andere manier te vermenigvuldigen, aarzel dan niet om met mij contact op te nemen.