Lehrveranstaltung: PR Rechnerorganisation Blatt 10. Thomas Aichholzer

Transkript

1 Aufgabe 10.1 Gegeben sei folgendes Code-Fragment, das zwei geschachtelte Schleifen implementiert: addi $t0, $a0, 100 outer: addi $t1, $a1, 200 inner: lw $t4, 0($t0) lw $t5, 0($t1) add $t2, $t0, $t1 add $t2, $t2, $a2 slt $t6, $t4, $t5 addi $t1, $t1, -1 sw $t6, 0($t2) bne $t1, $a1, inner addi $t0, $t0, -1 bne $t0, $a0, outer a. Wie viele Taktzyklen benötigt dieses Code-Fragment bei der Ausführung in der Beispiel- Pipeline (siehe Folie 4-36), wenn weder Delayed Branching noch Branch Prediction implementiert sind? b. Wie viele Taktzyklen werden benötigt, wenn eine 1-Bit Branch History Tabelle (BHT) implementiert ist?? c. Wie viele Taktzyklen werden benötigt, wenn eine 2-Bit BHT gemäß Folie 4-29 der Vorlesung implementiert ist? Quellcodeanalyse und Datenabhängigkeiten: addi $t0, $a0, 100 # t0 = a outer: addi $t1, $a1, 200 # t1 = a inner: lw $t4, 0($t0) # t4 = MEM[t0] lw $t5, 0($t1) # t5 = MEM[t1] add $t2, $t0, $t1 # (t2 = t0 + t1) add $t2, $t2, $a2 # t2 = t0 + t1 + a2 slt $t6, $t4, $t5 # t4 < t5? t6 = 1 : t6 = 0 addi $t1, $t1, -1 # t1 -= 1 sw $t6, 0($t2) # MEM[t2] = t6 bne $t1, $a1, inner # goto inner if( t1 a1) addi $t0, $t0, -1 # t0 -= 1 bne $t0, $a0, outer # goto outer if( t0 a0) Es treten keine Datenabhängigkeiten zwischen den einzelnen Befehlen auf die Stalls verursachen würden. (Ausnahme Branch Operationen) ad a) 1 Stall 1 Stall Wartezeiten zwischen Abhängigkeiten (Stalls) Integer OP Integer OP 0 Load Integer Integer OP 1 Branch 1 siehe Vorlesungsunterlagen (4-36) Wenn keine Branch Prediction sonstige Techniken zur Control Hazard Vermeidung eingesetzt werden benötigt die inner Schleife pro Schleifenzyklus 9 Takte. Diese Schleife wird 200 abgearbeitet, daher werden Takte benötigt (200 9). Seite 1

2 Die äußere Schleife (outer) wird 100 durchgeführt und eine Schleifeniteration benötigt die Anzahl der Takte für die inner Schleife plus die 3 Takte für weiteren 3 Befehle der Schleife, sowie einen zusätzlichen Stall Takt der durch den Branch (Not Equal) entsteht. Das bedeutet die äußere Schleife benötigt ( ) 100 = Takte. Die Initialisierung am Anfang für Register $t0 benötigt auch noch einen Takt, und somit benötigt das gesamte Codefragment Taktzyklen. ad b) Nun wird eine 1 Bit Branch History Tabelle angelegt um bedingte Sprünge vorherzusagen. Es wird hierbei der alte Programmzähler (PC) gespeichert. Um das ganze einfacher zu handhaben spricht man von 2 Zuständen: Branch Taken bzw. Branch Not Taken. Bei Start eines Codefragmentes wird auf einen Defaultwert zurück gegriffen, der hier günstigerweise als Branch Taken definiert werden kann. Sollte die Prediction (Sprungvorhersage) falsch sein, wird der nachfolgende Befehl in der Pipeline ungültig gemacht und die Branch History Tabelle überschrieben (bei Taken auf Branch Not Taken). Um sich eine solche Berechnung leicht durchzuführen kann folgende Notation verwendet werden: Outerschleife (100) Daher ergibt sich für die äußere Schleife eine Anzahl von Taktzyklen von: = ( 1) = = Schließlich wird noch der Initialisierungsschritt dazugezählt, was bedeutet, dass das gesamte Codefragment Taktzyklen benötigt. ad c) ( ) + 3 = 1604 Ausdruck in der Klammer ist Anzahl der Taktzyklen der inneren Schleife Default: Branch Taken Innerschleife (200) ( ) + 3 = Bild ( ) = 1606 Takte pro Schleifendurchlauf durch 1 Bit BHT Nun wird eine 2 Bit Branch History Tabelle verwendet. Dies bedeutet, das es zum Vergleich zu der 1 Bit Branch History Tabelle 2 weitere Zustände gibt Stärkeres Branch Taken Branch Taken Branch Not Taken Branch Taken Bild Seite 2 Branch Not Taken Stärkeres Branch Not Taken

