Cacheminnen: skrivning ● Träff ● Skrivbuffert ● Miss

Skrivträff ● Rätt adress finns i giltig adresslapp ● Ska huvudminnet uppdateras? – Ja = genomskrivning (write-through) – Nej = återskrivning (write-back, write-behind, copy-back)

Write-through ● Enkelt ● Primärminnet har alltid aktuella data ● Minus: kräver mycket busstrafik

Write-back ● Cacheminnet kan ha senaste värdet ● Uppdatera primärminnet när blocket byts ● "Dirty bit" anger om blocket skrivits ● Minskar busstrafiken – flera skrivningar till samma block kombineras ● Extra krångligt och extra nödvändigt i flerprocessorsystem

Mätning av skrivningar ● andel skrivningar till block med dirtybit = 1 ● enklare att mäta än write-back-trafik – data kvar i cache vid programslut ● linpack, liver

Skrivningar i pipeline ● Direktmappat, write-through IFRFALUMEMWB Loadläs tag + data läs tag och skriv data ● Associativt och/eller write-back IFRFALUMEMWB Loadläs tag + data Store tar 2 cyklerläs tagskriv data Store tar 1 cykel

Skrivbuffert ● Vi vill inte stoppa processorn medan skrivning sker till primärminnet ● Lösning: skrivbuffert mellan cacheminne och primärminne ●...eller mellan två cacheminnesnivåer

Skrivbuffert ● Endast skrivningar ● Blir skrivbufferten full så måste processorn vänta, annars inte Processor Cacheminne Skriv- buffert Primärminne

Enklast möjliga skrivbuffert ● Endast ett ord ● Alla cacheminnen behöver minst denna buffert ● Sparcstation SLC (1990): 1 STORE tar 1 cykel, 2 STORE i följd tar 18 cykler (minnets hastighet) adressdata giltigbit v

Write-through + skrivbuffert ● Alla skrivningar ska till skrivbufferten ● Skrivbufferten full vid skrivningar i tät följd ● Write-through är enkelt, därför snabbt men behöver en bra skrivbuffert

Write-back + skrivbuffert ● Skrivningar i följd till samma block slås ihop ● Hela blocket skrivs till primärminnet när det kastas ut ur cacheminnet (om dirty-biten = 1) ● Mindre skrivtrafik – enklare skrivbuffert räcker

Store-instruktioner i oordning ● Alla Store i rätt ordning – bara om – write-through – och enklast möjliga skrivbuffert ● Write-back och Store-instruktioner – till samma ord: bara det senaste värdet skrivs – till intilliggande ord: ordningen kan ändras ● Skrivbuffert och Store-instruktioner – beror på graden av sammansmältning

Sammansmältning ● En sammansmältande skrivbuffert (coalescing write buffer) kan ändra ordning på Store-instruktioner ● Olika varianter på sammansmältning beroende på hur många adresser som jämförs – alla adresser i skrivbufferten, eller – bara den senast inlagda

Skrivbuffert med flera platser ● Ska skrivningar till samma adress slås ihop eller ska man ta en ny plats? adressdatav adressdatav adressdatav

Bred skrivbuffert ● Ska skrivningar till intilliggande adresser slås ihop eller ska man ta en ny plats? adressv v v ABCD ord 0ord 1ord 2ord 3 ABCD ABCD

Grader av sammansmältning ● Ingen sammansmältning – ny plats för varje skrivning – STORE körs i ordning ● Begränsad sammansmältning – endast översta platsen i skrivbufferten kollas – fångar upp skrivningar till flera ord i följd ● Full sammansmältning – alla skrivbuffertplatser kollas ● Jouppi förutsätter full sammansmältning

Tömningspolicy ● Skrivbufferten töms så snart något finns i den – inga tillfällen till sammansmältning – slöseri med bandbredd på minnesbussen ● Skrivbufferten töms först när den blir full – kallas write cache av Jouppi – kan kombineras med "vanlig" skrivbuffert – kan fungera som victim cache också om även block med dirtybit=0 läggs i write cache

Load-instruktioner och skrivbuffert ● Load läser plats som Store nyligen skrivit STORE 0(R3) <- … LOAD … <- 0(R3) ● Ska Load kolla i skrivbufferten för att slippa vänta?

Skrivmissar ● 1. Skrivs nya värdet till cacheminnet? Ja = platsreservation vid skrivmiss (allocate on write miss) ● 2. Hämtas gamla värdet till cacheminnet? Ja = hämtning vid skrivmiss (fetch on write) ● 3. Skrivs cacheminnet medan adresslappen läses? Ja = write before hit

Write-before-hit ● Data skrivs medan adresslapp läses ● Träff – allt OK ● Miss – invalidera cacheblocket! ● Direktmappat, write-through IFRFALUMEMWB Loadläs tag + data läs tag och skriv dataStore tar 1 cykel

Alternativ vid skrivmiss

Fetch-on-write ● Reservera plats (släng ut något vid behov) ● Hela gamla blocket hämtas ● Efter hämtningen är det ingen miss längre - STORE kan köras igen, enkel logik

Exempel (i datacache med bara 1 block) Fetch-on-write 4711ABCD adresslappord 0ord 1ord 2ord 3 LOADI R1 <- #$ LOADI R2 <- #$0123 STORE 0(R1) <- R2 Medför platsreservation och hämtning XYZW …följt av skrivning 11147X0123ZW 1 1 1

Write-validate ● Reservera plats (släng ut något vid behov) ● Hämta inget ● Kräver giltigbitar för varje ord i blocket! ● Minskar busstrafik

Exempel (i datacache med bara 1 block) Write-validate LOADI R1 <- #$ LOADI R2 <- #$0123 STORE 0(R1) <- R2 Medför platsreservation men ingen hämtning......skrivning görs 4711ABCD adresslappord 0ord 1ord 2ord ABCD A0123CD

Write-around ● Ingen platsreservation ● Ingen hämtning (förstås) ● Ingen write-before-hit ● Cacheinnehåll helt opåverkat av skrivmiss ● Enkelt att bygga

Exempel (i datacache med bara 1 block) Write-around 4711ABCD adresslappord 0ord 1ord 2ord 3 LOADI R1 <- #$ LOADI R2 <- #$0123 STORE 0(R1) <- R2 Cacheminnet påverkas inte, skrivning endast till primärminnet 4711ABCD 1 1

Write-invalidate ● Cacheminnet skrivs alltid ● Adresslappen uppdateras inte vid miss - blocket måste ogiltigförklaras ● Enkel logik ● Endast direktmappade cacheminnen av genomskrivningstyp (write-through)

Exempel (i datacache med bara 1 block) Write-invalidate 4711ABCD adresslappord 0ord 1ord 2ord 3 LOADI R1 <- #$ LOADI R2 <- #$0123 STORE 0(R1) <- R2 Skrivning före adresslappskontroll A0123CD …leder till att adresslappen inte stämmer - ogiltigförklara blocket ogiltigtA0123CD 1 1 0

Träff och miss ● I princip oberoende ● I praktiken: – genomskrivning (write-through) vid träff - ofta write-around vid miss – återskrivning (write-back) vid träff - ofta fetch-on-write vid miss ● Med tanke på skrivning av flera ord i följd