TSEA28 Datorteknik Y (och U)

Transkript

1 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U) Föreläsning Kent Palmkvist, ISY Praktiska kommentarer Laboration 4 tips Sorteringsalgoritm använder A > B i flödesschemat Exemplet på instruktion är BGE motsvarande A B Sorteringstävlingen deadline: Onsdag /5 kl :59. Jag ska kunna la design, ändra värden i PM adress E-FF, trycka på regs=, nollställ klockcykler, och sedan Kont. Sista maskinkodsinstruktionen ska vara HALT från :a delen av labben. TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Dagens föreläsning Latens/genomströmning Minnestyper Läsminne (ROM) Läs och skriv minnen (RAM) Cache Princip Exempel Praktiska kommentarer, forts. Vad säger flaggor vid subtraktion A-B? Subtraktion implementeras som A+(-B), dvs vänd tecken på B och lägg ihop. -B fås genom att vända alla bitar i B och lägga till i LSB (minnessiffra till höger) Z: om subtraktionen gav noll som svar, dvs A=B C: om subtraktionen gav carry ut, gäller positiva heltal N: differensen är negativ (om differensen kan representeras) O: spill (overflow) när svaret beräknades (för -komplementstal) Exempel (an 4-bitars tal => talområde -8 till +7), A-B = A+(-B) 6-4= 4-6=- -4-6=- 4-(-6)= -8-7=-5 7-(-8)=5 OBS: 5-bitar = -= = -4= = -6= 7= -7= 8= -8= C= C= C= C= C= C= = -= N= N= N= N= N= N= 5= -5= O= O= O= O= O= O= Notera O=N respektive O<>N

