Hemlaboration Cache Cacheminnen

Transkript

1 IS1200 Datorteknik IS1500 Datorteknik och komponenter Hemlaboration Cache Cacheminnen Kursdeltagarens namn:.. Datum: Godkänd av (assistentens signatur):.. IS1200/IS1500 Hemlab cache: Cacheminnen sida 1

2 Målsättning med hemlaborationen När du har redovisat den här hemlaborationen kommer du att kunna: Förklara hur cacheminnen påverkar prestanda för olika datorprogram. Förklara hur ändringar i cacheminnets parametrar kan påverka prestanda för ett visst program. Förklara hur program kan ändras så att prestanda ökar i datorsystem med cacheminnen. Förkunskaper Innan du genomför den här hemlaborationen måste du kunna: Läsa och skriva program i språket C, på en nivå som motsvar godkänd hemlaboration 1 (om C). Förklara principer för cacheminnen, på en nivå som motsvarar kursboken. Förklara konstruktionsprinciper hos cacheminnen, på en nivå som motsvarar cacheminnesdelen av F Lundevalls kompendium Cacheminne och adressöversättning. Tekniska krav Du behöver inte köra någon programvara för den här hemlaborationen. Hemlaborationen är uppbyggd kring resultat från en simulator. Om du vill kan du köra simulatorn, men du behöver inte. Frågor Vi i kursteamet svarar gärna på frågor om du undrar över något när du arbetar med hemlaborationen! Använd kurswebben i KTH Social. Vi svarar så fort vi kan, och ibland kan någon annan student hinna svara före oss. Redovisning av hemlaborationen Sammanfattning: bokför allt, gör pappersutskrifter av allt som lab-pm säger att du ska skriva ut, tänk igenom motiveringar till alla dina svar på alla frågor, var väl förberedd vid redovisningen. Vid redovisningen måste du kunna visa din dokumentation, berätta om resultaten och förklara. Saknas någon dokumentation så måste du redovisa igen. Gör pappersutskrifter. Redovisningen genomförs utan dator. Du får använda dina anteckningar under redovisningen. Se till attt de är lätta att att hitta i. Ta gärna med frågorna. Samla de utskrifter och anteckningar som hör till en uppgift, till exempel uppgift 1, på 1 2 papper. Gör inte ett enda långt dokument, det blir svårt att hitta i. Ha papperen organiserade, så att du hinner visa tillräckliga kunskaper på utsatt tid. Vid redovisningen ställer läraren delvis andra frågor än dem som finns med här i lab-pm. En viktig fråga som läraren ställer ofta är "Varför?". Läraren kan till exempel fråga "Varför blir hit rate lika för programversion 1 och 2?" Var beredd på såna frågor. Ingen lärare frågar "läs upp svaret på uppgift 2.3". Är dina anteckningar gjorda för såna frågor så kommer redovisningen att gå dåligt. När du har visat tillräckliga kunskaper vid redovisningen bokförs din hemlabb som godkänd. Har du inte gjort klart allt, eller inte visar tillräckliga kunskaper, så får du göra om hela redovisningen vid ett annat tillfälle. Orsaken spelar ingen roll. Du måste visa tillräckliga kunskaper för godkänt. Till nästa redovisning kompletterar du förstås dina kunskaper, och repeterar så att du har hela labben aktuell vid redovisningen. Redovisning görs i grupp om 2 personer. Vid redovisningen bedöms kunskaperna individuellt. Om bara en person visar tillräckliga kunskaper så blir bara den personen godkänd. IS1200/IS1500 Hemlab cache: Cacheminnen sida 2

3 Lokalitet Cacheminnen utnyttjar lokalitet i program, för att snabba upp huvuddelen av de läsningar och skrivningar som görs mot minnet. En minnesläsning eller skrivning kallas ofta för referens. Därför talar man ibland om referenslokalitet. Den som konstruerar en ny dator studerar beteendet hos viktiga program, bland annat de testprogram som marknadsförarna ska använda för att hävda att datorn är snabb, och anpassar cacheminnena så att programexekveringen går fort utan att datorn blir för dyr. Ett annat sätt att få program att gå fort är den omvända metoden: studera hur cacheminnena fungerar och anpassa sitt program så att det utnyttjar cacheminnena på bästa sätt. I den här hemlaborationen ska du få möjlighet att studera båda vägarna. En av grundidéerna med cacheminnen är att de vanligtvis ger bra effekt utan ändringar i programmen. Att anpassa sina program till cacheminnena är alltså ett nischområde, men när det behövs kan prestandaförbättringen vara dramatisk. Låt oss repetera de båda typerna av lokalitet. Lokalitet i tiden: om en minnescell just har lästs eller skrivits, så läser eller skriver programmet troligen snart precis samma minnescell igen. Detta kallas också temporal lokalitet, eller re-use. Lokalitet i rummet: om en minnescell just har lästs eller skrivits, så läser eller skriver programmet troligen snart en annan minnescell med näraliggande adress. Detta kallas också spatial lokalitet, eller bara locality. Cacheminnen har alltid en blockstorlek som är 2 b bytes, där b måste vara ett heltal; b 0. Varje cacheminnes-ruta (se sida 4) har 2 r rader, där r måste vara ett heltal; r 0. På varje rad i cacheminnes-rutan finns 2 b bytes, så rutans storlek är 2 b 2 r bytes = 2 (b + r) bytes. Associativitetstalet a anger antalet rutor, och a måste vara ett heltal; a 1. Cacheminnets totalstorlek är a 2 (b + r) bytes. Påminnelse om potenser: 2 x / 2 y = 2 x 2 -y = 2 (x - y) för alla reella tal x och y. IS1200/IS1500 Hemlab cache: Cacheminnen sida 3

