Mikroprogrammering. Niels Olof Bouvin Institut for Datalogi Aarhus Universitet

Transkript

1 Mikroprogrammering Niels Olof Bouvin Institut for Datalogi Aarhus Universitet

2 Oversigt Mikroprogrammering: IJVM implementeret på Mic-1 Forbedringer af Mic-1 Metode til udvikling af symbolske maskinsprogsprogrammer

3 Mikroarkitekturen i al sin gru og skønhed dette diagram kan realiseres i hardware Kontrolenheden styrer fetch/ decode/execute cyklen Control store MPC indeholder mikroprogrammet PC for mikroprogrammet MIR den aktuelle mikroinstruktion Registre Beregningsenhed Mic-1 A bus Kontrolenhed

4 NEXT_ADDRESS JAM ALU Mikroinstruktionsformatet En mikroinstruktion indeholder altid adressen på næste instruktion (512 words 9 bit er nok) bruges til at modificere NEXT_ADDRESS, f.eks. ved branching og goto ALU og shifter håndteres her under ét C-bus vs. B-bus adressering det kan være nødvendigt at udpege flere registre som destination, derfor en bit/et signal per register der skal kun bruges ét register som input (foruden H) til ALU, så 9 registre kan nemt enkodes i 4 bit Memory fetch bruges til PC/MBR; read/write bruges til MDR/MAR B-bus registre 0 = MBR 5 = LV 1 = PC 6 = CPP 2 = MBR 7 = TOS 3 = MBRU 8 = OPC 4 = SP 9-15 er ubrugte Micro address NEXT_ADDRESS 9 JAM ALU C-bus Memory JMPC JAMN JAMZ SLL8 SRA1 F₀ F₁ ENA ENB INVA INC H OPC TOS CPP LV SP PC MDR MAR WRITE READ FETCH B-bus B-bus 4

5 PC=PC+1 som mikroinstruktion 1 1????????? B-bus registre 0 = MBR 5 = LV 1 = PC 6 = CPP 2 = MBR 7 = TOS 3 = MBRU 8 = OPC 4 = SP 9-15 er ubrugte Mikroinstruktioner leverer signaler til styre beregningsenheden, samt registrenes adgang til busserne og hukommelsen Mikroinstruktionerne hentes fra kontrollageret, der er helt adskilt fra det sædvanlige lager Den næste mikroinstruktion står enten i NEXT_ADDRESS eller udvælges

6 Udvælgelse af næste mikroinstruktion Ofte kan man blot vælge instruktionen angivet i NEXT_ADDRESS den sædvanlige sekventiel udførsel af instruktioner Goto og branches håndteres ved en kombination af JAM og NEXT_ADDRESS

7 Mikroprogrammering! Mikroprogrammet ligger som bits instruktioner i Control Store det betyder ikke, at vi behøver at skrive programmet som: (med mindre vi virkelig, virkelig, gerne vil) skønt det, naturligvis, faktisk er sådan programmet ser ud Som ved maskinsprog, kan man vælge at skrive i et absolut eller i et symbolsk sprog (jeg vil anbefale det sidste) 05f: 02e01408a0 060: 02e : 02f :

8 Programmeringssproget MAL Hvad skal man kunne udtrykke? Alt som Mic-1 kan: register B-bus C-bus registre aritmetiske og logiske operationer understøttet af ALU og shifter hukommelsesoperationer (læs og skriv) (til 32 og 8-bit hukommelse) if-else på N og Z goto et andet sted i mikroprogrammet, samt på MBR Én linje = en clock cycle i det tidsrum kan vi nå at gøre flere ting på Mic-1 (f.eks., lægge to tal sammen, og gemme resultatet i to registre) I princippet kunne vi jo blot angive alle signalerne men så kunne vi lige så godt holde os til den absolutte mikrokode

