Løsningsforslag til eksamen i IN147(A)

Transkript

1 Løsningsforslag til eksamen i IN147(A) Dag Langmyhr Øystein Gran Larsen 27. mai 1998 Oppgave 1: Oversettelse En ganske rett frem oversettelse ser slik ut: 1 #include <regdef.h> 2.text 4.globl iavg 6 # Name: iavg. # Synopsis: Compute the average. 8 # C signature: int iavg(int a[], int n). # Register use: 10 # a0 &a[i] # a1 n 12 # v0 sum # t0 i and ±n/2 14 # t1 a[i] 16 iavg: move v0,zero # sum = 0; move t0,zero # i = 0; 18 loop: lw t1,0(a0) # Hent a[i] og 20 add v0,v0,t1 # legg til sum. addi t0,t0,1 # Øk i og tilhørende 22 addi a0,a0,4 # &a[i]. blt t0,a1,loop # Gjenta om i<n. 24 sra t0,a1,1 # i = n/2; 26 bgez v0,round # if (sum<0) neg t0,t0 # i = -i; 28 round: add v0,v0,t0 # sum += i; div v0,v0,a1 # Returverdi er sum/n. 30 jr ra # Retur. Når vi skal utvide med en funksjonsparameter, må følgende endres: Vi må legge inn et kall på funksjonen. Vi må lagre verdier i sikre registre (og det opprinnelige innholdet av disse sikre registrene må gjemmes på stakken under kjøringen og legges tilbake etterpå). Løsningen kan da se slik ut: 1 #include <regdef.h> 2.text 4.globl fiavg 6 # Name: fiavg. # Synopsis: Compute an average. 8 # C signature: int fiavg(int a[], int n, int (*fx)(int)). # Register use: 1

2 10 # s0 &a[i] # s1 n 12 # s2 fx # s3 sum 14 # s4 i and ±n/2 16 fiavg: addi sp,sp,-24 # Sett av plass på stakken. sw ra,0(sp) # Gjem alle 18 sw s0,4(sp) # de sikre sw s1,8(sp) # registrene 20 sw s2,12(sp) # på stakken. sw s3,16(sp) # 22 sw s4,20(sp) # 24 move s0,a0 # Flytt parametrene move s1,a1 # til sikre 26 move s2,a2 # registre. move s3,zero # sum = 0; 28 move s4,zero # i = 0; 30 loop: lw a0,0(s0) # Hent a[i] og jalr s2 # kall fx(a[i]). 32 add s3,s3,v0 # Summér svaret. addi s4,s4,1 # Øk i og tilhørende 34 addi s0,s0,4 # &a[i]. blt s4,s1,loop # Gjenta om i<n. 36 sra s4,s1,1 # i = n/2; 38 bgez s3,round # if (sum<0) neg s4,s4 # i = -i; 40 round: add s3,s3,s4 # sum += i; div v0,s3,s1 # Returverdi er sum/n. 42 lw ra,0(sp) # Hent de 44 lw s0,4(sp) # sikre lw s1,8(sp) # registrene 46 lw s2,12(sp) # tilbake lw s3,16(sp) # fra 48 lw s4,20(sp) # stakken. addi sp,sp,24 # Rydd opp på stakken. 50 jr ra # Retur. Funksjonen f finner det største elementet i float-vektoren a med n elementer; n 1. En versjon i C kan se slik ut: 1 float f(float a[], int n) 2 { float max = 0.0; 4 int i; 6 for (i = 0; i < n; ++i) if (a[i] >= max) max = a[i]; 8 return max; 10 Oppgave 2: Kontroll av en datapath Operasjon ALU en blir styrt til å produsere summen av ~A og B; 1. Operation styrer resultatet av addisjon ut på ALU ens utgang 2. CarryIn er 0, så det er ikke mente inn i minst signifikante posisjon 3. Ainvert er 1 og styrer dermed ~A til addisjonslogikken 2