4 Så här tar du fram cacheminnets utseende och adressuppdelning Du utgår från cacheminnets parametervärden för storlek, blockstorlek och associativitet. Den informationen räcker för att ta fram hur cacheminnet delar upp adressbitarna i adressetikett (även kallad adresslapp, eller tag på svengelska), radnummer (även kallat index), och bytenummer inom ett block (byte-offset på svengelska). För att lyckas behöver du använda samma enhet för storlek och blockstorlek. De flesta datortillverkare och forskare använder byte som enhet. Exempel: storlek 64 byte, blockstorlek 8 byte, associativitet 2. Vi antar att datorn har 32-bits adresser. Steg 1: Associativitetstalet avgör antalet rutor/delar/set. Associativitet 2 betyder att totalstorleken 64 byte delas upp på två lika stora rutor. Varje ruta har (förstås) rutstorlek = totalstorleken / associativitetstalet. Det finns inget allmänt vedertaget ord för en ruta. 32 byte 32 byte Steg 2: Rut-storleken avgör antalet adressbitar som inte är adressetikett. 32-bytes rutor medför att det behövs 5 bitar för att peka ut en byte någonstans i en ruta. Det blir 5 bitar eftersom 32 byte = 2 5 byte. De 5 bitarna ska delas upp ytterligare sedan. 32 adressbitar adressetikett 32-5 bitar annat 5 bitar 32 byte =2 5 byte 5 bitar väljer Steg 3: Blockstorleken avgör antalet byte per rad i varje ruta. Blockstorlek 8 byte betyder att varje 32-bytes-ruta har 8 byte breda rader. Då behövs det 3 bitar för att peka ut en byte i blocket. Det blir 3 bitar eftersom 8 byte = 2 3 byte. Nu vet vi hur "annat 5 bitar" ska delas upp. 3 av de 5 bitarna väljer byte i blocket och resten är då radnumret, även kallat index. Nu är cacheminnets uppdelning av adressbitarna klar. Se bilden på nästa sida. IS1200/IS1500 Hemlab cache: Cacheminnen sida 4

5 32 adressbitar adressetikett 32-5 bitar 2 bitar index 3 bitar byte-offset 2 3 byte/block 2 bitar är kvar, de blir radnummer 3 bitar väljer byte inom ett block Steg 4: Antalet indexbitar avgör antalet rader. Med 2 bitar index så har cacheminnet 4 rader. Det blir 4 rader eftersom 2 2 = 4. Nu går det att rita upp cacheminnet. 32 adressbitar adressetikett 32-5 bitar 2 bitar index 3 bitar byte-offset 3 bitar väljer byte inom blocket 2 bitar väljer rad i alla rutor samtidigt tag tag tag tag tag tag tag tag adressetiketten från processorn jämförs med de lagrade adressetiketterna för blocken på den utvalda raden =? =? tag = svengelska för adressetikett giltigbit (valid bit), om den är noll så är adressetiketten ogiltig och blocket ignoreras Steg 5: Ofta läser och skriver processorn alltid alignade ord. Ofta läser/skriver processorn hela ord, på adresser som är jämnt delbara med antalet byte per ord. Både Nios II och Mips läser och skriver oftast 4-bytes ord (det vill säga 32-bits ord). Både Nios II och Mips kräver att adressen till ett 4-bytes ord är jämnt delbar med 4. En adress är ju ett binärt tal, och ett binärt tal som är jämnt delbart med 4 slutar på 2 binära nollor eftersom 2 2 = 4. För Nios II och Mips kan de 3 bitarna byte-offset i exemplet delas upp ytterligare. Vi får 1 bit som väljer ord inom ett block, och 2 bitar som väljer byte inom ett ord. De 2 bitarna som väljer byte inom ordet är alltid noll när processorn läser eller skriver ett helt ord. Se figurerna på sida 9. IS1200/IS1500 Hemlab cache: Cacheminnen sida 5

6 Tidslinje ett sätt att analysera prestanda för cacheminnen Tidslinjen är ett verktyg för analys av cacheminnesprestanda. Med en tidslinje kan du för hand ta fram exakt vilka referenser ett visst program kommer att göra till cacheminnena. Det gör det möjligt att exakt beräkna den hit rate programmet bör ha. Om de simulerade värdena inte stämmer med de beräknade, så finns en felkälla någonstans. Simuleringen kan vara fel, till exempel för att någon kompilator- eller simulator-inställning inte är som den ska vara. Beräkningen kan också vara fel, till exempel på grund av misstag i analysen av vilka referenser som blir träff och vilka som blir miss. adress 0 adress 4 adress 8 adress 12 adress 16 adress 20 adress 24 tid Exempel på ofullständig tidslinje för instruktionscacheminne (I-cache). Programmet i detta exempel har inga hoppinstruktioner, utan består enbart av "rak" kod. När du har ställt upp tidslinjen analyserar du hur cacheminnet kommer att reagera på varje referens. Eftersom cacheminnets beteende beror på tidigare händelser så är det viktigt att ta händelserna i den ordning de verkligen inträffar. Som exempel studerar vi tidslinjen i figuren här ovanför. Fetch betyder att en instruktion hämtas. Vi antar att instruktionscacheminnet är tomt när vårt exempel börjar. Då kommer den första händelsen på tidslinjen, Fetch från adress 0, att medföra miss i cacheminnet. Vi bokför detta i tidslinjen. Miss innebär att cacheminnet inte har den information som CPU:n begärt. Cacheminnet kan alltså inte leverera informationen till CPU:n. Då startar cacheminnet en hämtning från primärminnet. Hur mycket cacheminnet hämtar från primärminnet beror på blockstorleken. Vid miss på grund av läsning, som det är fråga om här, så hämtar alla cacheminnen alltid ett helt block. Anta att blockstorleken är 8 byte (2 ord). Cacheminnet hämtar alla bytes i blocket, och med 8 bytes blockstorlek är det de bytes som har binär adress från och med xxxx000 till och med xxxx111. I figurerna på nästa sida ser du att cacheminnet i så fall hämtar två instruktioner: den instruktion som orsakade missen (på adress 0), och så den instruktion som ligger intill (på adress 4). Nästa referens är Fetch från adress 4. Den informationen har redan hämtats till cacheminnet, vid missen alldeles nyss. Vi får alltså en träff. Referensen därefter är Fetch från adress 8. Med blockstorleken 2 ord så ingår inte adress 8 i det block som just hämtades. Adress 8 är aldrig hämtad till cacheminnet, och vi får en miss. Vi fortsätter tidslinjen tills vi är helt säkra på att vi sett hela referensmönstret. Om vi slutar för tidigt så finns ju risk att vi använder fel värden i vår beräkning. adress 0 adress 4 adress 8 adress 12 adress 16 adress 20 adress 24 MISS TRÄFF MISS TRÄFF MISS Tidslinjen, när resultatet från de första fem referenserna har fyllts i. tid I det här fallet ska vi fortsätta tills vi har fyllt drygt två block. Vi ser att programmets förväntade hit rate i instruktionscacheminnet är 50%. IS1200/IS1500 Hemlab cache: Cacheminnen sida 6