9 Aritmetiske og logiske operationer De lovlige ALU operationer i MAL DEST er ethvert register, som C-bussen kan skrive til SOURCE er ethvert register, der kan skrive til B-bussen Der kan tilføjes shift-operationer << 8 >> 1 Shift foregår efter ALU, så det kan tilføjes gratis efter almindelige ALU operationer, f.eks. DEST = H + SOURCE >> 1 DEST = H DEST = SOURCE DEST = inv (H) DEST = inv (SOURCE) DEST = H + SOURCE DEST = H + SOURCE + 1 DEST = H + 1 DEST = SOURCE + 1 DEST = SOURCE - H DEST = SOURCE - 1 DEST = -H DEST = H and SOURCE DEST = H or SOURCE DEST = 0 DEST = 1 DEST = -1 H

10 Hukommelsesoperationer Stakområdet (her kan læses og skrives i words) specificeres v.hj.a. rd og wr det angivne ord udpeges af MAR og hentes/gemmes fra/i MDR Constant Pool (her kan læses i words) specificeres v.hj.a. rd det angivne ord udpeges af MAR og læses fra MDR Method Area (her kan læses i bytes) specificeres v.hj.a. fetch den angivne byte ender i MBR pop = 0x57: MAR = SP = SP - 1; rd empty TOS = MDR; goto main swap = 0x5F: MAR = SP - 1; rd MAR = SP H = MDR; wr MDR = TOS MAR = SP - 1; wr TOS = H; goto main Husk: Hukommelsesoperationer tager 2 clock cycles (altså 2 MAL linjer)

11 Hopinstruktioner Ubetingede hop: (vi kan definere labels, som vi kan hoppe til) goto L På indholdet af MBR (JMPC=1): (det er naturligvis praktisk til opcodes) goto MBR Betingede hop: (N og Z opfattes som (imaginære) registre) På N (JAMN = 1), dvs. ALU output negativt: if (N) goto L1; else goto L2 På Z (JAMZ = 1), dvs. ALU output 0 (Zero): if (Z) goto L1; else goto L2 Husk: Hopinstruktioner kan sagtens foregå som resultat af beregninger: Z = OPC - H; if (Z) goto T; else goto F

12 Fetch, decode, execute! Dét har I hørt nogen gange nu når vi omsider frem til hvor det faktisk sker FETCH DECODE EXECUTE Tanenbaum notation; I kommer til at arbejde med følgende: Lidt færre label definitioner bemærk hvordan labels matches med opcodes Bedste råd omkring det her? læs koden indtil I forstår, hvordan det virker følg med på mikroarkitekturen (Figure 4-6) main: PC = PC + 1; fetch; goto (MBR) nop = 0x00: goto main iadd = 0x60: MAR = SP = SP - 1; rd H = TOS MDR = TOS = MDR + H; wr; goto main

13 IJVM på Mic-1: Invarianter Det centrale sted i IJVM implementationen er main, hvorfra alting udgår Følgende krav skal altid være opfyldte, når vi når til main: PC udpeger den byte i Method Area, som indeholder instruktionskoden for den IJVM instruktion der skal afvikles MBR indeholder instruktionskoden for den IJVM instruktion, der skal afvikles, MBR=m[PC] SP udpeger det øverste element på stakken LV udpeger det første ord i det aktuelle stakafsnit CPP udpeger det første ord i Constant Pool TOS indeholder det øverste ord på stakken, TOS=m[SP] main: PC = PC + 1; fetch; goto (MBR) De opfyldes måske ikke løbende, men når vi går i gang med main, skal de være opfyldte

14 iadd eksempel iadd bipush 24 isub istore Method area: 0x60 0x10 0x18 0x64 0x36 Invariant MBR=0x60; TOS=m[SP]=0x0f Hensigt PC Næste instruktion main: PC = PC + 1; fetch; goto (MBR) iadd = 0x60: MAR = SP = SP - 1; rd H = TOS MDR = TOS = MDR + H; wr; goto main Efter udførsel SP 0x0f 0x0a 0x00 SP 0x19 0x00 PC=PC+1; MBR=0x10; SP=SP-1; TOS=0x19

