Minnesteknologier

1. Minnesteknologier Snabba minnen är dyra och billiga minnen är slöa! Principiella siffror. William Sandqvist william@kth.se

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 william@kth.se

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

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

5. 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 william@kth.se

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

7. 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 william@kth.se

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 3+1+1+1 busscykler, 6/4 = 1,5TBus/ord • Att hämta en ”Burst” med 8 ord tar 3+1+1+1+1+1+1+1 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. 5+3+3+3 osv. TBUS = 10*TCPU är valt som exempel. William Sandqvist william@kth.se

9. 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 heltCache-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 … TidslokalitetEn minnescell som blivit accessad nyligen kan bli accessad snart igen. RumslokalitetDe minnesceller som har adresser nära en som nyligen accessats har stor chans att bli accessade. William Sandqvist william@kth.se

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 william@kth.se

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

12. Beräkningar av hitrate tAVG 8, 15, 6 ns William Sandqvist william@kth.se

13. 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"); return0; } Hur excel använder minnet är hemligt – så vi får studera ett C-program i stället. William Sandqvist william@kth.se

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 william@kth.se

15. 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 3+1+1+1 (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 william@kth.se

16. 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,25 + 15*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 william@kth.se

17. 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 3+1+1+1 (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 16+16+16 = 48 orden tar vi också in 3*48 onödiga ord. Totalt 4*48*1,5 = 288 busscykler. William Sandqvist william@kth.se

18. 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 16+16 = 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 william@kth.se

19. 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 16+16+16 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 william@kth.se

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 william@kth.se

21. 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 william@kth.se

22. 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 william@kth.se

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