7 Placering av information i cacheminnet ord (4 byte) L: call f1 call f1 call f1 br L nop f1: ret Ett program i primärminnet. För att veta vilka referenser som ger träff och vilka som ger miss, så måste vi beräkna vilken information som placeras på vilken rad i cacheminnet. Som exempel använder vi programmet här till vänster. Vi studerar en I-cache med storlek 64 byte (16 ord), blockstorlek 8 byte (2 ord) och tvåvägsassociativitet (blocks in set = 2). Se figuren ovan. Först av allt ska CPU:n hämta instruktionen på adress 0. Indexdelen av adressen är noll. Därför används rad 0, som är den översta raden i cacheminnet. Översta raden är markerad i figuren. Cacheminnet är till en början tomt. Det blir miss och cachen ska hämta in ett block. Båda blocken på översta raden är lediga (eftersom cachen är tom). Då spelar det ingen roll om vi placerar blocket i vänster eller höger halva av cacheminnet. Vi väljer den vänstra halvan. Vid miss hämtas alltid ett helt block, alltså två instruktioner: den på adress 0 och den på adress 4. Sedan hämtas instruktionen på adress 4. Det blir en träff. Instruktionen call f1 hoppar till adress 36. Där ska alltså nästa instruktion hämtas. Binär form av talet 36 är Indexbitarna är 00, så vi undersöker översta raden i cacheminnet. I vänstra halvan finns information från adress 0. Alla bitar i adressetiketten (tag) är nollställda. Det stämmer inte med motsvarande del av adress 36: Ingen träff i den halvan alltså. I högra halvan av översta raden är det tomt, så där blir det inte heller träff. Nu har vi undersökt hela raden och inte hittat det vi sökte. Vi har en miss, och måste hämta från primärminnet. Eftersom indexbitarna är noll så ska informationen placeras på översta raden i cacheminnet. Som tur är finns ett ledigt block där: det högra. Cacheminnet hämtar alltid ett helt block vid miss, med binära adresser från och med xxxx000 till och med xxxx111, det vill säga instruktionerna på adress 32 och 36. Nu innehåller cacheminnet den information som visas i figuren här till höger. 27 bit tag 2 bit index 1 bit ordval 2 bit byte-i-ord Tvåvägsassociativt cacheminne, med storlek 64 byte (16 ord) och blockstorlek 8 byte (2 ord). Adressens fältindelning förklaras uppe till höger L: call f nop f1: Innehåll i cacheminnet efter de tre första referenserna. IS1200/IS1500 Hemlab cache: Cacheminnen sida 7

8 Olika parametervärden för cacheminnet Här nedanför till vänster visas en bild av ett cacheminne med simulatorns standardinställningar. Till höger visas ett cacheminne med fördubblad storlek. Längst ner till höger finns ett cacheminne med fördubblad blockstorlek. Cacheminne med fördubblad associativitet visas överst på föregående sida. Cacheminne (bild från simulatorn). Storlek: 64 byte (16 ord), blockstorlek 8 byte (2 ord), associativitet 1 (direktmappat). Dubbel storlek Cacheminne (bild från simulatorn). Storlek: 128 byte (32 ord), blockstorlek 8 byte (2 ord), associativitet 1 (direktmappat). Dubbel blockstorlek Cacheminne (bild från simulatorn). Storlek: 64 byte (16 ord), blockstorlek 16 byte (4 ord), associativitet 1 (direktmappat). IS1200/IS1500 Hemlab cache: Cacheminnen sida 8

9 Byte-adresserat minne och cacheminne I simulatorns minne innehåller en byte 8 bitar, och varje byte har en egen adress. Så fungerar de flesta nya datorer idag. Instruktionerna till en Mips-processor är alltid 4 byte långa, det vill säga 32 bitar. Om första instruktionen finns på adress 0 och är 4 byte lång, så finns nästa instruktion på adress 4. Sedan följer instruktioner på adresserna 8, 12, 16, 20 och så vidare. Se figuren. Adresserna för instruktioner är alltså alltid jämnt delbara med 4. Det gör att instruktionsadresserna alltid har 0:or i de båda minst signifikanta bitarna, alltså längst till höger. Ett minne blir enklare att konstruera om det bara behöver hantera hela ord. Därför byggs instruktionscacheminnet i Mips-datorer för att alltid hantera hela 4-bytes ord. Ett ord börjar alltid på en adress som är jämnt delbar med 4, och sådana adresser slutar ju med två binära 0:or. Av samma orsak innehåller alltid programräknaren (Program Counter, PC), alltid adresser som är jämnt delbara med 4 (och slutar med två binära 0:or). Instruktionscacheminnet konstrueras alltså med förutsättningen att de två minst signifikanta adressbitarna är noll. Då behöver cacheminnet inte använda de båda bitarna. För säkerhets skull kan det vara bra att cacheminnet kontrollerar att de två minst signifikanta adressbitarna verkligen är nollställda. Detta görs i de flesta datorer. Ett undantag är Nios II, där processorn i vissa konfigurationer ignorerar bitarnas värden och alltid arbetar som om de var nollställda. Läs om de här detaljerna i kompendiet Cacheminnen och adressöversättning. Mips-simulatorn särbehandlar de två minst signifikanta adressbitarna, och förutsätter att de är nollställda. Figuren till höger visar ett direktmappat cacheminne med storlek 64 byte (16 ord) och blockstorlek 8 byte per block (2 ord per block). väljer rad i cacheminnet adressetikett giltigbit (valid-bit) adress byte (8 bitar) en instruktion nästa instruktion en instruktion till ännu en instruktion och så vidare 4-bytes instruktioner i byte-adresserat minne. de 2 minst signifikanta adressbitarna ska vara noll väljer ord inom raden OCH-grind jämförare Cacheminne (bild från simulatorn). IS1200/IS1500 Hemlab cache: Cacheminnen sida 9