15 bipush eksempel iadd bipush 24 isub istore Method area: 0x60 0x10 0x18 0x64 0x36 Invariant MBR=0x10; TOS=m[SP]=0x19 Hensigt Efter udførsel PC SP 0x19 0x00 Næste instruktion SP 0x18 0x19 0x00 PC=PC+2; MBR=0x64; SP=SP+1; TOS=0x18 main: PC = PC + 1; fetch; goto (MBR) iadd = 0x60: MAR = SP = SP - 1; rd H = TOS MDR = TOS = MDR + H; wr; goto main bipush = 0x10: SP = MAR = SP + 1 PC = PC + 1; fetch MDR = TOS = MBR; wr; goto main

16 isub eksempel bipush 24 isub istore 3 Method area: 0x10 0x18 0x64 0x36 0x03 Invariant MBR=0x64; TOS=m[SP]=0x18 Hensigt Efter udførsel SP 0x18 0x19 0x00 PC Næste instruktion SP 0x01 0x00 PC=PC+1; MBR=0x36; SP=SP-1; TOS=0x01 main: PC = PC + 1; fetch; goto (MBR) iadd = 0x60: MAR = SP = SP - 1; rd H = TOS MDR = TOS = MDR + H; wr; goto main bipush = 0x10: SP = MAR = SP + 1 PC = PC + 1; fetch MDR = TOS = MBR; wr; goto main isub = 0x64: MAR = SP = SP - 1; rd H = TOS MDR = TOS = MDR - H; wr; goto main

17 istore eksempel isub istore 3 iload 3 Method area: 0x64 0x36 0x03 0x15 0x03 Invariant MBR=0x36; TOS=m[SP]=0x01 Hensigt Efter udførsel PC SP 0x01 0x00 Næste instruktion SP 0x00 istore = 0x36: H = LV MAR = MBRU + H istore_cont: MDR = TOS; wr SP = MAR = SP - 1; rd PC = PC + 1; fetch TOS = MDR; goto main 0x00 0x0f 0x0a LV link ptr PC=PC+2; MBR=0x15; SP=SP-1; TOS=0x00; m[lv+3]=0x01 0x01 0x0f 0x0a LV link ptr

18 Mic-1 værktøj Læs note 3 MAL Microassembler: Symbolsk mikrokode (MAL) absolut mikrokode mic1-asm ijvm.mal ijvm.mic1 Mic-1 simulator: Afvikler IJVM programmer på angivet mikroprogram mic1 ijvm.mic1 find_min.bc 9 8 Mic-1 assembleren har bl.a. til opgave at sørge for placere mikroinstruktionerne korrekt (labels er ikke længere nemme!) opcodes skal placeres, så goto MBR virker if else labels skal placeres 256 adresser fra hinanden

19 Fra sidste gang: find_min.j.method main // int main.args 3 // ( int a, int b ).define a = 1.define b = 2 // { bipush 88 // Push some object reference iload a iload b invokevirtual min ireturn // return min (a,b); // }.method min // int min.args 3 // ( int a, int b ){.define a = 1.define b = 2.locals 1 // int r;.define r = 3 iload a // if ( a >= b ) iload b isub // stack = a - b,... ; a - b < 0 => a < b iflt else iload b // r = b; istore r goto end_if else: // else iload a // r = a; istore r end_if: iload r // return r; ireturn // }