3 Dieser Zustandsgraph hat 4 Zustände. Die 4 Zustände speichern jeweils ein Branch Taken bzw. Branch Not Taken. Die Übergänge (grün für Branch Taken, rot für Branch Not Taken) kennzeichnen was passiert, wenn ein Branch ausgeführt wird. Befindet sich der Graph im linken oberen Bild, so wird bei einem Branch Not Taken (roter Pfeil) in den Zustand links unten gewechselt. Der neue Zustand würde einen Branch Taken machen, jedoch bei einem weiteren Branch Not Taken auf den Zustand rechts unten übergehen und bei einem weiteren Branch Not Taken ausführen. Kurz gesagt gibt es zwei Zustände die, bei denen man grob sagen kann, ist man ein in einem der beiden, dann muss die Sprungbedingung 2 falsch vorgehgesagt werden, um die Sprungvorhersage zu ändern (stärkerer Zustand). Daher ergibt sich für unsere Notation mit Defaultzustand Branch Taken (in diesem Fall egal ob stärkerer oder schwächerer Zustand) folgendes Bild: Outerschleife (100) ( ) + 3 = 1604 Ausdruck in der Klammer ist Anzahl der Taktzyklen der inneren Schleife Default: Branch Taken Innerschleife (200) ( ) + 3 = Bild ( ) = 1606 Takte pro Schleifendurchlauf durch 1 Bit BHT Es ergibt sich hier für die äußere Schleife folgende Anzahl von Taktzyklen: = = Mit Initialisierungsschritt benötigt daher dieses Codefragment Taktzyklen. Bemerkung: Die Annahme des Defaulteintrages in der Branch History Tabelle kann willkürlich gewählt werden, muss aber dann für die Berechnung angeführt werden. In diesem Fall wurde als Defaulteintrag immer Branch Taken genommen. Es hätte auch Branch Not Taken genommen werden können, und für die 2 Bit BHT hätte auch eine Unterscheidung zwischen starken bzw. schwächeren Zustand des Branch Not Taken dann erfolgen müssen Seite 3

4 Aufgabe 10.2 Wenden Sie auf das folgende Code-Fragment die Methode des Software Pipelining an, um die Ausführungszeit auf der Beispiel-Pipeline zu verkürzen. Die Initialisierung der Register $t0, $f28 und $f30 ist nicht angeführt. Nehmen Sie an, dass die Hardware Branch Prediction implementiert. Codebeschreibung: loop: l.d $f0, 0($t0) # f0 = MEM[t0] add.d $f2, $f0, $f30 # f2 = f0 + f30 addi $t0, $t0, -8 # t0 -= 8 s.d $f2, 8($t0) # MEM[t0+8] = f2 # f28 += f2 bnez $t0, loop # goto loop if(t0 0) a. Wie viele Takte pro Ergebniselement werden für die Ausführung des gegebenen Code- Fragments in der Beispiel-Pipeline benötigt? b. Wie viele Takte pro Ergebniselement werden für die Ausführung des durch Software Pipelining optimierten Codes auf derselben Hardware benötigt? Datenabhängigkeiten: loop: l.d $f0, 0($t0) 1 Stall add.d $f2, $f0, $f30 addi $t0, $t0, -8 1 Stall s.d $f2, 8($t0) 3 Stall bnez $t0, loop ad a) Bei Verwendung einer Branch Prediction wird die Anzahl der Takte pro Ergebniselement ca. 8 Takte umfassen (6 Befehle + 2 Stalls). Bei hoher Anzahl von Schleifeniterationen wirkt sich ein Stall durch eine Fehlvorhersage kaum aus. ad b) Für Software Pipelining werden direkte Daten Abhängigkeiten die auftreten in der Pipeline umgeschichtet, sodass es keine Stalls zwischen den einzelnen Befehlen gibt. Durch umordnen des Codes erhält man folgendes Codefragment, welches sich in 3 Blöcke unterteilen lässt, die jeweils Datenabhängigkeiten zum Nachfolgerblock aufweisen: loop: l.d $f0, 0($t0) # Block #1 Abhängigkeit: $f0 add.d $f2, $f0, $f30 # Block #2 Abhängigkeit: $f2 s.d $f2, 0($t0) # Block #3 addi $t0, $t0, -8 bnez $t0, loop Wartezeiten zwischen Abhängigkeiten (Stalls) FP. ALU OP FP. ALU OP 3 FP. ALU OP Store FP. double 2 Load FP. double FP. ALU OP 1 Load FP. double Store FP. double 0 Branch 1 siehe Vorlesungsunterlagen (4-36) Seite 4

