Les 4: Gegevensmanipulatie-instructies en machinemodellen

Presentatie over: "Les 4: Gegevensmanipulatie-instructies en machinemodellen"— Transcript van de presentatie:

1 Les 4: Gegevensmanipulatie-instructies en machinemodellen
“Everything that can be invented has been invented.” — Charles H. Duell, Commissioner, U.S. Office of Patents, 1899

2 Von Neumann-machine Fysiek zicht
BUS BUS adres adres CVE Controle controle cache data data klok klok controle controle ALU ALU registers registers Geheugen:bau-cellen RAM Geheugen In een eerdere les bespraken we reeds de Von Neumann machine, en het fysiek zicht erop. We concentreren ons nu op de ALU in de CVE (centrale verwerkingseenheid) en de operaties die deze ALU kan uitvoeren. Invoer/Uitvoer Invoer/Uitvoer

3 Overzicht Aritmetische instructies Logische instructies
Vlottende-komma-instructies MMX-instructies SSE/SSE2-4-instructies Varia Machinemodellen

4 Operatorgedeelte O1 O2 c-bit s-bit o-bit z-bit controle R S
De ALU is een circuit dat 2 operandi en controlesignalen als input heeft, en een resultaat en statusbits als output. De statusbits bevatten toestandsinformatie over de uitgevoerde functie, en worden typisch opgeslagen in het toestandsregister van de CVE. Een aantal van die statusbits kunnen zijn: c-bit: carry, overdracht uit de meest beduidende bit s-bit: sign, geeft het teken van het resultaat aan o-bit: overflow, resultaat is te groot of te klein om te worden voorgesteld z-bit: zero, resultaat is nul

5 Toestandsbits bij 32-bit optelling R = 01 + 02
c In dit voorbeeld van een 32-bit optelling, is de betekenis van de toestandsbits als volgt: s = 1 als R<31:31> = 1 z = 1 als R = 0 c = 1 als carry(31) = 1 Terminologie: A<m:n> verwijst naar het getal voorgesteld door het bitpatroon te vinden in A tussen de mde en de nde bit (randen incl.), waarbij de 0de bit de minst beduidende is, en de 31e de meest beduidende bit. Carry(m) duidt aan of er een overdracht was bij de bitsommatie van O1<m:m>+O2<m:m>+carry(m-1). z-bit = 1 indien resultaat = 0

6 Overflow overflow 100 101 110 111 000 001 010 011 -4 -3 -2 -1 1 2 3
1 2 3 010 2 011 3 010 2 101 5 Overflow kan gedetecteerd worden als (bij 32-bit optelling van 2-complementgetallen) carry(31) XOR carry(30). Met andere woorden: als bij de optelling de carry naar de tekenbit (carry(30)) verschillend is van de carry uit de tekenbit (carry(31)) dan is er sprake van overflow. Als 2 positieve operandi worden samengeteld, en het resultaat kan worden voorgesteld binnen de getalrepresentatie, dan is er noch carry(31) noch carry(30); Als 2 negatieve operandi worden samengeteld, en het resultaat kan worden voorgesteld binnen de getalrepresentatie, dan is er zowel carry(31) als carry(30); Als een negatieve en een positieve operand worden samengeteld, kan er nooit overflow zijn. Als het positieve getal de grootste absolute waarde heeft, zal er zowel carry(31) als carry(30) zijn, zoniet is er noch carry(31) noch carry(30). Als de som van 2 positieve operandi overflow geeft, is er steeds enkel carry(30) - die ervoor zorgt dat R<31:31>==1 en het resultaat dus “negatief” is. Als de som van 2 negatieve getallen overflow geeft, is er steeds enkel carry(31) - zodat R<31:31>==0 en het resultaat dus “positief” is. o-bit = carry(31) xor carry(30)

7 Getallencirkel 000 -1 111 001 1 aftrekken optellen -2 110 010 2 -3 3
1 2 3 -4 -3 -2 -1 111 001 aftrekken optellen 110 010 Bij modulorekenen werkt men met de getallencirkel. Alle voor te stellen getallen huizen op de getallencirkel. Het resultaat van de optelling van 2 positieve getallen kan een negatief getal opleveren, als er sprake is van overflow. Voor de 3-bit getallencirkel van de dia is bv. 3+1 = -4 en -4-2=2. Men maakt immers een gewone binaire optelling, en gaat daarna het resultaat als 2- complementgetal interpreteren (zie vroeger). 101 011 100

8 Saturatierekenen Overflow kan ook opgevangen worden door de waarden te plafonneren op de extremen 100 101 110 111 000 001 010 011 -4 -3 -2 -1 1 2 3 + (max) + (min) Bij saturatierekenen zal men op overflow reageren door het resultaat dat niet kan voorgesteld worden, te vervangen door het grootste (voor positieve overflow) of kleinste (voor negatieve overflow) getal dat men wel kan voorstellen. Ofschoon het resultaat verkeerd is, geeft dit soms betere resultaten omdat het teken niet omklapt. Het resultaat sluit meestal dichter aan bij de verwachtingen van de programmeur en de gebruiker.

9 Saturatierekenen saturatie overflow modulo
Beeldverwerking is een toepassing waarin saturatierekenen nuttig kan gebruikt worden. Beelden worden voorgesteld door beeldelementen of pixels (picture elements). Een zwart/wit beeld bestaat uit grijswaarden die b.v. kunnen variëren tussen 0 en 255: 0 is zwart en 255 is wit. Bij kleurenbeelden zullen er vaak drie componenten gebruikt worden (rood, groen en blauw, RGB) die elk afzonderlijk waarden kunnen krijgen van 0 tot en met 255. Een beeld kan b.v. helderder gemaakt worden door de pixelwaarden te verhogen met b.v. 10%. Probleem hierbij is dat de waarde 250 (zeer helder) na de transformatie 275 wordt, hetgeen niet kan voorgesteld worden in 8 bit en als waarde 11 zal opgeslagen worden (zeer donker). Om te vermijden dat helderder dan helder zeer donker wordt kan men saturatierekenen toepassen. In dat geval zal de waarde geplafonneerd worden op 255, de meest heldere waarde. Dit is een speciale toepassing waarin saturatierekenen nuttig kan zijn. De gevallen waarin men overflow wenst te detecteren zijn echter veel groter. In die gevallen moeten men de overflow-vlag testen na elke bewerking. overflow modulo

10 Resoluties hoofdbewerkingen
Som: n bit + n bit  (n+1) bit Verschil: n bit - n bit  (n+1) bit Product: n bit * n bit  (2n) bit Deling: n bit / n bit  n bit Deze dia geeft enkele wetmatigheden voor bewerkingen met binaire getallen. De som van 2 n-bit getallen kan maximaal een (n+1)-bit getal zijn Het verschil van 2 n-bit getallen kan maximaal een (n+1)-bit getal zijn Het product van 2 n-bit getallen kan maximaal een (2n)-bit getal zijn Het (gehele) quotiënt van 2 n-bit getallen kan maximaal een n-bit getal zijn

11 Alle waarden zijn hexadecimaal!
Optelling 32 00 04 08 0C 10 00B00300 A …. add doel, bron add eax, ebx add eax, 10h eax 1 add eax, [4] De animatie in de dia toont de optelling van een register met een ander register, met een letterlijke constante, en met de inhoud van een geheugenlocatie. Bemerk ook dat een aantal statusvlaggen door de ALU worden ingesteld naargelang het resultaat van de berekening. Bij de laatste optelling wordt het tekenbit op 1 gezet om aan te geven dat het resultaat negatief is. ebx Instructie:add s o c z Alle waarden zijn hexadecimaal!