3 4. Binvert er 0 og styrer dermed B til addisjonslogikken Signalet A er innholdet fra register 0 (se figur 7), som så blir invertert bitfor-bit. Denne nye verdien ~A svarer til toer-komplement representasjonen av 1. Følgelig beregner ALU en B +( 1), og Zero får verdien 1 hvis svaret ble 0 og 0 hvis svaret ikke ble 0. Instruksjonen Kontrollordet i figur 6 spesifiserer at reultatet fra ALU en skal skrives tilbake til RT [MemtoReg == 0, RegWrite == 1, RegDst == 0]. Dette er samme register som opptrer som argument B til ALU en [ALUSrc == 0]. Altså er en del av det instruksjonen gjør en dekrementering av RT [RT = RT +( 1)]. Videre er instruksjonen i stand til å endre programmtelleren gjennom et betinget hopp [Branch == 1], men i stedet for at dette skjer når resultatet fra ALU en er 0, så skjer det når resultatet fra ALU en er forskjellig fra 0. Dette forårsakes av XOR-porten som slipper Zero uforandret gjennom hvis InvZero == 0, men inverterer Zero i tilfelle InvZero == 1. Dette siste er tilfelle for denne instruksjonen. Alt-i-alt så er instruksjonen en «Decrement and Branch if Not Zero», som pakker følgende inn i en instruksjon: addi RT,RT,-1 # decrement RT bne RT,zero,label # branch to label if RT!= 0 En typisk anvendelse av slik funksjonalitet er i forbindelse med løkker, der label refererer til starten på et nytt gjennomløp. Generalisering av instruksjonen Dette betyr at instruksjonen skal gjøre RT = RT + «konstant» i stedet for RT = RT + ( 1). Ettersom det skal gjøres en subtraksjon i ALU en uten at CarryIn er satt, så må RS inneholde den inverterte av toer-komplement representasjonen av «konstant». Eksempel: hvis instruksjonen skal gjøre RT = RT + ( 4) må RS inneholde 0x3, ettersom ~0x3 == 0xfffffffc som er toer-komplement representasjonen av 4. Oppgave 3: Hukommelseshierarki Adressereferanser Koden i figur 8 sammen med initialverdiene gir sekvensen med adresser som er gjengitt i første kolonne i figur 1 (heksadesimale adresser). Etterhvert som koden blir kjørt så varierer verdiene i de relevante registrene som følger: register første gjennomløp andre gjennomløp tredje gjennomløp t0 0x3 0x2 0x2 0x1 0x1 0x0 t1 0x10002C 0x x t2 0x x x10003C Simulering av en «direct mapped» cache Cachen er på 16 ord 4 byte = 64 byte. Hver cachelinje er på 8 byte. Da er det 64 byte 8byte = 8 cachelinjer. Adressen brytes opp som følger: 2 bit byte offset (4byte i hvert ord) 3

4 adresse hendelse kommentar R/W/I index H/M lw t3, 0(t1) I 110 M 10002C t3 <- M[0-t1] leser fra 10002C R 101 M addi t1, t1, 4, t1 = I 110 H sw t3, 0(t2) I 111 M M[0+t2] <- t3 skriver til W 110 M 40233C addi t0, t0, -1, t0 = 2 I 111 H bne t0, zero, loop goto loop I 000 M addi t2, t2, 4, t2 = I 000 H neste gjennomløp lw t3, 0(t1) write back I 110 M t3 <- M[0-t1] leser fra R 110 M addi t1, t1, 4, t1 = I 110 M sw t3, 0(t2) I 111 H M[0+t2] <- t3 skriver til W 111 M 40233C addi t0, t0, -1, write back C, t0 = 1 I 111 M bne t0, zero, loop goto loop I 000 H addi t2, t2, 4, t2 = 10003C I 000 H neste gjennomløp lw t3, 0(t1) I 110 H t3 <- M[0-t1] leser fra R 110 M addi t1, t1, 4, t1 = I 110 M sw t3, 0(t2) I 111 H 10003C M[0+t2] <- t3 skriver til 10003C W 111 M 40233C addi t0, t0, -1, write back C, t0 = 0 I 111 M bne t0, zero, loop I 000 H addi t2, t2, 4, t2 = I 000 H Figur 1: Sekvens med adresser med tilleggsinformasjon. Notasjon: R read data, W write data, I instruction, M miss, H hit. 4

5 1 bit word offset (2 ord i hver cachelinje) 3 bit (2 3 = 8) index for å identifisere aktuell cachelinje øvrig mer signifikante bit blir brukt i tag De 6 bitene som utgjør offset er og index kommer fra den minst signifikante delen av adressen, f.eks. vil adressen 0x10002C bidra med (binært), der 101 blir index, word offset blir 1, og byte offset blir 00. Hvilken index de enkelte aksesser gir opphav til er gjengitt i 5. kolonne i figur 1, der det også fremgår typen aksess (R/W/I) og om det er hit (H) eller miss (M), i henholdsvis kolonne 4 og 6. Hit og miss fordeler seg som følger: instruksjoner data read write totalt miss Det endelige innholdet av cachen blir: index ord 0 ord bne t0, zero, loop addi t2, t2, ( tom ) ( tom ) 010 ( tom ) ( tom ) 011 ( tom ) ( tom ) 100 ( tom ) ( tom ) 101 data R data 10002C R 110 lw t3, 0(t1) addi t1, t1, sw t3, 0(t2) addi t0, t0, -1 Omgjøring av tilpassing til pipelining Delayed load betyr at når en load utføres så blir ikke resultatet (ny verdi i t3) tilgjengelig før én ekstra instruksjon er utført. Tilsvarende for delayed branch betyr at instruksjonen rett etter en branch alltid blir utført uavhengig av utkommet av testen. Man kan f.eks. tenke seg følgende kode før den ble tilpasset pipeliningen («schedulert»): loop: lw t3, 0(t1) sw t3, 0(t2) addi t1, t1, 4 addi t2, t2, 4 addi t0, t0, -1 bne t0, zero, loop Oppgave 4: Shared memory i software Å simulere en cache Figur 2 viser hvordan man relativt enkelt kan isolere aksesser til de delte data, og sikre at cachelinjen er i tilstanden READWRITE. Dette bygger på den valgte plasseringen av tilstandsinformasjonen i forhold til området der de delte data lagres, både om det er en aksess til delte data og adressen til tilstandsinformasjonen kan genereres ved skifting. delte data har mest signifikante bit i adressen satt tilstandsinformasjonen har en byte pr. 64 byte cachelinje denne informasjonen finnes ved å skifte adressen til de delte data 6 bit mot høyre, ettersom 0x > > 6 = 0x

