Lösningar till valda övningsuppgifter i. Computer Organization & Design The Hardware / Software Interface (2nd ed.)

Transkript

1 Lösningar till valda övningsuppgifter i Computer Organization & Design The Hardware / Software Interface (2nd ed.) David A. Patterson & John L. Hennessy Lösningarna gjorda av: Jonas Alowersson, Mats Brorsson, Fredrik Dahlgren, Hans Lindqvist, Håkan Nilsson, Jonas Skeppstedt, Patrik Sundström, Bengt Öhman och Sven Karlsson. Kapitel I denna uppgift skall vi beräkna CPI-talet för två olika system, M1 och M2. CPI-talet får ur formeln: T exe = I * CPI * T c där T exe är den totala exekveringstiden, I är antalet instruktioner och T c är cykeltiden. Vi vet följande från uppgiften: Insatt i formeln får vi att: 2.10 System T exe (sek) I T c (sek) M * /200* 10 6 M * /300* 10 6 CPI(S1) = 10 * 200* 10 6 / 200* 10 6 = 10 CPI(S2) = 5 * 300* 10 6 / 160* 10 6 = 9.4 Peak performance är den högsta hastighet som en maskin kan exekvera en instruktionssekvens vald för att ge maximal prestanda. Detta innebär att man skall välja en instruktionssekvens bestående av instruktioner med så lågt CPI-tal som möjligt. För implementation M1 fås: f(m1) / CPI min (M1) = 500* 10 6 / 1 = 500 MIPS och för M2 fås: f(m2) / CPI min (M2) = 750* 10 6 / 2= 375 MIPS

2 2.11 Vi skall jämföra två olika implementeringar, M1 och M2 map exekveringstid. Vi använder åter formeln: T exe = I * CPI * T c Genomsnittligt CPI-tal fås genom att vikta samman CPI-talen för de olika instruktionsklasserna. Insatt i formeln får vi: T exe (M1) = I * (0.25*1 0.25*2 0.25*3 0.25*4) * 1/500* 10 6 = I * 2.5/500* 10 6 T exe (M2) = I * (0.25*2 0.25*2 0.25*4 0.25*4) * 1/750* 10 6 = I * 3/750* 10 6 Speedup beräknas som kvoten mellan den långsammare implementeringen och den snabbare implementeringen. SP = T exe (M1) / T exe (M2) = (I * 2.5/500* 10 6 ) / (I * 3/750* 10 6 ) = 1.25 M2 är alltså 25% snabbare än M I förra uppgiften beräknades CPI-talen för de två implementeringarna till; CPI(M1) = 2.5 och CPI(M2) = 3. Vi skall nu beräkna den klockfrekvens som M1 måste ha för att ha samma prestanda som M2, mao vi sätter T exe (M1) = T exe (M2). Detta ger: Kapitel Orginalkoden ser ut så här: CPI(M1) * T c (M1) = CPI(M2) * T c (M2) => 2.5 * T c (M1) = 3 * 1/750* 10 6 => Fq(M1) = 1/T c (M1) = 2.5 * 750* 10 6 / 3 = 625 MHz Loop: add add add lw bne add j Exit: $t1,$s3,$s3 $t1,$t1,$t1 $t1,$t1,$s6 $t0,0($t1) $t0,$s5,exit $s3,$s3,$s4 Loop På 10 iterationer blir detta 7*10=70 instruktioner.