12 Alle waarden zijn hexadecimaal!
Aftrekking 32 00 04 08 0C 10 00B00300 A …. sub doel, bron sub eax, ebx sub eax, 10h eax 0091C000 8091BFF0 1 0091BFF0 sub eax, [4] De animatie in de dia toont de aftrekking van een register met een ander register, met een letterlijke constante, en met de inhoud van een geheugenlocatie. Bemerk ook dat een aantal statusvlaggen door de ALU worden ingesteld naargelang het resultaat van de berekening. Bv. bij de laatste aftrekking wordt het overflow-bit op 1 gezet om aan te geven dat het correcte resultaat niet kan worden voorgesteld; ook het tekenbit en de carry-bit komen op 1 te staan. ebx Instructie:sub s o c z Alle waarden zijn hexadecimaal!

13 Integer hoofdbewerkingen
add d,s adc d,s sub d,s sbb d,s mul s imul s div s idiv s neg d inc d dec d d = d + s d = d + s + c d = d - s d = d - s - c vermenigvuldiging (unsigned) vermenigvuldiging (signed) deling (unsigned) deling (signed) d = -d d = d + 1 d = d - 1 De voornaamste bewerkingen op gehele getallen worden in de dia voorgesteld. Enigszins bijzonder zijn de operaties ADC en SBB waarbij de carrybit (van de vorige operatie) betrokken wordt in de optelling/aftrekking. Dit kan nuttig zijn indien een operatie op zeer brede operandi wordt uitgevoerd door de operandi op te splitsen in verschillende delen ter grootte van de woordbreedte van de architectuur. adc = add with carry sbb = subtract with borrow Enkel voor het product en voor de deling dient men een onderscheid te maken tussen binaire en 2-complementgetallen.

14 64-bit optelling mov eax,[10h] mov ebx,[14h] add eax,[18h]
1ch 20h 24h 28h mov eax,[10h] mov ebx,[14h] add eax,[18h] adc ebx,[1ch] mov [20h],eax mov [24h],ebx ebx [14h] eax [10h] [1ch] [20h] [24h] [18h] + De dia illustreert hoe op een 32-bit machine als de Pentium een 64-bit optelling kan uitgevoerd worden, met behulp van de ADD- en ADC-operaties. Eerst worden de 2 minst beduidende 32-bit opgeteld (ADD), en daarna de 2 meest beduidende 32-bit (ADC). Door gebruik van ADC voor de 2e optelling, wordt de carry van de optelling van de minst beduidende helften overgedragen naar de optelling van de meest beduidende helften. Bemerk ook dat in deze optelling tot uiting komt dat de Pentium een little endian processor is. De minst beduidende bytes staan immers op de lagere geheugenadressen (10; 18 en 20).

15 mul & div mul bron edx:eax = bron * eax (bin) imul bron
edx:eax = bron * eax (2c) div bron eax = edx:eax / bron (bin) edx = edx:eax % bron De dia toont de operaties voor vermenigvuldiging en deling in de Pentium. In de instructie zelf kan slechts naar één operand verwezen worden. Voor de vermenigvuldiging (mul/imul) zit de andere operand in EAX, en het resultaat komt in EDX:EAX (of dus: de meest beduidende 32-bit van het 64-bit resultaat komen in EDX, de minst beduidende komen in EAX). De registers EDX:EAX worden een registerpaar genoemd. Voor de deling (div/idiv) zit de andere operand in EDX:EAX. Het quotiënt van de gehele deling komt in EAX terecht, de rest komt in EDX terecht. Bij de deling komt in register eax de afgekapte vorm van het resultaat van de deling. De rest in edx heeft steeds het teken van het deeltal en er moet gelden dat quotiënt * deler + rest = deeltal. Dus: -4 / 3 levert in -1 in eax op, en -1 in edx en -4 / -3 levert 1 in eax op en -1 in edx. Mul/imul werken op binaire en 2 complement getallen resp. Idem voor div en idiv. Instructie:mul Instructie:div deeltal = quotiënt * deler + rest en rest * deeltal ≥ 0.

16 imul: 3 varianten imul bron edx:eax = bron * eax imul d,bron
d = d * bron imul d,bron1,bron2 d = bron1 * bron2 Voor de imul-variant zijn er twee bijkomende formaten: een traditioneel formaat met twee operandi, en een formaat met drie operandi. In deze gevallen zal het resultaat echter niet in dubbele precisie voorgesteld worden, maar wel in dezelfde precisie als de operandi. Het is aan de programmeur om ervoor te zorgen dat de resolutie niet overschreden wordt. Indien men het resultaat beperkt tot de breedte van de operandi, dan zijn deze twee formaten zowel bruikbaar voor de binaire als voor de 2-complement producten. Het feit dat de resolutie van het resultaat hier beperkt wordt, is in de meeste gevallen helemaal niet erg. In een hoge-niveauprogrammeertaal zal men het resultaat maar in zeer uitzonderlijke gevallen bijhouden in een veranderlijke met een groter bereik. Doorgaans wordt een veranderlijke van hetzelfde type als de operandi gebruikt. Indien men overflow wil detecteren, dan kan men daarvoor de o-vlag raadplegen.

17 Product in helften b.v. Alpha (64 bit) mulq a,b,c
reg[c]:=(reg[a]*reg[b])<63:0> umulh a,b,c reg[c]:=(reg[a]*reg[b])<127:64> Andere architecturen zoals de alpha-architectuur hebben ervoor geopteerd om het product in twee stukken te laten berekenen. De laagste 64 bit voor de courante gevallen, en de hoogste 64 bit voor die omstandigheden waarin dit vereist zou zijn. <n1:n2> bits n1 tot n2 (neerwaarts genummerd)

18 Deling Indien deling door een constante, kan dit ook door vermenigvuldiging, b.v. deling door 15 X/15 =X*(1/15) 1/15 = …2= 50/15 = * = Een deling is een complexe operatie. Indien men deelt door een vast getal, dan kan men de deling soms ook benaderen door middel van een product met de reciproque van het getal. Indien de constante factor in het product echter een benadering is (wat meestal het geval zal zijn), dan moet men er wel rekening mee houden dat het resultaat ook slechts een benadering is. Dit wordt geïllustreerd in bijgaand voorbeeld met een 16-bit vermenigvuldiging van X en 1/15. De 16-bit voorstelling van 1/15 is (hex). Het product met 50 geeft het juiste resultaat 3. Het product met 45 geeft 2 wat niet juist is. 45/15 = 002D16 * = 0002.FFFD16

19 Deling X/15 =X*(1/15) 1/15 = …2= 1/15 = …2 >> = >> 3 45/15 = 002D16 * ( >> 3) = (002D16 * ) >> = >> = De deling kan preciezer gemaakt worden door 1/15 nauwkeuriger op te slaan. Dit is mogelijk door de voorstelling van de fractie zover naar links te schuiven totdat de eerste 1-bit na de punt komt te staan. Men vermenigvuldigt dus eigenlijk met een getal dat n keer te groot is, maar dit kan men compenseren door het resultaat opnieuw te delen door n (en als n een macht van 2 is, kan dit door gewoon te verschuiven). Ook in dit geval is het resultaat dan correct (maar het hangt wel af van de juiste benadering van 1/15<<3).

