Laboration 2

Laboration 2 


Syftet med denna laboration är att ingående lära sig konstruktionsprinciper, prestandavinster 

samt implementeringsaspekter för cacheminne i moderna minnessystem. 

Förberedelser 

Läs igenom laborationshandledningen och gör hemuppgifterna i handledningen. 

Inledning 


Ett datorsystem består som bekant av en centralenhet (eller processor), minne samt in/ut-enheter. Datorsystemets 

prestanda beror av prestanda hos dessa komponenter. I föregående laborationer fann vi att en processor kan uppnå 

mycket höga beräkningshastigheter med hjälp av pipelining. Load/Store-arkitekturer såsom DLX är utmärkta exempel 

på detta. En förutsättning för att den höga beräkningshastigheten skall bibehållas är emellertid att minnessystemet 

kan leverera instruktioner och data i varje klockcykel. Med en klockfrekvens på 200 MHz inses snabbt 

att man måste ta till speciella knep för att instruktioner och data skall kunna läsas varje 5 ns. Det är dessa knep som 

denna laboration skall lära ut. 

Det är givet att totalprestandan hos ett datorsystem är starkt beroende på den tid det tar för processorn att hämta 

och lämna information i minnet (den s.k. minnes-accesstiden). Eftersom snabba minnen är dyra och eftersom målet 

för en datortillverkare är att få ner totalkostnaden på datorsystemet, är det ett viktigt konstruktionsmål att erhålla 

ett så stort och snabbt minne till så låg kostnad som möjligt. 

På grund av en viktig princip, den s.k. lokalitetsprincipen för minnesreferenser, kan man kombinera små, snabba 

(och dyra) minnen med stora långsamma (och billiga) i en hierarki så att hela minnet skenbart uppträder som ett 

snabbt (som det dyra) och stort (som det billiga) så att totalkostnaden per minnescell ligger nära det stora minnets 

och accesstiden ligger nära det snabba. 

Denna viktiga teknik — cacheminnesteknik — är så avgörande i moderna datorsystem att en fundamental förståelse 

är viktig. Vi skall i denna laboration studera cacheminnestekniken från följande synvinklar: 

• Konstruktionsprinciper för cacheminne 

• Inverkan av cacheorganisationen på prestanda 

• Programbeteendets inverkan på prestanda 

I denna laboration skall vi använda en simulator för ett DLX-baserat datorsystem bestående av en DLX CPU (centralenhet) 

och ett minnessystem bestående av en cache och ett huvudminne. Minnessystemet kan konfigureras om 

så att man kan studera olika organisationer av cacheminnet och huvudminnet. Simulatorn gör det möjligt att studera 

prestanda för olika cacheorganisationer för program skrivna i assemblyspråk för DLX. Första delen av laborationen 

tjänar till att förstå hur vissa egenskaper hos minnesreferenserna kan utnyttjas av ett cacheminne så att de 

flesta minnesreferenserna kan hanteras av cachen (med dess accesstid). Konstruktionsrymden för en cache är stor 

och det är inte självklart hur organisationen påverkar prestanda. Andra delen tjänar till att bringa viss klarhet i detta. 

Realisering av “smarta” algoritmer i hårdvara omintetgörs oftast beroende på att de kostar så mycket antingen i 

prestanda eller i hårdvarukomplexitet att det inte lönar sig. I slutet av laborationen studerar vi detta. 

Vi börjar med att ge en beskrivning av simulatorn. 

Per Stenström, Fredrik Dahlgren och Håkan Grahn 

Handhavande av simulatorn 

Simulatorn som används under laborationen gör det möjligt att analysera olika cacheorganisationers inverkan på 

exekveringstiden för program skrivna för DLX. 

Simulatorn består av följande delar: 

• En simuleringsmodell av mikroprocessorn DLX 

• En simuleringsmodell av ett minnessystem bestående av en cache och ett huvudminne 

Cachen och huvudminnets organisation kan förändras och dess inverkan på exekveringstiden kan därmed studeras. 

1 

2


Assemblering av program 

DLX-simulatorn läser program skrivna i DLX-assemblyspråk. Man editerar ett assemblyspråksprogram på vanligt 

sätt. Det enda man måste tänka på är att programmet inte får exekveras i oändlig slinga och att det måste avslutas 

med assemblyinstruktionen trap #0. Filnamnet måste ha filtypen “s”. 

Start av simulatorn 

I katalogen /home/obelix/staff/ide/nesse/cache/ finns några algoritmer kodade i DLX-assemblyspråk. 

Ställ dig i hemmakatalogen. Dess filer, och några andra som inte finns där, kopieras till en underkatalog med 

namnet cache_lab genom kommandot: 

/home/obelix/staff/ide/nesse/bin/init_cache 

Förflytta Dig därefter till denna katalog och starta därefter cachesimulatorn med kommandot 

cache example0 

Efter att programmet lästs in och analyserats av simulatorn skapas ett fönster som lämpligtvis positioneras någonstans 

i mitten av skärmen. 

Simulatorns funktioner 

I Figur 2.1 visas en bild över simulatorn. Vi skall gå igenom de olika funktionerna nedan. Tre boxar symboliserar 

CPUn, cachen och huvudminnet. Mellan CPUn och cachen finns tre fält som vid exekvering visar adress, data och 

typ av operation för den minnesoperation som CPUn initierat. Adressen visas också indelad i tag, index och offset 

ovanför linjen mellan CPUn och cachen. 

Figur 2.1: Simulatorn med de tre boxarna: CPU, cache och minne. 

Minnesoperationerna som initieras av cachen visas på motsvarande sätt mellan cachen och minnet. I figuren visas 

ett läge då CPUn läser in en instruktion som är 32 bitar (Read L står för läsning av ett 32-bitars ord och I står för 

instruktionsuthämtning). Minnesoperationen ger upphov till en cachemiss (minnet är mörklagt) som leder till att 

blocket på samma adress hämtas. Allmänt gäller att den enhet som är aktiverad (cache eller minne) mörkläggs vid 