5 Diese 3 Blöcke werden nun in eine Software Pipeline verpackt: 1. Schleifendurchgang 2. Schleifendurchgang 3. Schleifendurchgang l.d $f0, 0($t0) Startup Code add.d $f2, $f0, $f30 l.d $f0, 0($t0) s.d $f2, 16($t0) add.d $f2, $f0, $f30 l.d $f0, 0($t0) s.d $f2, 16($t0) add.d $f2, $f0, $f30 s.d $f2, 16($t0) Tabelle Dies ist ein Ansatz wie man Software Pipelining machen könnte (siehe Tabelle ). Um eine solche Pipeline zum Laufen zu bringen benötigt man einen Startup Code (rot), sowie am Ende einen Widedown Code. Im diesen beiden Codeteilen können Stalls auftreten, jedoch innerhalb der Software Pipeline ist jede Pipelinestufe gefüllt (keine Stalls). Startup und Wide down Code 1 Stall Startup Code l.d $f0, 0($t0) add.d $f2, $f0, $f30 l.d $f0, -8($t0) 2 Stall Wide down Code s.d $f2, 0($t0) add.d $f2, $f0, $f30 s.d $f2, -8($t0) Offsets müssen dementsprechend korrigiert werden! (Startoffset beginnt bei 0) weitere Möglichkeit zur Software Pipeline zu gelangen 1. Pipelinestufe Um an eine Software Pipeline zu kommen muss zuerst die Anzahl der von einander abhängigen Blöcke ermittelt werden. In unserem Beispiel gibt es 3 Blöcke! Deshalb wird der Code 3 abgerollt und nach folgendem System in die Pipeline eingeordnet: Der erste Block in der Software Pipeline, ist der erste Block aus dem letzen Teil der abgerollten Schleife. Der zweite Block der Software Pipeline ist der 2. Block des vorletzten Teils der abgerollten Schleife, und so fort. Schließlich setzt sich der letzte Block der Software Pipeline aus dem letzten Block des ersten Teils der abgerollten Schleife zusammen. Seite 5

6 Folgende Tabelle veranschaulicht diesen Vorgang: 3 abgerollt l.d $f0, 0($t0) add.d $f2, $f0, $f30 s.d $f2, 0($t0) l.d $f0, -8($t0) add.d $f2, $f0, $f30 s.d $f2, -8($t0) l.d $f0, -16($t0) add.d $f2, $f0, $f30 s.d $f2, -16($t0) 1. Teil 2. Teil 3. Teil addi $t0, $t0, -24 # (-8) 4 bnez $t0, loop Tabelle Software Pipeline Startup Code s.d $f2, 0($t0) add.d $f2, $f0, $f30 l.d $f0, -16($t0) # Schleifenoverhead addi $t0, $t0, -8 bgti $t0, 16, loop Wide down Code Da keine Stalls innerhalb einer Software Pipeline auftreten, werden 6 Taktzyklen pro Ergebnis Element benötigt! Anmerkung: Da die Offsets innerhalb der Software Pipeline über eine größere Spanne (0-16) gehen muss die Branchbedingung geändert werden: bnez $t0, loop bgti $t0, 16, loop Pipeline Seite 6