20 Vergelijkingen cmp d,s test d,s d-s  vlaggen d ‘and’ s  vlaggen
Instructie:cmd Instructie:test cmp: vergelijken van waarden: >, =, < test: testen van bits: aan, uit De dia toont een aantal essentiële vergelijkingsoperaties. De operaties bewaren hun resultaat in de statusvlaggen van het EFLAGS-register. Operaties die op basis van het resultaat van de vergelijking werken, zullen dus naar de toestand van de statusvlaggen kijken om te beslissen wat ze moeten doen. CMP doet hetzelfde als SUB, maar gooit het resultaat weg (met behoud van de toestandsbits). CMP kan gebruikt worden om de waarde van twee bitpatronen met elkaar te vergelijken. TEST doet hetzelfde als AND, maar gooit het resultaat weg (met behoud van de toestandsbits). TEST kan gebruikt worden om na te gaan of bepaalde bits aan of af staan (aan de hand van het masker s, en het testen op het al dan niet 0 zijn van het resultaat). Complexere condities zoals ‘kleiner dan of gelijk aan’ zullen niet zomaar kunnen afgelezen worden uit de toestandsbits, maar zullen ontstaan uit een combinatie van de elementaire toestandsbits.

21 Natuurlijke getallen (binair)
c 010 2 111 ? 011 3 001 1 Voor de vergelijking van binaire getallen wensen we te kunnen uitdrukken dat getal a groter is dan getal b (uitgedrukt als binair getal). Om de condities te kunnen begrijpen proberen we te achterhalen wanneer a < b. We beginnen met een cmp-instructie uit te voeren, waardoor a-b berekend wordt. Indien a < b, dan zal er moeten geleend worden uit de hoogste rang (c==1). De voorwaarde a<b kan m.a.w. uitgedrukt worden door de voorwaarde (c==1). In de IA32 wordt de voorwaarde a<b op binaire getallen omschreven als “below”. Deze voorwaarde is hetzelfde als “not (above or equal)”, waardoor we meteen ook de voorwaarde voor “above or equal” kennen: c == 0. De voorwaarde equal komt tot uiting doordat (a-b)==0 of nog z==1. De voorwaarde “below or equal” geeft dan: (c==1) or (z==1) hetgeen hetzelfde is als (c or z) == 1. De voorwaarde “above” is het zelfde als “not (below or equal)” en wordt dus uitdrukt door (c or z) == 0. a nbe (c or z) == 0 above ae nb c == 0 above or equal b nae c == 1 below be na (c or z) == 1 below or equal binair

22 Gehele getallen (2-complement)
o == 1 o == 0 s == 1 s == 0 010 2 111 -1 011 3 001 1 010 2 101 ? 101 -3 011 ? Een volledig analoge redenering kan gevoerd worden voor de 2- complementgetallen. Opnieuw beginnen we met het zoeken van de voorwaarde voor a < b of a-b < 0. In het bovenstaande plaatje worden er vier mogelijke gevallen geschetst. Indien a<b, dan zou men veronderstellen dat a-b<0, en dat is ook zo, op voorwaarde dat het resultaat van a-b kan voorgesteld worden. In de onderste gevallen geeft de berekening van a-b echter aanleiding tot een overflow. In die gevallen moeten we dubbel voorzichtig zijn. Een blik op de tabel leert ons dat a<b indien (s == 1) xor (o == 1), of nog indien (s xor o) == 1. Op volledig analoge manier als bij de binaire getallen kunnen nu de andere condities afgeleid worden. Merk op dat men bij 2-complementgetallen spreekt van “less” en “greater”, en bij binaire getallen van ‘below” en “above”. g nle ((s xor o) or z) == 0 greater ge nl (s xor o) == 0 greater or equal l nge (s xor o) == 1 less le ng ((s xor o) or z) == 1 less or equal 2-comp

23 Conditiecodes 2-comp binair z z == 1 zero c c == 1 carry
o o == 1 overflow p p == 1 parity s s == 1 sign nz z == 0 no zero nc c == 0 no carry no o == 0 no overflow np p == 0 no parity ns s == 0 no sign g nle ((s xor o) or z) == 0 greater ge nl (s xor o) == 0 greater or equal l nge (s xor o) == 1 less le ng ((s xor o) or z) == 1 less or equal e z == 1 equal ne z == 0 not equal a nbe (c or z) == 0 above ae nb c == 0 above or equal b nae c == 1 below be na (c or z) == 1 below or equal 0100 0010 0000 1010 1000 0101 0011 0001 1011 1001 1111 1101 1100 1110 0111 0110 2-comp Dit geeft een overzicht van alle condities die men kan gebruiken. Er zijn er precies 16 verschillende in totaal, waardoor ze kunnen gecodeerd worden in 4 bits. Sommige benamingen zijn verschillend (b.v. zero en equal), maar worden door dezelfde combinatie van toestandsbits uitgedrukt. binair

24 Overzicht Aritmetische instructies Logische instructies
Vlottende-komma-instructies MMX-instructies SSE/SSE2-4-instructies Varia Machinemodellen

25 Logische Operaties and d,s or d,s xor d,s not d d = d ‘and’ s
d = d ‘or’ s d = d ‘xor’ s d = ‘not’ d De dia toont een aantal instructies die bitsgewijze logische operaties uitvoeren.

26 Verschuivingen shl d,n shr d,n sal d,n sar d,n shld d,s,n shrd d,s,n
rol d,n ror d,n rcl d,n rcr d,n d = d << n d = d >> n aritmetisch d = d << n aritmetisch d = d >> n d = (d:s << n)<63:32> d = (s:d >> n)<31:0> bitrotatie naar links bitrotatie naar rechts uitgebreide bitrotatie naar links uitgebreide bitrotatie naar rechts De dia toont een aantal schuifoperaties. SHL (shift left) en SHR (shift right) zijn gewone logische verschuivingen (de ingevoegde bits zijn 0) SAL (shift aritmetic left) is niets anders dan SHL, maar SAR (shift aritmetic right) wijkt af van de gewone SHR omdat de ingevoegde bits dezelfde waarde hebben als de tekenbit van de verschoven waarde. SHLD en SHRD voeren logische shiftoperaties uit op een registerpaar. ROL (rotate left) en ROR (rotate right) zijn bitrotaties, wat dus betekent dat de weggeschoven bits er aan de andere kant weer bijkomen. Bij RCL (rotate with carry left) en RCR (rotate with carry right) wordt met het carry-bit een 33-bit rotatie gecreëerd. … zie verder…

27 Schuifoperaties Schuif 1 positie naar links C=1 Schuif 5 posities naar links C=0 Bij een schuifoperatie worden de bits eenvoudigweg verschoven binnen het n- bit woord, dit kan zowel naar rechts als naar links. Bij een schuifoperatie naar links, worden er van rechts nullen ingevoegd. De laatste bit die er dan links uitvalt, wordt bewaard in de carrybit. Instructie: schuifoperatie

28 Schuifoperaties SHL C SHR C SAL C SAR C
SHR C SAL C SHL en SHR zijn gewone logische verschuivingen (de ingevoegde bits zijn 0) SAL is niet anders dan SHL, maar SAR wijkt af van de gewone SHR omdat de ingevoegde bits dezelfde waarde hebben als het tekenbit van de verschoven waarde, anders gezegd blijft het teken van het resultaat bewaard. Dit heeft als voordeel dat de SAR operatie kan dienen als een gehele deling door 2, zowel voor positieve als negatieve getallen. SAR C

