Digitaltechnik und Rechnerstrukturen. 5. Speicherhierarchie

Transkript

1 Digitaltechni und Rechnerstruturen 5. Speicherhierarchie 1 2

2 Uebersicht Dem Benutzer soviel Speicher wie möglich in der billigsten Technologie zur Verfügung stellen. Zugang zur grösstmöglichen Geschwindigeit Steuerung Datenpfad Register First Level Cache Second Level Cache Hauptspeicher (DRAM) Seundärer Speicher (Dis) Geschwindigeit: Grösse: Zugriffszeit: 1ns 10 ns 100 ns 10 ms < 1Byte <16MB <16GB >100GB ns ns ns 5 ms 3 Technologische Trends 4

3 Vergleich: Kapazität Geschwindigeit Logi x 2 in 3 Jahren x 2 in 3 Jahren DRAM x 4 in 3 Jahren x 1.4 in 10 Jahren Dis x 2 in 3 Jahren x 1.4 in 10 Jahren DRAM (dynamic random access memory): Jahr Kapazität Zeilenzugriff Spaltenzugriff bit ns 75 ns bit ns 50 ns bit ns 25 ns bit ns 20 ns bit ns 15 ns bit ns 12 ns Mbit ns 10 ns MBit ns 7 ns MBit ns 5 ns 5 Technologische Trends Technologische Trends Performance µproc CPU Moore s Law 60%/yr. (2X/1.5yr) Processor-Memory Performance Gap: (grows 50% / year) DRAM DRAM 9%/yr. (2X/10 yrs) Time 6

4 Ebenen der Speicherhierarchie Register Instr., Operanden Cache Blöce Hauptspeicher Seiten (Pages) Dis Dateien (Files) Magnetband verantwortlich Uebertragungseinheit Programm, Compiler 1-8 Bytes Cache Steuerung Bytes Betriebssystem 512 Bytes - 16Bytes Benutzer MBytes Obere Ebenen schneller grösser Untere Ebenen 7 Das Prinzip der Loalität Das Prinzip der Loalität Programme greifen in einem leinen Zeitintervall auf einen relativ leinen Teil des Adressraumes zu. Dies gilt sowohl für Instrutionen als auch für Daten. Zwei unterschiedliche Arten der Loalität Zeitliche Loalität: Falls ein Datum oder eine Instrution referenziert wird, so wird sie bald wieder referenziert. Oertliche Loalität: Falls ein Datum oder eine Instrution referenziert wird, werden bald Daten oder Instrutionen mit nahgelegenen Adressen referenziert. 8

5 Arbeitsprinzipien Daten werden nur zwischen aufeinanderfolgenden Ebenen opiert Uebertragungseinheit (z.b. Bloc, Seite): Die leinste Informationseinheit, die in den zwei Hierarchiebenen vorhanden oder nicht vorhanden sein ann. Beispiel: Cache / Hauptspeicher zum Prozessor vom Prozessor obere Ebene (Cache) Cachebloc X untere Ebene (Hauptspeicher) Speicherbloc Y 9 Terminologie Treffer (hit): Daten sind in der oberen Ebene (z.b. Bloc X) Hit-Rate: Anteil der Speicherzugriffe, die in der oberen Ebene erfolgreich sind Hit-Zeit: Zugriffszeit zur oberen Ebene: Hit-Zeit = Cachezugriffszeit + Zeit zur Bestimmung von hit/miss Fehlzugriff (miss): Daten müssen aus unterer Ebene geholt werden (z.b. Bloc Y) Miss-Rate: Miss-Rate = 1 - (Hit-Rate) Miss-Strafe: Miss-Strafe = Zeit zum Zugriff auf die Daten im Hauptspeicher + Zeit zum Uebertragen in den Cache Zugriffszeit: Hit-Zeit + Miss-Strafe Miss-Rate 10

6 Typische Werte und Arbeitsprinzipien typische Werte Blocgrössse Byte Hit-Zeit 1-4 Tatzylen Miss-Strafe 8-100Tatzylen Zugriffszeit 6-60Tatzylen Uebertragungszeit 2-40Tatzylen Miss-Rate 0.5% - 10% Cache-Grösse 1 Byte - 1 MByte Zeitliche Loalität: Halte ürzlich benutzte Informationen näher am Prozessor Oertliche Loalität: Bewege Blöce aus aufeinanderfolgenden Wörtern näher zum Prozessor 11 Implementierungsalternativen Wo ann ein Bloc plaziert werden, wie wird er gefunden? direte Abbildung, teilassoziativ, vollassoziativ Welcher Bloc sollte bei einem Miss ersetzt werden? zufällig, am längsten unbenutzt Was geschieht beim Schreiben eines Blocs? durchgängiges Schreiben, zurücopieren 12