3 Den första optimeringen vi kan göra är att eliminera det sista hoppet. Detta gör vi genom att alltid addera j på i. Vi kan då göra om bne instruktionen till en beq! Tyvärr kommer vi då att addera en gång för mycket men det kan vi kompensera för: Loop: add $t1,$s3,$s3 add $t1,$t1,$t1 add $t1,$t1,$s6 lw $t0,0($t1) add $s3,$s3,$s4 beq $t0,$s5,loop sub $s3,$s3,$s4 ; kompensera för den extra additionen På 10 iterationer blir detta 6*10=60 instruktioner i loopen och 1 utanför dvs totalt 61 instruktioner. Som vi ser går de flesta instruktioner åt till att skapa adressen till minnet. Vi kan faktiskt ta bort även dessa instruktioner genom att använda pekare in i vektorn i stället för index! För att i skall vara korrekt efter exekveringen måste pekaren räknas om! ; före loop sll $s3,$s3,2 ; gör om från index till adresser sll $t1,$s4,2 ; gör om inkrementen add $s3,$s3,$s6 ; addera på baspekare Loop: lw $t0,0($s3) ; nu används $s3 som pekare add $s3,$s3,$t1 ; som innan beq $t0,$s5,loop ; efter loop sub $s3,$s3,$t1 ; kompensera för den extra additionen sub $s3,$s3,$s6 ; subtrahera bort baspekare srl $s3,$s3,2 ; shifta tillbaka till index På 10 iterationer får vi 3*10=30 och 6 instruktioner utanför dvs 36 instruktioner totalt! Man kan även optimera på andra sätt som är effektivare. Mer om detta i fortsättningskursen Datorarkitektur. Fotnot: Vi har i lösningen inte tagit hänsyn till pipeline effekter. Mer om detta i senare kapitel Vi skall räkna ut CPI-talet för MIPS mha instruktionsfrekvenserna från figur 3.38 på sidan 189. Vi får: CPI = 0.49* * * *1.2 = 1.2

4 Kapitel I uppgift 4.44 och 4.45 används bokens notation för operationerna AND och OR. Dvs * är AND och är OR i logiska ekvationer. Som förkortad notation används också ab för a*b. Ekv 1: g i = a i * b i p i = a i b i Ekv 2: G i,i-3 = g i (p i g i-1 ) (p i p i-1 g i-2 ) (p i p i-1 p i-2 g i-3 ); P i,i-3 = p i p i-1 p i-2 p i-3 för i = 3,7,...,31. Exempelvis: G0 blir G 3,0 = g 3 (p 3 g 2 ) (p 3 p 2 g 1 ) (p 3 p 2 p 1 g 0 ) P0 blir P 3,0 = p 3 p 2 p 1 p 0 c 4 = G 3,0 (P 3,0 c 0 ) c 8 = G 7,4 (P 7,4 G 3,0 ) (P 7,4 P 3,0 c 0 ) c 12 = G 11,8 (P 11,8 G 7,4 ) (P 11,8 P 7,4 G 3,0 ) (P 11,8 P 7,4 P 3,0 c 0 ) c 16 = G 15,12 (P 15,12 G 11,8 ) (P 15,12 P 11,8 G 7,4 ) (P 15,12 P 11,8 P 7,4 G 3,0 ) (P 15,12 P 11,8 P 7,4 P 3,0 c 0 ) 4.45 Ekv. 1 och 2 enligt uppgift Ekv. 3: G i,i-15 = G i,i-3 (P i,i-3 G i-4,i-7 ) (P i,i-3 P i-4,i-7 G i-8,i-11 ) (P i,i-3 P i-4,i-7 P i-8,i-11 G i-12,i-15 ) P i,i-15 = P i,i-3 P i-4,i-7 P i-8,i-11 P i-12,i-15 för i = 15, 31, 47, 63 c 16 = G 15,0 (P 15,0 c 0 ) c 32 = G 31,16 (P 31,16 G 15,0 ) (P 31,16 P 15,0 c 0 ) c 48 = G 47,32 (P 47,32 G 31,16 ) P 47,32 P 31,16 G 15,0 ) (P 47,32 P 31,16 P 15,0 c 0 ) c 64 = G 63,48 (P 63,48 G 47,32 ) (P 63,48 P 47,32 G 31,16 ) (P 63,48 P 47,32 P 31,16 G 15,0 ) (P 63,48 P 47,32 P 31,16 P 15,0 c 0 ) <fin figur enligt fig4.24 i boken>