en minnesoperation. På så vis ser man lätt om en minnesoperation leder till träff (eng. hit) eller miss. Notera att alla 

minnesoperationer motsvarar 32 bitar. 

Exekvering av program 

Man kan välja mellan tre sätt att exekvera ett program. Dels kan man exekvera programmet i full fart med 

(till vänster i figuren) eller så kan man exekvera det till nästa minnesreferens med Step . 

Go 

3 


Ett tredje sätt är att exekvera programmet ett antal minnesreferenser framåt genom att ange ett antal i fältet under 

No of steps. I detta fall kan man låta exekveringen ske i halvfart genom Visual . Härvid kommer cachen respektive 

minnet att blinka till när de aktiveras. Man kan också exekvera det i full fart med Go fältet under No of 

steps. 

Det finns också möjlighet att ställa in brytpunkter på en viss adress. Detta görs under CPU-menyn (se nedan). 

Ovanstående funktioner erhålls genom att motsvarande fält pekas ut samtidigt som vänster musknapp trycks ned. 

Då programmet är färdigexekverat, kommer adressfälten att blankställas. 

Ändring av parametrar för CPU, cache- och minnesorganisation 

Det finns tre popup-menyer för att ställa in olika parametrar. Dessa menyer är CPU-menyn, cache-menyn samt 

minnes-menyn. Menyerna erhålls genom att peka på motsvarande box (CPU-menyn fås då CPUn pekas ut) samtidigt 

som vänster musknapp trycks ned. 

I CPU-menyn kan följande göras: 

• Reset. Initiering av CPUn. Detta måste göras före exekvering av ett program. 

• Change. Ändra klockcykeltid för CPUn. 

• Break On Address. Inställning av brytpunkt för adress. 

• Quit. Lämna simulatorn. 

I cache-menyn kan följande göras: 

• Change. Ändring av cacheorganisation. 

• Contents. Inspektion av cacheinnehållet. 

Om Change väljs, erhålls ett fönster i vilket man kan ändra olika parametrar som styr organisationen. Fönstrets 

utseende visas i Figur 2.2. 

Figur 2.2: Fönstret i vilket man ändrar cacheorganisationen. 

4



Som figuren visar kan man ändra cachestorlek, blockstorlek, antal mängder (eng. set) (adressavbildningsmetod), 

accesstid, uppdateringsstrategi (eng. write policy) samt utbytesalgoritm (eng. replacement policy). Cache och 

blockstorlek anges i antal 32-bitars ord, som vi hädanefter kommer att kalla för ord, kort och gott. 

De numeriska värdena ändras genom att man ökar eller minskar genom att trycka på “+” eller “-”. Övriga parametrar 

ändras genom att trycka på det högra fältet på motsvarande rad ett antal gånger tills önskat alternativ kommer 

upp. Om man exempelvis vill ändra till copy-back, pekar man ut fältet i vilket det står write-through och trycker 

därefter på vänster musknapp. Fönstret tas bort genom att aktivera rutan Close . 

Om Contents väljs skapas ett fönster i vilket man kan studera såväl innehållet i varje block i cachen som den information 

som krävs av adressavbildningsmetoden och utbytesalgoritmen. 

Nedan visas cacheinnehållet efter exekvering av ett program med en mängd-associativ, 8 ords cache med 1 ord / 

block och 2 block/mängd som använder utbytesalgoritmen LRU samt upp\-dateringsstrategin copy-back (förklaras 

senare i kommande avsnitt). 

V D R Tag Block 

- - - --- ----- 

0 : 1 1 0 80b 0 0 0 8 

1 0 1 805 0 a 24 d9 

1 : 1 0 0 805 4 80 0 0 

1 0 1 808 0 0 0 8 

2 : 1 1 1 80a 0 0 0 6 

1 0 0 805 0 1 66 f6 

3 : 1 0 0 805 4e 72 27 0 

1 1 1 80a 0 0 0 7 

Varje rad motsvarar informationen i ett cacheblock med statusbitarna (V=Valid, D=Dirty samt R=Reference för 

LRU och FIFO) och taggen. Därefter följer blockinnehållet (1 ord = 4 bytes). Fönstret uppdateras efter varje minnesoperation. 

Det tas bort genom att aktivera Close . 

Ovanför linjen mellan CPUn och cachen finns tre fält som visar adressen som CPUn lägger ut uppdelad i tag, index 

och offset. Detta är tänkt att underlätta inspektionen av cacheinnehållet. 

I minnes-menyn kan följande göras: 

• Change. Ändring av minnesorganisation. 

• Contents. Inspektion av minnesinnehållet. 

Under change kan man ändra minnesbredden, dvs det antal (32-bitars) ord som kan överföras mellan cachen och 

huvudminnet i en minnesaccess. Man kan också ändra minnesaccesstiden. 

Minnesinnehållet kan studeras genom att välja Contents. Detta presenteras blockvis och uppdateras efter varje 

minnesoperation. 

Resultat av simuleringar 

Med en fjärde popup-meny, show-menyn, kan man få ut resultatet från en simulering. Denna popup-meny erhålls 

då mittersta musknappen trycks ned inom simulator-fönstret. 

I show-menyn kan följande göras: 

• Show Result. 

• Show Hitgraph, All 

• Show Hitgraph, Data 

• Show Hitgraph, Instr 

• Show Localitygraph, All 

• Show Localitygraph, Data 

• Show Localitygraph, Instr 

Show Result visar andel träffar, exekveringstid, antal minnesreferenser, andel skrivningar etc för senaste simuleringen. 

Show Hitgraph visar hur hit-ratio varierar med tiden (i antal minesreferenser) under exekveringen. Man kan välja 

att studera detta för alla minnesreferenser, endast data eller instruktioner. 

Show Localitygraph visar hur minnesreferenserna fördelar sig i adressrymden som funktion av tiden (i minnesreferenser). 

Även här kan man välja att studera alla, endast data eller instruktionsreferenser. 

Man kan få ut diagram och textutskrifter på skrivare genom att aktivera Hardcopy fältet i respektive fönster. 