7 Aufgabe 10.3 Gegeben sei eine Rechnerarchitektur mit 3 Speicherebenen laut untenstehender Tabelle, welche die durchschnittliche Hitrate und die Verzögerung im Fall eines erfolgreichen Zugriffs auf die jeweilige Speicherebene angibt. Der durchschnittliche CPI - Wert ohne Berücksichtigung der Speicherzugriffe betrage 1,2. Nehmen Sie an, dass im Schnitt 10 % aller Instruktionen auf den Speicher zugreifen. a. Berechnen Sie den durchschnittlichen CPI - Wert der vorgestellten Architektur mit Berücksichtigung der Speicherzugriffe. Wie viel Prozent seiner Ausführungszeit verschwendet der Prozessor mit Stalls? b. Um welchen Prozentsatz würde sich der CPI - Wert verbessern, wenn ein 3rd Level Cache mit einer Hitrate von 99 Prozent und 15 Taktzyklen Zugriffszeit eingeführt würde? ad a) Idealer CPI Wert ist laut Angabe 1,2. 10 % der Operationen sind Zugriffe auf den Speicher. Von diesen 10 % sind 94 % Zugriffe auf L1 Cache und kosten 2 Zyklen, daher ergibt sich: 0,1 0,94 2 = 0,188 Die restlichen 6 % der 10 % verteilen sich auf L2 Cache und Hauptspeicher. Wobei 94 % (von den 6% der 10%) in L2 Cache stattfinden und 4 Zyklen dafür benötigt. (0,1 0,06) 0,94 4 = 0,02256 Der Rest ist Zugriff auf den Hauptspeicher, kostet den Prozess 100 Zyklen: (0,1 0,06) 0, = 0,036 Tatsächlicher CPI Wert 1,2 + (0, , ,036) = 1,2 + 0,24656 = 1,44656 Prozentsatz der Verschwendung durch Stalls 0,24656 / 1,44656 = 0, ( ~ 17 %) ad b) Es wird ein L3 Cache eingefügt, daher ändert sich für die Berechnungen von L1 und L2 Caches nichts. Zugriffe auf den L3 Cache (99 %), kosten 15 Zyklen: (0,1 0,06) 0,06 0,99 15 = 0, Rest der Zugriffe geht auf den Hauptspeicher (Kosten: 100 Zyklen): (0,1 0,06) 0,06 0, = 0,00036 Tatsächlicher CPI Wert 1,2 + (0, , , ,00036) = 1,2 + 0, = 1, Verbesserung des CPI Wertes 1, , Speicher Hitrate [%] Delay in Clockcycles 1st Level Cache nd Level Cache 94 4 Hauptspeicher = 1, ~ 2 % besser Seite 7

8 Aufgabe 10.4 Die Rechnerarchitektur von Aufgabe 10.3 b) werde um eine weitere Speicherebene (Swap File auf Festplatte) laut untenstehender Tabelle erweitert. Wie verändert sich der CPI - Wert gegenüber 10.3 a) bzw. b)? CPI Straf Werte aus 10.3 übernommen: L1 Cache: 0,188 L2 Cache: 0,02256 L3 Cache: 0, Für Hauptspeicher müssen die Strafwerte neu berechnet werden, da sich bis L3 Cache nichts ändert. Zugriffe 99,5% aus der Wahrscheinlichkeit von 0,00036 % ( = 6 % 6 % 1 % 10 %). Diese Wahrscheinlichkeit ergibt sich aus dem Wahrscheinlichkeitsprodukt der einzelnen Wahrscheinlichkeiten in jedem übergeordneten Speicherlevel einen Cache Miss zu erzielen. (Cache Miss Rate = 1 Hitrate). Es ergibt sich daher ein durchschnittlicher (CPI) Strafwert (für eine Verzögerung von 100): (0,06 0,06 0,01 0,1) 0, = 0, Die restlichen 0,5 % Zugriffe der 0,00036 %, die als Misswahrscheinlichkeit auftreten könnte, geschieht auf dem Swap File, und kostet Zyklen: (0,06 0,06 0,01 0,1) 0, = 0,18 Tatsächlicher CPI Wert 1,2 + (0, , , , ,18) = 1,2 + 0, = 1, Verschlechterung zu 10 a) und 10 b) 10 a) hatte einen CPI von 1,44656 Verschlechterung: 1, = 1, ( ~ 10,3 %) 1, b) hatte einen CPI von 1, Speicher Hitrate [%] Delay in Clockcycles 1st Level Cache nd Level Cache rd Level Cache Hauptspeicher 99,5 100 Swap File , = 1, ( ~ 12,7 %) 1, Seite 8