20 mic ijvm.mic1 find_min.bc 9 8 Mic1 Trace of ijvm.mic1 with find_min.bc stack = 0, 1, 8, 9, 15 bipush 88 [10 58] stack = 88, 0, 1, 8, 9, 15 iload 1 [15 01] stack = 9, 88, 0, 1, 8, 9, 15 iload 2 [15 02] stack = 8, 9, 88, 0, 1, 8, 9, 15 invokevirtual 1 [b ] stack = 12, 13, 0, 8, 9, 21, 0, 1, 8, 9, 15 iload 1 [15 01] stack = 9, 12, 13, 0, 8, 9, 21, 0, 1, 8, 9, 15 iload 2 [15 02] stack = 8, 9, 12, 13, 0, 8, 9, 21, 0, 1, 8, 9, 15 isub [64] stack = 1, 12, 13, 0, 8, 9, 21, 0, 1, 8, 9, 15 iflt 10 [9b 00 0a] stack = 12, 13, 0, 8, 9, 21, 0, 1, 8, 9, 15 iload 2 [15 02] stack = 8, 12, 13, 0, 8, 9, 21, 0, 1, 8, 9, 15 istore 3 [36 03] stack = 12, 13, 8, 8, 9, 21, 0, 1, 8, 9, 15 goto 7 [a ] stack = 12, 13, 8, 8, 9, 21, 0, 1, 8, 9, 15 iload 3 [15 03] stack = 8, 12, 13, 8, 8, 9, 21, 0, 1, 8, 9, 15 ireturn [ac] stack = 8, 0, 1, 8, 9, 15 ireturn [ac] stack = 8 return value: 8 Meh ikke så overraskende (8 er stadig mindre end 9)

21 mic -b isub ijvm.mic1 find_min.bc 9 8 Mic1 Trace of ijvm.mic1 with find_min.bc... iload 2 [15 02] stack = 8, 9, 12, 13, 0, 8, 9, 21 isub [64] MAR=24 MDR=8 PC=22 MBR=100 MBRU=100 SP=24 LV=17 CPP=10 TOS=8 OPC=13 H=17 0x002: PC = PC + 1; fetch; goto (MBR); MAR=24 MDR=8 PC=23 MBR=100 MBRU=100 SP=24 LV=17 CPP=10 TOS=8 OPC=13 H=17 0x064: MAR = SP = SP - 1; rd; goto 0x006; MAR=23 MDR=8 PC=23 MBR=-101 MBRU=155 SP=23 LV=17 CPP=10 TOS=8 OPC=13 H=17 0x006: H = TOS; goto 0x007; MAR=23 MDR=9 PC=23 MBR=-101 MBRU=155 SP=23 LV=17 CPP=10 TOS=8 OPC=13 H=8 0x007: MDR = TOS = MDR - H; wr; goto 0x002; MAR=23 MDR=1 PC=23 MBR=-101 MBRU=155 SP=23 LV=17 CPP=10 TOS=1 OPC=13 H=8 stack = 1, 12, 13, 0, 8, 9, 21, 0... return value: 8 Se det var jo straks lidt mere brugbart microtrace af Mic-1 ens tilstand

22 Oversigt Mikroprogrammering: IJVM implementeret på Mic-1 Forbedringer af Mic-1 Metode til udvikling af symbolske maskinsprogsprogrammer

23 Hvordan gør man en processor hurtigere? Reducér antallet af taktslag (clock cycles) for at udføre en instruktion Gør processoren simplere, så de enkelte taktslag bliver kortere, og øg klokfrekvensen Overlap udførslen af instruktionerne Udnyt så meget funktionalitet (specielt ALU) som muligt det er f.eks. lidt spild bare at lade en værdi passere ALU, hvis der ikke skal gøres noget ved den

24 Optimering af mikrokoden Hvis man kan spare bare et enkelt taktslag på processoren, vil alle programmer, der bruger den optimerede instruktion køre hurtigere Mic-1: Er det virkeligt nødvendigt altid at returnere til Main? pop = 0x57: MAR = SP = SP - 1; rd empty TOS = MDR; goto main main: PC = PC + 1; fetch; goto (MBR) pop = 0x57: MAR = SP = SP - 1; rd PC = PC + 1; fetch; TOS = MDR; goto (MBR) Så længe vi overholder vores invariant, kan vi tillade sådanne ting Omkostningen er et mikroprogram, der er mindre læseligt

