Minnesteknologier Teknologi Accesstid Kostnad $/GB SRAM 1 ns 1000 DRAM

En presentation över ämnet: "Minnesteknologier Teknologi Accesstid Kostnad $/GB SRAM 1 ns 1000 DRAM"— Presentationens avskrift:

1 William Sandqvist william@kth.se
Minnesteknologier Teknologi Accesstid Kostnad $/GB SRAM 1 ns 1000 DRAM 50 ns 100 HDD 10 ms 1 Snabba minnen är dyra och billiga minnen är slöa! Principiella siffror. William Sandqvist

2 Processor-memory performance gap
Både processorer och minnen ökar sina prestanda år efter år, men inte alls med samma ökningstakt – ett prestandagap har uppstått! Lösningen på detta problem har blivit uppfinnandet av Cache-minnet. William Sandqvist

3 William Sandqvist william@kth.se
Minneshierarki En tre nivåers minneshierarki. De snabbare minnestyperna används som ”buffertar” mot de långsammare. Principbild William Sandqvist

4 William Sandqvist william@kth.se
SRAM Varje bit i ett CMOS SRAM består av en låskrets uppbyggd av sex MOS-transistorer. William Sandqvist

5 William Sandqvist william@kth.se
DRAM Varje bit i ett DRAM består av en transistor och en minneskonden-sator. En laddad kondensator läcker ut laddningen efter ett tag. Periodiskt måste alla kondensatorer under-sökas och de som har laddning kvar måste då återladdas. Detta kallas för Refresh. Det sköts av kretsar inuti minnet. William Sandqvist

6 Kondensatorn byggs på djupet
Trench Capacitor (trench = dike) En bit i ett DRAM tar samma plats som två MOS-transistorer. En bit i SRAM som sex MOS-transistorer! William Sandqvist

7 William Sandqvist william@kth.se
Burst (skur) Minnet läses i tre steg: ROW, COL, och access. Accesstiden för ett valfritt minnes-ord blir därför tre Bussklock-cykler. Om man läser minnet ”skurvis” (Burst) räknar minnet självt fram adresserna till minnesordets ”grannar”. Resten av minnes-orden i skuren tar då bara en Bussklockcykel. Burst kan tex. vara 2, 4, 8 minnes-ord. William Sandqvist

8 Burst ger snabbare medelaccess
Att hämta 1 ”random” ord i minnet tar tre busscykler 3TBus/ord (varav 2 TBUS är Waitstates) Att hämta en ”Burst” med 2 ord tar 3+1 busscykler, 4/2 = 2TBus/ord Att hämta en ”Burst” med 4 ord tar busscykler, 6/4 = 1,5TBus/ord Att hämta en ”Burst” med 8 ord tar busscykler, 10/8 = 1,25TBus/ord Det gäller dock att ha användning för alla hämtade ord – annars slösar man bussklockcykler med Burst-metoden! Detta är ett principiellt resonemang. Gäller både SRAM och DRAM. Andra accessmönster förekommer, tex osv. TBUS = 10*TCPU är valt som exempel. William Sandqvist

9 William Sandqvist william@kth.se
Cacheminnet Cacheminnet kan hålla en liten del av huvudminnets innehåll. Processorn hämtar sin information från Cacheminnet, men om informationen saknas där (= Cache-miss), överförs den tillsam-mans med ett helt Cache-block från huvudminnet till Cache-minnet. Blockvis läsning av huvudminnet ger lägre genomsnittlig accesstid, men man måste ha nytta av de övriga orden i blocket … Chansen att övriga ord i blocket kommer till användning beror av … Tidslokalitet En minnescell som blivit accessad nyligen kan bli accessad snart igen. Rumslokalitet De minnesceller som har adresser nära en som nyligen accessats har stor chans att bli accessade. William Sandqvist