7 Wo ann ein Bloc plaziert werden? Plazierung eines Speicherblocs mit der Adresse 12: S. 503 Cachebloc, in dem Speicherbloc 12 liegt: direte Abbildung: (12 modulo 8) = 4 teilassoziativ: (12 modulo 4) = 0, vollassoziativ: beliebig 13 Direte Abbildung Cacheadresse = Speicheradresse MOD Anzahl Cacheeinträge Tag = Speicheradresse DIV Anzahl Cacheeinträge Cachespeicher Daten Tag d Hauptspeicher d 14

8 Diagramm S Beispiele Beispiel: Wie gross ist ein Cache für 64Byte Daten (Bloc = 1 Wort, 32 Bit Adressen)? 64Byte = 2 16 Byte = 2 14 Worte; Cachegrösse = 2 14 (32 + ( ) + 1) Bit = 803 Bit = 100 Byte Beispiel (8 Cacheblöce, 32 Speicherblöce): Speicherbloc hit/miss Cachebloc miss mod 8 = miss mod 8 = hit mod 8 = hit mod 8 = miss mod 8 = miss mod 8 = hit mod 8 = miss mod 8 =

9 Beispiel Index V Tag Daten 000 N 001 N 010 N 011 N 100 N 101 N 110 Y 10 Mem[10110] 111 N Index V Tag Daten 000 N 001 N 010 Y 11 Mem[11010] 011 N 100 N 101 N 110 Y 10 Mem[10110] 111 N Index V Tag Daten 000 Y 10 Mem[10000] 001 N 010 Y 11 Mem[11010] 011 N 100 N 101 N 110 Y 10 Mem[10110] 111 N Index V Tag Daten 000 Y 10 Mem[10000] 001 N 010 Y 11 Mem[11010] 011 N 100 Y 00 Mem[00100] 101 N 110 Y 10 Mem[10110] 111 N Index V Tag Daten 000 Y 10 Mem[10000] 001 N 010 Y 10 Mem[10010] 011 N 100 Y 00 Mem[00100] 101 N 110 Y 10 Mem[10110] 111 N 17 Oertliche Loalität Cachebloc: Cachedaten, die ihren eigenen Cachetag haben Vergrösserung der Cacheblocgrösse: Vorteil aus örtlicher Loalität ziehen effizientere Speicherung höhere Miss-Strafe (Zeit zum Ersetzen eines Blocs grösser) Berechnungen: L Bit breite Byte-Adresse, Cache mit 2 N Byte Daten, 2 M Byte pro Bloc Adr<M-1:0> : Bloc offset, Adr<N-1:M> : Index, Adr<L-1:N> : Tag Cachegrösse = 2 (N-M) (1 Bit + (L-N) Bit + 2 M Byte) = 2 N Byte + 2 (N-M) (1 + L-N) Bit Blocindex = Byteadresse / 2 M modulo 2 (N-M) 18

10 Diagramm eines 64Byte Cache mit 4-Wort (16 Byte) Blöcen: Diagramm S Assoziativer Cache Probleme bei direter Abbildung: Miss aufgrund eines Konflites (mehrere Speicherblöce werden auf einen festen Cachebloc abgebildet). Ungünstige festgelegte Ersetzungsstrategie bei einem Miss. Abhilfe: grösserer Cache oder mehrere Einträge pro Index (assoziativer Cache). Assoziativer Cache: K Einträge pro Index, K direte Caches arbeiten parallel Index seletiert eine Menge von Blöcen, die Tags werden mit dem entsprechenden Adressanteil parallel verglichen, die Daten werden entsprechend dem Resultat seletiert. 20

11 Vergleich der Cachestruturen S Diagramm eines teilassoziativen Caches S