5 4.46 Ripple-carry: c 4 a 3 FA s b 3 3 c 3 c 4 a 2 FA s b 2 2 a 1 c 2 FA s b 1 1 c 1 A B 4-bits RC add. S a 0 FA s b 0 0 c 0 c 0 Tid = 4 * 2T = 8T Carry lookahead: a 3 b 3 a 2 b 2 a 1 b 1 a 0 b 0 p 3 g 3 p 2 g 2 p 1 g 1 p 0 g 0 4.bit GP calc. c 4 c 3 c 2 c 1 a 3 FA s b 3 3 a 2 FA s b 2 2 a 1 FA s b 1 1 a 0 FA s b 0 0 A B c 4 4-bits CLA add. c0 S c 0 Tid = 2T T 2T = 5T Uppsnabbning med carry lookahead = 8T / 5T = 1.6 => 60% förbättring. OBS. man använder inte carry-utgången på FA-blocken. Det medför att man kan realisera heladderarna med mindre antal grindar, men inte med mindre fördröjning. FA-block används här för att tydliggöra.

6 4.47 Tid för 4 st 4 bits ripple-carry adderare, kopplade sinsemellan i ripple-carry: c 16 4-bits RC add. 4-bits RC add. 4-bits RC add. 4-bits RC add. c 0 Tid = 4* 8T = 32T Tid för 4st 4 bits carry-lookahead adderare, kopplade sinsemellan i ripple-carry: c 16 4-bits CLAadd. 4-bits CLAadd. 4-bits CLAadd. 4-bits CLAadd. c 0 Tid = 4* 5T = 20T Tid för 4st 4 bits carry-lookahead adderare, kopplade sinsemellan i carry-lookahead: c 16 4-bits GP calc. 4.bit GP calc. c 12 c 8 c 4 4-bits CLA adderare c 0 Tid = T 2T 2T 5T = 10 T

7 4.50 Tre 4-bits ripple-carry adderare i trädkoppling: Tal 1 4-bits RC adderare Tal 2 Tal 3 Tal 4 Summa Tid = 8T 8T = 16T Observera att hela talområdet i detta fall inte kan representeras eftersom summan av två fyrabitars tal generellt kräver 5 bitar för att representeras. Carry-save med ripple-carry på slutet: s 4 s 4 d 3 c 3 b 3 a 3 d 2 c 2 b 2 a 2 d 1 c 1 b 1 a 1 d 0 c 0 b 0 a s 3 s 2 s 1 s 0 Tid = 2T 2T 8T = 12T 4.51 Antalet carry-save steg beror ej på bitbredd utan på antal summander så att antal steg ~ log 3 (antal summander). Det medför att det är endast den slutliga summationen som beror på antalet bitar, antalet carry-save steg är detsamma som i Tid för 3 st 16 bits carry lookahead adderare, vardera med fördröjningen 5T enl. 4.46: 2 * 5T = 10 T

8 Observera att man i detta fallet inte kan unyttja hela talområdet pga samma anledning som i Tid för 2 steg av carry save struktur följt av 1 st 16 bits carry lookahead adderare: 2T 2T 5T = 9T 4.55 Med guard och round siffror: Normaliserat och avrundat: Inga guard eller round siffror: Normalisera: Med guard och round siffror: Normaliserat och avrundat: Inga guard eller round siffror: Normalisera:

9 Kapitel Se figur 5.29 sidan 372. Vi behöver skriva PC4 till register $31. Lägg till en ingång till muxen som anger Write-register till vänster om registerbanken. Denna nya ingång ska ha värdet 31 för att tvinga skrivning till register 31. Förut hade denna mux endast en bits styrsignal, men nu behöver den två bitars styrsignal. Vidare behöver vi en dataväg som går från den adderaren som utför PC4 till Write-data i registerbanken. Detta kan göras genom att lägga till en tredje ingång till muxen längst ner till höger, vars utgång är ingång till Write-data på registerbanken. Också denna mux behöver nu två bitars styrsignal Se figur 5.33 sidan 383. Vi behöver skriva PC4 till register $31. Lägg till en ingång till muxen som anger Write-register till vänster om registerbanken. Denna nya ingång ska ha värdet 31 för att tvinga skrivning till register 31. Förut hade denna mux endast en bits styrsignal, men nu behöver den två bitars styrsignal. Datavägen för att beräkna PC4, och skriva detta till registerbanken finns redan. 1. Instruction fetch step: Hämta instruktionen från minnet och öka program-räknaren. IR = Memory[PC]; PC = PC4; Detta är samma för alla instruktioner, eftersom vi ännu inte vet vilken instruktion som ska exekveras. 2. Instruction decode step Samma som beskrivet i boken. 3: Jump step: PC går via ALUn till register data write. Detta förutsätter har funktionen att kopiera A operanden direkt till ALUoutput, vilket vi antar är fallet. SkiftaInstruction[25-0] två steg till vänster och konkatenera medpc[31-28]. Välj detta till nytt PC-värde vid nästa klockpuls.

10 1 Inför nytt tillstånd 12 enligt nedan: 12 ALUSelA=0 ALUOp=11 MemToReg=0 RegDst=10 RegWrite PCSource=10 PCWrite (Op= JAL ) Till tillstånd 0 Vi har här antagit att koden 11 som ALUOp betyder att A-operanden kopieras till ALU:ns utgång Instruction Fetch och Instruction Decode/Register Fetch utförs likadant som för alla andra instruktioner, dvs enligt sid i boken. Execution-steget utförs vid en addi-instruktion genom att ALU:n adderar värdet från läsport 1 med värdet av bit 15-0 i instruktionsformatet: ALUoutput = A sign_extend(ir[15-0]) Efter Execution-steget skrivs resultatet i rätt register, på samma sätt som för allalw-instruktioner: Reg[IR[20-16]] = ALUoutput Inför nya tillstånd 13 och 14 enligt nedan: 1 (Op= addi ) 13 ALUSelA=1 ALUSelB=10 ALUOp=00 14 ALUSelA=1 ALUSelB=10 ALUOp=00 RegDst=0 RegWrite MemToReg=0 Till tillstånd 0 Observera att ALUOp ej skall vara 10 som i R-typ operationer (tillstånd 6 och 7 i grafen på sid 349) utan 0, d.v.s. addition. Anledningen är att typen av ALU-operation i instruktioner av I-typ bestäms av op-fältet, ej av funct-fältet i instruktionen.

11 Kapitel IF/ID ID/EX EX/MEM MEM/WB PC 32 bitar Instruktion 32 bitar Summa 64 bitar PC 32 bitar Reg data 1 32 bitar Reg data 2 32 bitar Offset 32 bitar TReg 5 bitar SReg 5 bitar Summa 138 bitar Branch target 32 bitar Zero 1 bit ALU result 32 bitar Reg data 2 32 bitar WriteReg 5 bitar Summa 102 Memory data 32 bitar ALU data 32 bitar WriteReg 5 bitar Summa 69 bitar 6.9 IF-steget Det kan vara vilken instruktion som helst. Omöjligt att bestämma. ID-steget rs = 10, rt = 11, rd = 1, offset = 2090 ALUop = 10, RegDst = 1, ALUsrc = 0 Branch = 0, MemWrite = 0, MemRead = 0 ALUop => R-typ instruktion, 6 minst signifikanta bitarna i offset ger funktion. funct = = 42 => slt enligt figur A.19