10 Cache miss penalty när blockstorleken är 4 ord (16 byte). Cache miss penalty Tidsförlusten för en miss i ett cache-minne (cache miss penalty) anges ofta som hur många extra CPU-klockcykler det tar att läsa/skriva huvud-minnet. Standardvärdet för denna "kostnad" är i Mips-simulatorn satt till 50 klockcykler per ord. De värden som har använts vid simuleringarna är framräknade så här. Vi antar att processorns klockfrekvens är 2 GHz, och primärminnets klockfrekvens 200 MHz. Vidare förutsätter vi att varje minnesreferens görs som en burst (skur), med 4 stycken överföringar av 4-bytes data, det vill säga 4 32 bits data. Orsaken till att överföringen görs som burst är att överföringen har en viss uppstartstid. Att läsa eller skriva ett enda ord (4 byte) i primärminnet tar 3 busscykler. Om man i stället läser en skur, så tar första ordet 3 busscykler och de följande orden 1 busscykel var. När CPU/cacheminne läser 4 ord i taget så blir alltså totaltiden busscykler. Detta brukar betecknas Referensmönster betyder alltså att den första referensen tar 3 busscykler och att efterföljande 3 referenser tar vardera 1 ytterligare busscykel. I vårt exempel är CPU:n 10 gånger så snabb som minnesbussen. Att referera 4 4 bytes tar då = 60 CPU-cykler. Vid en läs-miss som leder till att cacheminnet hämtar ett block på 4 ord (16 bytes), så blir alltså miss penalty 60 CPU-cykler. Med lite tur så kommer det i framtiden att göras referenser till andra ord/bytes inom detta block, och då ger de referenserna träffar i cachen. Tyvärr tar inte simulatorn någon hänsyn till att den första referensen i ett block tar längre tid. Det går inte att ställa in i simulatorn. För att få riktiga värden vid simuleringen måste du räkna ut medelvärdet av miss penalty. Det medelvärdet ställer du in som access time i simulatorn. Om totaltiden för att hämta 4 ord är 60 CPUcykler som i exemplet, så är genomsnittstiden per ord 15 cykler. 15 cykler är alltså den access time som ska anges i simulatorn när blockstorleken är 4 ord. Read och Write ska ha samma access time. IS1200/IS1500 Hemlab cache: Cacheminnen sida 10

11 Cache miss penalty när blockstorleken är 2 ord (8 byte). Simulatorn kan alltså inte simulera burstreferenser. I simulatorn ställer man in en access time som sedan gäller för alla ord. Därför behöver access time ändras vid ändring av blockstorleken, så att access time motsvarar genomsnittstiden enligt resonemanget här. Simulatorn klarar att man har olika blockstorlek för datacacheminne (D-cache) och instruktionscacheminne (I-cache). Tyvärr går det inte att ha olika access time för D-cache och I-cache. Det gör att simuleringen inte kan ge helt korrekta värden på körtiden (execution time) när blockstorleken är olika för data- och instruktionscacheminnena. För att felet vid mätningarna ska bli så litet som möjligt ställs access time in efter det cacheminne som har flest missar vid läsning/skrivning i primärminnet. I simulatorn kan man göra en provkörning, och studera antalet missar (miss count) för instruktions- och datacacheminnena. Det cacheminne som har högst värde på miss count kommer att påverka körtiden mest. Miss count multiplicerad med miss penalty ger ju den totala extratid som det aktuella cacheminnet (I eller D) har använt till hämtningar från det långsamma primärminnet. IS1200/IS1500 Hemlab cache: Cacheminnen sida 11

12 CPI, Cycles Per Instruction Här nedanför ser du simulatorns standardinställningar för I-cache och D-cache. Standardinställningarna för instruktions- och datacacheminnena i simulatorn. Observera att simulatorn räknar storlek och blockstorlek i ord, och varje ord motsvarar 4 byte. Du når de här inställningarna i simulatorn med Edit Cache/Mem Config. Associativitetstalet kallas i simulatorn för Blocks in sets. Utbytespolicyn (Replacement policy) spelar ingen roll så länge associativitetstalet är 1, det vill säga när cacheminnet är direktmappat. Standardinställningarna för primärminnet visas här nedanför till höger. Standardinställningarna i simulatorn ger inte så bra prestanda. Du har redan gjort provkörningar. Räkna fram CPI, Cycles Per Instruction: cycle count CPI = hit count miss count Lågt CPI betyder bättre prestanda, så länge klockfrekvensen är konstant. En Mips-processor kan hämta och utföra en instruktion varje klockcykel. Det betyder att processorn har CPI = 1. Ska vi vara noga så tar hoppinstruktioner 2 cykler, vilket höjer det genomsnittliga CPI-värdet till cirka 1,2. Beräkna det CPI-värde du fått vid provkörningen. Har du använt Standardinställningar, primärminne. standardinställningarna så blir CPI-värdet mycket högre än 1,2. Påminnelse: Read och Write ska ha samma access time. IS1200/IS1500 Hemlab cache: Cacheminnen sida 12

