minnesteknologier n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Minnesteknologier PowerPoint Presentation
Download Presentation
Minnesteknologier

Loading in 2 Seconds...

play fullscreen
1 / 23

Minnesteknologier - PowerPoint PPT Presentation


  • 112 Views
  • Uploaded on

Minnesteknologier. Snabba minnen är dyra och billiga minnen är slöa!. Principiella siffror. 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!.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Minnesteknologier' - conor


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
minnesteknologier
Minnesteknologier

Snabba minnen är dyra och billiga minnen är slöa!

Principiella siffror.

William Sandqvist william@kth.se

processor memory performance gap
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

minneshierarki
Minneshierarki

En tre nivåers minneshierarki. De snabbare minnestyperna används som ”buffertar” mot de långsammare.

Principbild

William Sandqvist william@kth.se

slide4
SRAM

Varje bit i ett CMOS SRAM består av en låskrets uppbyggd av sex MOS-transistorer.

William Sandqvist william@kth.se

slide5
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

kondensatorn byggs p djupet
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

burst skur
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

burst ger snabbare medelaccess
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

cacheminnet
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

cache adressavbildning
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

hitrate och accesstid
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

ber kningar av hitrate
Beräkningar av hitrate

tAVG 8, 15, 6 ns

William Sandqvist william@kth.se

en bokf ringsuppgift
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

bokf ringsuppgiften i datorminnet
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

l1 i cache 16 ord
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

l1 i cache 32 ord
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

l1 d cache 16 ord
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

l1 d cache 32 ord
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

l1 d cache 64 ord
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

l1 d cache 16 ord associativt
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

lura kompilatorn
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

sammanfattning
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

l1 l2 l3 cache
L1 L2 L3 Cache

Intel Itanium har storaassociativa Cacheminnen i tre nivåer …

William Sandqvist william@kth.se