12 Instruktion slt $1,$10,$11 EX-steget rs = 5, rt = 6, rd = 0, offset = 16 RegDst = 0, ALUop = 00, ALUsrc = 1 ALUop = 00 => lw el. sw-instruktion RegWrite = 0 => sw-instruktion Instruktion sw $6,16($5) MEM-steget Branch = 1 => Branch-instruktion Vi vet dock inte hoppadressen eller vilka register som jämförts. WB-steget RegWrite = 1, MemToReg = 1 => lw-instruktion rt = 15 (se i ID-steget) Vi vet dock inget om adress eller källregister. Instruktion lw $15,????($??) 6.7 IF: Samma som för load i figur 6.13u. ID: Samma som för load i figur 6.13n. EX: Muxen i EX-stegen är i läge 0. ALUn utför addition. MEM: Inget sker, mer än att ALUoutput kopieras från EX/MEM vippor till MEM/WB vippor. WB: Muxen i WB-steget är i läge 0, och muxens utsignal skrivs i registerbanken Vi har en pipeline med full forwarding och som stallar vid databeroenden mellan load och instruktionen efter load. Den ursprungliga sekvensen är: lw $3,0($5) lw $4,4($5) add $7,$7,$3 add $8,$8,$4 add $10,$7,$8 sw $6,0($5) beq $10,$11,Loop

13 Vi vill minimera prestandan dvs maximera exekveringstiden. Det gör vi genom att maximera antalet databeroenden mellan instruktionerna. Den riktigt dåliga instruktionssekvensen blir: lw $3,0($5) add $7,$7,$3 sw $6,0($5) lw $4,4($5) add $8,$8,$4 add $10,$7,$8 beq $10,$11,Loop ;$3 är resultatet av load => 1 stall ;$6 är oberoende av alla instr så ; vi sätter denna instruktion så ; långt bort från beroenden som möjligt ;$4 är resultatet av load => 1 stall ; beroende av tidigare instruktion ; beroende av tidigare instruktion Vi får alltså 2 extra stalls Sista frågan (ändrade forwarding-ekvationer) ingår ej IF / ID ID / EX EX / MEM MEM / WB Control RegWrite WB WB WB ALUSelA rs rt rt rd Forwarding unit ALUSelB rt rd rs = Instruction[25-21] rt = Instruction[20-16] rd = Instruction[15-11] RegWrite: bestämmer om instruktionen skriver resultat i register ALUSelX: Väljer återkopplingsväg Observera att i det här fallet ingen återkoppling sker från MEM / WB-registret.

14 6.20 lw $2,100($1) IM Reg DM Reg sw $2,100($3) IM Reg DM Reg Forwarding-muxarna vid ALU:n arbetar som tidigare, alltså enligt ekvationern på sid En ny forwarding-mux tillkommer vid dataminnets skrivport för att möjliggöra forwarding enligt figuren ovan. Styrvillkoret för denna mux är: if (MEM/WB.RegWrite and (MEM/WB.WriteRegister = EX/MEM.ReadRegister2) and EX/MEM.MemWrite) MemSel=1 det krävs alltså att informationen ReadRegister2 transporters längre i pipelinen än förut Hazardvillkoret på sid. 490 måste ändras så att instruktioner som kan exekveras tack vare den nya forwarding-muxen ej stoppas: if (ID/EX.memRead and ((ID/EX.WriteRegisterRt = IF/ID.ReadRegisterRs) or ((ID/EX.WriteRegisterRt = IF/ID.ReadRegisterRt) and not store-instruction))) stall the pipeline Eftersom hazarddetekteringsenheten ligger redan i Instruction-decode-steget har den inte tillgång till signalen MemWrite utan måste själv kunna avgöra om den nya instruktionen är en store-instruktion Ursprunglig version med predict-branch-not-taken. 36 sub $10,$4,$8 40 beq $1,$3,28 44 and $12,$2,$ lw $4,50($7) Eftersom det inte finns data beroende mellan sub och beqd, kan vi byta plats på dessa instruktioner, och låta sub vara i delay-slot för branch. 36 beqd $1,$3,32 <-- delayed branch 40 sub $10,$4,$8 <-- delay-slot 44 and $12,$2,$ lw $4,50($7)