12 Assoziativer Cache Cacheadresse = Speicheradresse MOD Anzahl Cachesets Tag = Speicheradresse DIV Anzahl Cachesets Set 0 Set 1 Set 2 Set 3 Cachespeicher Daten Tag d Hauptspeicher d ~ ~ 23 Vergleich 2-fach 4-fach 8-fach LRU Rand. LRU Rand. LRU Rand. 16 Byte 5.18% 5.69% 4.67% 5.29% 4.39% 4.96% 64 Byte 1.88% 2.01% 1.54% 1.66% 1.39% 1.53% 256 Byte 1.15% 1.17% 1.13% 1.13% 1.12% 1.12% 24

13 Wahl der Blocgrösse Miss Penalty Miss Rate durchschn. Zugriffszeit Blocgrösse Blocgrösse Blocgrösse 25 Ersetzungsstrategien Direte Abbildung: Jeder Speichbloc ann nur auf einen Cachebloc abgebildet werden -> eine Auswahl möglich Assoziativer Cache: Jeder Speicherbloc ann in einen von K Cacheblöcen, bei vollassoziativem Cache: in irgendeinen Cachebloc. Einige Ersetzungsstrategien: Zufällige Auswahl des ersetzten Blocs durch Hardware. Der am längsten unbenutzte Bloc wird ersetzt. Hardware speichert die jeweiligen Zugriffszeiten (aufwendig). 26

14 Schreibalternativen Wie werden Informationen im Cache und im Hauptspeicher onsistent gehalten? Zurücopieren: Prozessor schreibt nur in den Cache; falls der Bloc bei einem Miss ersetzt wird, wird er in den Hauptspeicher opiert. Ein dirty bit für jeden Cachebloc zeigt an, ob der Bloc zurücopiert werden muss. Aufwendige Steuerung, leiner Bandbreitenbedarf. Durchgängiges Schreiben: Schreiben von Cache und Hauptspeicher zur gleichen Zeit Wie soll das gehen? Ist der Speicher nicht zu langsam? 27 Durchgängiges Schreiben Tric: Pufferspeicher (typ. Grösse 4) zwischen Prozessor und Speicher; Prozessor schreibt in Cache und Pufferspeicher; Steuerung schreibt Pufferspeicher in Hauptspeicher. Geht gut, falls: mittlere Speicherrate << 1 / DRAM-Schreibzyluszeit Sonst: Sättigung des Puffers (Rechner muss jeweils anhalten, bis wieder ein Pufferplatz frei ist), d.h. CPU-Zylusszeit <= DRAM-Schreibzylusszeit Prozessor Cache Hauptspeicher Pufferspeicher 28

15 Grundlegende Gleichungen: CPU-Zeit = (CPU-Instrutionszylen + CPU-Wartezylen) Tatperiode CPU-Wartezylen = Lese-Wartezylen + Schreib-Wartezylen Lese-Wartezylen = Leseinstrutionen/Programm Lese-Miss-Rate Lese-Miss-Strafe Schreib-Wartezylen = (Schreibinstrutionen/Programm Schreib-Miss-Rate Schreib-Miss-Strafe) + Schreibpuffer-Wartezylen Vereinfachte Gleichungen: Leistungsberechnungen CPU-Wartezylen = Speicherinstrutionen/Programm Miss-Rate Miss-Strafe = Instrutionen/Programm Miss/Instrution Miss-Strafe 29 Gegeben: Für ein bestimmtes Programm: 33% aller Instrutionen sind Speicherinstrutionen, Miss-Rate bei Instrutionen 5%, Miss-Rate bei Daten 10%, CPI perfet = 4, Miss-Strafe ist 12 Zylen Frage: Um wieviel schneller wäre ein Rechner mit perfetem Cache? Antwort: Instrutions-Miss-Zylen = Instrutionen 5% 12 = 0.6 Instrutionen Daten-Miss-Zylen = Instrutionen 33% 10% 12 = 0.4 Instrutionen Miss-Zylen = 1.0 Instrutionen CPI warten = (4 + 1) Zylen/Instrution CPU-Zeit mit perfetem Cache ist um Fator 5/4 besser. Beispiel 30

16 Gegeben sind die gleichen Randbedingungen wie oben. Frage: Wie steigt die Leistung des Rechners bei K-facher Tatrate. Annahme: Speicher wird nicht schneller. Antwort: Miss-Zylen = K 1.0 Instrutionen = K Instrutionen CPI schnell = (4 + K) Zylen/Instrution CPU-Zeit langsam / CPU-Zeit schnell = (Instrutionen CPI warten Tatrate) / (Instrutionen CPI schnell Tatrate / K) = K 5/ (4 + K) Beispiel: K = 6, Beschleunigungsfator = 3 Beispiel 31 Speicherorganisationen 32