9 Aufgabe 10.5 Gegeben sei folgendes C-Code-Fragment: int a[8]; int b[8]; int c; int i; c=0; for( i=0; i<8; i+=2) c=a[i]+b[6-i]; a. Berechnen Sie die Folge der Speicheradressen, die aufgrund von Datenzugriffen durch das gegebene Programmfragment generiert werden. Nehmen Sie an, dass c und i in Registern gehalten werden und nicht aus dem Speicher geladen werden. Nehmen Sie an, dass die Startadresse von a auf der Adresse 0 liegt, dass alle Variablen und Arrays in der angegebenen Reihenfolge aufsteigend und lückenlos im Speicher angelegt werden und in der Berechnung zuerst auf a und dann auf b zugegriffen wird. b. Nehmen Sie einen direkt abbildenden Cache (initial leer) mit 32 1-Wort-Blöcken an (1 Wort = 4 Bytes = 1 Integer). Kennzeichnen Sie jeden der Zugriffe als Hit oder Miss und geben Sie den Cache-Inhalt nach Ausführung des letzten Befehls an. (Dazu müssen Sie natürlich die durch den Referenzstrom entstehende Entwicklung des Cache-Inhaltes protokollieren.) c. wie a) für einen direkt abbildenden Cache gleicher Größe (32 Worte), aber 8-Wort- Blöcken. d. wie a) für einen vollassoziativen Cache gleicher Größe und 1-Wort-Blöcken. Nehmen Sie zusätzlich eine LRU - Ersetzungsstrategie für die Cache - Blöcke an. e. Wie c) für einen vollassoziativen Cache gleicher Größe und 8-Wort-Blöcken. f. Wie c)für einen 2-fach satz-assoziativen Cache gleicher Größe und 1-Wort-Blöcken. g. Wie c)für einen 2-fach satz-assoziativen Cache gleicher Größe und 4-Wort-Blöcken. ad a) Variable a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] RAM Adr ad b) Ablauf des C Codes: for( i=0; i<8; i+=2) c=a[i]+b[6-i]; i läuft von 0 bis 6 und zwar in 4 Schritten. Im ersten Schritt (i=0) wird auf a[0] und b[6] zugegriffen. Im zweiten Schritt (i=2) wird auf a[2] und b[4] zugegriffen. Im dritten Schritt (i=4) wird auf a[4] und b[2] zugegriffen. Im vierten Schritt (i=6) wird auf a[6] und b[0] zugegriffen. Wir verwenden einen Direct Mapped Cache mit 32 1-Wortblöcken: Seite 9