10 Cache – Adressavbildning
De flesta huvudminnen är Byteorganiserade, men eftersom huvudminnet accessas blockvis brukar det bli enklare om man ritar det som en följd av Minnesblock. Direkt adressavbildning: Minnesblock: i  Cacheblock: j = i % K Minnesblocket i avbildas på Cacheblocket j tills Cache-minnet tar slut – då börjar det om från Cache-minnets början. Två Minnesblock som avbildas på samma Cache-block kan inte användas samtidigt – det ena ”knuffar ut” det andra. William Sandqvist

11 William Sandqvist william@kth.se
Hitrate och accesstid a) tAVG = 8 ns h = ? h är hitrate. b) tAVG = 15 ns h = ? c) tAVG = 6 ns h = ? William Sandqvist

12 Beräkningar av hitrate
tAVG 8, 15, 6 ns William Sandqvist

13 William Sandqvist william@kth.se
En bokföringsuppgift #include <stdio.h> int Oskar[16]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; int Lotta[16]={16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1}; int Totalt[16]; int main(void) { int i; printf("Oskar\tLotta\tTotalt\n"); for(i = 0; i<16 ; i++) Totalt[i] = Oskar[i] + Lotta[i]; printf("%d\t%d\t%d\n", Oskar[i], Lotta[i], Totalt[i]); } system("PAUSE"); return 0; Hur excel använder minnet är hemligt – så vi får studera ett C-program i stället. William Sandqvist

14 Bokföringsuppgiften i datorminnet
Hur stor plats for-loopen tar ser man genom att studera assemblerkoden! Var data hamnar i minnet ser man med hjälp av adressoperatorn & Level1 Cache. Processorer har ofta två små inbyggda cacheminnen på chippet, en I-cache för kod och en D-cache för data. Detta inbyggda minne är lika snabbt som processorns egna register. Hur stora Cacheminnen behöver man till detta program? William Sandqvist

15 William Sandqvist william@kth.se
L1 I-cache 16 ord Utan Cache läses minnet ord för ord med accesstiden 3. Instruktionerna till for-loopens 16 varv tar då 16*20*3 = 960 busscykler att läsa in. Antag att instruktionsöverföringen till I-cachen sker med block om fyra ord (1 ord = 1 instruktion) med accessmönstret (medeltalet 1,5). Antag att Cacheminnet är 16 ord stort. for-loopen som är 20 ord lång får då inte plats i sin helhet. När det 4:e blocket lästs in i cachen är den full. Det 5:e blocket kommer att skriva över loopens början i cachen. Från början är Cacheminnet tomt och då läses ett block med 4 instruk-tioner in. Det första ordet i blocket är den Cache-miss som orsakade inläsningen, men de tre extra orden kommer att vara önskade instruktioner. Träffbilden skrives MTTT, dvs. 75% Hitrate eller 25% Missrate. Denna Hitrate fortsätter därefter under hela for-loopkörningen. Med 16 ord Cache tar instruktionerna till for-loopens16 varv 16*20*0,25*1,5 = 120 busscykler att läsa in. William Sandqvist

16 William Sandqvist william@kth.se
L1 I-Cache 32 ord Antag nu att vi kostar på oss ett större Cache-minne om 32 ord. Hela for-loopens 20 instruktioner ryms i detta minne. Första varvet får vi träffbilden MTTT (Missrate 0,25), men därefter finns sedan alla instruk-tioner på plats i det snabba cache-minnet och träffbilden blir TTTT (Missrate 0,0). Med 32 ord Cache tar inläsningen av instruktionerna till for-loopens 16 varv (1*0, *0,0)*20*1,5 = 8 busscykler! Viktigast vid dimensionering av I-Cachens storlek är tydligen att den är större än den största typiska loop som programmet använder. För en ”general purpose”-processor kan man inte påverka vilka program som körs – då gäller det bara att I-Cachen ska vara så stor som möjligt! William Sandqvist