17 Speicherorganisation 33 Beispiel Speicherstruturen Annahmen: Adresse senden: 4 Zylen Zugriffszeit pro Wort: 24 Zylen Wort senden: 4 Zylen 1.2 Speicherzugriffe pro Instrution ohne Cache-Misses: CPI=2 Blocgrösse = 1 führt zu Miss-Rate=3% Blocgrösse = 2 führt zu Miss-Rate=2% Blocgrösse = 4 führt zu Miss-Rate=1% Vergleich: 32Bit Bus, 32Bit Speicher, 1 Wort pro Bloc, einfach: CPI = 2 + (1.2 * 3% * 32)=

18 Beispiel Speicherstruturen 32Bit Bus, 32Bit Speicher, 2 Worte pro Bloc, einfach: CPI = 2 + (1.2 * 2% * 2 * 32) = Bit Bus, 32Bit Speicher, 2 Worte pro Bloc, 2 fach interleaved: CPI = 2 + (1.2 * 2% * (4+24+8)) = Bit Bus, 64Bit Speicher, 2 Worte pro Bloc, breit: CPI = 2 + (1.2 * 2% * 32) = Bit Bus, 32Bit Speicher, 4 Worte pro Bloc, 4 fach interleaved: CPI = 2 + (1.2 * 1% * ( )) = Bit Bus, 64Bit Speicher, 4 Worte pro Bloc, breit: CPI = 2 + (1.2 * 1% * 2 * 32) = Gründe für Misses Compulsory (notwendig): Jeder Bloc, auf den zugegriffen wird, muss mindestens einmal in den Cache gebracht werden. Capacity (Kapazität): Das wiederholte Laden von Blöcen in den Cache ann notwendig werden, wenn das gesamte Programm einschliesslich der Daten nicht in den Cache passt. Der Miss hat Kapazitätsgründe, wenn er auch bei vollassoziativer (optimaler) Plazierungsstrategie stattgefunden hätte. 36

19 Gründe für Misses Conflict (Konflit): Ein Bloc muss wiederholt geladen werden, wenn er zwischen zwei Zugriffen durch einen anderen Bloc ersetzt wurde. Es wird angenommen, dass dieser Grund bei einem vollassoziativen Cache mit optimaler Strategie nicht auftritt. Beeinflussungsmöglicheiten: Cachegrösse Plazierungsstrategie Compulsory - - Capacity X - Conflict - X 37 Redution von Misses durch HW Prefetching E.g., Instruction Prefetching Alpha fetches 2 blocs on a miss Extra bloc placed in stream buffer On miss chec stream buffer Prefetching relies on extra memory bandwidth that can be used without penalty 38

20 Redution durch Software Prefetching Data Prefetch Load data into register (HP PA-RISC loads) Cache Prefetch: load into cache (MIPS IV, PowerPC, SPARC v. 9) Special prefetching instructions cannot cause faults; a form of speculative execution Issuing Prefetch Instructions taes time Is cost of prefetch issues < savings in reduced misses? 39 Redution durch Compiler Optimierungen Instructions Reorder procedures in memory so as to reduce misses Profiling to loo at conflicts McFarling [1989] reduced caches misses by 75% on 8KB direct mapped cache with 4 byte blocs Data Merging Arrays: improve spatial locality by single array of compound elements vs. 2 arrays Loop Interchange: change nesting of loops to access data in order stored in memory Loop Fusion: Combine 2 independent loops that have same looping and some variables overlap Blocing: Improve temporal locality by accessing blocs of data repeatedly vs. going down whole columns or rows 40

21 Merging Arrays /* Before */ int val[size]; int ey[size]; /* After */ struct merge { int val; int ey; }; struct merge merged_array[size]; Reducing conflicts between val & ey if both are typically accessed simultaneously. 41 Loop Interchange /* Before */ for ( = 0; < 100; = +1) for (j = 0; j < 100; j = j+1) for (i = 0; i < 5000; i = i+1) x[i][j] = 2 * x[i][j]; /* After */ for ( = 0; < 100; = +1) for (i = 0; i < 5000; i = i+1) for (j = 0; j < 100; j = j+1) x[i][j] = 2 * x[i][j]; Sequential accesses instead of striding through memory every 100 words 42