För diagrammen måste man därefter aktivera Postscript och blankställa fältet med skrivarens namn. Allra sist 

aktiveras OK varvid diagrammet skrivs ut på laserskrivaren. 

Konstruktionsprinciper för cacheminne 

Lokalitetsprincipen 

En cacheminneshierarki består av ett litet snabbt minne (cacheminnet) och ett långsamt större minne (huvudminne). 

Genom att endast lagra de delar av huvudminnet som används ofta i cacheminnet, kommer de flesta minnesreferenser 

att kunna betjänas av cachen och vi får en skenbar accesstid som ligger mycket nära cacheminnets. Anledningen 

att denna enkla teknik fungerar bra beror på lokaliteten hos minnesreferenserna i adressrymden. 

Vi skall studera lokaliteten för två program. Det första programmet — example0 — finns längst bak i denna 

handledning. Programmet bestämmer en svit av Fibonaccital. 

Hemuppgift 2.1 

Studera assemblykoden för programmet example0.s och besvara nedanstående fråga 

Hur många (32-bitars) ord upptar for-loopen Ledning: Du finner adresserna i hexadecimal form längst till vänster 

i listan. 

Svar: _____________________________________________________________________________________ 

——————————————————————————————————— Slut på hemuppgift 2.1 

Vi skall studera vilka adresser som refereras under exekveringen av detta program. Detta görs genom att studera 

den s.k. lokalitetsgrafen för programmet. I lokalitetsgrafen avsätts adressrymden längs y-axeln och tiden (räknat i 

minnesreferenser) längs x-axeln. 

5 

6


Med adressrymden för ett program menas storleken på det område som definieras av den lägsta och högsta adress 

som CPUn adresserar under exekveringen av programmet. Adressrymden definierar hur stort huvudminnet måste 

göras för att rymma programmet. 

Uppgift 2.1 

I katalogen /home/obelix/staff/ide/nesse/cache/ finns några algoritmer kodade i DLX-assemblyspråk. 

Ställ dig i hemmakatalogen. Dess filer, och några andra som inte finns där, kopieras till en underkatalog med 

namnet cache_lab genom kommandot: 

/home/obelix/staff/ide/nesse/bin/init_cache 

Förflytta Dig därefter till denna katalog och starta därefter cachesimulatorn med kommandot 

cache example0 

Exekvera programmet genom att peka på Go (till vänster) och samtidigt trycka ned vänster musknapp. Tag 

därefter upp lokalitetsgrafen för detta program genom att välja alternativet Show Localitygraph, All i popup-menyn 

som erhålls då mittersta musknappen trycks ned. Efter en stund ritas grafen ut i ett fönster på skärmen. 

Hur stor adressrymd i antal ord upptar programmet 

Svar: _____________________________________________________________________________________ 

Hur många ord refereras (instruktioner och data) då for-loopen exekveras 

Svar: _____________________________________________________________________________________ 

Hur stor andel av adressrymden refereras vid exekvering av for-loopen 

Svar: _____________________________________________________________________________________ 

———————————————————————————————————— Slut på uppgift 2.1 

Vi skall nu studera referenslokaliteten för ett annat program, nämligen example1, som är en sorteringsalgoritm 

som finns listad längst bak i handledningen. 


Studera C-programmet example1.c längst bak i handledningen och besvara följande frågor: 

Hur många gånger kommer then-satsen i den inre for-loopen att exekveras med aktuella värden på elementen i 

vektorn X 

Svar: _____________________________________________________________________________________ 

Hur många varv kommer sista for-loopen att exekveras 

Svar: _____________________________________________________________________________________ 


7 


Uppgift 2.2 

Gå ur simulatorn. Detta gör du genom att välja Quit i popup-menyn som erhålls då CPUn pekas ut och vänstra 

musknappen trycks ned. 

Starta simulatorn (cache example1) och exekvera programmet. 

Tag därefter upp lokalitetsgrafen för instruktionsreferenser för programmet (Show LocalityGraph, Instr) och besvara 

följande frågor: 

Hur stor adressrymd i antal ord upptar programmet 

Svar: _____________________________________________________________________________________ 

Hur många ord (instruktioner) refereras då inre for-loopen (for2) exekveras 

Svar: _____________________________________________________________________________________ 

Hur stor andel av adressrymden refereras vid exekvering av for2 

Svar: _____________________________________________________________________________________ 

Hur många ord refereras då sista for-loopen exekveras 

Svar: _____________________________________________________________________________________ 

Hur stor andel av adressrymden refereras vid exekvering av sista loopen 

Svar: _____________________________________________________________________________________ 

Vad kan man säga om andelen av adressrymden som refereras i looparna i de båda programmen då man jämför 

detta med hela programmets totala adressrymd 

Svar: _____________________________________________________________________________________ 


En intressant iakttagelse är de två faser som sorteringsprogrammet arbetar i. Den första motsvarar sorteringen och 

den andra kopieringen. Lägg märke till hur dessa faser visar sig i lokalitetsdiagrammet som två områden. 

Programmen du studerat har det gemensamt att de vid exekvering tillbringar mesta delen av tiden i loopar. Den 

andel av adressrymden som används av looparna i programmen är därför viktig att centralenheten kommer åt 

snabbt. Dessbättre är denna förhållandevis liten jämfört med programmets totala adressrymd, vilket är hemligheten 

bakom cacheteknikens prestandavinster. 

8


Cacheorganisationer och algoritmer 

I denna del av laborationen skall vi studera hur cacheminnen är organiserade och dess funktion. Som vi sett verkar 

det lovande att låta cachen vara liten i förhållande till huvudminnet och samtidigt uppnå att de flesta minnesreferenserna 

kan tas om hand av cachen utan inblandning av huvudminnet. Huvuduppgiften för cachekonstruktören är 

därför att implementera funktioner som ser till att de för tillfället mest refererade delarna av adressrymden ligger i 

cachen. 

Konstruktionsrymden för ett cacheminne är stor och omfattar följande viktiga punkter: 

• Cachestorlek 

• Adressavbildningssmetod (eng. address mapping method) 