13 Laborationsuppgifter Läs hela lab-pm innan du börjar! Uppgift 1. Längd, bredd, höjd hos olika cacheminnen Figuren längst ner på sidan visar ett cacheminne med simulatorns standardinställningar. Det är direktmappat, med storlek 64 byte (16 ord) och blockstorlek 8 byte (2 ord per block). Svara på följande frågor. Vid redovisningen ska du kunna besvara nya frågor med andra siffervärden, och kunna förklara och motivera svaren i detalj. 1 ord är 4 bytes, det vill säga 32 bitar, i simulatorn. Fråga 1.1. Hur många bitars adress krävs (till exempel i Program Counter) i en byteadresserad dator med ett primärminne (RAM-minne) som är 1 Gbyte stort? Fråga 1.2. Visa i vilka fält adressen delas och hur många bitar som ingår i varje fält, för ett direktmappat cache-minne med storlek byte (32 kbyte) och blockstorlek 32 byte (8 ord). Ange också namnet på varje fält. Figuren här ovanför visar hur en fältindelning kan se ut. På sida 4 5 finns en längre beskrivning. Fråga 1.3. Figuren längst ner på sidan visar ett direktmappat cacheminne med storlek 64 byte (16 ord) och blockstorlek 8 byte (2 ord per block). I vilka fält delas adressen och hur många bitar ingår i varje fält? Fråga 1.4. Figuren längst ner på sidan visar den minnesmatris som behövs för ett direktmappat cacheminne. Vilken information finns på varje rad i minnesmatrisen? Hur används de olika delarna av informationen? Fråga 1.5. Utgå från figuren till höger. Hur ändras cacheminnets utseende om du ökar cacheminnesstorleken (Size) från 64 byte till 256 byte, och hur påverkas fältindelningen av adressen? Fråga 1.6. Utgå från figuren till höger. Hur ändras cacheminnets utseende om du ökar blockstorleken (block size) från 8 byte till 32 byte (från 2 ord per block till 8 ord per block), och hur påverkas fältindelningen av adressen? Adress från CPU:n (32 bitar) Exempel på fältindelning, här med 3 fält Exempel på fältindelning av den adress som kommer från CPU:n. Bilden saknar namn och storlekar på fälten. Fråga 1.7. Utgå från figuren till höger. Hur ändras cacheminnets utseende om du ändrar från Cacheminne (bild från simulatorn). associativitet 1 (direktmappat cacheminne) till associativitet 4, och hur påverkas fältindelningen av adressen? IS1200/IS1500 Hemlab cache: Cacheminnen sida 13

14 Uppgift 2. Instruktions- och datacacheminne Fråga 2.1. Vilket cacheminne används oftast, instruktionscacheminnet eller datacacheminnet? processor Fråga 2.2. Anta att du ska göra en simulering där instruktions- och datacacheminne har olika blockstorlek. Du gör en provkörning och ser att båda har 50% hit-rate. Vilket cacheminne ska styra din inställning av access time? adress I-cache adress buss data D-cache data data Fråga 2.3. Om instruktions- och datacacheminne har olika blockstorlek och olika hit-rate, hur ska du då ställa in access time? primärminne En dator med separata cacheminnen för instruktioner och data. Förklaring till färgerna: grönt adresser, gult data från primärminnet, vinrött data till primärminnet (skrivningar). Fråga 2.4. Varför har datacacheminnet (D-cache) en write-policy, men inte instruktionscacheminnet? Ledning till alla fyra frågorna: vilket cacheminne används vid och vilket cacheminne används när Load och Store utförs? IS1200/IS1500 Hemlab cache: Cacheminnen sida 14

15 Uppgift 3. Provkörning av ett enkelt program: string-copy I den här uppgiften ska du provköra programmet strcpy.c, som visas här nedanför. Du kan hämta programtexten på kursens webbsidor om labben. strcpy.c 1 /* strcpy.c */ 2 3 #include <stdio.h> 4 #include <idt_entrypt.h> 5 6 /* C stringcopy */ 7 8 static void str_cpy( char *to, const char *from) 9 { 10 while( *from) 11 { 12 *to = *from; 13 to = to + 1; 14 from = from + 1; 15 } 16 *to = '\0'; 17 } int main() 20 { 21 static char* hello = "Hello World!"; 22 static char to[4711] = "blaha blaj blurk bletch"; 23 int Time; printf("strangen hello ser ut sa har: %s\n", hello); 26 flush_cache(); /* toem cache-minnet */ 27 timer_start(); /* nollstall tidmatning */ str_cpy( to, hello); Time = timer_stop(); /* las av tiden */ 32 printf("time to copy: %d\n",time); 33 printf("och kopian sa har: %s\n", to); 34 } Kompilering av strcpy.c För kompileringen av strcpy.c används inställningen Optimization level: Default. Det innebär att programmet kompileras utan optimering. Simulering Summan av Hit Count och Miss Count för instruktionscacheminnet anger antalet instruktioner som hämtats och utförts. För progrrammet här ovanför är summan 283, så vid en körning utförs 283 instruktioner. Programmet består av initialisering, anrop till funktionen str_cpy, och avslutning. Efter initialiseringen anropas specialfunktionerna flush_cache och timer_start. De nollställer mätvärdena, så att initialiseringens påverkan på cacheminnena inte tas med i slutresultaten. Om vi lägger till ett tecken i textsträngen hello i programmet får strängen en ny längd. Då körs ett extra varv i loopen. Summan av Hit Count och Miss Count för instruktionscacheminnet blir nu 18 enheter större. Antalet instruktioner som körs i ett varv i loopen är alltså 18 instruktioner. IS1200/IS1500 Hemlab cache: Cacheminnen sida 15