15 6.27 Beslutet att hoppa måste tas i steg 2, vilket medför att exakt en instruktion (den i steg 1) kan behöva annuleras. För detta behöver vi en adderare för PC branchoffset i steg 2, samt en komparator för att avgöra ifall hoppet ska tas eller ej. Detta illustreras i Labhandledningen på sidan 29 i figur 2. En separat adderare och en komparator finns där i steg 2. Kapitel Minnesreferenser som missar i cacheminnet är markerade med M och de som träffar är markerade med H. Träffar respektive missar: M M M M M M M M M M M M H M H H Sluttillståndet i cachen är följande: Block nr. Adress Block nr. Adress Träffar respektive missar: M M M H M M H M M H M M H H M H

16 Sluttillståndet i cachen är följande: Block nr. Adress (till första ordet i blocket) Träffar respektive missar: M M M M M M M M M M H M H M H H Sluttillståndet i cachen är följande: Mängd nr. Block 1 adress Block2 adress Träffar respektive missar: M M M M M M M M M M H M H M H H

17 Sluttillståndet i cachen är följande: Block nr. Adress Block nr. Adress Träffar respektive missar: M M M H M M H M M H M M H H H M Sluttillståndet i cachen är följande: Block nr. Adress (till första ordet i blocket) Den totala storleken för sidtabellerna är antalet poster multiplicerat med storleken på varje post. Antalet poster är lika med antalet sidor i den virtuella adressrymden som är: 2 40 bytes = Kbytes = 2 26 Varje post innehåller 4 22 = 26 bitar. Totalt innehåller sidtabellen alltså 26 * 2 26 = 1664 Mbitar eller 208 Mbyte. 2 40

18 7.33 Page, 26 bitar Offset, 14 bitar 7 Tag VPDU 128 poster i varje Fysisk sidnummer Tag VPDU Fysisk sidnummer 19 =? =? Valid-bit & & 1 Träff/Miss? Page, 22 bitar Tag är 26-7 = 19 bitar VPDU = 4 bitar Offset, 14 bitar

19 7.27 Vi skall beräkna antalet cykler (per instruktion) som läggs till CPI på grund av cache-missar för tre olika cache-system. C miss = MPI * (1-H) * T m = (MPI instr * (1-H instr ) MPI data * (1-H data )) * T m I alla tre fallen gäller: MPI instr = 1, MPI data = 0.5 Sensmoral: Även om en större blockstorlek har högre misskostnad än för en mindre blockstorlek kan man få bättre prestanda genom att träffsannolikheten höjs. Genom högre grad av associativitet kan träffsnnolikheten höjas ytterligare. Detta fungerar dock till en viss gräns, se t ex laborationen om cache-minnen eller figur 7.12 i kursboken (s 559) Cache 1-H instr 1-H data T m C miss =7 (1* *0.08)*7 = =10 (1* *0.05)*10 = =10 (1* *0.04)*10 = 0.4 Enligt uppgift 7.13 är CPI för maskinen med cache 1, CPI 1 = 2, CPI = CPI orig C miss => CPI orig = = 1.44 Cache T exe 1 I*( )*2 = I*4 ns 2 I*( )*2 = I*3.78 ns 3 I*( )*2.4 = I*4.42 ns Sensmoral: Om nu förbättringen i 7.28 genom att göra cachen 2-vägs, mängdassociativ leder till längre klockcykeltid så hjälper det inte att själva misskostnaden i klockcykler blir mindre eftersom alla cacheträffar också straffas med en längre klockcykeltid. Make the common case fast! 7.11 (a) (b) (c) 1 16 * * 1 = 177 cykler 1 4 * 10 4 * 1 = 45 cykler 1 4 * * 1 = 57 cykler