• Utbytesalgoritm (eng. replacement algorithm) 

• Uppdateringstrategi (eng. write policy) 

Vi säger att en träff (eng. hit) erhålls om den information som refereras vid en skrivning eller läsning finns i cachen. 

Motsatsen till träff kallar vi miss. En träff kommer att hanteras på samma tid som klockcykeltiden för processorn 

(CPUn) medan en miss gör att pipelinen stoppas. Ett första ordningens mål för cachekonstruktören är därför att se 

till att medelaccesstiden blir så liten som möjlig. Som vi skall se är andelen träffar (eng. hit ratio) en viktig storhet 

att betrakta vid denna optimering. 

Cachestorlek 

Det är klart att desto större cachen är, desto större är sannolikheten att en träff uppstår vid en minnesreferens. För 

att få en hög andel träffar vid exekvering av ett program, är det en god approximation att välja cachen så stor att 

den rymmer de delar av adressrymden som refereras av den slinga som exekveras flest gånger. 

Uppgift 2.3 

Med ledning av de lokalitetsbetraktelser du gjorde i föregående avsnitt, besvara nedanstående fråga: 

Hur stor bör cachen väljas för att rymma den del av adressrymden som refereras i slingan i example0 

Svar: _____________________________________________________________________________________ 


Adressavbildningsmetoder 

Eftersom en cache endast innehåller delar av huvudminnets innehåll, och eftersom processorn genererar minnesadresser 

är det viktigt att cachen avbildar minnesadresser på cachens minne enligt någon metod. Den metod som 

används kallas mängd-associativ avbildning (eng. set-associative mapping) och förklaras nedan. 

Cachen är indelad i ett antal mängder som består av ett antal block. Blocken i sin tur är indelade i ett antal 32-bitars 

ord. Minnesadressen är indelad i tre fält enligt Figur 2.3 med mest signifikant adressbit till vänster. 

Tag Index Offset 

Figur 2.3: Indelning av adressen vid mängd-associativ adressavbildning. 

9 


Avkodare 

0 

1 

2 

3 

Tag-minne Status Dataminne 

. . . 

Mängd 0, block 0 








= 

Multiplexer 

Index 

Träff/miss 

Tag 

Offset 

Figur 2.4: Adressavbildningsmekanism för en cache med 4 mängder och 2 block/mängd. 

Hur adressavbildningen går till för en cache med 4 mängder och 2 block/mängd framgår ur Figur 2.4. Index pekar 

ut aktuell mängd i cachen. Inom denna mängd jämförs tag-fältet med samtliga tag-fält för de block som finns lagrade 

i mängden. Om motsvarande block finns, erhålls det adresserade ordet genom att indexera inom blocket med 

offset-fältets värde. Om det inte finns hämtas blocket in från huvudminnet och motsvarande tag-fält uppdateras. 

Om samtliga block i den aktuella mängden är upptagna, måste något bytas ut. Olika kriterier för utbyten är tänkbara. 

Vi återkommer till dessa senare. 

Det finns två specialfall vid val av antal mängder. Det ena specialfallet innebär att antalet mängder är lika med 

antalet block. Denna avbildningsmetod kallas direkt-avbildning (eng. direct mapping). Det andra specialfallet fås 

om hela cachen motsvarar en mängd. Denna metod kallas fullt associativ avbildning (eng. fully associative mapping). 

Minnesadressen är i detta fall endast indelad i två fält enligt Figur 2.5. 

Tag Offest 

Figur 2.5: Indelning av adressen vid fullt associativ adressavbildning. 

Märk noga att CPUn måste kunna referera till 8-bitars ord (bytes). För att detta skall kunna vara möjligt, bestäms 

antalet adressbitar av log 2 N M , där N M är minnets storlek i antal bytes. 


Besvara nedanstående frågor 

Uttryck cachestorleken (N C ) i antalet mängder (S) och blockstorlek (B) för en direkt-avbildande cache 

Svar: _____________________________________________________________________________________ 

Antag att cachens storlek är 8 ord och blockstorleken är 1 ord. Ange antalet adressbitar i tag, index- och offsetfältet 

för en direkt-avbildande cache om huvudminnets storlek är 64 kord (64 x 1024 ord). 

Svar: _____________________________________________________________________________________ 

10


Ange antalet adressbitar i tag-fältet för en fullt associativt avbildande cache med storleken 8 ord samt blockstorleken 

1 ord om huvudminnets storlek är 64 kord. 

Svar: _____________________________________________________________________________________ 


Vi skall nu studera en direkt-avbildande cache genom att exekvera programmet example0. 

Uppgift 2.4 

Gå ur simulatorn och starta den med det första programmet (cache example0). Peka på cachen och tryck på 

vänster musknapp. Du får då upp en popup-meny i vilken du väljer Change. Du kan nu välja cacheorganisation. 

Välj cache-storlek enligt uppgift 2.3. Välj blockstorlek 1 samt antal mängder så att cachen blir direkt-avbildande. 

Ändra dock inga andra fält. Stäng därefter fönstret med Close . 

I Cache-menyn väljer du nu Contents som skapar ett fönster i vilket du kan studera cacheinnehållet. 


Varje rad i cachen mostvarar ett block. Till varje block hör en statusbit V, en tag samt blockinnehållet. V biten 

(Valid) anger om blocket innehåller giltig data (jfr. med Figur 2.4). 

Uppgift 2.5 

Gör nu reset och exekvera programmet stegvis genom att trycka på Step . Följ hela tiden med i programlistan 

så att du vet vilka instruktioner som exekveras. Fortsätt tills cachen fyllts. Tryck ytterligare en gång och notera 

noga vilket block som byts ut. 

Vilket block byts ut och varför 

Svar: _____________________________________________________________________________________ 

Vilken instruktion hämtades in i cachen 

Svar: _____________________________________________________________________________________ 

Fortsätt nu stegvis tills hela loopen ligger i cachen. Studera därefter cachens beteende genom att låta ett antal steg 

exekveras i halvfart. Detta gör du genom att skriva in ett antal (välj 32) i fältet No of steps. Tryck därefter på 