25 Udvid hardwaren: Tre busser i stedet for to Et problem ved Mic-1 er H ofte skal man bruge et taktslag til at kopiere en værdi fra et register via B og ALU til H (tager tid, spilder ALU tid) løsning: fasthold H som register (flere registre er altid godt), og skab to outputbusser i stedet for blot B Med to outputbusser, kan mikroprogrammet simplificeres yderligere iload = 0x15: H = LV MAR = MBRU + H; rd iload_cont: MAR = SP = SP + 1 PC = PC + 1; fetch; wr TOS = MDR; goto main main: PC = PC + 1; fetch; goto (MBR) iload = 0x15: MAR = MBRU + LV; rd iload_cont: MAR = SP = SP + 1 PC = PC + 1; fetch; wr TOS = MDR PC = PC + 1; fetch; goto (MBR)

26 Udvid hardwaren: Instruction Fetching Unit Hvad skal man altid lave i en mikroinstruktion? hente den næste instruktion, og muligvis indlejrede argumenter Hvis man kunne hente instruktionerne løbende, så de hele tiden var klar til mikroprogrammet, behøvede man ikke at rode eksplicit med PC eller opbygge 16-bit værdier i mikrokode dette kræver separat hardware Hvad har vi brug for til IJVM? hav den næste byte klar som 8-bit (signed og unsigned) hav de næste to bytes klar som 16-bit (signed og unsigned) nogen gange vil det ikke give mening at fortolke de næste to bytes som et 16-bit tal, men det er ok, hvis vi ikke bruger det

27 Instruction Fetch Unit Bytes læses løbende ind i shift registret, og kopieres over i MBR1 og MBR2 IFU detekterer selv, når MBR? læses og tæller derefter PC op (1 eller 2, alt efter hvor meget, der er blevet læst) IFU læser hukommelsen i 32-bit words, så IMAR tilføjes til at håndtere disse adresser

28 Mic-2 Der kræves flere kontrolsignaler for at kunne regulere A og B bussen PC håndteres oftest autonomt af IFU undtaget ved branches og invokevirtual/ireturn her sættes PC manuelt som sædvanligt iadd = 0x60: MAR = SP = SP - 1; rd H = TOS MDR = TOS = MDR + H; wr; goto main main: PC = PC + 1; fetch; goto (MBR) iadd = 0x60: MAR = SP = SP - 1; rd empty MDR = TOS = MDR + TOS; wr; goto (MBR1)

29 ldc_w optimering Fordi IFU automatisk samler bytes for os (hvad enten vi skal bruge det eller ej), kan en instruktion som ldc_w reduceres drastisk i størrelse og kompleksitet ldc_w = 0x13: PC = PC + 1; fetch H = MBRU << 8 H = MBRU OR H MAR = H + CPP; rd; goto iload_cont iload_cont: MAR = SP = SP + 1 PC = PC + 1; fetch; wr TOS = MDR; goto main main: PC = PC + 1; fetch; goto (MBR) ldc_w = 0x13: MAR = MBR2U + CPP; rd MAR = SP = SP + 1 TOS = MDR; wr; goto (MBR1)

30 Pipelining: Overlap udførslen af instruktionerne Der er tre ting, der sker hvert taktslag kopiér data fra register til bus behandl data i ALU kopiér data fra bus til registre Disse aktiviteter foregår i Mic-1 og Mic-2 sekventielt, dvs. busser og ALU arbejder hver kún en tredjedel af tiden ingen grund til at registre skal vente på, at ALU bliver færdig eller ALU skal vente på, at registre bliver fyldt igen A