29 Schuifoperaties SHLD C D S SHRD S D C
SHLD en SHRD voeren logische shiftoperaties uit op een registerpaar. De operatie voert eigenlijk een 32-bit schuifoperatie uit, waarbij de in te schuiven bits uit een ander register afkomstig zijn. D C

30 Rotatieoperaties C C C C ROL ROR RCL RCR Instructie: rotatieoperatie
ROL en ROR zijn bitrotaties, wat dus betekent dat de weggeschoven bits er aan de andere kant weer bijkomen. Bij RCL en RCR wordt met de carry-bit een 33-bit rotatie gecreëerd. RCR C Instructie: rotatieoperatie

31 Schuifoperaties: logisch
links 1  x 2 links 1  x 2 rechts 1   2 rechts 1   2 Bij logische schuifoperaties zal men zowel bij het naar links als bij het naar rechts schuiven, nullen invoegen om de niet-opgevulde plaatsen op te vullen. Numeriek komen de schuifoperaties overeen met het vermenigvuldigen met 2 (naar links schuiven) of delen door 2 (naar rechts schuiven). Merk op dat het gaat om een gehele deling: bv. 7/2=3, en waarbij het resultaat afgekapt wordt. links n  x 2n rechts n   2n

32 Schuifoperaties: aritmetisch
links 1  x 2 links 1  x 2 rechts 1   2 rechts 1   2 rechts 1   2 Bij aritmetische schuifoperaties let men erop dat wanneer men naar rechts schuift, men niet zomaar nullen inschuift (zoals bij logische schuifoperaties). Daarentegen zullen de ingeschoven bits (aan de linkerkant) van dezelfde waarde zijn als de tekenbit van de bitrij vóór de schuifoperatie. Aldus blijft de schuifoperatie overeenkomen met het vermenigvuldigen met 2 (naar links schuiven) of delen door 2 (naar rechts schuiven) – zowel voor binaire als voor 2-complementgetallen. Merk op dat dit een deling is waarvan het teken van de rest positief is, en niet hetzelfde teken draagt als het deeltal (zoals dit bij div het geval is). Dit geeft soms wat vreemde effecten. Zo zal bij het verschuiven naar rechts de waarde -1 steeds opnieuw -1 opleveren, ongeacht het aantal bits waarover men verschuift. -1 / 2 = -1 rest 1 Proef: -1 * = -1 rechts 1   2

33 Oefening 000011 001011 101011 sal 2 001100 101100 101100 sar 2 000011 111011 111011 shl 2 shr 2 001011 000011 101011 001100 101100 Dit is voorbeeld dat duidelijk laat zien wat het verschil is tussen aritmetische en logische verschuivingen, en hoe de beide zich gedragen in de aanwezigheid van overflow.

34 Voorbeeld j := i*40+10 ; reg[eax] := mem32[i] mov eax, [10]
mov ebx, eax shl ebx, 3 shl eax, 5 add eax, ebx add eax, 10 mov [14], eax ; reg[eax] := mem32[i] ; reg[ebx] := ‘i’ ; reg[ebx] := ‘i’*8 ; reg[eax] := ‘i’*32 Het voorbeeld in de dia illustreert hoe met schuifoperaties vermenigvuldigingen kunnen uitgevoerd worden. Op oudere processors werd dit vaak gebruikt omdat de vermenigvuldigingsoperaties veel trager waren dan een verschuiving. Het feit dat er meer instructies aan te pas komen, mag dus niet verkeerd geïnterpreteerd worden als zou deze instructiereeks trager zijn. De meeste compilers zullen ook vandaag nog vermenigvuldigingen met een macht van 2 vervangen door een verschuiving naar links. Vooral bij adresberekeningen kan men er baat bij hebben de datastructuur zodanig te kiezen dat er met machten van 2 moet vermenigvuldigd worden. Sommige berekeningen zijn van de vorm a+b*2n, met n een kleine waarde. In die gevallen kan de lea instructie ook gebruikt worden om het product en de som in één keer uit te rekenen. b.v. lea ebx, [eax+ecx*4] Door het effectieve adres te berekenen wordt immers eax+ecx*4 berekend. In de dia is ‘i’ een verkorte notatie voor mem32[i]. ; reg[eax] := ‘i’*8+’i’*32 ; reg[eax] := ‘i’*8+’i’*32+10 ; mem32[j] := reg[eax]

35 Product door verschuivingen
x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x 11 x 12 x2+x1 x4-x1 011 0100 0101 0110 0111 01000 01001 01010 01011 01100 101 1100 1011 1010 1001 1000 10111 10110 10101 10100 x4 x4+x1 x4+x2 x8-x2 x8-x1 x8 x8+x1 Op deze dia staan een aantal mogelijkheden om factoren te vormen door middel van sommen en verschillen van verschuivingen. De tweede kolom gebruikt hiervoor alleen maar optellingen. De derde kolom gebruikt alleen maar verschillen. Merk de gelijkenis op tussen de binaire voorstelling van de factoren, en de 2-complementvoorstelling van de genegeerde factor. x8+x2 x8+x2+x1 x16-x4-x1 x8+x4 x16-x4

36 Soms combinatie van de twee:
Verschuivingen Soms combinatie van de twee: x 57 = x64 - x8 + x1 x 113 = x128 - x16 + x1 Soms kan het eenvoudiger door sommen en verschillen te mengen.

37 Bit test instructies bt d, o bts d, o btr d, o btc d, o
c = d<o:o> c = d<o:o>; d<o:o> = 1 c = d<o:o>; d<o:o> = 0 c = d<o:o>; d<o:o> = d<o:o> Deze instructies hebben tot doel om een particulier bit uit de d-operand te selecteren (bit nummer ‘o’). Deze bits worden geteld van rechts naar links, te beginnen bij nul indien d een register betreft. Er wordt met andere woorden een aflopende bitnummering gebruikt. (bt: bit test; bts: bit test and set; btr: bit test and reset; btc: bit test and complement). Instructie: bitoperaties

38 Bit scan instructies bsf d, s bsr d, s d = minst significante 1-bit
d = meest significante 1-bit Deze instructies gaat op zoek naar het eerste niet-nul bit in de operand s (in voorwaartse of achterwaartse richting). Het resultaat komt in de operand d. Indien er geen 1-bit gevonden wordt, dan wordt de z-flag aangezet en is het resultaat in d onbepaald. Er wordt een aflopende bitnummering gebruikt. (bsf: bit scan forward; bsr: bit scan reverse) d = index van bit, neerwaarts genummerd Indien allemaal 0: d = onbepaald, z=1

39 Set byte on condition set<cc> d d = conditiecode setge al
seto ah reg[al] = ge ? 1 : 0 reg[ah] = o ? 1 : 0 Deze instructie kopieert een particuliere conditiecode (zie de vorige dia’s voor een bespreking van de 16 verschillende condities die kunnen optreden) naar de operand d die op basis hiervan de waarde 1 of 0 krijgt. Deze constructie is zeer nuttig ter ondersteuning van hoge-niveautaalinstructies zoals a = (b==c); waarbij het resultaat van de vergelijking in een veranderlijke moet gekopieerd worden als 0 of 1. Indien met niet 0 of 1 maar wel 0 of 0ffh in de operand d wenst te krijgen, kan men de tegenovergestelde conditie (deze bestaat steeds) in de operand d kopiëren en dan de waarde met 1 verminderen. setno al dec al reg[al] = o ? 0ffh : 00h