Visual . Cachen blinkar till vid träff och minnet vid miss. 

Det genereras två missar per varv i loopen. Vilka adresser motsvarar dessa 

Svar: _____________________________________________________________________________________ 

Varför genereras missar vid just dessa adresser 

Svar: _____________________________________________________________________________________ 


11 


Trots att hela adressrymden som loopen refererar till får plats i cachen erhålls missar. Detta beror på en svaghet 

hos direkt-avbildande cachar som går under benämningen konfliktmissar (eng. conflict misses) eller “bumps”. 

Utbytesalgoritmer 

Antalet konfliktmissar, dvs situationer där två minnesadresser konkurrerar om samma block i cachen, kan minskas 

genom att välja en mängd-associativ cache med färre antal mängder än antal block i cachen. Extremfallet motsvaras 

av fullt associativa cachar. 

För alla cachar som inte är direkt-avbildande är det inte självklart vilket block som skall bytas ut då man erhåller 

en cache-miss. Många algoritmer är tänkbara men måste förkastas pga att de ej går att implementera till rimlig kostnad. 

Vi skall studera tre utbytesalgoritmer, nämligen Random, FIFO och LRU. 

Vid Random (eller pseudo-random) väljs det block som skall bytas ut slumpmässigt. Denna algoritm kan approximeras 

med round-robin som är ganska lätt att implementera. I simulatorn är Random implementerad genom 

slumptalsdragning. 

Vid FIFO (First In First Out) bytes det block ut som funnits längst tid i cachen. Denna algoritm kan implementeras 

exakt genom att associera en räknare till varje block. Vid varje blockutbyte inkrementeras samtliga räknare. Det 

block vars räknare har högst värde byts ut. Räknarens storlek definieras av antalet block i setet. Nackdelen med 

denna algoritm är främst att det block som varit längst i cachen nödvändigtvis inte behöver vara det som är minst 

refererat. 

LRU (Least Recently Used) tar hänsyn till referensintensiteten till varje block. Man associerar en räknare till varje 

block. Räknaren nollställs då blocket refereras. Övriga räknare inkrementeras. Vid utbyte väljs det block vars räknare 

har högst värde. Räknaren kan teoretiskt behöva vara hur stor som helst. I praktiken räcker det med ett fåtal 

bitar (många implementeringar använder endast en bit). I simulatorn anges räknarens värde under R i fönstret med 

cachens innehåll. 

Val av utbytesalgoritm påverkar kostnaden för cachen på grund av de statusbitar som behövs för beslutsfunktionen. 

Uppgift 2.6 

Gör nu cachen i förra uppgiften fullt associativ och välj LRU som utbytesalgoritm. Exekvera tills cachen fyllts. 

Studera speciellt hur räknarnas värden förändras. 

Vilket block kommer att bytas ut vid nästa referens och varför Ledning: Studera räknarnas värde för de olika 

blocken 

Svar: _____________________________________________________________________________________ 

Verifiera resultatet! 

Fortsätt nu tills hela loopen finns i cachen och exekvera sedan programmet i halvfart 32 steg. 

Vilken minnesoperation ger upphov till att både cachen och minnet blinkar 

Svar: _____________________________________________________________________________________ 

Hur många missar genereras per varv och varför 

Svar: _____________________________________________________________________________________ 

_________________________________________________________________________________________ 

12



Exekvera programmet till slut genom att trycka på Go . Studera därefter statistiken för denna körning genom 

att välja alternativet Show result i popup-menyn som fås då mellersta musknappen trycks ned. 

Vilken andel träffar erhölls (hit ratio) 

Svar: _____________________________________________________________________________________ 

Jämför detta med cachens storlek kontra storleken på programmets adressrymd (dvs huvudminnets storlek). 


Uppdateringsstrategier 

Den sista konstruktionsdetaljen vi skall studera har att göra med hur huvudminnet skall uppdateras. En metod går 

ut på att vid en skrivning uppdatera såväl cachen som huvudminnet s.k. write-through. Nackdelen med detta alternativ 

är att varje skrivning därmed tar tid. Ett annat alternativ är att endast uppdatera cachen. I detta fall kommer 

huvudminnet inte att innehålla det aktuella värdet varför blocket måste skrivas tillbaka i minnet vid utbyte. Denna 

strategi kallas copy-back och kräver att det finns en bit till varje block som anger om blocket skall skrivas tillbaka 

(D(irty)-bit). I simulatorn anges D-biten för varje block i fönstret med cachens innehåll under D. 

Det bör också nämnas att det finns olika strategier för när ett block skall hämtas in från huvudminnet. Antingen 

väljer man att alltid hämta in blocket vid en miss. Ett alternativ då write-through används är att aldrig hämta blocket 

vid skrivmissar utan istället uppdatera huvudminnet. Först vid en läsmiss hämtas blocket. I laborationen förutsätter 

vi att samtliga missar leder till att blocket hämtas in. 

Uppgift 2.7 

Vid förra exekveringen blinkade både cachen och minnet som följd av att vi har valt write-through. Ändra i cachemenyn 

cachen så att copy-back används och exekvera programmet i halvfart (64 steg). 

Vad blev resultatet vad beträffar minnestrafiken 

Svar: _____________________________________________________________________________________ 


Cacheorganisationens inverkan på prestanda 

Denna del av laborationen tjänar till att förstå hur cacheorganisationen påverkar exekveringstiden för program. 

Prestandamodell 

Vi skall börja med att gå igenom en förenklad prestandamodell för ett datorsystem med cache och huvudminne. Vi 

inför följande beteckningar för olika egenskaper i systemet: 

• t CPU —Tiden från det att CPUn tagit emot svar från en minnesreferens tills nästa minnesreferens genereras. 

• t A1 — Accesstid för cacheminnet. 

• t A2 — Accesstid för minnet. 

• B — Blockstorlek i antal ord (32 bitar) 

• I — Minnesbredd, dvs hur många ord på konsekutiva adresser som kan överföras mellan cache och huvudminne 

i en minnes-cykel. 