16 Variera parametrar för instruktionscacheminnet (I-cache) Nr Size (byte) Block size (byte) Associativitet (blocks in sets) Acces s time Cycle count CPI I-cache hit rate I-cache miss count D-cache hit rate D-cache miss count ,9 61% % ,0 86% 40 90% % 69 90% (LRU) % % ,8 86% 39 90% 17 Tabellen här ovanför innehåller resultat från körningar av programmet strcpy med olika parametervärden. Fråga 3.1. Beräkna CPI för de två rader där detta inte är ifyllt. Fråga 3.2. Studera resultaten för storlek 64 byte, blockstorlek 8 byte och associativitet 1. Varför blir det så låg hit rate i instruktionscacheminnet? Fråga 3.3. Vilka parametervärden ger kortast körtid (minsta cycle count) på grund av förbättrad hit rate i I-cachen? Fråga 3.4. Varför ökar inte hit-rate i instruktionscacheminnet när storleken ökas från 128 byte till 256 byte? Uppgift 4. Ett teoretiskt program Bilden till höger visar ett primärminne (RAM-minne). I minnet finns ett särskilt program, som vi kallar programmet Pelle. Programmet Pelle har en ovanlig egenskap: programmet saknar helt hoppinstruktioner. Programmet innehåller alltså inga br (branch), inga jmp (jump), inga call, inga trap, och inte heller några varianter av dessa instruktioner. Fråga 4.1. Har programmet Pelle tidslokalitet för instruktionshämtning? Fråga 4.2. Har programmet Pelle rumslokalitet för instruktionshämtning? Fråga 4.3. Anta att programmet Pelle körs på en dator med likadant instruktionscacheminne som nr 1 i tabellen här ovanför. Beräkna teoretiskt vilken hit-rate körningen skulle ge i detta instruktionscacheminne. adress 0 adress 4 adress 8 adress 12 adress 16 adress 20 adress 24 adress 28 adress 32 adress 36 adress 40 adress 44 adress 48 adress 52 adress 56 adress 60 1 ord (4 byte) add r2,r4,r5 add r3,r6,r7 add r8,r9,r10 add r9,r3,r8 add r8,r9,r10 Ett primärminne med ett speciellt program Pelle. Programmet Pelle innehåller inga hoppinstruktioner. IS1200/IS1500 Hemlab cache: Cacheminnen sida 16

17 Uppgift 5. Matris-addition Studera programmet matris.c som visas här nedanför. Du kan hämta programtexten på kursens webbsidor om labben. För matris.c används kompileringsinställningen Optimization level: 3 (High). Det medför att programmet kompileras med effektiv optimering. 1 /* matris.c */ 2 #include <stdio.h> 3 #include <idt_entrypt.h> 4 5 #define MATRIXSIZE 16 6 #define MATRIXSIZE_ROWS 16 7 #define MATRIXSIZE_COLS /* 10 * addera two matriser 11 */ 12 void matrisadd( int res[matrixsize_rows][matrixsize_cols], 13 int a[matrixsize_rows][matrixsize_cols], 14 int b[matrixsize_rows][matrixsize_cols] ) 15 { 16 int i,j; for(j=0; j < MATRIXSIZE; ++j) /* variera kolumn-index */ 19 for(i=0; i < MATRIXSIZE; ++i) /* variera rad-index */ 20 res[i][j] = a[i][j] + b[i][j]; 21 } int main() 24 { 25 static int a[matrixsize_rows][matrixsize_cols]; 26 static int b[matrixsize_rows][matrixsize_cols]; 27 static int res[matrixsize_rows][matrixsize_cols]; 28 int i,j, Time; /* 31 * initiera matris a och b 32 */ 33 for( i=0; i<matrixsize; ++i) 34 for( j=0; j<matrixsize; ++j) 35 { 36 a[i][j] = i+j; 37 b[i][j] = i-j; 38 } flush_cache(); /* toem cachen */ 41 timer_start(); /* nollstall tidmatning */ matrisadd( res, a, b); Time = timer_stop(); /* las av tiden */ 46 printf("time: %d\n",time); 47 } IS1200/IS1500 Hemlab cache: Cacheminnen sida 17

18 De tre matrisernas placering i primärminnet Programmet matris.c gör beräkningar på matriser. Varje matris innehåller ett antal matriselement, och varje matriselement består av ett heltal. Ett heltal är 4 byte stort i simulatorn. Kompilatorn placerar matriserna omedelbart efter varandra i primärminnet, som figuren till höger visar. Inom varje matris placeras matriselementen radvis, helt enligt definitionen av programmeringsspråket C. Index för några av matriselementen finns angivna i figuren till höger. adress 0 1 ord (4 byte) a[0][0] a[0][1] a[0][2] Addition av matriser Figuren här nedanför visar en principskiss över addition av matriser. Matriserna lagras radvis i primärminnet. Fråga 5.1. Vilket index, radnummer eller kolumnnummer, är det som ska variera i inre loopen för att programmet ska referera närliggande adresser i primärminnet? a[0][15] a[1][0] a[1][1] Addition av matriser För varje i och j utförs: res[i][j] = a[i][j] + a[i][j] kolumn j a[1][15] a[2][0] rad i = + a[15][15] b[0][0] b[0][1] res[i][j] a[i][j] b[i][j] Elementen i en matris M lagras radvis i primärminnet. Ett element väljs ut med uttrycket M[radnummer][kolumnnummer]. b[15][15] res[0][0] res[0][1] res[15][15] De tre matrisernas placering i primärminnet. IS1200/IS1500 Hemlab cache: Cacheminnen sida 18