31 Mic-3 Mic-2 udstyres med ekstra registre, latch A, B og C disse isolerer udgående bus, ALU og indgående bus fra hinanden Nu kan de tre trin arbejde uafhængigt Hver trin er drevet af et taktslag, men da det enkelte trin er mindre, kan vi bruge ⅓ så lange taktslag tredobbel klokfrekvens Hukommelseoperationer tager stadig ét taktslag (tilgængelig efter to)

32 swap optimering swap = 0x5F: MAR = SP - 1; rd MAR = SP H = MDR; wr MDR = TOS MAR = SP - 1; wr TOS = H; goto (MBR1) For at kunne udnytte de nye latches, skabes tre nye registre A, B og C Alle operationer skal nu brydes ned i mikroskridttripler ( bus, ALU, bus ) Ideelt skal vi udnytte så meget på processoren samtidigt som muligt

33 swap optimering MAR = SP - 1; rd MAR = SP H = MDR; wr MDR = TOS MAR = SP - 1; wr TOS = H; goto (MBR1) 1 B = SP 2 C = B - 1 B = SP 3 MAR = C; rd C = B 4 MDR = Mem MAR = C 5 B = MDR 6 C = B B = TOS 7 H = C; wr C = B B = SP 8 Mem = MDR MDR = C C = B - 1 B = H 9 MAR = C; wr C = B 10 Mem = MDR TOS = C 11 goto (MBR1) Instruktioner ved siden af hinanden: Parallel udførsel ( bus, ALU, bus ) Hvis vi skal vente på noget, har vi en stall, som i skridt 5 (vi venter på MDR)

34 Hurtigere? swap på Mic-3 tager 11 taktslag, hvor det tog 6 taktslag på Mic-2, men da vi samtidigt har tredoblet klokfrekvensen er det stadig hurtigere Hvis 1 Mic-3 taktslag tager t, så tager swap Mic-3 11 taktslag = 11 t Da tager et Mic-2 taktslag 3 t, og swap Mic-2 tager 6 taktslag = 18 t Her ses op til fire instruktioner i gang simultant: Langt bedre udnyttelse Pipelining anvendes på alle moderne CPUer, oftest med mange flere trin

35 Oversigt Mikroprogrammering: IJVM implementeret på Mic-1 Forbedringer af Mic-1 Metode til udvikling af symbolske maskinsprogsprogrammer

36 Elementer i symbolsk maskinkode.method main // int main.args 3 // ( int a, int b ).define a = 1.define b = 2 // { bipush 88 // Push some object reference iload a iload b invokevirtual min ireturn // return min (a,b);}.method min // int min.args 3 // ( int a, int b ){.define a = 1.define b = 2.locals 1 // int r;.define r = 3 iload a // if ( a >= b ) iload b isub iflt else iload b // r = b; istore r goto end_if else: iload a // else istore r // r = a; end_if: iload r // return r; ireturn // } Symbolske ordrer iload, isub 1-1 afbildning Direktiver/pseudoinstruktioner.define a=1 symbolsk konstant.method min metode start.args 3 antal argumenter.locals 1 antal lokale variable Labels else: end_if: Symbolske operander a, b, r symbolske konstanter min metodenavne else, end_if labels

37 Symbolske maskinsprog Skønt der er gennemgående begreber og elementer, varierer symbolske maskinsprog fra arkitektur til arkitektur Beregning af N = I + J i (a) Pentium 4, (b) Motorola 680x0, (c) SPARC