t CPU utgör den tid det tar för centralenheten att bearbeta varje minnesreferens. Om minnesaccesstiden vore noll, 

skulle det ta Nt CPU att utföra N minnesreferenser. 

För varje minnesreferens som centralenheten genererar, finns ett antal olika utfall. Dels är första frågan om det 

kommer att uppstå en träff i cachen. Isåfall blir accesstiden samma som cachens, dvs t A1 . 

Om det uppstår en miss måste i bästa fall blocket läsas in från minnet vilket tar tiden t A2 B/I eftersom B ord måste 

överföras och I ord kan överföras samtidigt. 

Om copy-back används och det block som skall bytas ut är uppdaterat, måste det skrivas tillbaka vilket ger en ökning 

med t A2 B/I. 

Vid en skrivträff och då write-through används kan minnet uppdateras samtidigt som cachen varför tiden för denna 

operation är accesstiden för minnet, nämligen t A2 . 

I tabellen nedan presenteras tiden det tar för skrivningar och läsningar beroende på utfall och beroende på den uppdateringsstrategi 

som används. I hemuppgiften nedan skall du komplettera tabellen. 

Utfall 

Lästräff 

Läsmiss utan tillbakaskrivning 

Läsmiss med tillbakaskrivning 

Skrivträff — write through 

Skrivträff — copy back 

Skrivmiss — write through 

Skrivmiss — copy back, fall 1 

Skrivmiss — copy back, fall 2 


Komplettera tabellen ovan och besvara följande frågor: 

Vilka två fall är möjliga vid skrivmiss då copy-back används 

Svar: _____________________________________________________________________________________ 

Härled uttrycket för skrivmiss då write-through används. 

Formel 

t A1 

t A1 + t A2 B/I 


Exekveringstiden för ett program som genererar N 1 lästräffar, N 2 läsmissar, N 3 skrivträffar och N 4 skrivmissar för 

en cache som utnyttjar write-through är då 

T = N( t CPU 

+ ( 1 – W )t A1 

+ Wt A2 

+ ( 1 – H)t A2 

( B ⁄ I) 

) 

där N = N 1 + N 2 + N 3 + N 4 för en cache som utnyttjar write-through. 

Cachens organisation kan beskrivas med en fem-tipel O = < S, B, A, R, U >, där S = cachestorlek, B = blockstorlek, 

A = adressavbildningsmetod, R = utbytesalgoritm samt U = uppdateringsstrategi. 

t A2 

t A1 

t A2 B/I + t A2 

T = N 1 

t A1 

+ N 2 

( t A1 

+ t A2 

( B⁄ 

I) 

) + N 3 

t A2 

+ N 4 

( t A2 

( B⁄ 

I) + t A2 

) 

(2.1) 

Andelen träffar betecknas med H. För exemplet ovan gäller att H = ( N 1 

+ N 3 

) ⁄ ( N 1 

+ N 2 

+ N 3 

+ N 4 

) . Om 

andelen skrivningar är W så gäller att 

(2.2) 

13 

14


I den förenklade prestandamodellen har vi inte tagit hänsyn till inverkan av cacheorganisationen på hit-ratio och 

accesstid. I själva verket beror hit-ratio på cacheorganisationen och programbeteendet, P. H är således en funktion 

av dessa, dvs H = H( O, P ). Vidare gäller att accesstiden för cachen beror av cacheorganisationen, dvs 

A 1 = A 1 ( O ). Eftersom det inte finns något icke-trivialt analytiskt uttryck för dessa funktioner, är enda sättet att via 

experiment studera inverkan av cacheorganisationen och programbeteendet på dessa. 

Låt oss nu studera hur hit-ratio varierar i tiden under det att ett program exekveras. 

Uppgift 2.8 

Starta simulatorn med programmet example1. Välj en direktavbildande cache med 64 ord och 2 ord/block. Exekvera 

programmet i full fart (med Go ). Tag därefter upp show-menyn (mittersta musknappen) och välj alternativet 

Show Hitgraph, All. Efter en stund kommer ett diagram upp. I diagrammet ser man hur hit-ratio varierar 

med tiden. Tag även upp lokalitetsgrafen för instruktionsreferenser. 

Förklara varför hit-ratio till en början är mycket låg 

Svar: _____________________________________________________________________________________ 

_________________________________________________________________________________________ 

Vad beror variationerna i hit-ratio i mitten av grafen på 

Svar: _____________________________________________________________________________________ 

Varför sjunker hit-ratio i slutet Ledning: Studera programlistan 

Svar: _____________________________________________________________________________________ 


Cachestorlekens inverkan på hit-ratio 

Vi skall nu studera cachestorlekens inverkan på hit-ratio. 

Uppgift 2.9 

Ändra cachens organisation enligt följande. Välj en direktavbildande cache på 16 ord som utnyttjar write-through 

och med blockstorleken 1 ord. 

Vi skall bara studera instruktionsreferenser. Vi väljer därför en cache som endast cachar instruktioner. Välj därför 

Cache Type = Instr. cache i samma meny som du väljer övriga cache parametrar. 

Exekvera programmet i full fart. Tag därefter upp Show result och fyll i uppgifterna i tabellen nedan. Gör om samma 

mätningar för de cachestorlekar som finns upptagna i tabellen. Se hela tiden till att du har en direkt-avbildande 

cache. Rita in mätpunkterna i diagrammet och besvara därefter frågorna nedan. 

S (cachestorlek) H (total hit-ratio) 

16 

32 

64 

128 

15 


H 

1.0 

0.8 

0.6 

0.4 

0.2 

S 

16 32 64 128 

Studera diagrammet du upprättat. 

Vid en viss cachestorlek ger ytterligare ökning av storleken endast marginell ökning av hit-ratio. Vilken storlek 

avses 

Svar: _____________________________________________________________________________________ 

Vilken hit-ratio erhålls vid denna cachestorlek 

Svar: _____________________________________________________________________________________ 

Jämför cachestorleken med den adressrymd som refereras av den inre for-loopen (se uppgift 2.2). Kommentar 

Svar: _____________________________________________________________________________________ 