19 En första provkörning av matris.c Programmet kompileras med effektiv optimering. För alla körningar har write policy varit inställd på write back. För associativitet större än 1 har utbytespolicyn varit LRU (Least Recently Used). Datacacheminnet har vid samtliga körningar i tabellen varit inställt på följande sätt: storlek 64 byte (16 ord), blockstorlek 8 byte (2 ord), associativitet 1 (direktmappat),. Numreringen av cacheminnena i tabellen här nedanför fortsätter från tabellen på sida 16. Två av cacheminnena är likadana som i den tidigare tabellen och har därför samma nummer. Cache nr Size (byte) Block size (byte) Associativitet (blocks in sets) Access time Cycle count I-cache hit rate I-cache miss count D-cache hit rate D-cache miss count % 31 1% % 31 1% % 17 1% (LRU) % 31 1% 771 Fråga 5.2. Resultat från prov med olika parametervärden finns i tabellen här ovanför. Förklara resultaten vid redovisningen. Fråga 5.3. Cacheminne nr 2 ger 86% hit-rate med prorgrammet strcpy, men 99% hit-rate med programmet matris. Förklara varför. Fråga 5.4. Förklara varför access time = 20 cykler för storlek 256 byte, blockstorlek 16 byte, associativitet 1. I fortsättningen av uppgift 5 gäller följande inställningar för instruktionscacheminnet. Storlek: 128 byte (32 ord). Blockstorlek (block size): 8 byte (2 ord). Associativitet: 1 (direktmappat). Datacacheminnet har skrivpolicyn Write back inställd, i hela denna uppgift. IS1200/IS1500 Hemlab cache: Cacheminnen sida 19

20 Variera D-cache-storlek (size) för programversion 1 Test av olika storlekar på datacacheminnet, från 64 byte (16 ord) till 4096 byte (1024 ord). Blockstorleken är 8 byte (2 ord), och associativiteten (blocks in set) = 1. Access time: 20 cykler. Size Hit rate Cycle count 64 byte (16 ord) 128 byte (32 ord) 256 byte (64 ord) 512 byte (128 ord) 1024 byte (256 ord) 2048 byte (512 ord) 4096 byte (1024 ord) 1% 1% 1% 1% 1% 17% 50% Fråga 5.5. Förklara mätvärdena för hit rate. Fråga 5.6. Varför blir det så låg hit-rate ända tills storleken når 512 ord? Variera D-cache-associativitet (blocks in sets) för programversion 1 Fråga 5.7. Test av olika associativitetstal. Utbytespolicy (replacement policy): LRU (Least Recently Used). Access time: 15 cykler. Storlek 512 byte (128 ord) 512 byte (128 ord) Blockstorlek 16 byte (4 ord) 16 byte (4 ord) Associativitet 1 4 Hit rate 1% 1% Cycle count Fråga 5.8. Rita upp cacheminnet med associativitet 4, och hur det delar upp adressbitarna. Använd gärna den metod som förklaras på sida 6 och 7. Fråga 5.9. Anta att det första matriselement som hämtas in till D-cachen är a[0][0]. För associativitetstalet 4, analysera fram och förklara i detalj vilket element i vilken matris som skriver över a[0][0] i D-cachen. Använd figuren från föregående fråga. Fråga Förklara mätvärdena för hit rate, för båda cacheminnena. IS1200/IS1500 Hemlab cache: Cacheminnen sida 20

21 Matris-addition program-version 2 (med inre och yttre loop växlade) Du ska nu ändra programmet på följande sätt. I funktionen matrisadd finns ett loop-nest bestående av två slingor (loopar) i varandra. Program-version 1 (originalversion från lab-pm) ser ut så här: for(j=0; j < MATRIXSIZE; ++j) /* variera kolumn-index */ for(i=0; i < MATRIXSIZE; ++i) /* variera rad-index */ res[i][j] = a[i][j] + b[i][j]; Du ska byta plats på de två raderna med for, så att programmet gör samma beräkningar fast i en annan ordning. I det nya programmet ser de tre raderna i ut så här: for(i=0; i < MATRIXSIZE; ++i) /* variera rad-index */ for(j=0; j < MATRIXSIZE; ++j) /* variera kolumn-index */ res[i][j] = a[i][j] + b[i][j]; Variera D-cache-storlek (size) för programversion 2 Test av olika storlekar på datacacheminnet, från 64 byte (16 ord) till 4096 byte (1024 ord). Blockstorleken är 8 byte (2 ord), och associativiteten (blocks in set) = 1. Access time: 20 cykler. Size Hit rate Cycle count 64 byte (16 ord) 128 byte (32 ord) 256 byte (64 ord) 512 byte (128 ord) 1024 byte (256 ord) 2048 byte (512 ord) 4096 byte (1024 ord) 1% 1% 1% 1% 1% 17% 50% Fråga Förklara mätvärdena för hit rate. Fråga Varför blir det så låg hit-rate ända tills storleken når en viss gräns? Variera D-cache-associativitet (blocks in sets) för programversion 2 Datacacheminnet ska alltid ha Write policy = Write back. Obs, viktigt! Fråga Test av olika associativitetstal. Utbytespolicy (replacement policy): LRU (Least Recently Used). Access time: 15 cykler. Storlek 512 byte (128 ord) 512 byte (128 ord) 512 byte (128 ord) Blockstorlek 16 byte (4 ord) 16 byte (4 ord) 16 byte (4 ord) Associativitet Hit rate 1% 1% 75% Cycle count Fråga Rita upp cacheminnet med associativitet 4, och hur det delar upp adressbitarna. Fråga Anta att det första matriselement som hämtas in till D-cachen är a[0][0]. För associativitetstalet 4, analysera fram och förklara i detalj vilket element i vilken matris som skriver över a[0][0] i D-cachen. Använd figuren från föregående fråga. Fråga Förklara mätvärdena för hit rate, för alla tre cacheminnena. IS1200/IS1500 Hemlab cache: Cacheminnen sida 21

22 Variera utbytespolicy (replacement policy) för D-cache för programversion 2 Betrakta ett datacacheminne (D-cache) med följande egenskaper. Storlek (size): 128 byte (32 ord). Blockstorlek (block size): 32 byte (8 ord). Associativitet (blocks in set): 4. Skrivpolicy (write policy): Write back. Utbytespolicy Random FIFO LRU Hit rate cirka 80% 84% 87% 87% Cycle count cirka Fråga Rita upp cacheminnet enligt den metod som förklaras på sida 6 och 7. Rita också upp hur cacheminnet delar upp adressbitarna, enligt den metod som förklaras på sida 6 och 7. Fråga Varför blir värdena på hit rate och körtid lika för FIFO och LRU? Fråga Förklara varför värdet på hit rate för LRU blev just det värde du fick. Kunde värdet lika gärna ha varit 5% högre eller lägre? Varför, eller varför inte? IS1200/IS1500 Hemlab cache: Cacheminnen sida 22

