dcomnet-nr. 8 Simpel aritmetik på maskinniveau Computere og Netværk (dcomnet)

Transkript

1 dcomnet-nr. 8 Simpel aritmetik på maskinniveau Computere og Netværk (dcomnet) Efterår 2009

2 1 Simpel aritmetik på maskinniveau I SCO, appendix A, er det beskrevet, hvordan man adderer ikke-negative heltal repræsenteret i det binære talsystem. I SCO, afsnit 3.2.3, er det forklaret hvordan en aritmetisk logisk enhed kan udføre binær addition. Vi skal se, hvordan denne binære addition både kan benyttes til at lave addition og subtraktion af ikke-negative heltal og til addition og subtraktion af heltal. Samtidig skal vi se, hvordan disse operationer benyttes i et højniveausprog, som f.eks. C, til at lave addition og subtraktion på simple heltallige værdier. 1.1 Konvertering imellem ikke-negative heltal og heltal Betragt følgende C-program: #include <stdio.h> #define printint16(i) printf("i = %hd \n", i) #define printuint16(ui) printf("ui = %hu \n", ui) typedef short int INT16 ; typedef unsigned short int UINT16 ; int main() { INT16 i; UINT16 ui; } i = 5; ui = i; printint16(i); printuint16(ui); i = -3; ui = i; printint16(i); printuint16(ui); ui = 65526; i = ui; printint16(i); printuint16(ui); Variable af typen INT16 har værdier som ligger i I 16 = [ 2 15, ] mens variable af typen UINT16 har værdier i UI 16 = [ 0, ]. Dette gælder i hvert fald hvis der benyttes 2-komplement repræsentation af heltal og der bruges 16 bit til variable af typen short int. 1