22 Loop Fusion /* Before */ for (i = 0; i < N; i = i+1) for (j = 0; j < N; j = j+1) a[i][j] = 1/b[i][j] * c[i][j]; for (i = 0; i < N; i = i+1) for (j = 0; j < N; j = j+1) d[i][j] = a[i][j] + c[i][j]; /* After */ for (i = 0; i < N; i = i+1) for (j = 0; j < N; j = j+1) { a[i][j] = 1/b[i][j] * c[i][j]; d[i][j] = a[i][j] + c[i][j];} 2 misses per access to a & c vs. one miss per access 43 Blocing /* Before */ for (i = 0; i < N; i = i+1) for (j = 0; j < N; j = j+1) {r = 0; for ( = 0; < N; = +1){ r = r + y[i][]*z[][j];}; x[i][j] = r; }; Two Inner Loops: Read all NxN elements of z[] Read N elements of 1 row of y[] repeatedly Write N elements of 1 row of x[] Capacity Misses a function of N & Cache Size: 3 NxN => no capacity misses; otherwise... Idea: compute on BxB submatrix that fits 44

23 Blocing Representation of original algorithm j i N y z N 45 Blocing Representation of original algorithm j i N y z 2N 46

24 Blocing Representation of original algorithm j i y N N 2 z 47 Blocing Representation of original algorithm j i y 2 N N + N 2 z 48

25 Blocing Representation of original algorithm j i y 2 N 2N + N 2 z 49 Blocing Representation of original algorithm j i y 2 N 2 N 2 z 50

26 Blocing Representation of original algorithm j i y N 2 N 3 z 51 Blocing Example /* After */ for (jj = 0; jj < N; jj = jj+b) for ( = 0; < N; = +B) for (i = 0; i < N; i = i+1) for (j = jj; j < min(jj+b,n); j = j+1) {r = 0; for ( = ; < min(+b,n); = +1) { r = r + y[i][]*z[][j];}; x[i][j] = x[i][j] + r; }; Capacity Misses from ~ N 3 to ~N 3 /B B called Blocing Factor 52

27 Blocing Representation of bloced algorithm j i B y z B 53 Blocing Representation of bloced algorithm j i B y z 2B 54

28 Blocing Representation of bloced algorithm j i y B B 2 z 55 Blocing Representation of bloced algorithm j i y 2 B B 2 z 56

29 Blocing Representation of bloced algorithm j i y N B B 2 z 57 Blocing Representation of bloced algorithm j i y 2 N B 2 B 2 z 58

30 Blocing Representation of bloced algorithm j i y 3 N B 3 B 2 z 59 Blocing Representation of bloced algorithm j i N 2 y z N B 60

31 Blocing Representation of bloced algorithm j i y N B + N 2 N B + B 2 z 61 Blocing Representation of bloced algorithm j i y 2 N 2 2 N B z 62

32 Blocing Representation of bloced algorithm j i y N 3 /B N 2 z 63 Zusammenfassung: Compiler Optimierungen vpenta (nasa7) gmty (nasa7) tomcatv btrix (nasa7) mxm (nasa7) spice cholesy (nasa7) compress Performance Improvement merged arrays loop interchange 64 loop fusion blocing

33 Einfluss der Speicherhierarchie auf Algorithmen Today CPU time is a function of (ops, cache misses) vs. just f(ops): What does this mean to Compilers, Data structures, Algorithms? The Influence of Caches on the Performance of Sorting by A. LaMarca and R.E. Ladner. Proceedings of the Eighth Annual ACM-SIAM Symposium on Discrete Algorithms, January, 1997, Quicsort: fastest comparison based sorting algorithm when all eys fit in memory. Radix sort: also called linear time sort because for eys of fixed length and fixed radix a constant number of passes over the data is sufficient independent of the number of eys For Alphastation 250, 32 byte blocs, direct mapped L2 2MB cache, 8 byte eys, from 4000 to Quicsort vs. Radix Instructions/ey Radix sort Quic (Instr/ey) Radix (Instr/ey) Quic sort E+07 Set size in eys 66

34 Quicsort vs. Radix Radix sort Time Quic (Instr/ey) Radix (Instr/ey) Quic (Clocs/ey) Radix (clocs/ey) Quic sort Instructions E+07 Set size in eys Radix sort Quicsort vs. Radix Quic(miss/ey) Radix(miss/ey) 3 2 Cache misses 1 Quic sort Set size in eys 0 What is proper approach to fast algorithms? 68