Blockstorlekens inverkan på hit-ratio 

Uppgift 2.10 

Använd samma program som tidigare (example1). Välj en direkt-avbildande cache som utnyttjar write-through. 

Låt cachen vara 32 ord i storlek. 

Vi skall nu låta vår cache lagra såväl data som instruktioner. Välj därför Cache type = Cache. 

Ställ in cachens accesstid till 10 ns, minnets accesstid till 100 ns och minnesbredden till 1. CPUns klockcykeltid 

(t CPU ovan) skall vara 10 ns. 

16


Börja med en blockstorlek lika med 1 ord och kör programmet i full fart. Tag därefter upp Show result och fyll i 

uppgifterna i tabellen nedan. Gör om samma mätningar för de blockstorlekar som finns upptagna i tabellen och 

besvara frågorna. 

B H I H D H T 

1 

2 

4 

8 

16 

• B — Blockstorlek i antal ord 

• H I — Hit-ratio för instruktioner 

• H D — Hit-ratio för data 

• H — Total hit-ratio 

• T — Exekveringstiden för programmet i µs 

Hur stor är andelen skrivningar (W) 

Svar: _____________________________________________________________________________________ 

Hur många referenser genererar programmet (N) 

Svar: _____________________________________________________________________________________ 

Vilken typ av information (instruktioner eller data) ger högst andel träffar Förklaring 

Svar: _____________________________________________________________________________________ 

_________________________________________________________________________________________ 

Vid vilken blockstorlek uppnås högst andel träffar 

Svar: _____________________________________________________________________________________ 

Varför minskar andelen träffar därefter 

Svar: _____________________________________________________________________________________ 

Trots att andelen träffar ökar så ökar exekveringstiden. Varför Ledning: Studera ekvation 2.2. 

Svar: _____________________________________________________________________________________ 

_________________________________________________________________________________________ 

17 


Beräkna exekveringstiden för en blockstorlek på 1 ord genom att sätta in aktuella värden på storheterna i ekvation 

2.2. Jämför detta med exekveringstiden i tabellen.} 

Svar: _____________________________________________________________________________________ 


Minnesbreddens inverkan på exekveringstiden 

Minnesbredden anger hur många ord som kan överföras mellan cachen och minnet vid blocköverföringar. För att 

dra nytta av den minskade andelen träffar vid ökad blockstorlek, bör minnesbredden väljas lika med blockstorleken. 

Uppgift 2.11 

Gör om mätningarna i föregående uppgift för blockstorlekarna i tabellen nedan men med samma minnesbredd som 

blockstorlek. 

B H T 

1 

2 

4 

Hur förändras nu exekveringstiden med total hit-ratio 

Svar: _____________________________________________________________________________________ 

Vilken är den minsta exekveringstid som uppmäts 

Svar: _____________________________________________________________________________________ 


Adressavbildningsmetodernas inverkan på hit-ratio 

Vi skall nu studera hur antalet mängder inverkar på hit-ratio för cachesystemet. Som vi såg kunde vi totalt eliminera 

de missar som uppstod som följd av konfliktmissar genom att göra cachen fullt associativ. I praktiken är det kostsamt 

att implementera cachar fullt associativa varför man nöjer sig med mängd-associativ adressavbildning. 

Uppgift 2.12 

Gör om mätningarna i föregående uppgift med cachesize = 32 ord, blockstorleken 4 ord och med de antal mängder 

som anges i tabellen nedan. Använd FIFO som utbytesalgoritm. 

S H 

8 

4 

2 

1 

18


Förklaring till beteckningar: 

• S — Antal mängder 

• H — Total hit-ratio 

Hur förändras hit-ratio med minskat antal mängder 

Svar: _____________________________________________________________________________________ 

Vid vilket antal mängder uppnås högst hit-ratio 

Svar: _____________________________________________________________________________________ 

Hur stor är skillnaden mellan högsta och lägsta hit-ratio 

Svar: _____________________________________________________________________________________ 

Vilken slutsats drar du om storleken på inverkan av antalet mängder på hit-ratio 

Svar: _____________________________________________________________________________________ 


En slutsats av denna mätning är att det inte lönar sig att ha så många block per mängd. I praktiken visar det sig att 

2 till 4 block per mängd ger en ökning av hit-ratio. Därefter är ökningen marginell. Med tanke på att implementeringskostnaden 

ökar markant då vi ökar associativiteten (ökning av antal block per mängd), skall prestandahöjningen 

vara markant för att det skall löna sig. 

Utbytesalgoritmernas inverkan på hit-ratio 

Uppgift 2.13 

Undersök skillnaderna i hit-ratio för de olika utbytesalgoritmerna med samma cache och blockstorlek som i föregående 

uppgift samt med 4 block/mängd. Fyll i tabellen nedan. 

H Random H FIFO H LRU 

Hur stor är skillnaden i hit-ratio mellan Random och LRU 

Svar: _____________________________________________________________________________________ 

Hur stor är skillnaden i hit-ratio mellan FIFO och LRU 

Svar: _____________________________________________________________________________________ 

19 


Vilken slutsats drar du om storleken på utbytesalgoritmens inverkan på hit-ratio 

Svar: _____________________________________________________________________________________ 


Uppdateringsstrategiernas inverkan på exekveringstiden 

I prestandamodellen såg vi att uppdateringsstrategin påverkar exekveringstiden hos programmet. Vi skall studera 

dess inverkan på sorteringsprogrammet example1. 

Uppgift 2.14 

Välj en fullt associativ cacheorganisation med storlek 32 ord, blockstorlek 4 ord samt LRU. Mät exekveringstiden 

för programmet med olika minnesbredder för copy-back och write-through enligt tabellen nedan. 

I T write-through T copy-back 

1 

2 

4 

För vilken minnesbredd är write-through bättre än copy-back och varför 

Svar: _____________________________________________________________________________________ 

_________________________________________________________________________________________ 

Hur mycket kortare blir exekveringstiden för copy-back jämfört med write-through i bästa fallet 

Svar: _____________________________________________________________________________________ 


