ITPE/DATS 2400: Datamaskinarkitektur og Nettverk Instruksjonsettarkitektur 2 Knut Nygård / T. M. Jonassen Institute of Computer Science Faculty of Technology, Art and Design Oslo and Akershus University College of Applied Sciences 30. Januar 2015
Oversikt 1 En enkel maskinmodell 2 Om ARC - A RISC COMPUTER 3 ARC - instruksjonsettet 4 ARC - pseudo-operasjoner 5 ARC - syntetiske instruksjoner 6 ARC - et eksempel 7 Multiplikasjon av ikke-negative heltall 8 Divisjon av ikke-negative heltall
Repetisjon Vi tar først endel repetisjon fra forrige forelesning.
Bus Data bus: Kommunikasjonslinjer for å overføre informasjon. Addresse bus: Kommunikasjonslinjer dedikert for å sende adressser. Control bus: Kommunikasjonslinjer for å sende kontrollsignaler (styringssignaler).
CPU En modell av en CPU med ALU (aritmetisk-logisk enhet), registerfil og kontrollenhet. ALU og registerfil kalles en datapath, og utfører operasjoner (dekodede instruksjoner) som kalles mikrooperasjoner. Kontrollenheten dekoder instruksjoner fra minnet (og andre ting).
CPUs arbeidssteg skjematisk 1. Hent neste instruksjon fra minnet som skal utføres. 2. Dekode opcode (operation code). 3. Les eventelle operand(er) fra minnet. 4. Utfør instruksjonen og lagre eventuelle resultater. 5. Start på nytt med ny instruksjon. Viktige registere: Programteller (PC): Inneholder adressen til neste instruksjon som skal utføres. Instruksjonsregister (IR): Inneholder instruksjonen som skal utføres før den dekodes.
Datapath Skjematisk fremstilling av en datapath. Vi skal se nøyere på denne senere (kap. 5).
Minnet Minnemodellen for ARC arkitekturen vi skal bruke som eksempel i dette kurset.
Mer om ARC-minnemodellen 1 Flatt minne. Minste adresserbare enhet er en byte. Ordstørrelse (word) er fire byte. Bruker big-endian. Big-endian: Første bit på adresse mest signifikant. Little-endian: Første bit på adresse minst signifikant. 32-bits adresser, derfor er en adresse 32/4 = 8 heksadesimale siffer.
Mer om ARC-minnemodellen 2 Deler av minnet reservert OS. Deler av minnet reservert stack. Deler av minnet reservert I/O-enheter. Resten kalles user space. Minne for programmer. Bruker hard-alignment modellen: To halvord (2 byte hver) må settes sammen like-byte adresser, og to ord (4 byte hver) må settes sammen på like-ord adresser. Halvord har adresser som er like, ord har adresser som er multipler av 4.
ARC - A RISC Computer Forfatterene av læreboken har laget en tenkt og forenklet maskinmodell: ARC - A Risc Computer. RISC - Reduced Instruction Set Computer. Det er laget en simulator for denne etter modell av SPARC prossorene fra Sun (open doc ca 1992). Simulator (i Java) kan lastes ned fra bluemaster.cs.hioa.no under: /edu/darknet-14/files/arctoolsv2.1.2.zip Arkivet inneholder simulator, eksempler og README-filer.
Om ARC Vi skal i det følgende se litt mer detaljert på modellen ARC. Minnet. Registerfilen, andre registere. ARC assemblerspråket generelt. Instruksjonsettet. ARC simulatoren. Noen enkle eksempler på ARC assembler programmer.
Minnet Detaljer: Resevert OS: Adresse 0 til 2 11 1 altså 2048 bytes. User space: Fra adresse 2048 til topp på stack. Stack: Starter på adresse 2 31 4 og vokser mot lavere adresser. Reservert I/O enheter: Adresser mellom 2 31 og 2 32 1. (Memory mapped I/O).
Memory modell
Registerfil - registere ARC har en registerfil med 32 registere, hvert på 32 bit (ett ord). Disse betegnes med %r0 til %r31. Tre av disse har spesiell bruk: %r0 er alltid 0, %r14 brukes som stackpeker, %sp og%r15 er et link register, brukes ved kall av subrutiner. I tillegg finnes %pc (32 bits) som inneholder adressen til insrtuksjonen som utføres. Vi har også %psr (processor status register) som inneholder informasjon om status til prossessor.
Traps Registeret PSR har bits som støtter traps. Dette er en mekanisme for å stoppe vanlig flyt av instruksjoner. PÅ noen prossessorer kalles dette interupts. På x86 prossessorer brukes dette for kommunikasjon med annen hardware.
Om instruksjonene generelt Alle instruksjoner har 32 bits størrelse. ARC er en load - store maskin. Dette betyr at minne bare kan aksesseres gjennom slike operasjoner. Alle operasjoner utføres på data i registere. ARC instruksjonene (50) er en delmengde av SPARC prossessoren instruksjoner (200). ARC og SPARC instruksjoner har samme syntaks (nesten alltid sant). ARC er en 2-komplement maskin.
Instruksjonstyper Aritmetiske instruksjoner. Logiske instruksjoner. Load/store instruksjoner. Kontroll (branch) instruksjoner
Eksempel 1 add rs1, reg or imm, rd vil medføre rd rs1 + rs2 hvor rs2 er reg eller imm. add %r1, %r2, %r3 gir %r3 %r1 + %r2. add %r1, 12, %r2 gir %r2 %r1 + 12.
Mer om instruksjoner Notasjonen a b + c kalles register transfer language (RTL). Alle instruksjoner lagres på 32 bits. Dette gir 13 bits til konstanter, så disse må være mellom 4196 og 4195. Konstanter tolkes i base 10. Konstanter som starter med 0x tolkes heksadesimalt. En instruksjon har inntil seks felt: Label, opcode, opptil tre operander, kommentar
Load/store 1 Load: ld [address], rd rd M[address] Store: st rd, [address] M[address] rd
Load/store 2
Kontroll operasjoner Brukes til å komme til en annen del av programmet.
Pseudo-operasjoner Pseudo-operasjoner er ikke instruksjoner, men direktiver til assembleren. Eksempler:
Syntetiske instruksjoner (makro) En syntetisk instruksjon er ikke en instruksjon men noe som omformes av assembler til instruksjoner under assemblingen. Eksempler:
Addere to tall! Legg sammen to tall.begin.org 2048 prog1: ld [x], %r1! Legg x i r1 ld [y], %r2! Legg y i r2! Data x: 15 y: 12 z: 0.end addcc %r1, %r2, %r3! r3 = st %r3, [z]! Lagre r3 i z jmpl %r15 + 4, %r0! Avslutt r1 + r2
bin - filen 00000800 00000800 c2002814 00000804 c4002818 00000808 86804002 0000080c c620281c 00000810 81c3e004 00000814 0000000f 00000818 0000000c 0000081c 00000000
lst -filen (ARCTools Version 2.0.2) HexLoc DecLoc MachWord Label Instruction Comment.org 2048 00000800 0000002048 c2002814 prog1: ld [2068], %r1! Legg x i r1 00000804 0000002052 c4002818 ld [2072], %r2! Legg y i r2 00000808 0000002056 86804002 addcc %r1, %r2, %r3! r3 = r1 + r2 0000080c 0000002060 c620281c st %r3, [2076]! Lagre r3 i z 00000810 0000002064 81c3e004 jmpl %r15, 4, %r0! Avslutt! Data 00000814 0000002068 0000000f x: 00000818 0000002072 0000000c y: 0000081c 0000002076 00000000 z: --- Symbol Table --- x: 2068 z: 2076 prog1: 2048 y: 2072
Whiteboard Multiplikasjon av ikke-negative heltall gies skjematisk på whiteboard. Se læreboken kap. 3.
Multiplikasjon Hvordan få til multiplikasjon når denne mangler som instruksjon? Flere måter å gjøre dette på. Den binære multiplikasjonstabellen er enkel! Vet hvordan vi gjør dette for hånd. Bruker da kun shift og addisjon. Husk: Et produkt av to tall kan trenge dobbelt så mange bits som multiplikand og muliplikator.
C kode #include <stdio.h> #include <stdlib.h> main() { int p, m, n; m=554; n=234; // Performs m x n, product in p printf("m=%d n=%d\n",m,n); p = 0; // initialize product p to 0 while (n!= 0) // while multiplier n is not 0 { if ((n & 0x01)!= 0) // test lsb of multiplier p = p + m; // if 1 then add multiplicand m m = m << 1; // left shift multiplicand n = n >> 1; // right shift multiplier } printf("mxn=%d\n",p); exit(0); }
Kjøringseksempel Her er et kjøringseksempel av C-programmet. [torejo@zbook lec08]$ gcc -o mult mult.c [torejo@zbook lec08]$./mult m=554 n=234 mxn=129636 [torejo@zbook lec08]$
ARC program! The program implements multiplication of unsigned integers! p = m x n! %r1 - contains m initially, modified during loop! %r2 - contains n initially, modified during loop! %r3 - contains p, initially 0.begin.org 2048 ld [m],%r1 ld [n],%r2 st %r0,[p] and %r0,%r0,%r3 loop: andcc %r2,%r2,%r0 be done andcc %r2,1,%r0 be next add %r1,%r3,%r3 next: sll %r1,1,%r1 srl %r2,1,%r2 ba loop done: st %r3,[p] jmpl %r15 + 4,%r0 m: 20 n: 13 p: 0.end
Whiteboard Divisjon av ikke-negative heltall gies skjematisk på whiteboard. Se læreboken kap. 3.
Divisjon av heltall Divisjon er vanskligere enn multiplikasjon. Vet hvordan vi gjør dette for hånd. Vil bruke en modifisert metode: shift, test, restore. Beskrevet i seksjon 3.2.2 i læreboken. Lønner seg å skrive et C-program først, deretter assembler program.
C-program, del 1 #include <stdio.h> #include <stdlib.h> main() { int i; int q, r, b; q=22; b=5; r=0; printf("q=%d, b=%d, r=%d\n",q,b,r); // Performs q/b, result in q, reminder in r Fortsetter neste slide...
C-program, del 2 for (i = 0; i < 32; i++) // do 32 times { // double left shift r-q pair if ((q & 0x80000000)!= 0) // check if carry from q to r r = (r << 1) + 1; // left shift r w/ carry in else r = r << 1; // left shift r w/o carry q = q << 1; // left shift q if (r - b >= 0) // test if b can be subtracted from q { q = q 0x01; // set lsb of q r = r - b; } } printf("q=%d r=%d b=%d\n",q,r,b); exit(0); }
Kjøringseksempel Her er et kjøringseksempel av C-programmet. [torejo@zbook lec08]$ gcc -o div div.c [torejo@zbook lec08]$./div q=22, b=5, r=0 q=4 r=2 b=5 [torejo@zbook lec08]$
ARC program, del 1! The program implements division of unsigned integers! Computes q/b, result in q, reminder in r! %r1 - contains q! %r2 - contains b! %r3 - contains r! %r4 - loop counter! %r5 - the constant 0x80000000.begin.org 2048 ld [q], %r1 ld [b], %r2 st %r0, [r] and %r0, %r0, %r3 and %r0, %r0, %r4 add %r4, 32, %r4! Insert code for 0x80000000 sethi 0x200000, %r5
ARC program, del 1 loop: andcc %r4, %r4, %r0 be done sub %r4, 1, %r4 andcc %r1, %r5, %r0 be else sll %r3, 1, %r3 add %r3, 1, %r3 ba endif else: sll %r3, 1, %r3 endif: sll %r1, 1, %r1 subcc %r3, %r2, %r0 bneg next or %r1, 1, %r1 sub %r3, %r2, %r3 next: ba loop done: st %r1, [q] st %r3, [r] jmpl %r15 + 4, %r0 q: 22 b: 5 r: 0.end
Hvis teknikken virker, vise programmene på simulator.