10 In jeden dieser Blöcke passt daher genau ein Wort (ein Integer z.b. a[i]). Daraus ergibt sich daher folgendes Abbild: Block Inhalt a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] Block Inhalt Blöcke 16 bis 31 werden daher gar nicht benötigt! Im ersten Schritt wird versucht a[0] aus dem Cache zuladen. Da der Cache kein a[0] enthält gibt es einen Cache Miss. a[0] wird daher in den Cache geladen. Das gleiche passiert mit b[6] im ersten Schritt. Der Prozessor sucht b[6] im Block 14 die Folge Cache Miss und b[6] muss in den Speicher geladen werden. Im zweiten bis vierten Schritt ändert sich hierbei nichts. Es gibt bei jedem Versuch auf den Cache benötigte Daten zu finden einen Cache Miss. Alle Daten müssen daher vom Hauptspeicher geholt werden. Die Missrate ist daher 100 % ad c) Wir verwenden einen Direct Mapped Cache mit gleicher Größe aber 8-Wortblöcken: Es gibt daher 4 Blöcke: In jeden dieser Blöcke passen daher genau 8 Worte (8 Integer z.b. a[0 7]). Block Inhalt a[0 7] b[0 7] Die Blöcke 2 und 3 werden nicht verwendet! Nun wird im ersten Schritt beim Zugriff auf a[0] wird ein Cache Miss verursacht und aus dem Hauptspeicher wird der Block 0 geladen mit den Elementen a[0] bis a[7]. Bei Zugriff auf b[6] wird ebenso ein Cache Miss verursacht. Darauf hin wird dieser ebenso in den Cache geladen. In den weiteren Schritten sieht das ganze System bereits besser aus, da die benötigten Blöcke bereits in den Caches vorhanden sind, und daher bei jedem Zugriff immer ein Cache Hit erfolgt. Es erfolgen 8 Zugriffe auf den Cache, davon sind die ersten 2 ein Cache Miss, und die anderen ein Cache Hit. Cache Missrate ergibt sich daher 25 %. ad d) Nun wird ein vollassoziativen Cache gleicher Größe (32 Worte) in 1-Wort-Blöcken verwendet. Es soll zusätzlich eine LRU - Ersetzungsstrategie für die Cache - Blöcke gemacht werden. Bei einem vollassoziativen Cache kann jeder Block aus dem Hauptspeicher an einer beliebigen Stelle im Cache abgelegt werden. Dadurch wird ein Ping Pong Effekt, wie es beispielsweise bei direkt abbildenden Caches oft möglich ist, vermieden. Der Nachteil ist jedoch, das nach dem Cache Eintrag im ganzen Cache gesucht werden muss, und dies erfordert einen weiteren Hardwareaufwand durch Komparatoren. Seite 10

11 In diesem Beispiel gibt es nichts zu rechnen jeder Block zuerst in den Cache geladen werden muss, und daher die Missrate wieder 100 % ist. Je nach der Reihenfolge der Zugriffe auf den Hauptspeicher wird der Cache gefüllt: Block Inhalt a[0] b[6] a[2] b[4] a[4] b[2] a[6] b[0] Block Inhalt Es werden 8 Speicherzugriffe innerhalb von 4 Schritten gemacht: Im ersten Schritt (i=0) wird auf a[0] und b[6] zugegriffen. Im zweiten Schritt (i=2) wird auf a[2] und b[4] zugegriffen. Im dritten Schritt (i=4) wird auf a[4] und b[2] zugegriffen. Im vierten Schritt (i=6) wird auf a[6] und b[0] zugegriffen. Es werden daher auch nur 8 Blöcke im vollassoziativen Cache benötigt. ad e) Es wird wieder ein vollassoziativer Cache verwendet mit 32 Worten Größe, jedoch eingeteilt in 8 Wort Blöcke. Es werden wiederum 8 Speicherzugriffe innerhalb von 4 Schritten gemacht: Im ersten Schritt (i=0) wird auf a[0] und b[6] zugegriffen. Diese Einträge sind jedoch nicht im Cache vorhanden (Cache Miss), also werden beide Mal der gesamte 8 Worte lange Block aus dem Hauptspeicher in den Cache geladen (a[0] a[7] wird geladen und b[0] b[7] wird geladen). Nach diesem Zugriff auf den Speicher sieht der Cache wie folgt aus: Block Inhalt a[0 7] b[0 7] Im zweiten Schritt (i=2) wird auf a[2] und b[4] zugegriffen. Diese beiden Einträge wurden im vorherigem Schritt bereits aufgrund der Blockgröße von 8 Worten in den Cache gelesen. Cache Hit Im dritten Schritt (i=4) wird auf a[4] und b[2] zugegriffen. Diese Einträge sind auch im Cache zu finden. Cache Hit Im vierten Schritt (i=6) wird auf a[6] und b[0] zugegriffen. Diese beiden Einträge sind auch im Cache gespeichert. Cache Hit In diesem Fall werden wieder die Blöcke 2 und 3 des Caches nicht verwendet! Ersetzungen finden also nicht statt. Die Cache Missrate beträgt 25 %. ad f) Nun soll ein n fachassoziativer Cache verwendet werden, mit 32 Worten Größe und 1 Wort- Blöcken. n ist in diesem Beispiel 2fach assoziativ. Nun gibt es ein paar Formeln für das Rechnen mit Caches: Um die Anzahl der Blöcke eines Caches zu berechnen kann man folgende Formel verwenden: Size Size Größe des Cachespeichers # CL = CLSize Größe einer Cacheline ( = Cache Block) CLSize # CL Anzahl der Cachelines ( = Cache Blöcke) Seite 11