20 Kapitel 8 8.1! To be added later on. Tills dess besvaras frågor av d92ms@efd.lth.se 8.2! A: Den 10e måste vänta 20 ms 1s 1s/20ms = 50 block a 10 operationer På 1s hinnes 500 I/O-operationer B: som ovan hinnes 500 I/O-op med på 18 * 500/10 = 900ms och 10 * 100ms/25ms = 40 I/O-op på reserande 100 dvs på 1 s hinnes 540 I/O-op ReadRq tid Data Ack DataRdy accept address memory latency 4 ggr överföring av fyra ord med handskakning för varje ord.

21 200 MHz buss => 5 ns busscykel. Varje handskakningssteg tar 20 ns. Minnessaccess tar 60 ns. Asynkront protokoll enligt exempel på s. 661: Steg 1: 20 ns Steg 2,3,4: max(3 * 20 ns, 60 ns) = 60 ns Steg 5,6,7: 3 * 20 = 60 ns (första ordet) Steg 4,5,6,7: 3* (4 * 20 ns) = 240 ns (de efterföljande 3 överföringarna) Total överföringstid = 380 ns. Maximal bandbredd = 64/ 380 = 168 MB/s Synkront protokoll enligt exempel s. 665: OBS! Detta system använder en 64-bitars buss. 1. Skicka adress till minnet: 5 ns (en busscykel) 2. Läs i minnet: 60 ns 3. Skicka 16 ord: 4 *(22) * 5 ns = 80ns Total överföringstid = 145ns. Maximal bandbredd = 64/145= 441 MB/s. Detta systemet är 2.6 gånger snabbare trots hälften så bred buss f(bus) = 200 MHz Minnessystem 32 bits gränssnitt, 4 ords överföring. Vid skrivning accepteras ett ord i varje klockcykel för fyra cykler sedan vila i fyra klockcykler. DMA-gränssnitt 4 ord / block, Initiering av access tar 1ms. I/O - buss 10 MB/s, ett ord/överföring => BW = 2.5 Mord / s. Disk seek rot. latency = 12 ms, BW = 5 MB / s. Skall läsa 16 KB från disk till minne. Minnet kan ta emot 16 bytes / 8 busscykler => 2 bytes / cykel. T 1 = tid att initiera läsning från disk till minne = 1 12 ms = 13 ms. Processor-minnebussen har en bandbredd på 200 MB/s (50 MHz * 4 bytes), varför tiden att läsa från disk via I/O-bussen blir begränsande för överföringstiden. T 2 = tid att läsa från disk = 16 KB / 5 MB/s = 3.2 ms. Total tid T 1 T 2 = = 16.2 ms I en write-back cache sker skrivningar i cachen och ej till minnet. Minnet uppdateras först då

22 blocket behöver bytas ut och blocket har blivit ändrat under tiden det har befunnit sig i cachen. Vi beräknar först antalet stallcykler för blockstorleken 8 ord. Det inträffar 0.05 cachemissar per instruktion. 40 % av missarna kräver förutom att ett nytt block skall läsas in även att det nuvarande cacheblocket skrivs till minnet. För resterande missar krävs endast en läsning. Enligt exemplet på sid 665 kostar en access till minnet 45 klockcykler för de första 4 orden. Resterande block om 4 ord kostar 4 cykler. Misskostnad: Läsdel = 45 4 = 49 cykler Write-back del = 45 4 = 49 cykler Total misskostnad = 0.4*49 49 = 68.6 cykler Antal misscykler per instruktion = 0.05*68.6 = 3.43 cykler För blockstorlekar om 16 ord inträffar 0.03 cachemissar per instruktion. Misskostnad: Läsdel = = 57 cykler Write-back del = = 57 cykler Total misskostnad = 0.4*57 57 = 79.8 cykler Antal misscykler per instruktion = 0.03*79.8 = 2.39 cykler Trots att det nu tar längre tid att läsa och skriva ett cacheblock till minnet blir antalet misscykler färre.