Anm. Det bör noga påtalas att vi i vår prestandamodell antagit att CPUn måste vänta tills varje skrivning har genomförts 

då write-through används. I praktiska implementeringar använder man skrivbuffertar som gör det möjligt 

för CPUn att fortsätta efter att en skrivning utförts. Detta betyder att prestanda för write-through är avsevärt bättre 

än vad dessa siffror visar. 

Uppgift 2.15 

Du skall nu exekvera samma program med den cacheorganisation som du kommit fram till ger bäst exekveringstid 

och besvara följande frågor. 

Hur lång exekveringstid får du 

Svar: _____________________________________________________________________________________ 

Tag nu bort cachen genom att ändra fältet Cache type till No cache. Exekvera därefter programmet. 

20



Hur lång exekveringstid får du nu 

Svar: _____________________________________________________________________________________ 

Hur många gånger längre blir exekveringstiden utan cache 

Svar: _____________________________________________________________________________________ 


Cacheorganisationens inverkan på accesstiden för cachen 

I ovanstående mätningar har vi inte tagit hänsyn till att cacheorganisationen påverkar accesstiden för cachen. Sambandet 

mellan accesstiden och organisationen är icke-trivialt. Vi skall dock nämna några generella egenskaper. 

I allmänhet gäller att desto större ett minne är desto längre accesstid har det. Detta beror på att adressavkodningsmekanismen 

har större grinddjup och ger därför längre fördröjning. 

Adresseringen av ett mängd-associativt cacheminne tillgår så att index först adresserar aktuellt set. Därefter sker 

en associativ sökning av det block inom setet som överensstämmer med tag-fältet. Allra sist sker en adressering av 

ordet inom blocket med hjälp av offset. 

Den tid det tar att adressera sig till setet och till ordet är vanligtvis proportionell mot logaritmen på antalet mängder 

resp. blockstorleken. Den associativa sökningen är proportionell mot antalet block/mängd. 

Vi har begränsat minnesbredden och antalet block/mängd för att göra uppgiften mer realistisk. Ett brett minne är 

kostsamt i ett verkligt system eftersom det bestämmer bussvidden mellan cachen och minnet. Vidare är stora associativa 

minnen dyrbara. I praktiska implementeringar brukar man därför sällan använda sig av mer än 4 block/ 

mängd. 

Utnyttja allt du lärt dig och lek med simulatorn så mycket du orkar och tycker är kul. 


Vi sammanfattar nu vad du skall ha lärt dig i laborationen. Fundera igenom punkterna nedan och kontakta din handledare. 

• Programlokalitetens inverkan på hit-ratio. 

• Funktionen hos de olika cacheminnesorganisationerna. 

• Cachestorelekens inverkan på hit-ratio och exekveringstid. 

• Blockstorlekens inverkan på hit-ratio och exekveringstid. 

• Minnesbreddens inverkan på hit-ratio och exekveringstid. 

• Adressavbildningsmetodens inverkan på hit-ratio och exekveringstid. 

• Utbytesalgoritmernas inverkan på hit-ratio och exekveringstid. 

• Uppdateringsstrategiernas inverkan på hit-ratio och exekveringstid. 

I denna del av laborationen skall du med hjälp av ett förenklat uttryck för accesstiden välja den cache organisation 

som ger bäst prestanda. 

Förutsättnigar 

Vi antar att accesstiden endast påverkas av cachestorleken (S) enligt följande uttryck där tiden anges i nanosekunder 

(ns): 

t A1 

= 7log 2 

S 

(2.3) 

Det finns en speciell funktion som ger dig accesstiden för cachen enligt ekvation 2.3 ovan. Denna erhålls genom 

att välja Auto access time i cache menyn. 

Uppgift 2.16 Extra 

Finn den cache med nedanstående förutsättningar som ger kortast exekveringstid för programmet example2, som 

utför matrisaddition, och som finns listad längst bak. 

Förutsättnigar: 

• Auto access time On 

• CPUns klockcykeltid är 10 ns 

• Minnets accesstid är 100 ns 

• Maximal minnesbredd är 4 

• Maximalt antal block/mängd är 4 

21 

22



Programlistor 

Programlista för “example0.c” och “example0.s” 

Beräkning av Fibonacci tal 

main(int argc, char **argv) 

{ 

int x0, x1, x2, temp, i; 

} 

x0 = 1; 

x1 = 1; 

for (i = 0; i < 10; i++) { 

temp = x0 + x1; 

x0 = x1; 

x1 = temp; 

x2 = temp; 

} 

Assemblykod för DLX 

0000 addi r1,r0,#1 ; x0=1; 

0004 addi r2,r0,#1 ; x1=1; 

0008 addi r5,r0,#x2 ; 

000C addi r3,r0,#10 ; i=10; 

0010 L1: add r4,r1,r2 ; temp:=x0+x1; 

0014 add r1,r0,r2 ; x0:=x1; 

0018 add r2,r0,r4 ; x1:=temp; 

001C sw 0(r5),r4 ; x2:=temp; 

0020 subi r3,r3,#1 

0024 bnez r3,L1 ; then branch L1 

0028 nop 

002C trap #0 

0030 x2: 

Programlista för “example1.c” 

The bubblesort algorithm 


{ 

int x[10], y[10]; 

int i, j, temp; 

} 

for (i = 0; i < 10; i++) 

x[i] = 10 - i; 

for (i = 0; i < 9; i++) { 

for (j = 9; j > i; j--) { 

if (x[j] < x[j - 1]) { 

temp = x[j - 1]; 

x[j - 1] = x[j]; 

x[j] = temp; 

} 

} 

} 

for (i = 0; i < 10; i++) 

y[i] = x[i]; 

Programlista för “example2.c” 

Matrix addition algorithm 


{ 

int A[10][10], B[10][10], C[10][10]; 

int i, j; 

} 

for (i = 0; i < 10; i++) { 

for (j = 0; j < 10; j++) 

C[i][j] = A[i][j] + B[i][j]; 

} 

23 

24

Laboration 2

Create successful ePaper yourself

Delete template?

Save as template?