35 Timing Peculiarities in Modern Computer Architectures The following example is taen from an exercise in Systemprogrammierung. It was not! constructed for challenging the timing predictability of modern computer architectures; the strange behavior was found by chance. A straightforward GGT algorithm was executed on an UltraSparc (Sun) architecture and timing was measured. Goal in this lecture: Determine the cause(s) for the strange timing behavior. 69 Program Only the relevant assembler program is shown (and the related C program); the calling main function just jumps to label ggt times. Here, we will introduces nop statements; there are NOT executed. 70

36 Observation Depending on the number of nop statements before the ggt label, the execution time of ggt(17, 17*97) varies by a factor of almost 2. The execution time of ggt(17*97, 17) varies by a factor of almost 4. This behavior is periodic in the number of nop statements, i.e. it repeats after 8 nop statements. Measurements: nop time[s] ggt(17,17*97) time[s] ggt(17*97,17) nop time[s] ggt(17,17*97) time[s] ggt(17*97,17) 71 Simple Calculations The CPU is UltraSparc with 360 MHz cloc rate. Problem 1 (ggt(17,17*97) ): Fast execution: 96*3* / 0.35 = 823 MIPS and 0.35 * 360 / 96 = 1.31 cycles per iteration. Slow execution: 96*3* / 0.65 = 443 MIPS and 0.65 * 360 / 96 = 2.44 cycles per iteration. Therefore, the difference is about 1 cycle per iteration. Problem 2 ( ggt(17*97, 17) ): Fast execution: 96*4* / 0.63 = 609 MIPS and 0.63 * 360 / 96 = 2.36 cycles per iteration. Slow execution: 96*4* / 2.78 = 138 MIPS and 2.78 * 360 / 96 = cycles per iteration. Therefore, the difference is about 8 cycles per iteration. 72

37 Explanations Problem 1 (ggt(17,17*97) ): The first three instructions (cmp, blu, sub) are called 96 times before ggt returns. The timing behavior depends on the location of the program in address space. The reason is most probably the implementation of the 4 word instruction buffer between the instruction cache and the pipeline: The instruction buffer can not be filled by different cache lines in one cycle. In the slow execution, one needs to fill the instruction buffer twice for each iteration. This needs at least two cycles (despite of any parallelism in the pipeline). 73 Bloc Diagram of UltraSparc Instruction buffer for hiding latency to cache 74

38 User Manual (page 361 ) 75 Address Alignment 0 nop Cache line: cmp blu sub Instruction buffer: cmp blu sub 5 nop Cache line: nop nop nop nop nop Instruction buffer: cmp blu sub cmp blu sub Cache lines: 6 nop nop sub nop nop nop nop nop cmp blu Instruction buffer: cmp blu 76 2 fetches are necessary as sub is missing