6 Figur 2: Skisse av cache_store(address). Oppgaven tar seg nok en viss frihet når den ber om å kombinere C-kode med assembly, men det er en skisse det spørres etter! /* keep most significant bit of address */ tmp1 = address >> 31; /* isolate references to shared data */ if ( tmp == 0 ); /* not shared data */ else /* reference to shared data */ { /* find address of cacheline's state */ tmp2 = address >> 6; /* */ /* read byte from state table */ tmp1 = *((unsigned char*) (tmp2)); /* state must be READWRITE before read is performed */ if ( tmp1!= READWRITE ) remote_interaction( REQUEST, address, tmp1, READWRITE); /* original store instruction can proceed */ Man kunne også gjort maskering for å finne om det er en aksess til delte data, men det kompliserer koden ettersom man må generere (laste inn) masken. Videre antar skissen tilgjengeligheten av to variable (registre) tmp1 og tmp2 som makroen kan bruke. Dette anonymiserer hvilke registre det er snakk om, men det er rimelig å anta at det er mulig å finne ledige registre Avbrudd i stedet for polling Skissen av makroen inneholder kall på remote_interaction for å kommunisere med andre prosesser. Som det fremgår av figur 10 i oppgaven behandler denne prosedyren henvendelser fra andre prosesser mens den venter på svar. Dette er altså polling. Ettersom load og store opptrer hyppig i programmer, kan man forvente en tilsvarende hyppig polling i remote_interaction. Dette gir andre prosesser en rimelig oppmerksomhet fra den lokale prosessen. Hvis polling skal erstattes av avbrudd må det legges kritiske regioner rundt endringer av tilstandsinformasjonen til linjene i den simulerte cachen. Det kan være én semafor for alt, eller en semafor pr. cachelinje (kanskje plass i tilstandsinformasjonen). Men avbrudd koster mye (tusenvis av instruksjoner), samtidig som den hyppige forekomsten av load og store på andre prosesser vil rette mange henvendelser til den lokale prosessen. Derfor er avbrudd et dårlig alternativ til polling i denne sammenhengen. Prosedyrer eller makroer Makroer er funksjonalitet som blir tekstlig substituert inn i koden («inlining»), slik at koden vokser for hver kopi. Prosedyrer, derimot, er funksjonalitet det bare finnes én kopi av, og som dermed kan brukes fra flere steder. 6

7 Konsekvenser ved bruk av prosedyrer i stedet for makroer består i at prosedyrer utnytter lokalitet i tid, samtidig som kostnadene øker på grunn av kall og retur. Ettersom load og store opptrer hyppig vil denne kostnaden vokse seg (for) stor. Oppgave 5: Parallellstyring De to prosessene som kommuniserer via et felles lager er en variant av produsent/konsument-problemet, men litt enklere; vi trenger bare to semaforer: én til å blokkere L og én til å blokkere M. En løsning kan da se slik ut: 1 semaphore Ls = 0; /* Blokkerer L */ 2 semaphore Ms = 1; /* Blokkerer M */ 4 comm_data *cp =...; /* Peker til felles lager */ 6 process L(void) { 8 unsigned char buf[200]; 10 while (1) { down(&ls); 12 if (cp->code == 0) strcpy(buf,cp->data); else strcpy(cp->data,buf); 14 up(&ms); 16 Når løsningen utvides med en ringbuffer, kan den se slik ut: 1 semaphore Ls = 0; /* Blokkerer L */ 2 semaphore Ms = 1; /* Blokkerer M */ 4 comm_data *cp =...; /* Peker til felles lager */ 6 #define N 20 8 process L(void) { 10 unsigned char *ringb[n]; /* Ringbufferen */ int inn, i; 12 for (i = 0; i < N; ++i) 14 ringb[i] = (unsigned char*)malloc(200); inn = 0; 16 while (1) { 18 down(&ls); if (cp->code == 0) { 20 /* Sett inn i ringbufferen: */ 22 strcpy(ringb[inn],cp->data); if (++inn >= N) inn = 0; 24 else { /* Hent fra ringbufferen: */ 26 i = inn - cp->code; if (i < 0) i += N; 28 strcpy(cp->data,buf[i]); 30 up(&ms); 32 7