40 Overzicht Aritmetische instructies Logische instructies
Vlottende-komma-instructies MMX-instructies SSE/SSE2-4-instructies Varia Machinemodellen

41 Vlottende-komma-registerverzameling
79 78 64 63 s exp mantisse st st(1) st(2) st(3) st(7) st(6) st(5) st(4) De vlottende-kommaregisterverzamelling van de IA32 architectuur bestaat uit 8 registers van elk 80 bit breed. Een dergelijk register kan dubbele extended- precisie vlottende-kommagetal bevatten met de hierboven opgegeven layout. De registers zijn georganiseerd in een stapelstructuur. Het register st wijst naar de top van de stapel, st(1) zit 1 element onder de top van de stapel enz. Register st(7) zit het diepst in de stapel. Registers: vlottende-komma

42 Datatypes FP Enkelvoudige precisie (32 bit)
FP Dubbele precisie (64 bit) FP Dubbele extended precisie (80 bit) Integer woord (16 bit) Integer dubbelwoord (32 bit) Integer quadwoord (64 bit) BCD 18 nibbles + tekenbyte (80 bit) Naast vlottende-kommagetallen ondersteunt de vlottende-komma-eenheid ook nog operaties op (lange) integers, en op grote BCD-getallen.

43 Adresseermodes Zuivere stapeladressering fadd st(1) = st+st(1); pop
Registeradressering fadd st(i) st = st+st(i) fadd st(i),st st(i) = st+st(i) fadd st,st(i) st = st(i)+st faddp st(i),st st(i) = st+st(i); pop De vlottende-komma-eenheid beschikt over een aantal speciale adresseermodes om de gegevens op de vlottende-kommastapel te kunnen gebruiken. Heel wat vlottende-komma-operaties kunnen met verschillende adresseermodes gebruikt worden. Om de notatie niet te verzwaren wordt hier st(n) gebruikt i.p.v. reg[st(n)]. Uit de context is echter duidelijk wat er precies bedoeld wordt. Geheugenadressering fadd <ae> st = st+mem[ae]

44 Vlottende-kommabewerkingen
fadd fsub fdiv fprem fmul fabs fchs fcomi FP optelling verschil deling rest na deling vermenigvuldiging absolute waarde st = abs(st) negatie st = - st FP compare and set eflags De dia toont een lijst met een selectie van de vlottende-kommabewerkingen voor de Pentium.

45 Wiskundige functies fsqrt fsin fcos fptan fpatan fyl2x fyl2xp1 f2xm1
vierkantswortel sinus cosinus tangens arcus tangens logaritme st(1) = st(1)*log2(st); pop logaritme st(1) = st(1)*log2(st+1); pop exponent st = 2st-1 De vlottende-komma ALU ondersteunt ook rechtstreeks een aantal gekende functies uit de analyse. Door middel van de regels van de goniometrie kunnen ook de andere goniometrische functies afgeleid worden. Van sommige logaritmische functies bestaan er varianten zoals fyl2xp1 die moeten toelaten om het 2-logaritme in de zeer dichte buurt van 1 te berekenen

46 Load-store operaties fbld fbstp fild fist fld fst
Load/push BCD-getal (ld=load) Store BCD and pop Load/push integer 16/32/64 bit Store integer 16/32/64 bit Load/push floating point value 32/64/80 bit Store floating point value 32/64/80 bit Alle datatypes (vlottende komma, integer, bcd) hebben hun eigen lees- en schrijf- operaties om bitpatronen met het geheugen uit te wisselen. Bij deze uitwisseling gebeurt er een conversie van het intern 80-bit formaat naar het gewenste formaat in het geheugen.

47 Load constant fld1 fldl2t fldl2e fldpi fldlg2 fldln2 fldz push 1.0
push log210 push log2e push π push log102 push loge2 push +0.0 Naast de operaties die gewoon waarden uit het geheugen laden, zijn er ook een aantal load-instructies die constanten op de stapel laden. Dit zijn vaakgebruikte constanten. Het voordeel van ze in te laden met een speciale instructie is dat de nauwkeurigheid van deze constanten hoger kan zijn. Men kan gebruik maken van alle bits in de mantisse, vermeerderd met nog eventueel guard of rounding bits.

48 Overzicht Aritmetische instructies Logische instructies
Vlottende-komma-instructies MMX-instructies SSE/SSE2-4-instructies Varia Machinemodellen

49 Aanleiding Multimedia-applicaties en het web Beeld (10 KiB)
Geluid (100 KiB) Video (MiB). Opkomst van 64-bit processors In de jaren 90 is er een explosie geweest van multimediale data die gekenmerkt worden door een groot aantal onafhankelijke kleine data-elementen. Deze evolutie naar kleine data-elementen stond haaks op de toename van de woordbreedte van processors tot 64 bit. Kleine data-elementen (8 of 16 bit) Zeer veel data-elementen Onafhankelijke data-elementen

50 Maar 64 bit 00 00 00 00 00 00 00 64 bit 00 00 00 00 00 00 Oplossing:
Het gevolg hiervan is dat er van die 64 bits per keer maar 8 of 16 bits effectief gebruikt werden. De multimedia-uitbreidingen bestaan voornamelijk uit instructies die in staat zijn om parallel op de verschillende onafhankelijke data-elementen in te werken. 64 bit

51 Multimedia-extensies
Sparc: Visual Instruction Set PA-RISC: MAX-2 X64: MMX, SSE, AVX PowerPC: Altivec Alle grote processorfabrikanten hebben hun versie van de multimedia-extensies ontworpen in de loop der jaren 90.

52 MMX: registers 8 MMX-registers van 64 bit (mm0-mm7)
Dezelfde registers als ST register geschikt voor de opslag van 8 bytes 4 woorden De uitbreiding voor de IA32 architectuur wordt MMX genoemd. MMX is een merknaam die door Intel gebruikt wordt, en naar hun zeggen de afkorting is voor Matrix Math eXtentions. De acht nieuwe registers overlappen met een deel van de ST-registers. Op deze manier heeft Intel er proberen voor te zorgen dat oude systeemsoftware probleemloos kon werken met de processors met MMX-uitbreidingen. Als de oude software correct omging met de ST-registers, dan werden de MMX-registers ook correct behandeld. De toestand van de processor werd door de MMX- uitbreiding dus niet vergroot. 2 dubbelwoorden 1 quadwoord Registers: mmx

53 MMX: Instructies 57 instructies die subwoordparallellisme ondersteunen
Voorbeeld: acht 8-bit optellingen in parallel vier 16-bit optellingen in parallel twee 32-bit optellingen in parallel één 64-bit optelling Heel wat MMX-instructies hebben als doel om gegevens in de geschikte vorm in de registers te krijgen (b.v. 8 bytes op een rij), en dan simultaan een operatie uit te voeren op de verschillende registeronderdelen.

54 Instructies paddb paddw paddd paddq padds[b/w] paddus[b/w] psubb psubw
psubd psubq psubs[b/w] psubus[b/w] Bij de optelling en het verschil, kunnen de gegevens byte per byte, woord per woord of dubbelwoord per dubbelwoord of per quadwoord verwerkt worden. De p aan het begin van elke instructie is kenmerkend voor MMX-instructies en staat voor ‘packed’. Ze zou ook kunnen staan voor parallel. De operatie padds[b/w] past saturatierekenen toe op de operandi, dit in tegenstelling tot het modulorekenen van de operaties die erboven staan. padds werkt op 2-complementgetallen, en paddus werkt op binaire getallen (u=unsigned). Bij saturatierekenen moet men immers rekening houden met de gebruikte getalvoorstelling om de extremen te kunnen bepalen.