3 En kørsel af programmet gav: i = 5 ui = 5 i = -3 ui = i = -10 ui = At de to først udskrevne værdier er identiske kan vel ikke undre. Sådan skulle det gerne være. Værdien 5 ligger jo i begge værdiområder. Men for de fire sidst udskrevne værdier kræves vist en forklaring. Værdien -3 ligger jo ikke i UI 16, så hvordan får ui så værdien ved tildelingen ui = i? Vi ved fra forrige afsnit, at værdien -3 repræsenteres i variablen i med et bitmønster W B 16 så der gælder: 3 = W 2 = W 2 16 dvs. W = = = Så noget kunne jo tyde på, at de 16 bit som repræsenterer værdien -3 i variablen i blot er kopieret fra i over i ui ved tildelingssætningen; det er de to forskellige fortolkninger af bitmønstret W, som giver de to forskellige resultater i udskriften. Denne antagelse om hvad der foregår passer også med de to sidste udskrifter: 10 = W 2 = W 2 16 = Nu kan det være lidt besværligt at tænke i bitmønstre, når vi i almindelighed skal finde en sammenhæng imellem de to fortolkninger. I stedet kan vi indføre følgende simple afbildninger UINT N : I N UI N og INT N : UI N I N idet i I N, ui UI N : { i når i 0 UINT N (i) = i + 2 N når i < 0 og { ui når ui < 2 N 1 INT N (ui) = ui 2 N når ui 2 N 1 Med disse afbildninger kan vi simpelt beskrive hvad der sker ved tildelingssætningerne i C-programmet: UINT 16 ( 3) = = og INT 16 (65526) = = Addition og subtraktion af ikke-negative heltal Når den aritmetiske enhed udfører addition (f.eks. når IJVM udfører ordren iadd med to bitmønstre af længde 32 som operander) sker det som binær addition af de binære cifre i de to operander; de enkelte binære cifre adderes med menteoverføring fra de mindst betydende cifre til de mest betydende cifre. En eventuel mente fra additionen af de mest betydende cifre ses der bort fra. Dette kan udtrykkes som en afbildning add : B N B N B N. F.eks. således i B 5 : 2

4 add(01000, 00110) = add(01011, 10110) = add(10011, 11000) = add(11111, 11111) = add(01100, 01000) = En konkret implementation af denne afbildning ved hjælp af digitale komponenter i den aritmetisk logiske enhed kan ses i SCO, figur 3-20 og I figur 3-18 redegøres der for, at resultatet af en beregning i det kombinatoriske kredsløb i (b) netop svarer til den lille additionstabel for binær addition, (a) i figuren. I figur 3-20 er det to 8 bit operander A = A 7... A 0 og B = B 7... B 0. Resultatet O = O 7... O 0 er altså det bitmønster som kommer ud af afbildningen add(a, B) vel at mærke hvis INC = 0 (INC er menten ind i den mindst betydende bitposition). Kalder vi menten fra den mest betydende bitposition for C N ( Carry; optræder som C bit i Program Status Word (PSW) på de fleste maskiner, SCO, s. 310) fås generelt, at afbildningen add opfylder: add(w 1, W 2 ) + C N 2 N = W 1 + W 2 Dette slutter vi ud fra strukturen i figur 3-20 og korrektheden af den enkelte ciffervise addition forklaret i figur Vi kan også skrive sammenhængen imellem en ikke-negativ heltalsfortolkning af bitmønstrene add(w 1, W 2 ), W 1 og W 2 således: { W1 + W add(w 1, W 2 ) = 2 når C N = 0 W 1 + W 2 2 N når C N = 1 eller add (W 1, W 2 ) = ( W 1 + W 2 ) mod 2 N Hvis der ikke er mente, altså hvis C N = 0, gælder der jo: add (W 1, W 2 ) = W 1 + W 2 Dvs. resultatet er korrekt betragtet som addition i de ikke-negative heltal UI N. Hvis der derimod optræder en mente, er resultatet større end 2 N 1 altså udenfor værdiområdet for UI N og vil derfor ikke kunne repræsenteres med N bit ved afbildningen 1. I denne situation taler vi om overløb m.h.t. UI N. Når der er overløb, er resultatet altså ikke korrekt, men de N bit som fås ved add(w 1, W 2 ) er dog korrekte i den forstand, at de svarer til de mindst betydende N bit af de N + 1 bit der ved overløb skal til for at repræsenterer summen W 1 + W 2. Når vi udfører addition på elementer i UI N kan vi altså risikere at ryge ud af værdiområdet. Vi skal nu undersøge hvordan dette viser sig i følgende C-program: 3

5 #include <stdio.h> #define printuint16(ui) printf("ui = %hu \n", ui) typedef unsigned short int UINT16 ; int main() { UINT16 max = 65535; UINT16 ui, ui1, ui2; } // Addition ui1=32000; ui2=32000; ui = ui1 + ui2; printuint16(ui); ui1=64000; ui2=64000; ui = ui1 + ui2; printuint16(ui); ui1=max; ui2=1; ui = ui1 + ui2; printuint16(ui); // Subtraction ui1=45; ui2=27; ui = ui1 - ui2; printuint16(ui); ui1=7; ui2=10; ui = ui1 - ui2; printuint16(ui); ui1=0; ui2=1; ui = ui1 - ui2; printuint16(ui); Resultatet af en kørsel blev: ui = ui = ui = 0 ui = 18 ui = ui = Første resultat er jo i UI 16, så det er godt nok. Den anden addition skulle jo give , men giver Det rigtige resultat kan skrives som = = Dette stemmer med, at vi i denne situation får 4

6 smidt menten væk og resultatet er altså korrekt på nær menten. Og max + 1 skulle jo give 65536, men resultatet er 0. Der startes simpelthen forfra ved 0, når vi lægger en til det bitmønster som repræsenterer det største tal i UI 16. En slags binær kilometertæller. Addition i UI N, afbildningen add UI : UI N UI N UI N, udføres altså som binær addition i den aritmetisk logiske enhed på de to bitmønstre som repræsenterer de to aktuelle operandværdier ui 1 og ui 2. Dette giver os følgende udtryk for addition af ikke-negative heltal: { ui1 + ui add UI (ui 1, ui 2 ) = 2 når ui 1 + ui 2 < 2 N ui 1 + ui 2 2 N når ui 1 + ui 2 2 N eller add UI (ui 1, ui 2 ) = (ui 1 + ui 2 ) mod 2 N Læg også mærke til, at man ikke får noget at vide om, at der har været overløb undervejs ved kørslen af C-programmet. Ved subtraktion fås det rigtige resultat, når dette er i værdiområdet. Et eksempel ses i den første subtraktion i C-programmet. Hvis resultatet derimod ikke er i værdiområdet er resultatet forkert. F.eks. er dette tilfældet i udregningen 7-10 = -3, hvor resultatet i udskriften er et stort heltal Nu ved vi jo fra tidligere, at dette netop er ikke-negativ heltalsfortolkningen af det bitmønster som repræsenterer -3. I denne situation ser det altså ud som om subtraktionen foregår ved at vi får lov til at låne 2 16 = 65536, altså i almindelighed: { ui1 ui sub UI (ui 1, ui 2 ) = 2 når ui 1 ui 2 2 N + ui 1 ui 2 når ui 1 < ui 2 eller sub UI (ui 1, ui 2 ) = (ui 1 + (2 N ui 2 )) mod 2 N Den subtraktion, der foregår, kan således forstås ud fra addition af ikke-negative heltal, nemlig denne addition: sub UI (ui 1, ui 2 ) = add UI (ui 1, (2 N ui 2 )) Dette viser, at subtraktion kan udføres ved hjælp af den tidligere definerede addition, hvis vi vel at mærke først udregner 2 N ui 2. Nu er dette igen en subtraktion, så det ser ud som om vi alligevel ikke slipper for at skulle lave en subtraktion. Men netop denne specielle subtraktion 2 N ui kan klares simpelt uden subtraktion: 2 N ui = ui + 1 hvor ui er det heltal man får ved at se på bitmønstret for ui, dvs. ui 1, danne bitvis komplement af dette og så fortolke dette som et ikke-negativt heltal. Resultatet fås ud fra den relation vi udledte i forrige afsnit: som her kan udtrykkes således: W + W = 2 N 1 ui + ui = 2 N 1 Heraf fås: sub UI (ui 1, ui 2 ) = add UI (ui 1, add UI (ui 2, 1)) 5

7 Det er netop sådan den aritmetisk logiske enhed i SCO udfører subtraktion: Bitmønstret for den ene operand adderes binært til det bitkomplementerede bitmønster for den anden operand, der lægges 1 til ved at lade menten ind i den mindst betydende bit være 1 (INC = 1 i figur 3-20). Den sidste subtraktion i C-programmet passer også med denne beskrivelse: Alt ialt har vi altså fundet at: sub UI (0, 1) = add UI (0, add UI (1, 1)) = add UI (0, add UI (2 16 2, 1)) = add UI (0, ) = = sub UI (ui 1, ui 2 ) = add UI (ui 1, add UI (ui 2, 1)) = { ui1 ui 2 når ui 1 ui 2 2 N + ui 1 ui 2 når ui 1 < ui 2 Dette viser, at subtraktion giver det korrekte resultat, når resultatet er i værdiområdet og at subtraktion kan udføres ved hjælp af bitkomplementering og addition. Bemærk, at vi heller ikke ved subtraktion får at vide om der har været overløb undervejs ved kørslen af programmet. 1.3 Addition og subtraktion af heltal Betragt C-programmet: #include <stdio.h> #define printint16(i) printf("i = %hd \n", i) typedef short int INT16 ; int main() { INT16 maxpos = 32767; INT16 minneg = ; INT16 i, i1, i2; i1=5; i2=7; i = i1 + i2; printint16(i); i1=32000; i2=32000; i = i1 + i2; printint16(i); i1=maxpos; i2=1; i = i1 + i2; printint16(i); 6

8 } i1=45; i2=27; i = i1 - i2; printint16(i); i1=-32000; i2=32000; i = i1 - i2; printint16(i); i1=minneg; i2=1; i = i1 - i2; printint16(i); og resultatet af en kørsel: i = 12 i = i = i = 18 i = 1536 i = Igen er resultaterne korrekte sålænge de er i værdiområdet for de heltallige variable, her I 16. Når resultatet er udenfor værdiområdet [-32768, 32767] er det tydeligvis ikke korrekt. Ser man i den genererede symbolske maskinkode (f.eks. til en SPARC), så kan man se, at udregningen af i1 + i2 = faktisk bliver udført af samme ordre som blev brugt i det forrige C-program til at udføre ui1 + ui2 = Der blev resultatet jo korrekt udregnet til Fortolker vi bitmønstret for som et tal i I 16 får vi: INT 16 (64000) = = 1536 altså netop den udskrevne værdi i anden linie. Addition af heltal i et C-program, altså afbildningen add I : I N I N I N, kan derfor udtrykkes således: add I (i 1, i 2 ) = INT N (add UI (UINT (i 1 ), UINT (i 2 ))) De to operander i 1 og i 2 opfattes som ikke-negative heltal, dernæst adderes disse som bitmønstre i den aritmetisk logiske enhed, og endelig fortolkes resultatet som et 2-komplement repræsenteret heltal. Men hvad har nu dette med det resultat at gøre som vi ønsker, altså i 1 + i 2? Og hvornår er der overløb i denne beregning? For at finde ud af det skal vi først bemærke, at der gælder følgende for i I N : UINT (i) = i mod 2 N Dette fås simpelt ud fra definitionen af UINT. Bruges dette fås: add I (i 1, i 2 ) = INT N (add UI (i 1 mod 2 N, i 2 mod 2 N )) = INT N ((i 1 mod 2 N + i 2 mod 2 N ) mod 2 N ) = INT N ((i 1 + i 2 ) mod 2 N ) = INT N { i1 + i 2 når 0 i 1 + i 2 i 1 + i N når i 1 + i 2 < 0 7

9 Benyttes definitionen for INT N på de to tilfælde fås: i 1 + i 2 når 0 i 1 + i 2 < 2 N 1 i add I (i 1, i 2 ) = 1 + i 2 2 N når 2 N 1 i 1 + i 2 < 2 N i 1 + i N når 2 N < i 1 + i 2 < 2 N 1 i 1 + i 2 når 2 N 1 i 1 + i 2 < 0 Resultatet er altså korrekt, når i 1 +i 2 I N. Hvis vi derimod falder udenfor værdiområdet bliver resultatet forkert. Dette kaldes også her for overløb. Overløb kan forekomme på to måder: 1. summen af to positive tal i 1 og i 2 er større end 2 N 1 1, i denne situation bliver resultatet af beregningen i 1 + i 2 2 N, altså et negativt tal, som jo oplagt er forkert; 2. summen af to negative tal bliver mindre end 2 N 1, i denne situation bliver resultatet i 1 + i N, altså et positivt tal, igen oplagt forkert. I begge de to overløbssituationer er resultatet altså forkert, men vi får dog den korrekte restklasse mod 2 N. På lignende måde kan vi finde afbildningen sub I : I N I N I N ud fra sub UI : sub I (i 1, i 2 ) = INT N (sub UI (UINT N (i 1 ), UINT (i 2 ))) = INT N (sub UI (i 1 mod 2 N, i 2 mod 2 N )) = INT N ((i 1 mod 2 N + 2 N i 2 mod 2 N ) mod 2 N ) = INT N ((i 1 i 2 ) mod 2 N ) { i1 i = INT 2 når 0 i 1 i 2 N i 1 i N når i 1 i 2 < 0 i 1 i 2 når 0 i 1 i 2 < 2 N 1 i = 1 i 2 2 N når 2 N 1 i 1 i 2 < 2 N i 1 i N når 2 N < i 1 i 2 < 2 N 1 i 1 i 2 når 2 N 1 i 1 i 2 < 0 Igen er resultatet korrekt, når det er i værdiområdet. Og igen kan overløb forekomme på to måder. Addition og subtraktion af heltal kan altså foregå med de samme maskinordre, som blev benyttet ved de tilsvarende regneoperationer i de ikke-negative heltal. Der er imidlertid forskel m.h.t. hvilke situationer, der betragtes som overløb giver ikke overløb i UI N, mens det giver overløb i I N giver overløb i UI N men ikke i I N. Ønsker man i et program at kunne kontrollere om der har været overløb m.h.t. UI N kan man i et maskinprogram efter udførelsen af en regneoperation undersøge indholdet af PSW og kontrollere bit C. Overløb m.h.t. I N kontrolleres ved at se på bit V (overflow), SCO, s

10 1.4 Relationer Vi skal nu se på, hvordan man udregner relationer imellem heltal på maskinniveau f.eks. en relationen som x < y, hvor de to operander er 32 bit 2- komplement repræsenterede heltal, som vi kender det fra elementerne på stakken på IJVM. Umiddelbart kunne vi jo forsøge os med: iload x iload y isub // stack = x - y, x - y < 0 => x < y iflt else Sådan bliver det jo blevet gjort i darkos-e02-nr.2 i metoden gcd. Der er vi i den situation, at de to operander er antaget at være positive. Og så går det godt. Der kan jo ikke optræde overløb i subtraktionen i den situation. Men i almindelighed kan der jo optræde overløb og hvad sker der så? Ja, så kan resultatet blive forkert. Betragt f.eks. x = og y = -10. Så er resultatet jo x - y = Da værdiområdet for 32 bit heltal er [ , ] vil staktoppen altså i dette tilfælde ikke rumme det rigtige resultat, men i stedet vil vi få et bitmønster, som vil blive fortolket som negativt i iflt. Dette fører til, at x fejlagtigt betragtes som mindre end y. Vi kan altså ikke klare os med den simple programstump ovenfor. Problemet er at vi lidt sløset har skrevet stack = x - y i stedet for stack = sub(x,y) og vi har ikke taget stilling til hvad der skal ske ved overløb. Hvad skal vi stille op med dette problem? En mulighed er at undersøge fortegn for de to operander og så bruge dette til at afgøre forholdet imellem de to operander i de tilfælde, hvor isub kan føre til overløb. På den måde kan man sikre sig, at man kun udføre subtraktion, når der ikke kan forekomme overløb. Det bliver imidlertid ret omfattende at tage hånd om overløb eksplicit på denne måde. På JVM er der da også ordrer, som klarer heltalsrelationerne direkte, f.eks. vil ordren if icmplt sammenligne de to værdier øverst på stakken med relationsoperatoren <. På de fleste maskiner er der sådanne ordrer. 9

11 Opgaver Opgave 2.1 Få definitionen af INT N og UINT N til at passe med: fra afsnit 1. Opgave 2.2 Betragt W 2 = W w N 1 2 N add(01000, 00110) = add(01011, 10110) = add(10011, 11000) = add(11111, 11111) = add(01100, 01000) = i B 5. Kontroller at add (W 1, W 2 ) = ( W 1 + W 2 ) mod 2 N gælder i eksemplerne. Hvor optræder der overløb m.h.t. UI 5? Opgave 2.3 Betragt igen add(01000, 00110) = add(01011, 10110) = add(10011, 11000) = add(11111, 11111) = add(01100, 01000) = i B 5. Kontroller at add (W 1, W 2 ) 2 mod 2 N = ( W W 2 2 ) mod 2 N gælder i eksemplerne. I hvilke af eksemplerne er der overløb m.h.t. I 5? Få eksemplerne til at passe med analysen af overløb. Opgave 2.4 Når vi udfører binær subtraktion sker det f.eks. således: Vi låner altså 2 5 = 32 i det første eksempel. Generelt fås: { W1 W sub (W 1, W 2 ) = 2, når W 1 W 2 2 N + W 1 W 2, når W 1 < W 2 Få formlen til at passe med de to eksempler i B 5 ovenfor. 10

12 Opgave 2.5 Betragt to simple heltalsvariable i og j i et symbolsk IJVM program. Vi refererer til dem ved hjælp af navnene i og j f.eks. således iload i. Beskriv, hvordan de seks relationsoperatorer <, <=, >, >=, = og kan udregnes på IJVM anvendt på i og j. Man kan f.eks. vise, hvordan C-sætningen: if ( i relationsoperator j ) S_1 else S_2 programmeres på IJVM for de seks relationsoperatorer. Prøv bare for en af dem at tage højde for overløb. Det er godt nok besværligt, men prøv alligevel. 11