38 To eksempler på forskellige syntakser for x86 symbolsk maskinkode (der er flere!) AT&T Intel.L2: movl $6, %eax ; start k = 6 - i - j subl 12(%ebp), %eax ; eax = 6 - i subl 16(%ebp), %eax ; eax = 6 - i - j movl %eax, -12(%ebp); k = eax movl 8(%ebp), %eax ; start towers(n-1, i, k) decl %eax ; eax = n-1 subl $4, %esp pushl -12(%ebp) ; k pushl 12(%ebp) ; i pushl %eax ; n-1.l2: mov eax, 6 ; start k = 6 - i - j sub eax, DWORD PTR [ebp+12] ; eax = 6 - i sub eax, DWORD PTR [ebp+16] ; eax = 6 - i - j mov DWORD PTR [ebp-12], eax ; k = eax mov eax, DWORD PTR [ebp+8] ; start towers(n-1,i,k) dec eax ; eax = n-1 sub esp, 4 push DWORD PTR [ebp-12] ; k push DWORD PTR [ebp+12] ; i push eax ; n-1

39 Oversættelse til symbolsk maskinkode Hvordan kommer man fra et høj niveau program til et stykke symbolsk maskinkode? en trinvis metode, beskrevet i Note 5 Altid en god idé at starte med et testet program, som man så oversætter

40 Største fælles divisor /* gcd.c */ #include <stdio.h> #include <stdlib.h> int gcd(int x, int y) { while ( x!= y ) { if ( x < y) y = y - x; else x = x - y; } return x; } int main(int argc, char *argv[]) { int x = atoi(argv[1]); int y = atoi(argv[2]); printf("gcd(%d,%d) = %d\n", x, y, gcd(x, y)); }

41 Input til metoden int gcd(int x, int y) { while ( x!= y ) { if ( x < y) y = y - x; else x = x - y; } return x; }.method gcd // int gcd.args 3 // (int x, int y).define x = 1.define y = 2

42 Kroppen til metoden int gcd(int x, int y) { while ( x!= y ) { if ( x < y) y = y - x; else x = x - y; } return x; }.method gcd // int gcd.args 3 // (int x, int y).define x = 1.define y = 2 // { // }

43 Metodens return sætning int gcd(int x, int y) { while ( x!= y ) { if ( x < y) y = y - x; else x = x - y; } return x; }.method gcd // int gcd.args 3 // (int x, int y).define x = 1.define y = 2 // { iload x ireturn // return x; // }

44 Den ydre løkke int gcd(int x, int y) { while ( x!= y ) { if ( x < y) y = y - x; else x = x - y; } return x; }.method gcd // int gcd.args 3 // (int x, int y).define x = 1.define y = 2 // { while: // while iload x iload y if_icmpeq end_while // (x!=y) { goto while end_while: // } iload x ireturn // return x; // }

45 If sætningen int gcd(int x, int y) { while ( x!= y ) { if ( x < y) y = y - x; else x = x - y; } return x; }.method gcd // int gcd.args 3 // (int x, int y).define x = 1.define y = 2 // { while: // while iload x iload y if_icmpeq end_while // (x!=y) { iload x // if iload y isub // stack=x-y, x-y<0 (x<y) iflt then goto else else: end_if: goto while // else end_while: // } iload x ireturn // return x; // } then: // then goto end_if

46 If sætningens første linje int gcd(int x, int y) { while ( x!= y ) { if ( x < y) y = y - x; else x = x - y; } return x; }.method gcd // int gcd.args 3 // (int x, int y).define x = 1.define y = 2 // { while: // while iload x iload y if_icmpeq end_while // (x!=y) { iload x // if iload y isub // stack=x-y, x-y<0 (x<y) iflt then goto else then: // then iload y iload x isub istore y // y=y-x; goto end_if else: end_if: goto while // else end_while: // } iload x ireturn // return x; // }

47 If sætningens anden linje int gcd(int x, int y) { while ( x!= y ) { if ( x < y) y = y - x; else x = x - y; } return x; }.method gcd // int gcd.args 3 // (int x, int y).define x = 1.define y = 2 // { while: // while iload x iload y if_icmpeq end_while // (x!=y) { iload x // if iload y isub // stack=x-y, x-y<0 (x<y) iflt then goto else then: // then iload y iload x isub istore y // y=y-x; goto end_if else: // else iload x iload y isub istore x // x=x-y; end_if: goto while end_while: // } iload x ireturn // return x; // }