55 paddb paddb mm0,mm1 mm0 + + + + + + + + mm1 mm0
mm1 Dit is een illustratie van de werking van paddb. Er is in dit geval geen overdracht op de bytegrenzen, en per byte wordt er modulorekenen toegepast. mm0

56 paddd paddd mm0,mm1 mm0 + + mm1 mm0
mm1 Dit is een analoog voorbeeld voor dubbelwoorden. mm0

57 Instructies a b c d e f g h pmullw (a*e).l (b*f).l (c*g).l (d*h).l
pmulhw (a*e).h (b*f).h (c*g).h (d*h).h De vermenigvuldigingsoperaties zijn complexer omdat we hier opnieuw geconfronteerd worden met de dubbele resolutie van het resultaat. Verder zal overflow een groter gevaar vormen omdat de individuele subwoorden klein zijn (b.v. 16 bit). Er zijn 2 vermenigvuldigingen op packed integers: pmull die de laagste 16 bits van de producten oplevert, en pmulh die de hoogste 16 bits van de vermenigvuldiging oplevert. Er is ook een zogenaamde mac-instructie (multiply-accumulate) die de producten sommeert waardoor een groter gedeelte van de vereiste precisie beschikbaar komt. pmaddwd a*e+b*f c*g+d*h

58 pcmpeqd pcmpeqd mm0,mm1 FF 00 00 FF FF 00 FF FF mm0 FF 00 00 FF
mm0 De mmx-operaties kunnen niet zomaar gebruik maken van het eflags register om de conditiecodes bij te houden. Dit komt omdat er door een parallelle vergelijking verschillende conditiebits nodig zijn (1 per vergelijking). De oplossing voor dit probleem bestaat erin de vergelijkingsoperatie geen conditiebits te laten genereren, maar wel een masker. Dat masker zal 1’tjes bevatten op die plaatsen waar de vergelijking opging, en nulletjes op die plaatsen waar ze niet opging. In het bovenstaande voorbeeld zijn de linker dubbelwoorden gelijk waardoor er op die plaats 32 1-tjes in het resultaat verschijnen. De rechter dubbelwoorden zijn niet gelijk, waardoor er nullen verschijnen. Dit principe komt trouwens al meer voor in computerarchitecturen zonder toestandsregister. Daar zal men de conditie associëren met de vergelijkingsoperator of test die dan een nul of een één (of allemaal nulletjes of allemaal eentjes) teruggeeft die dan als gewone waarde in een register kan opgeslagen worden voor verdere verwerking. Het hebben van een toestandsregister beperkt in het algemeen de vrijheid van de compiler om instructies te verplaatsen (tussen een cmp en de instructie die de toestandsbits gebruikt mogen er b.v. geen andere toestandsveranderende instructies komen). De opslag van een conditie in een vrij te kiezen register biedt meer mogelijkheden. Andere: pcmpeq[b/w/d] pcmpgt[b/w/d]

59 Logische instructies psra[w/d] psll[w/d/q] psrl[w/d/q] pand pandn por
pxor Naast de aritmetische instructies zijn er ook logische instructies. Behalve voor de verschuivinginstructies naar links en naar rechts zijn er geen echt functionele redenen waarom er ook klassieke bitsgewijze logische operatoren zouden nodig zijn, aangezien deze reeds in de basisarchitectuur aanwezig zijn. De reden waarom men deze instructies toch heeft toegevoegd is dat de klassieke bitsgewijze logische operaties op de registers voor algemeen gebruik inwerken (eax, ebx, enz.), en dat het dus nodig zou zijn om de waarden eerst te transfereren naar de registers voor algemeen gebruik, en dan weer terug naar de mmx-registers. Aangezien de cmp-instructies maskers opleveren, zijn de en-operatie en de of- operaties courante bewerkingen die nu rechtstreeks op de mmx-registers kunnen toegepast worden. pandn negeert de eerste operand, alvorens de en-operatie uit te voeren. Dit kan b.v. het masker zijn dat door de cmp-instructie aangemaakt werd. Door hier het masker te kunnen inverteren moeten er geen cmp-instructies zijn voor de inverse condities.

60 Unpack instructies punpckhbw mm0,mm1 mm0 mm1 mm0
De operaties op subwoorden zijn een grote vooruitgang, maar slechts bruikbaar in die gevallen dat het mogelijk is om de verschillende subwoorden op de goede plaatsen in de mmx-registers te krijgen. Om in die gevallen waar dit niet zonder meer mogelijk is toch de mmx-uitbreidingen te kunnen gebruiken bestaan er inpak- en uitpak-operaties. De uitpakoperatie die hierboven geïllustreerd staat zet de hoogste bytes van mm0 en mm1 op woordafstand van elkaar, en alterneert de bytes van de twee bronoperandi. punpckl[bw/wd/dq] punpckh[bw/wd/dq]

61 Pack instructies packssdw mm0,mm1 mm0 mm1 mm0 packss[wb/dw] packuswb
De inpakoperatie die hierboven geïllustreerd wordt, reduceert dubbelwoorden naar woorden en doet dit op saturerende wijze op 2-complementgetallen (signed, vandaar de dubbele s). Er zijn nog heel wat andere varianten, zowel signed (s) als unsigned (u). packss[wb/dw] packuswb

62 Einde van MMX-programma
emms empty MMX state Tijdens het gebruik van de mmx-registers bevatten de st-registers geen geldige waarden. Deze instructie zorgt ervoor dat de st-registers opnieuw goed geïnitialiseerd worden, en dus opnieuw bruikbaar. Het geeft het einde van het gebruik van de mmx-registers aan.

63 Overzicht Aritmetische instructies Logische instructies
Vlottende-komma-instructies MMX-instructies SSE/SSE2-4-instructies Varia Machinemodellen

64 SSE-extensies Streaming SIMD Extensions: 70 nieuwe instructies
8 extra registers XMM (128 bits lang) Subwoordparallellisme met vlottende-kommagetallen (enkelvoudige precisie) De SSE-extensie (streaming SIMD extensions) werd toegevoegd aan de Pentium familie in de Pentium III generatie. Gelijkaardig aan de MMX uitbreiding, wordt de instructieset hier uitgebreid met subwoordparallellisme voor vlottende-kommagetallen, en een achttal nieuwe registers. 128 bit

65 Packed SSE-operaties addps xmm0, xmm1 x3 x2 x1 x0 xmm0 y3 y2 y1 y0
x3+y3 x2+y2 x1+y1 x0+y0 xmm0 De “add packed single-precision floating point values” instructie telt vier enkelvoudige precisie vlottende kommagetallen bij elkaar op.

66 Scalaire SSE-operaties
addss xmm0, xmm1 x3 x2 x1 x0 xmm0 y3 y2 y1 y0 xmm1 x3 x2 x1 x0+y0 xmm0 De “add scalar single-precision floating point values” instructie telt twee enkelvoudige precisie vlottende kommagetallen bij elkaar op. De andere drie waarden blijven onveranderd.