23 Matris-addition program-version 3 (med inre och yttre loop växlade, och med konstanten MATRIXSIZE_ROWS ändrad till 17) Utgå från programversion 2. Kontrollera att looparna i funktionen matrisadd ser ut så här: for(i=0; i < MATRIXSIZE; ++i) /* variera rad-index */ for(j=0; j < MATRIXSIZE; ++j) /* variera kolumn-index */ res[i][j] = a[i][j] + b[i][j]; Ändra nu konstanten MATRIXSIZE_ROWS från 16 till 17. Fråga När MATRIXSIZE_ROWS ändras från 16 till 17, så blir det ju flera matriselement i varje matris. Markera i figuren här intill var de nya matriselementen placeras i datorns primärminne, och hur många de nya matriselementen är. Motivera. Fråga Förklara vilken påverkan de nya matriselementen kan förväntas få på programkörningen. adress 0 1 ord (4 byte) a[0][0] a[0][1] a[0][2] a[0][15] a[1][0] a[1][1] a[1][15] a[2][0] a[15][15] b[0][0] b[0][1] b[15][15] res[0][0] res[0][1] res[15][15] De tre matrisernas placering i primärminnet. IS1200/IS1500 Hemlab cache: Cacheminnen sida 23

24 Matris-addition program-version 3 (fortsättning) Instruktionscache (I-cache) ska alltid ha Size = 32 ord; Block size = 2 ord; Blocks in sets = 1. Var noga med att datacacheminnet alltid har Write policy = Write back. Variera D-cache-storlek (size) för programversion 3 Test av olika storlekar på datacacheminnet, från 64 byte (16 ord) till 4096 byte (1024 ord). Blockstorleken är 8 byte (2 ord), och associativiteten (blocks in set) = 1. Access time: 20 cykler. Size Hit rate Cycle count 64 byte (16 ord) 128 byte (32 ord) 256 byte (64 ord) 512 byte (128 ord) 1024 byte (256 ord) 2048 byte (512 ord) 4096 byte (1024 ord) 1% 17% 50% 50% 50% 50% 50% Fråga Förklara mätvärdena för hit rate. Fråga Nu har vi ju förbättrat programmet på två olika sätt. Varför blir det ändå så låg hit rate när storleken är 64 byte? Variera D-cache-associativitet (blocks in sets) för programversion 3 Fråga Test av olika associativitetstal. Utbytespolicy (replacement policy): LRU (Least Recently Used). Access time: 15 cykler. Storlek 512 byte (128 ord) 512 byte (128 ord) Blockstorlek 16 byte (4 ord) 16 byte (4 ord) Associativitet 1 4 Hit rate 75% 75% Cycle count Fråga Förklara mätvärdena för hit rate. Variera D-cache-blockstorlek (block size) för programversion 3 Test av olika blockstorlekar för D-cachen, från 8 byte (1 ord) till 32 byte (8 ord). Storleken (size) är 512 byte (128 ord), och associativiteten (blocks in set) är 1. Block size 4 byte (1 ord) 8 byte (2 ord) 16 byte (4 ord) 32 byte (8 ord) Access time Hit rate 1% 50% 75% 87% Cycle count Fråga Förklara mätvärdena för hit rate och körtid. IS1200/IS1500 Hemlab cache: Cacheminnen sida 24

25 Extra för den intresserade: kompilerad programkod för Mips Här följer ett urklipp/avskrift av optimerad Mips-assembler för inre och yttre slinga (loop), i programversion 2. for(i=0; i < MATRIXSIZE; i++) /* variera rad-index */ for(j=0; j < MATRIXSIZE; j++) /* variera kolumn-index */ res[i][j] = a[i][j] + b[i][j]; 1 move $11,$0 ;i=0 2 la $10,b.5 ;reg10 pekar på matris b 3 la $9,a.4 ;reg9 pekar på matris a 4 la $8,res.6 ;reg8 pekar på matris res 5 $L38: move $7,$0 ;j=0 6 move $6,$8 ;reg6 pekar på res[i,j] 7 move $5,$10 ;reg5 pekar på b[i,j] 8 move $4,$9 ;reg4 pekar på a[i,j] 9 $L42: lw $3,0($5) ;reg 3 innehåller nu a[i,j] 10 addu $5,$5,4 ;peka ut nästa radelement i a 11 lw $2,0($4) ;reg 2 innehåller nu b[i,j] 12 addu $4,$4,4 ;peka ut nästa radelement i b 13 addu $7,$7,1 ;j++ 14 addu $2,$2,$3 ;reg2 = a[i,j] + b[i.j] 15 sw $2,0($6) ;skriv till res [i,j] 16 slt $2,$7,16 ;reg2 :=1 om i<16 17 bne $2,$0,$L42 ;hoppa om i<16, samt i hoppluckan 18 addu $6,$6,4 ;peka ut nästa radelement i res 19 addu $10,$10,64 ;byt rad i b 20 addu $9,$9,64 ;byt rad i a 21 addu $11,$11,1 ;i++ 22 slt $2,$11,16 ;reg2 :=1 om i<16 23 bne $2,$0,$L38 ;hoppa om i<16 24 addu $8,$8,64 ;byt rad i res (i hopplucka) Rad 1 4 är initialisering av slingorna. Yttre slingan omfattar rad 5 24 och inre slingan rad Mips-assembler har egenskapen att instruktionen närmast efter en hoppinstruktion alltid utförs, även om hoppet tas. Därför hör både rad 17 och 18 till den inre slingan. På samma sätt hör både rad 23 och 24 till den yttre slingan. IS1200/IS1500 Hemlab cache: Cacheminnen sida 25