2 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Enkel RISC-baserad struktur Enkelt exempel från kursboken (avsnitt 7.) PC, registerfil och minne klockade Chapter 7 Handout från TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Pipelining: olika delar av flera instruktionener körs samtidigt Flera instruktionen hanteras parallellt Hämta instruktion, Läs operand,beräkna (ALU-operation), Minnesaccess, Skriv till registerfil Implementeras med klockade register mellan de olika enheterna Figuren lite missvisande: från vänster tidigare instruktioner, från höger senare instruktioner Chapter 7 Handout från TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Exekveringstid i exemplet Klockfrekvens begränsas av längsta väg från register till nästa register Instruktion LDR D,(S,#L) ; Läs minnescell som (S) +L pekar på t cycle = t pc + t Imem + t RF + t ALU + t Dmem + t MPLX + t RF Chapter 7 Handout från Pipelining är en möjlig lösning Pipelining tillåter högre klockfrekvens Ökar maximalt antal operationer per sekund Minskar INTE tid för en enskild operation att slutföras Databeroende mellan operationer begränsar hur användbar ökning av klockfrekvens är Villkorliga hopp behöver flaggorna satta innan hopp kan göras Behöver NOP (No-operations) läggas till mellan compare och villkorligt hopp? Tillåter flaggorna att beräknas innan villkorliga hoppet avgör om hopp ska tas

3 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Begrepp: latens, genomströmning Latens: Hur lång tid det tar att få utföra en komplett instruktion Genomströmning: Hur många instruktioner per sekund som kan utföras /Genomströmning = hur ofta en ny instruktion startas För pipelining: Latens > /Genomströmning latens /genomströmning Minnen (program och datamminne) Utvecklingen av läshastighet för minne går långsammare än för processorn Ca 5% bättre processorprestanda per år Ca % bättre minnesprestanda per år Större och större skillnad, processorn måste oftast vänta på minnet Olika hastighet och pris för olika minnen Finns många typer Chapter 7 Handout från TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Problem med högre klockfrekvenser Alla delar i datorn är inte lika snabba Register skickar fort ut värden på bussen ALU går olika fort beroende på operation Shift, AND, OR etc. går fort Add/sub går långsammare Multiplikation ännu långsammare Minnen är långsamma Större minnen långsammare än mindre Fysisk gräns: ljusets hastighet GHz motsvarar ps/klockcykel = cm (vakum!) Långsammare på chip pga material Minnesegenskaper Många olika egenskaper intressanta Processorns användning av minnesceller Kan värde skrivas in i minnesceller (read-write resp. read-only) Latens för läsning och skrivning Genomströmningshastighet för läsning och skrivning Försvinner värdena när strömmen slagits av (flyktiga) Tekniska/ekonomiska begränsningar Pris per bit i minnet Storlek på minnet Speciell hantering för att behålla värdet (dynamiska)

4 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Minnesegenskaper läs/skriv Enbart läsning (ROM, Read Only Memory) Processorn kan bara läsa, inte skriva till minnet Maskprogrammerade ROM Programmeras vid tillverkning, billigt i stora volymer PROM: Programmable Read Only Memory Skrivning kan göras gång, oftast i speciell programmeringsutrustning EPROM: Eraseable Programmable Read Only Memory Minnet kan raderas i speciell utrustning (T ex UV) och programmeras om EEPROM: Electrically Eraseable Programmable Read Only Memory Minnet kan raderas cell för cell eller block elektriskt, eventuellt utan speciell utrustning FLASH: Speciell typ av EEPROM Kan inte radera enstaka celler, utan stora block (kbyte eller Mbyte) raderas per gång. Långsamma att skriva. Minnesegenskaper flyktigt/icke flyktigt Flyktigt minne, förlorar informationen vid spänningsbortfall (engelsk term: volatile) Måste initieras/fyllas när strömmen slås på (t ex SRAM, DRAM) Icke-flyktiga minnen, behåller värde även om strömförsörjning tas bort T ex: ROM, EPROM, FLASH Måste finnas icke-flyktigt minne i en dator Annars vet maskinen inte vad som ska göras när strömmen slås på BIOS, bootsekvens, etc. Brukar vara av ROM typ FLASH vanligt (tillåter uppdatering av bootsekvens etc.) TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Minnesegenskaper läs/skriv, forts. Läs och skriv (RAM, Random Access Memory) Processorn kan skriva och läsa till varje cell i minnet Beroende på teknik kan värdet i minnet försvinna om man inte läser värdet inom viss tid SRAM: Statiskt RAM, värdet ligger kvar så länge strömmen är på DRAM: Dynamiskt RAM, värdet försvinner om inte det läses och skrivs tillbaks inom viss tid (- ms mellan varje läsning) Bygger på lagring av lning i en kondensator som sakta las ur Jämför skriva i sanden på en strand med vågor. Texten blir till slut oläslig om den inte skrivs om med jämna mellanrum SRAM mycket dyrare per minnescell och snabbare än DRAM Andra typer av minne På gång? Intel Optane (D Xpoint) Snabbt, icke-flyktigt, kompakt? Lagring av information som magnetisk egenskap Hårddisk, magnetiska media (dock inte som program och dataminne) Ferromagnetiska minnen (FE-RAM), icke-flyktigt utan behov att raderas Kärnminnen (gammal teknik) Seriella minnen: lång väntan på :a värdet, sedan ganska snabbt nästa värde i samma sekvens (gammal teknik) Bubbelminnen (magnetiska öar skiftas runt i en enhet) Kvicksilverminnen (ljudvågor skickas genom kvicksilverränna) Kassettband, tape

5 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Sammanfattande minneshierarki (data och programminne) RAM Läs och skrivbara, Flyktiga, snabba, ganska dyra SRAM snabbast, dyrast DRAM långsammare, mer komplicerad, billigare ROM Endast läsning, icke-flyktiga, snabba, varierande pris FLASH är snabba, ganska billiga, och omprogrammerbara Sekundärminnen Hårddiskar (mekaniska, SSD), flash-minnen Tape, molntjänster Uppdatering av cacheminnet Kan hanteras manuellt/programmeringsmässigt Görs mha operativsystem när det gäller hårddisk primärminne primärminnet fungerar som cacheminne för hårddisk Vill automatisera kopiering Processor anger adress att läsa eller skriva (liten snabbt minne) svarar med data om kopia från långsamma minnet finns i cacheminnet Långsamma minnet läses om data inte finns i cacheminnet, kopia sparas i cacheminnet t behöver komma ihåg vilken adress i primärminnet varje minnescell är en kopia av Processor Cache- Minne Primär- Minne TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Snabbare minnesaccess Använd ett litet snabbt minne (cacheminne) Ungefär lika snabbt som resten av processorn Slipper vänta på läsning/skrivning till lilla minnet När cacheminnet fullt/saknar data skickas data till/från långsammare billigare minne (primärminnet). Behöver inte spara mellanvärden Skriver endast slutresultatet till primärminnet Gör inte så mycket om primärminnets latens är stor Jfr program på en hårddisk Processor Cache- Minne Primär- Minne ts funktion Vanliga program har lokalitet Programmet läser och skriver data i vissa delar av minnet De delar av minnet som inte används behöver inte kopieras till cacheminnet Samma adresser läses ofta flera gånger Dela upp primärminnet i små block (cachelines) Hantera blocket som en enhet Läs alla eller skriv alla värden i ett block Block överlappar aldrig varandra Block startar på adress i primärminnet med alla bytepositionsbitar i adressen = x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x index st st st Adress från processor 4.. t Byteposition i cacheline (om 6 byte lång)

6 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist ts struktur Multipla cachelinjer (cachelines) Innehåller kopia av block från primärminnet Varje cachelinje i cacheminnet består av (kopia av primärminnet) Vanlig storlek 6 eller bytes (8 eller 56 bit per cacheline) Märkarea () anger adressen till kopians orginal i primärminnet Statusbitar (st). Giltigt innehåll i dataarea, ändrad data etc. index st st st x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x Adress från processor 4.. t Byteposition i cacheline (om 6 byte lång) Exempel utan datacache Räkna samman antal klockcykler som krävs för alla instruktioner. Normal instruktion Sammanlagt:. Normal instruktion Sammanlagt: klockcykler. Normal instruktion Sammanlagt: klockcykler TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Exempel på fördel med datacache Enkelt exempel Program: Summera 6-bitars -komplementtal An minnesaccess till primärminne tar 5 klockcykler An cacheminnet läses på Instruktionerna ligger redan i t x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x Hela programmet läses in till cacheminnet när :a instruktionen ska startas Exempel utan datacache, forts. Räkna samman antal klockcykler som krävs för alla instruktioner (steg 4 till 6) 4. Läsning I primärminnet Adress x5 5 klockcykler Sammanlagt: 5 klockcykler 5. Normal instruktion Sammanlagt: 54 klockcykler 6. Normal instruktion Sammanlagt: 55 klockcykler

7 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Exempel utan datacache, forts. Räkna samman antal klockcykler som krävs för alla instruktioner (steg 7 till 9) 7. Normal instruktion Sammanlagt: 56 klockcykler 8. Läsning i primärminnet Adress x5 5 klockcykler Sammanlagt: 6 klockcykler 9. Normal instruktion Sammanlagt: 7 klockcykler Exempel med datacache Anande om cacheegenskaper Cacheline 6 bytes lång Cache är 496 bytes stor 496/6 = 56 cachelines i cacheminnet Fullt associativt Vilken ress som helst kan ligga i varje cacheline Address från processorn bitar lång Tag måste vara -4 = 8 bitar index status Adress från processor 4.. dataarea Byteposition i dataarea tom x x x x tom x x x x tom x x x x tom x x x x TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Exempel utan datacache, totalt Fortsätt med alla 5 itionerna Totalt +5*4 instruktioner utförs instruktioner Varje instruktion tar att hämta om ingen dataminnesaccess Totalt 5 dataminnesläsningar Dessa instruktioner tar 5 klockcykler var Totalt antal klockcykler (utan cache för data) *+5(*+*5) = 65 klockcykler Exempel med datacache, forts. Räkna samman antal klockcykler som krävs för alla instruktioner (steg - precis som förra gången). Normal instruktion Sammanlagt:. Normal instruktion Sammanlagt: klockcykler. Normal instruktion Sammanlagt: klockcykler

8 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Exempel med datacache, forts. Räkna samman antal klockcykler som krävs för alla instruktioner (steg 4) 4. Läsning I primärminnet Finns den I cacheminnet? Exempel med datacache, forts. 5. Normal instruktion Sammanlagt: 54 klockcykler 6. Normal instruktion Sammanlagt: 55 klockcykler index status valid tom x5 x 7. Normal instruktion Sammanlagt: 56 klockcykler dataarea x4 x5678 xabcd x x x tom x x x x tom x x x x TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Exempel med datacache, forts. Läsning ress x5 Finns inte i cacheminnet Kräver läsning av primärminnet, 5 klockcykler Kopia läggs i cache (inklusive efterföljande 5 byte) Tag är ress minus bitar som indexerar i dataarean 4 sista bitarna väljer byte i dataarea index status dataarea valid x5 x4 x5678 xabcd tom x x x x tom x x x x tom x x x x x5 x5 x5 x4 x5678 xabcd xbeef xbeef xbeef x x x 4. Cachemiss, 5 klockcykler Sammanlagt: 5 klockcykler Exempel med datacache, forts. Läsning ress x5 Finns i cacheminnet Kräver ingen läsning av primärminnet Kostnad 4 lägsta bitarna väljer byte i cacheline () index status dataarea valid x5 x4 x5678 xabcd tom x x x x tom x x x x tom x x x x x5 x5 x5 x4 x5678 xabcd xbeef xbeef xbeef x x x 8. Cacheträff, klockcykler Sammanlagt: 57 klockcykler

9 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Exempel med datacache, forts. Cacheträffar fås för resser x54 - x5e Kräver ingen läsning av primärminnet Sammanlagt *+*5+7*+8* = 84 klockcykler Ny cachemiss för läsning av adress x5 Läs 6 bytes med start från adress x5 till dataarea rad i cache Uppdatera till ress (borträknat 4 LSB-bitar) Tar 5 klockcykler index status dataarea valid x5 x4 x5678 xabcd valid x5 xbeef xbeef xbeef tom x x x x tom x x x x x5 x5 x5 x4 x5678 xabcd xbeef xbeef xbeef x x x 6. Cacheträff, klockcykler Sammanlagt: 4 klockcykler Viktig kommentar ang. ordlängder I exemplet råkar bytepositionen i cacheline vara 4 bitar lång Stämmer bra med antal bitar i en hexadecimal siffra Valt för att lättare se hur och minnesadress hänger ihop Kan vara andra värden! Ex: 5 bitar byteposition ( byte/cacheline) Tänk binär representation! x54 = Adressen x54 delas då upp: Tag: = = x8 Byteposition: = x4 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Exempel med datacache, totalt Efter instruktioner (samma som tidigare) 7 cachemissar (7*6 = byte = 56 ord) Sammanlagt *+5**+(5-7)*+7*5 = 546 klockcykler Jämför utan cache: 65 klockcykler Cache ger 5 gånger snabbare exekvering! Mer komplicerat exempel Summera värden två vektorer placerade på ress x5 och x6, placera svar i vektor på ress x6 Vektorlängd: 5, elementstorlek halvord ( byte) Ungefärligt program mov r,#x5 mov r,#x6 r,[r,r] r4,[r,r] r4,r4,r strh r4,[r,r] r,r,# cmp r,#5 x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x x6 x x x5 x6 xffff xffff xffff dataarea tom tom tom tom 4 tom

10 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Mer komplicerat exempel, forts. Första minnesåtkomst, cachemiss på adress x5 La in adress x5 till första lediga cacheline (index ) Läs 6 byte till dataarea x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x x6 x x x5 x6 xffff xffff xffff Sätt till adress förutom de sista 4 bitarna dataarea r,[r,r] valid x5 x4 x5678 xabcd r4,[r,r] tom r4,r4,r strh r4,[r,r] tom r,r,# tom cmp r,#5 4 tom Mer komplicerat exempel, forts. Tredje minnesåtkomst, skrivning på adress x6 Ingen cachemiss (uppdatera inte primärminnet) cachemissar totalt Spara nya datat till motsvarande plats i cacheminnet x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x x6 x x x5 x6 xffff xffff xffff Värdet i d = x4+x4=x5555, indikera ändrat värde i cacheline (dirty) Index, :a ordet i dataarean (byte och ) dataarea r,[r,r] valid x5 x4 x5678 xabcd r4,[r,r] dirty x6 x5555 x x r4,r4,r strh r4,[r,r] tom r,r,# tom cmp r,#5 4 tom TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Mer komplicerat exempel, forts. Andra minnesåtkomst, cachemiss på adress x6 cachemissar totalt La in adress x6 till första lediga cacheline (index ) Läs 6 byte till dataarea Sätt till adress förutom de sista 4 bitarna strh cmp bne r,[r,r] r4,[r,r] r4,r4,r r4,[r,r] r,r,# r,#5 loop dataarea x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x x6 x x x5 x6 xffff xffff xffff valid x5 x4 x5678 xabcd valid x6 x4 x x tom tom 4 tom Mer komplicerat exempel, forts. Fjärde minnesåtkomst, läsning på adress x5 Cacheträff, data finns i cache index, :a ordet cachemissar totalt Femte minnesåtkomst, läsning på adress x6 Cacheträff, data finns i cache index, :a ordet cachemissar totalt strh cmp bne r,[r,r] r4,[r,r] r4,r4,r r4,[r,r] r,r,# r,#5 loop dataarea x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x x6 x x x5 x6 xffff xffff xffff valid x5 x4 x5678 xabcd dirty x6 x5555 x x tom tom 4 tom

11 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Mer komplicerat exempel, forts. Sjätte minnesåtkomst, skrivning på adress x6 x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x Cacheträff, data skrivs till index, :e ordet x6 x4 x x cachemissar totalt x6 x x x5 Inga cachemissar för adresser till och med x5e respektive x6e x6 xffff xffff xffff cachemissar totalt dataarea r,[r,r] valid x5 x4 x5678 xabcd r4,[r,r] r4,r4,r dirty x6 x5555 x6789 xabce strh r4,[r,r] tom r,r,# tom cmp r,#5 4 tom Mer komplicerat exempel, forts. Fortsätter tills alla 5 halvord lästs från adress x5-x564 respektive x6- x664 x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x Totalt 4 cachemissar x6 x4 x x x6 x x x5 Alla skrivningar hamnar i cache x6 xffff xffff xffff Vid någon senare tidpunkt töms cacheline och skrivs till primärminnet T ex pga full cache eller speciell signal från processorn dataarea r,[r,r] valid x5 x4 x5678 xabcd r4,[r,r] r4,r4,r dirty x6 x5555 x6789 xabce strh r4,[r,r] valid x5 xbeef xbeef xbeef r,r,# dirty x6 xcfef xbeef xbef cmp r,#5 4 valid x5 x x x TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Mer komplicerat exempel, forts. 4:e minnesåtkomsten, Cachemiss på adress x5 cachemissar totalt La in adress x5 till första lediga cacheline (index ) Läs 6 byte till dataarea Sätt till adress förutom de sista 4 bitarna strh cmp bne r,[r,r] r4,[r,r] r4,r4,r r4,[r,r] r,r,# r,#5 loop dataarea x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x x6 x x x5 x6 xffff xffff xffff valid x5 x4 x5678 xabcd dirty x6 x5555 x6789 xabce valid x5 xbeef xbeef xbeef tom 4 tom Fullt associativ cachestruktur Fördel Enkel att använda (och förstå?) Alla cachelines kan placeras var som helst i cacheminnet Nackdel Dyr Använder hela cacheminnet Varje cacheline innehåller jämförelsehårdvara för att jämföra och adressens -del Tag är lång (antal bitar i adress 4 i exemplet ovan) Långsam Resultat från alla jämförelser ska samlas ihop innan beslut om cache-hit eller cachemiss index st st st Adress från processor 4.. Byteposition i cacheline

12 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Direktresserad cache Varje cacheline från minnet kan bara placeras på en plats i cache Cache < Minne => flera olika minnesadresser placeras på samma plats i cache Del av adressen används för att bestämma index till cache Resten adressen sparas i för att ange vilken minnesline som finns i cache Endast en jämförelse per minnesaccess: Addressens högsta bitar jämfört med lagrad Enklare implementera, kan använda vanliga minnen jämförare för hela cache istället för jämförare för varje cacheline index st st st Adress från processor index Byteposition i cacheline Direktresserad cache, exempel Minnesåtkomst, cachemiss på adress x5. Endast index får lagra data från adress x5 (indexbitar i adress = ) x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x x6 x x x5 Läs 6 byte från adress x5, sätt till resten av bitarna i adress (bit till ) x6 xffff xffff xffff dataarea r,[r,r] valid x5 x4 x5678 xabcd r4,[r,r] r4,r4,r tom strh r4,[r,r] tom r,r,# tom cmp r,#5 4 tom TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Direktresserad cache, exempel Samma uppgift som tidigare bitar adress bitar indikerar vilket minnesblock data kommer ifrån 8 bitar index för att välja cacheline i cacheminnet 4 MB minne, 6 byte/cacheline => 56 cacheline 4 bitar indexering inom dataarean i varje cacheline strh cmp bne 6 byte per cacheline (dataarea) r,[r,r] r4,[r,r] r4,r4,r r4,[r,r] r,r,# r,#5 loop dataarea x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x x6 x x x5 x6 xffff xffff xffff tom tom tom tom 4 tom Direktresserad cache, exempel Minnesåtkomst, läsning på adress x6. Endast index får lagra data från adress x6 (indexbitar i adress = ) x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x Adress har = x6, cacheminne har = x5 => cachemiss! x6 x4 x x Måste ersätta innehåll i cacheline index x6 x x x5 Läs 6 byte från adress x6, sätt till x6 xffff xffff xffff resten av bitarna i adress (bit till ) Totalt cachemissar dataarea r,[r,r] valid x6 x4 x x r4,[r,r] r4,r4,r tom strh r4,[r,r] tom r,r,# tom cmp r,#5 4 tom

13 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Direktresserad cache, exempel Minnesåtkomst, skrivning på adress x6. strh cmp bne Adress har = x6, cacheminne har = x6 => cacheträff Markera data ändrat (dirty) Totalt cachemissar r,[r,r] r4,[r,r] r4,r4,r r4,[r,r] r,r,# r,#5 loop dataarea x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x x6 x x x5 x6 xffff xffff xffff dirty x6 x5555 x x tom tom tom 4 tom Direktresserad cache, exempel Minnesåtkomst 5, läsning på adress x6. Adress har = x6, cacheminne har = x5 => cachemiss! Totalt 4 cachemissar Varje läsning ger cachemiss i detta exempel Totalt cachemissar kommer ske x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x x6 x x x5 x6 xffff xffff xffff Kunde lösts om annan adress använts för en av vektorerna T ex x54 instället för x5 dataarea valid x6 x5555 x x tom strh r4,[r,r] tom r,r,# tom 4 tom cmp r,[r,r] r,#5 bne r4,[r,r] loop r4,r4,r TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Direktresserad cache, exempel Minnesåtkomst 4, läsning på adress x5. Adress har = x5, cacheminne har = x6 => cachemiss! x5 x4 x5678 xabcd x5 xbeef xbeef xbeef x5 x x x x6 x4 x x Behöver ersätta innehåll på index i cache x6 x x x5 x6 xffff xffff xffff Dirty flaggan satt, skriv först data till primärminne (alla 6 byte) Totalt cachemissar dataarea r,[r,r] valid x5 x4 x5678 xabcd r4,[r,r] r4,r4,r tom strh r4,[r,r] tom r,r,# tom cmp r,#5 4 tom Gruppassociativ cache en kompromiss Låt varje adress i primärminnet Adress från processor kunna placeras på flera ställen i cache index Byteposition Exempel i cacheline I en fyrvägsassociativ cache kan en viss adress i primärminnet placeras i en av fyra cachelines I princip 4 direktadresserade cache placerade bredvid varandra, kräver 4 jämförelser per åtkomst i cache I exemplet ovan skulle öka i längd index bitar till, 6 bitar för index till cacheline, 4 bitar för byteposition i cacheline st st st st st st st st st st st st index

14 TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Skrivning till cache, alternativ Writeback Skrivningar sker bara till cache Flagga indikerar om data måste skrivas till primärminne när cacheline töms Writethrough Skrivningar går alltid till primärminnet Kopia av värdet lagras också i cache Enklare att implementera, mindre effektivt Val av cache parametrar Associativitet Vanligen till 8 idag Störst vinst när man går från direktmappad till -vägs associativ cache Högre associativitet betalar sig dåligt Vanligt ha separat data och instruktionscache Kallad nivå cache Multipla nivåer av cache möjliga T ex AMD multiprocessorer: Nivå, nivå, nivå cache innan primärminnet nås TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist TSEA8 Datorteknik Y (och U), föreläsning, Kent Palmkvist Val av cacheline att ersätta, alternativ LRU Least recently used Håll reda på vilken cacheline som inte använts på länge Dyrt att hålla reda på vilken som senast använts Random Slumpmässigt val. Billigare, dock större risk ta fel Round-Robin/FIFO etc. Kasta ut den cacheline som varit i cachen längst, oberoende om den använts nyligen Problem orsakade av cache Data från I/O Läsning av t ex statussignaler får inte lagras i cache (missar ändringar från externa signaler) Skrivning i rätt ordning? Cache-koherens Om primärminnet kan skrivas från flera enheter (Multiprocessor) måste allas cache få reda på ändringen Notering: variabler i C gande med volatile kommer inte undan problemet med cache-koherens Behöver få hårdvara och/eller mjukvara hantera tömning av cache i vissa fall

15