67 SSE2-extensies Subwoordparallellisme met vlottende-kommagetallen (dubbele precisie) + integers. 144 nieuwe instructies Int FP/Int 16 bytes De SSE2-extensie werd toegevoegd aan de Pentium familie in de Pentium 4 generatie. Gelijkaardig aan de SSE uitbreiding, wordt de instructieset hier uitgebreid met subwoordparallellisme voor vlottende-kommagetallen, maar nu voor vlottende-kommagetallen in dubbele precisie. 8 woorden 4 dubbelwoorden 2 quadwoorden

68 Packed SSE2-operaties addpd xmm0, xmm1 xmm0 x1 x0 y1 y0 xmm1 x1+y1
De “add packed double-precision floating point values” werkt op analoge manier als de addps-instructie.

69 Scalaire SSE2-operaties
addsd xmm0, xmm1 xmm0 x1 x0 y1 y0 x0+y0 xmm1 xmm0 De “add scalar double-precision floating point values” werkt op analoge manier als de addss-instructie.

70 Shuffle operaties shufps xmm0, xmm1, pat x3 x2 x1 x0 xmm0 y3 y2 y1 y0
De “suffle packed single-precision floating point values” laat toe om willekeurige vlottende-kommagetallen te kopiëren: twee uit xmm0 en twee uit xmm1. Indien men xmm0 en xmm1 gelijk neemt, dan kan men de waarden op willekeurige manier permuteren. De selectie wordt bepaald door het 8-bit patroon pat (2 bit per waarde). y? y? x? x? xmm0

71 SSE3-uitbreidingen haddps xmm0, xmm1 x3 x2 x1 x0 xmm0 y3 y2 y1 y0 xmm1
In 2004 werden de SSE3 uitbreidingen toegevoegd. Bijzonder aan deze uitbreiding is dat ze naast operaties op verticale operandi (uit 2 registers), ook operaties op horizontale operandi (hetzelfde register) aanbiedt. haddps = Horizontal-Add-Packed-Single

72 SSE4-uitbreidingen 54 bijkomende instructies Zeer gespecialiseerd
In 2006 aangekondigd voegt SSE4 nog eens 54 extra instructies toe aan de instructieverzameling.

73 AVX, AVX2, AVX-512 AVX (2008): AVX2 (2011): AVX-512 (2013)
bit registers YMM0-YMM15 Drie operandi (d,s1,s2) … AVX2 (2011): Fused Multiply-Accumulate AVX-512 (2013) bit registers ZMM0-ZMM31 Na SSE heeft Intel Advanced Vector Extensions (AVX) toegevoegd. Deze worden vooral gekenmerkt door nog bredere registers, drie operandi (nuttig indien er meer register zijn, het zorgt er o.a. voor dat er minder gegevens een tweede keer moeten ingeladen worden uit het geheugen omdat de bronoperandi niet overschreven worden). In AVX2 werd een Fused Multiply-Accumulate instructie toegevoegd, dit is een instructie die een product en een som berekent, maar tussentijds niet afrondt (daarom fused). De afronding gebeurt op het einde waardoor het resultaat nauwkeuriger is. Het kan anderzijds ook leiden tot kleine verschillen in de resultaten indien fused en non-fused instructies in combinatie gebruikt worden. In 2013 werd de registerbreedte nogmaals uitgebreid, ditmaal tot 512 bits.

74 Overzicht Aritmetische instructies Logische instructies
Vlottende-komma-instructies MMX-instructies SSE/SSE2-4-instructies Varia Machinemodellen

75 nop nop doe niets Instructie: nop
NOP is een instructie zonder nuttige verwerking van gegevens. Ze heeft geen effect op de registers voor algemeen gebruik, of op de vlaggen. In sommige gevallen is deze instructie nuttig om b.v. plaats te reserveren in een instructiestroom. Andere instructies kunnen soms ook als NOP-instructies gebruikt worden, b.v. mov eax, eax.

76 xadd xadd d,s t = d+s s = d d = t
De exchange and add instructie vervangt s door d, en overschrijft d met de som van de oorspronkelijke d en s. Hierbij is d een geheugenoperand of een registeroperand en moet s een registeroperand zijn.

77 cmpxchg cmpxchg d,s if (reg[eax]==d) d = s; else reg[eax] = d;
De compare and exchange instructie is nog een illustratie van de combinatie van een exchange instructie met een ALU-operatie. De semantiek is vrij complex. De voornaamste toepassing is het atomair veranderen van een waarde. Veronderstel dat men een getal ‘getal’ uit het geheugen op atomaire manier wenst te kwadrateren. Men leest eerst het getal in in eax, berekent het kwadraat in b.v. ebx en voert dan de instructie cmpxchg getal,ebx uit. Indien het getal tussen het lezen uit het geheugen, en de uitvoering van de cmpxchg-instructie niet veranderd werd, dan zal ebx gekopieerd worden naar getal. In het andere geval zal de nieuwe waarde van getal in eax gekopieerd worden, waarna men opnieuw kan kwadrateren, en opnieuw kan beginnen.

78 lock-prefix lock add [1000],eax
atomaire optelling van eax bij de geheugenlocatie [1000] Lock is een zogenaamd prefix. Dit is een byte dat men net voor een instructie kan plaatsen waardoor de semantiek van de instructie die erop volgt licht gewijzigd wordt. Het lock-prefix wordt gebruikt om de instructie die erop volgt atomair uit te voeren (read-modify-write cyclus). Het lock-prefix kan gebruikt worden in combinatie met de geziene instructies: add, adc, and, btc, btr, bts, cmpxchg, dec, inc, neg, not, or, sbb, sub, xor, xadd, xchg op voorwaarde dat deze instructies inwerken op een geheugenoperand. slechts combineerbaar met een beperkt aantal instructies

79 set/clear status bits stc c = 1 clc c = 0 std d = 1 cld d = 0 sti
cli c = 1 c = 0 d = 1 d = 0 i = 1 i = 0 Sommige toestandsbits kunnen expliciet aan- en af-gezet worden door middel van speciale instructies. De set-instructies zetten de bits aan, en de clear- instructies zetten de bits af. Behalve de c, d, en i bits zijn er geen bits die op deze manier gemanipuleerd kunnen worden.

80 Overzicht Aritmetische instructies Logische instructies
Vlottende-komma-instructies MMX-instructies SSE/SSE2-4-instructies Varia Machinemodellen

81 Globale machinetypes Stapelmachines Accumulatormachines
Registermachines Elke van de vele computerarchitecturen is wel anders dan de andere, op de één of andere manier. Men kan echter een aantal globale machinetypes herkennen, door een klassering te maken op basis van het aantal en de toegankelijkheid van de registers in de CVE. Aldus komt men tot 3 grote types: de stapelmachines, accumulatormachines en registermachines.