39 Explanations Problem 2 (ggt(17*97,17) ): The loop is executed (cmp, blu, sub, bgu, sub) 96 times, where the first sub instruction is not executed (since blu is used with ',a suffix, which means, that instruction in the delay slot is not executed if branch is not taen). Therefore, there are four instructions to be executed, but the loop has 5 instructions in total. The main reason for this behavior is most probably due to the branch prediction scheme used in the architecture. In particular, there is a prediction of the next bloc of 4 instructions to be fetched into the instruction buffer. This scheme is based on a two bit predictor and is also used to control the pipeline and to prevent stalls. But there is a problem due to the optimization of the state information that is stored (prediction for blocs of instructions and single instructions): 77 User Manual (page 342 ) We exactly have this situation, if there are 1 or three nops statements inserted 78

40 Conclusions Innocent changes (just moving code in address space) can easily change the timing by a factor of 4. In our example, the timing oddities are caused by two different architectural features of modern superscalar processors: branch prediction instruction buffer It is hard to predict the timing of modern processors; this is bad in all situations, where timing is of importance (embedded systems, hard real-time systems). What is a proper approach to predictable system design? 79 Virtueller Speicher Gründe für die Verwendung virtueller Speicher: Manche Programme passen einschliesslich ihrer Daten nicht in den Hauptspeicher. Beispiel: Multimediaprogramm einschliesslich Videofilm. Das Laden eines ganzen Programms in den Hauptspeicher ann zu erheblichen Startzeiten führen. Viele Betriebssysteme erlauben die gleichzeitige Ausführung mehrerer Prozesse, die jeweils ihren eigenen Adressraum haben. Damit ergibt sich ein grosser Gesamtspeicherbedarf. 80

41 Virtueller Speicher Cache - Hauptspeicher Die verschiedenen Cacheblöce gehören im Allgemeinen zum gleichen Programm. Cache-Miss wird diret über die Hardware bearbeitet. Cachegrösse ist unabhängig vom Adressraum des Prozessors. Cache wird exlusiv für die Speicherhierarchie verwendet. Hauptspeicher - seundärer Speicher Ein Prozess ann gleichzeitig mit anderen Prozessen ausgeführt werden. Jeder Prozess hat seinen eigenen Speicherbereich. Fehlzugriffe werden über Software gelöst. Adressraum bestimmt die Grösse des virtuellen Speichers. Der seundäre Speicher wird auch zur Datenhaltung (z.b. Filesystem) verwendet. 81 Virtueller Speicher 82

42 Virtueller Speicher Zusätzliche Aufgaben: Protetionsmechanismus: Ein Prozess sollte im Allgemeinen die Daten eines anderen Prozesses nicht verändern önnen. Ein Prozess muss an verschiedenen Stellen im Hauptspeicher ausführbar sein, da a priori nicht beannt ist, welche Prozesse gemeinsam ausgeführt werden. Speicher muss automatisch verwaltet werden. Adressabbildung: virtuelle Adressen eines Programms müssen in physialische Adressen umgewandelt werden. 83 Virtueller Speicher Adressabbildung 84

43 Virtueller Speicher Was ist ein Bloc? Page (feste Blocgrösse), Segment (variable Blocgrösse) Relativ gross, um die hohen Zugriffszeiten zu amortisieren. Wo ann ein Bloc platziert werden? Üblicherweise vollassoziative Platzierung. Welcher Bloc wird bei einem Miss ersetzt? Miss nennt man auch Seitenfehler (page fault). Aufwendige Algorithmen (in Software), z.b. LRU. Was geschieht beim Schreiben? Zurücopieren (bei einem Miss wird die Seite in den seundären Speicher opiert), da das Schreiben einzelner geänderter Daten zu lange dauert. 85 Typische Parameterwerte Seitengrösse 4 Byte - 64 Byte Hit Time Zylen Miss Penalty Zylen Zugriffszeit Zylen Transferzeit Zylen Miss-Rate % Kapazität 16M - 8G Bytes 86

44 Adressabbildung V = {0, 1,..., n - 1} virtual address space M = {0, 1,..., m - 1} physical address space n > m MAP: V --> M U {0} address mapping function MAP(a) = a' if data at virtual address a is present in physical address a' and a' in M Processor a = 0 if data at virtual address a is not present in M Addr Trans Mechanism 0 a' missing item fault fault handler Main Memory Secondary Memory physical address 87 OS performs this transfer Adressabbildung P.A frame Physical Memory 1K 1K 1K Addr Trans MAP Address Mapping 10 VA page no. disp V.A page Virtual Memory 1K 1K 1K unit of mapping also unit of transfer from virtual to physical memory Page Table Base Reg index into page table V Page Table Access Rights PA + table located in physical memory 88 physical memory address actually, concatenation is more liely

45 Adressabbildung Jeder Prozess hat seine eigene Seitentabelle. Der Beginn einer Seitentabelle ist jeweils in einem speziellen Register gespeichert. 89 Seitenfehler Wie wird ein Seitenfehler erannt? Valid-Bit in der Seitentabelle ist 0. Eine Unterbrechung des Programmablaufs wird erzeugt und die Kontrolle an das Betriebssystem übergeben. Wo ist die Seite im seundären Speicher? Betriebssystem unterhält eine Datenstrutur, in der diese Information enthalten ist. Diese Information ann auch in die Seitentabelle integriert sein. Welche Seite im Hauptspeicher wird ersetzt? Ueblicherweise LRU (least recently used) Strategy. 90

46 Seitenfehler Grösse einer Seitentabelle: 32 Bit virtuelle Adresse 4 Byte Seitengrösse 4 Bytes pro Tabelleneintrag Zahl der Tabelleneinträge: / 2 Tabellengrösse: Es existieren verschiedene Technien, um den Speicherbedarf auf etwa 64Byte zu senen. 20 Einträge 2 2 Bytes/Eintrag 4 MByte 91 Seitenfehler 92

47 Virtuelle Adressen und Cache CPU VA PA miss Translation Cache data hit Main Memory It taes an extra memory access to translate VA to PA This maes cache access very expensive, and this is the "innermost loop" that you want to go as fast as possible Why access cache with PA at all? VA caches have a problem! synonym / alias problem: two different virtual addresses map to same physical address => two different cache entries holding data for the same physical address! 93 TLB (Translation Looaside Buffer) A way to speed up translation is to use a special cache of recently used page table entries. This has many names, but the most frequently used is Translation Looaside Buffer or TLB Really just a cache on the page table mappings TLB access time comparable to cache access time (much less than main memory access time) 94

48 Translation Loo-Aside Buffers Just lie any other cache, the TLB can be organized as fully associative, set associative, or direct mapped TLBs are usually small, typically not more than entries even on high end machines. This permits fully associative looup on these machines. Most mid-range machines use small n-way set associative organizations. CPU hit VA PA miss TLB Cache Looup Main Memory Translation with a TLB miss Translation 95 hit data t 1/2 t 20 t TLB 96

49 Translation Loo-Aside Buffers Typische Werte und Eigenschaften: Misses werden entweder in Hardware oder Software (mit speziellen Instrutionen, die den direten Zugriff auf den TLB erlauben) aufgelöst. Oft aufwendige Strutur (assoziativ, LRU). Grösse: Einträge Blocgrösse: 1-2 Tabelleneinträge (je 4-8 Byte). Hitzeit: 1 Tatperiode Missstrafe: Tatperioden Missrate: 0.01% - 1% 97 Integration von TLB und Cache 98

50 Ablauf eines Speicherzugriffs 99 Seitenfehler und TLB Misses TLB Miss Ursache ann aus Valid Bit der im Hauptspeicher abgelegten Seitentabelle abgelesen werden: a. Seite ist im Hauptspeicher, aber TLB Eintrag nicht (reiner TLB Miss). b. Seite ist nicht im Hauptspeicher (Seitenfehler). Ationen a. Der fehlende Eintrag im TLB wird aus dem entsprechenden Eintrag in der Seitentabelle unter Hardware oder Softwareontrolle erzeugt. 100

51 Seitenfehler und TLB Misses b. Eine Unterbrechung des Programmablaufs wird erzwungen. Das Betriebssystem führt drei Schritte durch: 1. Der Eintrag in der Seitentabelle führt zum Ort der Seite im seundären Speicher. 2. Eine Seite im Hauptspeicher wird ausgewählt, die ersetzt werden soll. Ist die Seite dirty (verändert worden), wird sie zunächst in den seundären Speicher zurücopiert. 3. Die fehlende Seite wird vom seundären Speicher in den Hauptspeicher opiert. Der gesamte Vorgang ist omplex und stellt hohe Anforderungen an die Hardware- und Softwarestrutur, z.b. exate Unterbrechungen von Instrutionen sowie Unterbrechungen der Betriebssystemroutinen. 101 Protetionsmechanismen Aufgaben: Es sollte möglich sein, das es Prozessen nicht erlaubt ist, Speicherbereiche anderer Prozesse (oder gar des Betriebssystems) zu lesen oder zu schreiben. Benutzerprozesse dürfen eine Seitentabellen verändern. Lösung: Zusätzliche Informationen über Lese- und Schreibberechtigungen in der Seitentabelle. Unterstützung unterschiedlicher Prozessmodi (user und ernel) Einige Operationen önnen nur im Kernel-Modus ausgeführt werden, z.b. TLB-Zugriff, Änderung des Zeigers auf die Seitentabelle. Übergang der CPU zwischen den verschiedenen Modi. 102

52 Überlappter TLB- und Cachezugriff Falls physialische Seitennummer und Adress-Tag gleiche Breite haben: TLB 32 Einträge Cache 8 x 4 x Worte Hit PPA PPA Hit Daten VPA 17 = Offset 13 2 Valid 103 Beispiele von Speicherhierarchien Virtueller Speicher (Pentium Pro, PowerPC 604) First Level Cache (Pentium Pro, PowerPC 604) 104

53 Speicherhierarchie ALPHA Speicherhierarchie DEC Alpha