12 Es sollte bei diesen Formeln vorzugsweise in Byte gerechnet werden, wobei gilt: 1 Wort = 4 Bytes Um die Anzahl der Sets Blöcke zu berechnen kann folgende Formel verwendet werden: # CL # Sets = n # CL Anzahl der Cachelines ( = Cache Blöcke) n die Assoziativität (bei Direkt abbildenden Speicher n = 1) # Sets Anzahl der Sets Blöcke Direkt abbildendende Caches sowie auch vollassoziative Caches bilden hier die Extremfälle. Denn bei direkt abbildendenden Caches ist die Anzahl der Sets Blöcke gleich der Anzahl der Cache Blöcke, und bei vollassoziativen Caches gibt es nur einen (großen) Block. Um die Blocknummer eines Speichers auszurechnen gibt es eine nützliche Formel: Addr Blocknr = % # Sets CLSize # Sets Anzahl der Sets Addr Adresse im Speicher CLSize Größe einer Cacheline ( = Cache Block) Blocknr Blocknummer im Cache Nützlich können auch folgende Formeln sein, um den niedrigsten Speicheradresseintrag (Lower) bzw. den höchsten Speicheradresseintrag (Upper) im Cache zu erhalten: Addr Lower = CLSize CLSize Upper = Lower + CLSize 1 Addr Adresse im Speicher CLSize Größe einer Cacheline ( = Cache Block) Lower niedrigster Adresseintrag aus dem Speicher Upper höchster Adresseintrag aus dem Speicher Wenn man nun diese Formeln verwendet kann man folgende Berechnungen durchführen: Anzahl der Blöcke: (Cachegröße: 32 Worte, Cacheblockgröße 1 Wort) Size 32Worte 128Byte # CL = = = = 32 CLSize 1Wort 4Byte Anzahl der Sets - Blöcke: (n = 2) # CL 32 # Sets = = = 16 n 2 Folgende Tabelle soll den zeitlichen Zugriff auf den Speicher veranschaulichen: Variable Adresse im Hauptspeicher Blocknummer Set Blocknummer a[0] Miss b[6] Miss a[2] Miss b[4] Miss a[4] Miss b[2] Miss a[6] Miss b[0] Miss Cacheinhalt nach Codefragment (2fach assoziativ 2 Sätze / Sets) Block Set 0 a[0] a[2] a[4] a[6] b[0] b[2] b[4] b[6] Set 1 Set 1 wird nie verwendet! Missrate beträgt 100 %. Seite 12

13 ad g) Nun soll sich die Größe eines Cacheblockes vergrößern: Blockgröße 4 Worte. 2fach satz-assoziativer Cache mit 32 Worten Größe. Anzahl der Blöcke: (Cachegröße: 32 Worte, Cacheblockgröße 4 Worte) Size 32Worte 128Byte # CL = = = = 8 CLSize 4Worte 16Byte Anzahl der Sets - Blöcke: (n = 2) # CL 8 # Sets = = = 4 n 2 Die Einteilung geschieht nun wieder über 2 Sets, jedoch gibt es nur 4 Blöcke pro Set und ein Block kann 4 Worte (16 Byte) speichern. Folgende Tabelle soll den zeitlichen Zugriff auf den Speicher veranschaulichen: Variable Adresse im Hauptspeicher Blocknummer Set Blocknummer a[0] Miss b[6] Miss a[2] Hit b[4] Hit a[4] Miss b[2] Miss a[6] Hit b[0] Hit Cacheinhalt nach Codefragment (2fach assoziativ 2 Sätze / Sets) Block# Set 0 a[0 3] a[4 7] b[0 3] b[4 7] Set 1 Set 1 wird auch hier nie verwendet! Missrate beträgt 50 %. Seite 13