48 Komplet med en main metode.method main // int main.args 3 // ( int x, int y ).define x = 1.define y = 2 // { bipush 88 // Push OBJREF iload x iload y invokevirtual gcd ireturn // return gcd(x,y);.method gcd // int gcd.args 3 // (int x, int y).define x = 1.define y = 2 // { while: // while iload x iload y if_icmpeq end_while // (x!=y) { iload x // if iload y isub // stack=x-y, x-y<0 (x<y) iflt then goto else then: // then iload y iload x isub istore y // y=y-x; goto end_if else: // else iload x iload y isub istore x // x=x-y; end_if: goto while end_while: // } iload x ireturn // return x; // }

49 Kørsel $ ijvm gcd.bc 4 8 IJVM Trace of gcd.bc stack = 0, 1, 8, 4, 20 bipush 88 [10 58] stack = 88, 0, 1, 8, 4, 20 iload 1 [15 01] stack = 4, 88, 0, 1, 8, 4, 20 iload 2 [15 02] stack = 8, 4, 88, 0, 1, 8, 4, 20 invokevirtual 1 [b ] stack = 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 iload 1 [15 01] stack = 4, 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 iload 2 [15 02] stack = 8, 4, 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 if_icmpeq 34 [9f 00 22] stack = 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 iload 1 [15 01] stack = 4, 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 iload 2 [15 02] stack = 8, 4, 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 isub [64] stack = -4, 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 iflt 6 [9b 00 06] stack = 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 iload 2 [15 02] stack = 8, 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 iload 1 [15 01] stack = 4, 8, 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 isub [64] stack = 4, 17, 13, 8, 4, 25, 0, 1, 8, 4, 20 istore 2 [36 02] stack = 17, 13, 4, 4, 25, 0, 1, 8, 4, 20 goto 10 [a7 00 0a] stack = 17, 13, 4, 4, 25, 0, 1, 8, 4, 20 goto -35 [a7 ff dd] stack = 17, 13, 4, 4, 25, 0, 1, 8, 4, 20 iload 1 [15 01] stack = 4, 17, 13, 4, 4, 25, 0, 1, 8, 4, 20 iload 2 [15 02] stack = 4, 4, 17, 13, 4, 4, 25, 0, 1, 8, 4, 20 if_icmpeq 34 [9f 00 22] stack = 17, 13, 4, 4, 25, 0, 1, 8, 4, 20 iload 1 [15 01] stack = 4, 17, 13, 4, 4, 25, 0, 1, 8, 4, 20 ireturn [ac] stack = 4, 0, 1, 8, 4, 20 ireturn [ac] stack = 4 return value: 4

50 Altså: Start udefra Opbyg strukturen trin for trin Brug klare labels, der matcher den oprindelige kode End med de inderste elementer Brug kommentarer i rigt mål Når ALTING virker efter hensigten, SÅ kan man BEGYNDE at overveje at optimere på koden ikke før! Lav aldrig, aldrig, ALDRIG optimering halvvejs igennem et stykke kode!

51 Opsummering Med det rigtige værktøj er selv programmering af en CPU blot endnu et programmeringssprog på den ene side særdeles simpelt, fordi man rent beset ikke kan særligt meget på den anden side kompliceret/anderledes, fordi ting kan foregå parallelt, og hukommelsetilgang tager 2 clock cycles man kan f.eks. sagtens nå at bruge den gamle værdi i MDR, selvom man har sat en rd i gang måske ikke intuitivt, men sådan er det! Timing er afgørende på dette niveau nævnt to gange på samme slide, fordi det er vigtigt Effektive programmer er helt centrale på mikrokodeniveauet udnyt parallelismen maksimalt for en gangs skyld et sprog og en omgivelse, hvor oneliners er en dyd med passende hardwareudvidelser kan hastigheden øges betragteligt