17 William Sandqvist william@kth.se
L1 D-Cache 16 ord Antag att dataöverföringen till D-cachen sker med block om fyra ord (1 ord = 1 int) med accessmönstret (medeltalet 1,5). Det är olyckligt med en 16 ords D-cache till detta program. De tre arrayer-na är vardera på 16 ord och ligger i en följd efter varandra i minnet. Motsvarande element Oskar[i] Lotta[i] och Totalt[i] mappas till samma ord i Cache-minnet. De är ömsesidigt ”utknuffande” när vi gör operationen Totalt[i] = Oskar[i]+Lotta[i] i loopen! När vi läser in ett block om fyra ord så kommer de tre extra orden att senare bli utknuffade av andra block innan de hinner komma till nytta! Träffbilden blir MMMM ! När vi accessar de nödvändiga = 48 orden tar vi också in 3*48 onödiga ord. Totalt 4*48*1,5 = 288 busscykler. William Sandqvist

18 William Sandqvist william@kth.se
L1 D-Cache 32 ord Även en 32 ords D-Cache är ett olyckligt val till detta program. Oskar[i] och Totalt[i] mappas till samma block och kommer därför att knuffa ut varandra varje varv i loopen. Lotta[i] mappas på egna block i cachen och förblir därför orörd mellan varven. Oskar och Totalt accessar de nödvändiga = 32 orden till-sammans med 3*32 onödiga ord. Lotta accessar 4 ord åt gången, 16/4 = 4 accesser för de nödvändiga 16 orden. (32+3*32+4)*1,5 = 198 busscykler William Sandqvist

19 William Sandqvist william@kth.se
L1 D-Cache 64 ord Med ett 64 ords D-Cacheminne cachas de tre arrayerna i helt egna block. Totat[i] = Oskar[i] + Lotta[i] kan beräknas utan att något block knuffas ut. 16/4+16/4+16/4 accesser behövs för de orden. Inga av extraorden i blocken är onödiga! 3*16/4*1,5 = 18 busscykler. Man skulle även kunna vinna på att använda blockstorleken 8. 3*16/8*1,25 = 8 busscykler William Sandqvist

20 L1 D-Cache 16 ord associativt
Ett annat sätt att konfigurera ett litet cacheminne är att dela upp det i olika set. Ett block kan lagras i vilket set som helst. Sannolikheten att det ska behöva knuffa ut ett annat användbart block minskar därmed. Speciell snabb ”associativ” logik behövs för att styra dataordet från rätt set till processorn. Cacheminnet kallas för associativt. Trots att D-Cacheminnet är så litet som 16 ord tar data-accesserna 3*16/4*1,5 = 18 busscykler. William Sandqvist

21 William Sandqvist william@kth.se
Lura kompilatorn! int Oskar[20]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}; int Lotta[20]={16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1}; int Totalt[16]; Genom att dimensionera arrayerna Oskar och Lotta med 4 extra element (som man inte tänker utnyttja!) förskjuts arrayerna i minnet så att adressavbildningen mappas till nya block. Om dom knuffade ut varandra tidigare så kan dom ju inte knuffa ut varandra nu! Även ett så litet D-Cacheminne som 16 ord klarar på detta sätt data-accesserna på 3*16/4*1,5 = 18 busscykler. Fråga: Hur skulle det gå om blockstorleken 8 användes till 16 ords cachen? William Sandqvist

22 William Sandqvist william@kth.se
Sammanfattning Den som arbetar med ”inbyggnadsprocessorer” kan påverka den kod processorn kommer att köra. Då kan även mycket små Cache-minnen göra stor nytta – liksom felaktigt dimensionerade Cache-minnen kan göra stor skada. När det gäller ”general-purpose”-processorer så vet ingen vilken kod som kommer att köras – då är det bara Cache-storleken och associativiteten som räknas. William Sandqvist

23 William Sandqvist william@kth.se
L1 L2 L3 Cache Intel Itanium har stora associativa Cacheminnen i tre nivåer … William Sandqvist