82 Stapelmachine A := (B-C)/D O1 R PUSH B O2 PUSH C SUB Expressiestapel
PUSH D DIV POP A Expressiestapel In zijn zuiverste vorm bevat de CVE van een stapelmachine een aantal registers die georganiseerd worden als een stapel. Het plaatsen van een nieuw element op de top (push) heeft als gevolg dat alle reeds aanwezig elementen een plaats naar beneden geduwd worden. Wanneer het element aan de top verwijderd wordt (pop), schuiven alle elementen één plaats naar boven. In een zuivere stapelarchitectuur worden de operandi O1 en O2 van aritmetische of logische operaties van de top van de stapel genomen (en verwijderd), en het resultaat R wordt op de stapel geplaatst. Men hoeft dus nooit een registernaam te vermelden; alle registeroperandi zijn impliciet. Dit zorgt voor extreem korte instructies. De stapel wordt opgeladen vanuit het geheugen door middel van PUSH <adres> instructies, en resultaten worden weggeschreven door middel van POP <adres> instructies. De dia toont de instructiesequentie nodig om A:= (B-C)/D te berekenen. Eerst worden B en C uit het geheugen genomen en op de stapel geplaatst. Nadat het verschil van de 2 topelementen wordt gemaakt, wordt D uit het geheugen op de top van de stapel geplaatst. De deling van de 2 topelementen berekent dan (B- C)/D. Uiteindelijk wordt het resultaat teruggeschreven naar geheugenplaats A. Een typisch voorbeeld van een stapelarchitectuur is de HP48 zakrekenmachine. Ook de Java Virtuele Machine is een stapelarchitectuur. b.v.: hp-calculator

83 Accumulatormachine A := (B-C)/D O1 R ACC LOAD B SUB C O2 DIV D STORE A
Bij een accumulatormachine maken bewerkingen voor een van de operandi O1 steeds impliciet gebruik van hetzelfde register (de accumulator), maar voorts zijn de overige registers in de architectuur individueel adresseerbaar. Het resultaat R van een bewerking komt steeds in de accumulator terecht. De binaire ALU- instructies moeten dus wel de identiteit van de 2e operand O2 vermelden: dit kan een register zijn, of een geheugenlocatie. Het voordeel van deze methode is opnieuw het kort houden van de instructies, maar het duidelijke nadeel is de geringe soepelheid van de bewerkingen, aangezien voor elke bewerking eerst de accumulator gepast moet ingesteld worden. Accumulatormachines hebben over het algemeen niet veel registers, en kwamen derhalve veel voor in perioden waarin de technologie het aantal registers beperkte. Dit gaat op voor de vroege minicomputers uit de jaren Zelfs de Intel 8086 toont een aantal kenmerken van accumulatormachines (o.a. het AX- register). Ook de klassieke zakrekenmachines werken met een accumulator (het display). De dia toont hoe het voorbeeld A:=(B-C)/D er zou kunnen uitzien op een accumulatormachine. Eerst wordt B in de accumulator geladen, en vervolgens wordt er C van afgetrokken. Dit resultaat (in de accumulator) wordt gedeeld door D, waarna het resultaat kan worden weggeschreven naar A. b.v.: klassieke calculator

84 Registermachine A := (B-C)/D R0 R1 MOV R1,B MOV R2,C O1 R2
SUB R3,R1,R2 MOV R1,D DIV R2,R3,R1 MOV A,R2 O1 O2 R Bij registermachines heeft men vrije toegang tot de registers, en van de operandi O1 en O2 is er geen enkel impliciet. In sommige registerarchitecturen wordt het resultaat weggeschreven naar één van beide operand-locaties (twee- adresmachines), maar bij de meest flexibele klasse kan men vrij een adres opgeven waar het resultaat moet terechtkomen (drie-adresmachines). Men maakt overigens nog een belangrijk onderscheid naargelang men voor de operandi enkel registerlocaties kan opgeven (zgn. load/store of register-naar- register machines), of ook geheugenlocaties. Als de operandi uit geheugenlocaties kunnen komen, maakt men verder nog onderscheid of het resultaat ook meteen naar het geheugen kan verwezen worden (geheugen-naar- geheugen), ofwel enkel in een register kan geschreven worden (geheugen-naar- register). In deze dia wordt het voorbeeld A:=(B-C)/D uitgewerkt voor een 3-adres-, register-naar-registermachine. De waarde in geheugenlocaties B, C, D moeten eerst naar een register gekopieerd worden, alvorens ze te kunnen betrekken in de berekeningen.

85 Registermachine A := (B-C)/D R0 R1 MOV R1,B SUB R1,C O1 R2 DIV R1,D
MOV A,R1 O1 O2 R In een vorige dia werd het verschil uitgelegd tussen 2-adres- en 3-adresmachines onder de registermachines, alsook het verschil tussen de klassen register-naar- register, register-naar-geheugen en geheugen-naar-geheugen. In deze dia wordt het voorbeeld A:=(B-C)/D uitgewerkt voor een 2-adres-, geheugen-naar-registermachine (waarbij maximaal 1 operand uit het geheugen kan komen); het resultaat wordt steeds bewaard in het register van de 1e operand. De waarde in geheugenlocatie B wordt eerst naar een register gekopieerd, maar voor geheugenlocaties C en D is dit niet het geval. Het finale resultaat wordt eerst in een register weggeschreven, en dan gekopieerd naar geheugenlocatie D.

86 Registermachine A := (B-C)/D R0 R1 SUB R1,B,C DIV A,R1,D O1 R2 R3 R R4
In een vorige dia werd het verschil uitgelegd tussen 2-adres- en 3-adresmachines onder de registermachines, alsook het verschil tussen de klassen register-naar- register, register-naar-geheugen en geheugen-naar-geheugen. In deze dia wordt het voorbeeld A:=(B-C)/D uitgewerkt voor een 3-adres-, geheugen-naar-geheugenmachine (waarbij eventueel beide operandi uit het geheugen kunnen komen). Het verschil kan nu meteen beide operandi uit het geheugen betrekken, en de deling kan meteen het resultaat kwijt in het geheugen. Er komen geen extra transferinstructies aan te pas. Conclusie: ogenschijnlijk leidt de geheugen-naar-geheugen machine dus tot het meest elegante, kortste en snelste programma. In realistische machines en programma’s is dit niet altijd zo. De bitpatronen die A, B, C, D voorstellen zijn langer dan de registernamen; bovendien is de toegang tot een register veel sneller dan deze tot het geheugen – wat vooral als een gegeven meerdere malen wordt gebruikt, tot grote verschillen kan leiden; tot slot is het zo dat een geheugen-naar-geheugenmachine complexer is dan een register-naar-register machine, en dus wellicht intrinsiek trager werkt (bv. qua kloksnelheid).

87 Machinetypes stapelmachine 0-adresmachine -
accumulatormachine 1-adresmachine met registeroperand R met geheugenoperand M registermachine 2-adresmachine tot 0 geheugenoperandi RR tot 1 geheugenoperand MR tot 2 geheugenoperandi MM 3-adresmachine tot 0 geheugenoperandi RRR tot 1 geheugenoperand MRR tot 2 geheugenoperandi MMR tot 3 geheugenoperandi MMM Samenvattend kunnen we de verschillende machinetypes karakteriseren aan de hand van het aantal en type van hun operandi, zoals in de tabel in de dia. De hier gebruikte stapel wordt een expressiestapel genoemd, dit in tegenstelling met een controlestapel. Een expressiestapel wordt gebruik door de ALU om expressies te evalueren. Een controlestapel wordt gebruikt door de CVE om het proceduremechanisme te ondersteunen (zie volgende les).

88 Oefening A := (A+B)*(C+D) Stapel Accu RRR push A push B add push C
push D mul pop A load C add D store T load A add B mul T store A mov R1,A mov R2,B add R1,R2,R1 mov R2,C mov R3,D add R2,R3,R2 mul R1,R2,R1 mov A,R1 Als oefening wordt in deze dia de bewerking A:=(A+B)*(C+D) uitgewerkt voor drie types machine. Met de kennis uit deze les mag deze oefening geen verrassingen meer bevatten.

89 Pauze