Hauptspeicherverwaltung - Www I6 Informatik Rwth Aachen

Contents 

7 Hauptspeicherverwaltung (Main Memory) 

7.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 

7.1.1 Speicherhierarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 

7.1.2 Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 

7.1.3 Adressenbindung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262 

7.1.4 Logische vs. physikalische Adressen . . . . . . . . . . . . . . . . . . . . . . 264 

7.1.5 Dynamisches Laden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 

7.1.6 Dynamisches Linken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 

7.1.7 Overlays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 

7.2 Swapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 

7.3 Zusammenhängende Speicherbelegung . . . . . . . . . . . . 273 

7.3.1 Memory Mapping and Protection . . . . . . . . . . . . . . . . . . . . . . . . 274 

7.3.2 Speicherbelegung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276 

7.3.3 Fragmentierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 

7.4 Buddy-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . 288 

Ney: Betriebssysteme und Systemsoftware, WS 2007/8 c○RWTH Aachen 28. Januar 2008 

253

7.5 Paging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 

7.5.1 Prinzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 

7.5.2 Protection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 

7.5.3 Shared Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305 

7.5.4 Hardware und TLB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 

7.6 Struktur der Page Table . . . . . . . . . . . . . . . . . . . . . 312 

7.6.1 Hierarchical Paging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312 

7.6.2 Hashed Page Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 

7.6.3 Inverted Page Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320 

7.7 Segmentierung . . . . . . . . . . . . . . . . . . . . . . . . . . 322 

7.8 Beispiel: Intel Pentium . . . . . . . . . . . . . . . . . . . . . . 329 


254

7.1 Grundlagen 

7.1.1 Speicherhierarchie 

• Der Hauptspeicher in Verbindung mit der Festplatte kann selbst 

als Ressource betrachtet werden, die vom OS verwaltet wird. 

• Ziel ist es, einen guten Kompromiß zwischen Kosten und 

Leistung (= Zeit + Größe) zu erreichen. 

• Der Hauptspeicher sieht nur die Folge der Speicherreferenzen, 

unabhängig von der Art der Adressierung. 

Wiederholung: Darstellung der Speicherhierarchie 


255


256

CPU-Auslastung und Multiprogramming: 

CPU utilization and multiprogramming 

• probabilistisches Modell: 

– CPU-Auslastung wird durch I/O behindert 

– Wahrscheinlichkeit, daß 1 Prozeß auf I/O wartet: ϑ 

– Wahrscheinlichkeit, daß alle n Prozesse warten: ϑ n 

• Ergebnis: 

CPU-Auslastung = 1 − ϑn (siehe Darstellung im nächsten Bild) 

• typische Situation (interaktive Prozesse): 

– ϑ = 0.80 

– n = 10 Prozesse müssen im Hauptspeicher sein, 

damit die CPU-Auslastung bei 90% liegt 

Beachte die Näherung: 

– Modell: Berechnung basiert auf unabhängigen Prozessen 

– Wirklichkeit: zu jedem Zeitpukt kann nur 1 Prozeß die CPU benutzen 


257

CPU utilization (in percent) 

100 

80 

60 

40 

20 

0 

CPU utilization and multiprogramming 

20% I/O wait 

50% I/O wait 

80% I/O wait 

1 2 3 4 5 6 7 8 9 10 

Degree of multiprogramming 


258

7.1.2 Hardware 

CPU und Speicherzugriffe: 

• Cache: extrem schneller Speicher zwischen CPU und Hauptspeicher, 

um ’langsamem’ Hauptspeicher entgegenzuwirken. 

• legale oder gültige Adressen: 

– jeder Prozeß hat eigenen Speicherbereich 

– Hardware: base register und limit register 

– Vergleich erfolgt bei jedem Speicherzugriff 

• OS verwaltet diese beiden Register: 

– Schutz der Speicherbereiche der anderen Prozesse 

– Schutz des OS-Speicherbereichs 


259

Definition of logic address space using base and limit registers 


260

HW address protection with base and limit registers 


261

7.1.3 Adressenbindung 

Erstellung des ausführbaren Codes erfolgt in mehreren Schritten. 

Adressen können zu verschiedenen Zeiten und in verschiedenen 

Varianten festgelegt werden: 

• Compilierzeit (compile time): 

– ’absolute code’: Startaddresse muß bekannt sein 

– ’relocatable code’: Adressen relativ zur Startadresse 

• Ladezeit (load time): 

– ’relocatable code’: absolute Adressen werden jetzt festgelegt 

• Laufzeit (execution or run time): 

– Speicherbereich kann sich während der Laufzeit ändern 

– Hardware erforderlich: MMU (memory management unit) 


262

Multistep Processing of a User Program 


263

7.1.4 Logische vs. physikalische Adressen 

Unterscheide zwei Arten von Adressen: 

• logische oder virtuelle Adressen: 

Adreßraum der CPU 

= Adreßraum des Programms 

• physikalische Adresse: 

reale Adresse des (physikalischen) Hauptspeichers 

• Memory Management Unit (MMU): 

– setzt die logischen in physikalische Adressen um 

– einfachste Form: relocation register = base register 

– typische Form: Paging (und/oder Segmentierung) 


264

Relocation register and logical vs. physical addresses 


265

CPU 

Memory mangagement unit (MMU) and its function 

CPU 

package 

The MMU sends physical 

addresses to the memory 

The CPU sends virtual 

addresses to the MMU 

Memory 

management 

unit 

Memory 

Disk 

controller 


266 

Bus

7.1.5 Dynamisches Laden 

Motivation: 

– gesamtes Programm im Hauptspeicher 

– Aufteilung des Programms zur besseren Nutzung des Hauptspeichers 

Dynamisches Laden (dynamic loading): 

• Prinzip: 

eine Routine wird erst zum Zeitpunkt des Aufrufs geladen 

• Festplatte: Routinen in ’relocatable’ Format 

• Ablauf: 

– aufrufendes Programm prüft, ob Routine schon geladen ist 

– gegebenenfalls Aufruf der entsprechenden Lade-Routine 

• Vorteil: 

– Routinen werden nur bei Bedarf geladen 

– gegeignet für Routinen für Fehlerbehandlung und (seltene) Sonderfälle 

• Verantwortlichkeit: 

liegt beim Programmierer 


267

7.1.6 Dynamisches Linken 

Dynamisches Linken (dynamic linking): 

• Prinzip (ähnlich zu dynamischem Laden): 

der Link-Vorgang wird aufgeschoben bis zur Laufzeit 

• typische Anwendung: 

Routinen, die von mehreren Prozessen benötigt werden 

(z.B. system and language subroutine libraries) 

• Vorteile: 

– Speicherplatz (Hauptspeicher und Festplatte) wird nur einmal benötigt 

– library updates: kein neuer Link-Vorgang nötig 

• Realisierung: 

– ’stub’: kurzer Code am Anfang jedes ’image’ einer library routine 

– lokalisiert die library routine im Hauptspeicher oder lädt sie bei Bedarf 

• Mitwirkung des OS bei ’memory protection’: 

mehrere Prozesse benutzen denselben Speicherbereich 


268

7.1.7 Overlays 

Overlay-Technik (nicht mehr benutzt): 

• Es gibt Teile des Programms, die niemals gleichzeitig 

im Hauptspeicher benötigt werden. 

• Diesen Teilen wird derselbe Adreßbereich zugeordnet, 

d.h. sie werden ‘übereinandergelegt’. 

• Entwurf dieser Overlay-Struktur erfolgt durch den Programmierer. 

• Problem: mühsam und fehleranfällig 

Erweiterung dieses Konzepts: 

virtueller Speicher, bei dem die Verwaltung vom OS übernommen wird 


269

7.2 Swapping 

Swapping: 

• Prozeßauslagerung vom Hauptspeicher auf Hintergrundspeicher (backing store) 

oder Festplatte (hard disk) und umgekehrt. 

• Multiprogramming erfordert Swapping, da nicht alle Prozesse 

gleichzeitig im Hauptspeicher gehalten werden können. 

Swapping kostet Zeit: 

• (head) seek time: 0 msec (hier; sonst typisch: 15 msec) 

• (rotational) latency time: 8 msec 

• transfer time: 40 MByte/sec 

Prozeß mit 10 MByte: 2 · 258 msec (1 GByte: 2 · 25 sec!) 

(Faktor 2: ein- und ausladen) 

Konsequenz: 

• Prozeßwechsel soll zwischen Prozessen stattfinden, 

die bereits im Hauptspeicher sind. 

• deswegen: mehrere Prozesse gleichzeitig im Hauptspeicher 

• Aufgabe der Speicherbelegung 


270

Swapping and backing store (hard disk) 


271

Swapping und I/O-Operationen: 

Swapping: Einzelheiten 

• Methode A: Prozeß, der I/O ausführt (ohne CPU!), 

darf nicht ausgelagert werden. 

• Methode B: I/O erfolgt in 2 Schritten: 

a) zwischen I/O-Gerät und OS-Speicherpuffer 

b) zwischen OS-Speicherpuffer und Prozeß-Speicherbereich 

Varianten des Swappings: 

• standard swapping: nicht mehr weit verbreitet, 

weil Swapping-Zeit zu groß ist im Vergleich zur Bearbeitungszeit 

• weitere Varianten: 

– UNIX: nur falls zuviele Prozesse laufen und Memory knapp wird 

– MS Windows (Version 3.1): Steuerung durch den Benutzer 


272

7.3 Zusammenhängende Speicherbelegung 

• einfachste Form der Speicherbelegung: 

(bisher mehr oder weniger vorausgesetzt): 

– jeder Prozeß hat einen zusammenhängenden Bereich im Hauptspeicher 

– gilt für OS und Benutzerprozesse 

• Hardware (meistens): 

Interrupt-Vektoren im niedrigen Adreßbereich 

(verweist auf die Addresse der Interrupt-Service-Routine) 

• deswegen meistens: 

OS ebenfalls im unteren Adreßbereich 


273

7.3.1 Memory Mapping and Protection 

Verwendung der ’relocation-’ und ’limit-’Register: 

• Prozeß (nach Auswahl durch CPU-Scheduler und vor Start): 

’relocation-’ und ’limit-’Register werden geladen. 

• Speicherschutz: 

für die Speicherbereiche des OS und der anderen Prozesse 

• dynamische Anpassung: 

Speicherbereich eines Prozesses (und des OS) kann sich dynamisch verändern. 


274

Hardware support for relocation and limit registers 


275

7.3.2 Speicherbelegung 

Zusammenhängende Speicherbelegung: 

• einfachste Form der Nutzung des Hauptspeichers 

• Unterteilung des Hauptspeichers in sog. Partitionen oder Bereiche: 

a) Die Partitionen variieren in ihrer Größe. 

b) Die Partitionen werden vom OS verwaltet und den Jobs zugewiesen. 

• Vorstufe zu modernen Verfahren: 

Paging und Segmentieren 


276

OS 

process 5 

process 8 

process 2 

Example of Contiguous Memory Allocation 

OS 

process 5 

process 2 

OS 

process 5 

process 9 

process 2 

OS 

process 5 

process 9 

process 10 

process 2 


277

system 

system 

system 

system 

system 

system 

system 

Memory allocation changes as processes come into memory and leave it 

Time 

C 

C 

C 

C 

B 

B 

B 

A 

A 

A 

A 

D 

D 

D 

Operating Operating Operating Operating Operating Operating Operating 

(a) 

(b) 

(c) 

(d) 

(e) 

(f) 

(g) BC 

278 

Ney: Betriebssysteme und Systemsoftware, WS 2007/8 c○RWTH Aachen 28. Januar 2008

unterscheide: 

• Speicherbelegung grenzt an Lücke: 

Prozeß kann wachsen 

Dynamisch wachsender Speicherbedarf 

• Speicherbelegung grenzt nicht an Lücke: 

Prozeß muss ausgelagert werden und warten, 

bis genügend zusammenhängender Speicherbereich verfügbar ist. 

• alternative Strategie: 

von vorneherein Platz für Wachstum einplanen 


279

AA-Program 

B 

Operating 

system 

Allocating memory for growing segments 

Room for growth 

in use 


Actually in use 

Actually 

B-Stack 

B-Data 

B-Program 

A-Stack 

A-Data 

Operating 

system 

(a) (b) 



growing data segment only growing stack and growing data segment 

Ney: Betriebssysteme und Systemsoftware, WS 2007/8 280 

c○RWTH Aachen 28. Januar 2008

• Bitmaps: 0 frei, 1 belegt 

Verwaltung der Speicherbelegung 

• Linked List (verkettete Liste): 

Partition := belegter oder freier Speicherbereich 

Liste der Partitionen mit den folgenden Einträgen: 

– Flag (belegt/frei), 

– Startadresse der Partition, 

– Größe der Partition, 

– Zeiger zum nächsten Eintrag 

Dabei ist ein Sortieren nach Startadresse vorteilhaft 

• weitere Varianten: 

– getrennte Listen für belegte und freie Partitionen 

– freie Partitionen: sortieren nach der Größe 


281

Memory allocation for five processes 

A B C D E 

8 16 24 

1 1 1 1 1 0 0 0 P 0 5 H 5 3 P 8 6 P 14 4 

(a) 

1 1 1 1 1 1 1 1 

1 1 0 0 1 1 1 1 

1 1 1 1 1 0 0 0 

H 18 2 P 20 6 P 26 3 H 29 3 X 

Hole Starts Length 

Process 

at 18 2 

(b) (c) 

a) Speicherbelegung (5 Prozesse, 3 Lücken) 

b) zugehörige Bitmap 

c) zugehörige verkettete Liste 


282

• einfache und effiziente Listenoperationen 

• zweckmässig: doppelt-verzeigerte Liste 

Before X terminates A 

(a) A X B 

(b) A X(c) X B 

(d) X 

Aktualisieren der verketteten Liste 

becomes 

becomes 

becomes 

becomes 

Ney: Betriebssysteme und Systemsoftware, WS 2007/8 283 

c○RWTH Aachen 28. Januar 2008 

After X terminates 

BAB

• First Fit: 

die erste passende Lücke wird ausgewählt. 

Belegungsstrategien 

• Best Fit: 

die kleinste passende Lücke wird ausgewählt. 

• Worst Fit: 

die größte Lücke wird ausgewählt. 

• Rotating First Fit (auch: Next Fit): 

fast wie First Fit: der Speicher wird jeweils ausgehend 

von der letzten Plazierung zirkulär durchsucht. 

• Quick Fit: 

separate Listen für verschiedene Partitionsgrößen 


284

Beispiel: Belegungsstrategien 


285

Beispiel: Belegungsstrategien 


286

7.3.3 Fragmentierung 

• Beobachtung: 

der Hauptspeicher wird zerstückelt (’Fragmentierung’) 

• Gegenmaßnahmen: 

’Garbage Collection’ oder ’Compaction’ 

Fragmentierung des Hauptspeichers: 

• interne Fragmentierung: 

ungenutzter Speicher innerhalb einer Partition 

(kleinste Einheit: 1 KByte) 

• externe Fragmentierung: 

Lücken zwischen den belegten Partitionen 

• 50%-Regel (im zeitlichen Mittel) für externe Fragmentierung: 

Bei N belegten Partitionen gibt es 0.5N freie Partitionen 

(Asymmetrie: Lücken werden vereinigt, Prozesse nicht). 


287

7.4 Buddy-Systeme 

Speicher-Segmente mit festen Längen: 

• Anforderungen nur in 2-er Potenzen 

• Ansatz: 

Binär-Darstellung der Speicheradressen wird als binärer Baum interpretiert 

• Liste der freien und belegten Speicherbereiche 

mit den Operationen: 

– sukzessives Verschmelzen (falls möglich) bei Freiwerden eines Segmentes 

– sukzessives Spalten eines freien Segmentes, bis passende 2-er Potenz erreicht ist. 

• Vorteil: effizientes Verschmelzen und Spalten der Segmente 

• Nachteil: erhebliche Fragmentierung 

Terminologie (siehe Beispiel): 

Paare von Buddies (=Kumpel): (AL, AR), (BL, BR), (CL, CR) 


288

Buddy System Allocator 


289

Darstellung aller 4-Bit-Folgen: 

Binär-Darstellung für Buddy-Systeme 

0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 

0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 

0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 

0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 

Darstellung der 4-Bit-Folgen durch binären Baum: 

0 1 

0 1 0 1 

0 1 0 1 0 1 0 1 

0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 


290

Beispiel: Anforderung der Größe 2 16 


291

7.5 Paging 

7.5.1 Prinzip 

Unterteilung des Adreßraums in Blöcke fester Größe 

• Logischer Speicher: (Virtual) Pages (= Seiten) 

• Physikalischer Speicher: (Page) Frames (= Rahmen, Kacheln) 

• Adresse mit n Bits wird zerlegt: n = p + d 

– p Bits = page number: 2 p Pages 

– d Bits = displacement (=page offset): Offset innerhalb der Page 

Fragmentierung des Speichers: 

• externe Fragmentierung: 

existiert nicht bei Paging 

• interne Fragmentierung: 

existiert nur für die ’letzte Page’ 


292

Paging Model of Logical and Physical Memory 


293

Paging Example: Pages of 4 Bytes 


294

Adreßkonvertierung: von virtuellen zu physikalischen Adressen 

(4+12 Bits → 3+12 Bits) 

Virtual 

address 

space 

60K-64K 

56K-60K 

52K-56K 

48K-52K 

44K-48K 

40K-44K 

36K-40K 

32K-36K 

28K-32K 

24K-28K 

20K-24K 

16K-20K 

12K-16K 

8K-12K 

4K-8K 

0K-4K 

X 

X 

X 

X 

7 

X 

5 

X 

X 

X 

3 

4 

0 

6 

1 

2 

Virtual page 

Physical 

memory 

address 

28K-32K 

24K-28K 

20K-24K 

16K-20K 

12K-16K 

8K-12K 

4K-8K 

0K-4K 

Page frame 


295

Page 

table 

MMU: Konvertierung der Adressen 

(4+12 Bits → 3+12 Bits) 

1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 

15 

14 

13 

12 

11 

10 

9 

8 

7 

6 

5 

4 

3 

2 

1 

0 

000 

000 

000 

000 

111 

000 

101 

000 

000 

000 

011 

100 

000 

110 

001 

010 

0 

0 

0 

0 

1 

0 

1 

0 

0 

0 

1 

1 

1 

1 

1 

1 

Virtual page = 2 is used 

as an index into the 

page table 

110 

Present/ 

absent bit 

0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 

12-bit offset 

copied directly 

from input 

to output 

Outgoing 

physical 

address 

(24580) 

Incoming 

virtual 

address 

(8196) 


296

Paging Hardware 


297

• Interpretation des Paging: 

spezielle Form einer dynamischen Relokation 

• typische Größe einer Page: 

4-8 KByte 

• virtueller Adreßraum für 32 bit: 

– Anzahl der Speicherzellen: 2 32 = 2 2 · 2 30 = 4G 

– Größe einer Page: 2 12 = 4K 

– Anzahl der Pages: 2 20 = 1M 


298

Allokation freier Frames 

• neuer Prozeß: 

braucht eine Anzahl freier Frames (siehe Beispiel) 

• OS verwaltet den physikalischen Hauptspeicher: 

frame table: spezielle Datenstruktur mit den Informationen: 

– frei oder belegt; 

– falls belegt, welcher Prozeß 

• OS: 

separate Page Table für jeden Prozeß 

(wie PC und CPU-Register; Teil des PCB) 


299

Allocation of Free Frames 

Before allocation After allocation 


300

Paging: Konzept 

• Wunsch des Pogrammierers: 

– einheitlicher Adreßraum von 0 bis ∞ (oder 2 32 = 4G) 

– kein Interesse an Speicherverwaltung 

• Realisierung durch Paging: 

– Speicherbereiche können über den Hauptspeicher verteilt sein 

– Zuordnung erfolgt mittels Page Table 

• Vorteile des virtuellen Adreßraums: 

– kann deutlich größer sein als der physikalische; 

– inaktive Programmteile werden vom OS auf Hintergrundspeicher ausgelagert. 


301

7.5.2 Protection 

• für jeden Page Frame: 

read-only, read-write, execution 

• zusätzliches Bit: legale vs. illegale Adressen 

valid-invalid bit 

• Sonderfall (interne Fragmentierung): 

die letzte Page (siehe Beispiel) 

• illegale Adressen: 

trap zum OS 

manchmal zusätzlich: 

PTLR: page table length register 

= aktuelle Größe der Page Table 


302

Valid/Invalid Bit In A Page Table 


303

• Nummer des Page Frames 

• valid/invalid-Bit (auch: present/absent) 

• Protection-Bits: 

read/write, read only, execute only, ... 

Struktur der Einträge der Page Table 

• Modified- und Referenced-Bits: 

– Modified (= dirty): die Page ist beschrieben worden 

– Referenced (= Use): die Page ist gelesen oder beschrieben worden 

• caching-Bit: für I/O-Operationen 

Caching 

disabled Modified Present/absent 

Referenced Protection 

Page frame number 


304

7.5.3 Shared Pages 

• Code, der von mehreren Programmen benutzt wird: 

– z.B. Texteditor, Compiler, Datenbanksysteme, Laufzeit-Bibliotheken, ... 

• Voraussetzung: 

– re-entrant code (reiner Code) 

(sollte vom OS geprüft werden!) 

– jeder Prozeß: Daten + CPU-Register 

• Konzept: vergleichbar mit Threads 

(shared: Adreßraum) 


305

Example of Shared Pages 


306

7.5.4 Hardware und TLB 

Beispiel eines 16-bit-Minicomputers: DEC PDP 11 

• Entwurf des Paging: 16 = 3+13 

– page size of 8K = 2 13 : 13 Bits 

– 3 Bits für die Pages: Tabelle mit 2 3 = 8 Einträgen 

• Hardware: 

– 8 spezielle Register (schneller als Hauptspeicher) 

Beispiel eines 32-bit-Prozessors: 

• Entwurf des Paging: 32 = 20 + 12 

– page size of 4K = 2 12 : 12 Bits 

– 20 Bits für die Pages: Tabelle mit 2 20 = 1M Einträgen 

• Hardware: 

– Page Table wird im normalen Hauptspeicher gehalten 

– PTBR: ’page table base register’ zeigt auf die Page Table 


307

Zugriffszeit und TLB: 

• Page Table: 

– befindet sich im Hauptspeicher 

– Problem: Verdoppelung der Zugriffszeit 

• Abhilfe: 

– spezielle (und teure) Hardware innerhalb der MMU 

– assoziativer Speicher: Translation Look Aside Buffer (TLB) 

• Größe des TLB: 64 - 1024 Einträge 

d.h. nur ein Teil der Page Table wird im TLB gehalten 


308

Paging Hardware With TLB 


309

Mit den Größen: 

• TMem = 100 nsec: Zugriffszeit des Hauptspeichers 

• TTLB = 20 nsec: Zugriffszeit des TLB 

• q: hit ratio (’Adresse steht im TLB’) 

ergibt sich die effektive (=mittlere) Zugriffszeit: 

T = q · (TTLB + TMem) + (1 − q) · (TTLB + 2 TMem) 

= TTLB + TMem + (1 − q) · TMem 

q[%] T[nsec] 

0 220 

80 140 

90 130 

98 122 

100 120 

Folgerung: ’hit ratio’ sollte bei 98% und höher liegen. 


310

TLB 

• Einträge im TLB: 

– die ausgewählten Pages müssen laufend aktualisiert werden 

– Frage der Ersetzungstrategie (vgl. Paging) 

• Aufbau der Einträge im TLB: i.w. wie Page Table 

 

 

Valid Virtual page Modified Protection Page frame 

 

 

 

 

 

1 140 1 RW 31 

 

 

 

 

 

1 20 0 R X 38 

 

1 130 1 RW 29 

 

 

1 

 

129 

 

 

1 

 

RW 

 

62 

 

 

 

 

 

 

1 19 0 R X 50 

 

1 21 0 R X 45 

 

 

 

1 

 

 

860 

 

 

1 

 

 

RW 

 

 

14 

 

 

 

1 861 1 RW 75 

• manchmal zusätzlich: Prozeß-ID 

Vorteil: keine Initialierung des TLB bei Prozeßwechsel erforderlich 


311

7.6 Struktur der Page Table 

7.6.1 Hierarchical Paging 

virtueller Adreßraum mit 32 Bits: 

• Größe der Page: 2 12 = 4KByte 

• Größe der Page Table: 

– 2 32 /2 12 = 2 20 = 1M Einträge 

– 4 Byte pro Eintrag 

• Ergebnis: 

4 MByte werden für die Page Table benötigt! 

• Gegenmaßnahmen: 

– Hierachical Paging 

– Hashed Page Table 

– Inverted Page Table 


312

Two-Level Page-Table Scheme 


313

Address Translation Scheme 


314

Beispiel: 

• Prozeß: 

– Programm-Code 

– Daten 

– Stack 

jeweils: 4 MByte 

• erste Stufe des Paging: 

jeder Eintrag steht für 2 22 = 4 MByte 

• zweite Stufe des Paging: 

jeder Eintrag steht für 2 12 = 4 KByte 

• Speicher: effiziente Nutzung 

– erste Stufe: Page Table 

– zweite Stufe: 3 Page Tables 

Beispiel: Zweistufiges Paging 


315

Bits 10 10 12 

PT1 PT2 Offset 

(a) 

Beispiel: Zweistufiges Paging 

1023 

6 

5 

4 

3 

2 

1 

0 

Top-level 

page table 

1023 

(b) 

6 

5 

4 

3 

2 

1 

0 

Second-level 

page tables 

Page 

table for 

the top 

4M of 

memory 


316 

To 

pages

Zerlegung der Adresse mit 64 Bits: 

= 42 + 10 + 12 

= (32+10) + 10 + 12 

d.h. dreistufiges Paging (?) 

Three-Level Paging: 64 Bits 


317

7.6.2 Hashed Page Table 

logischer Adreßraum: 64 bit 

• hierachisches Paging: zu ineffizient 

• Abhilf: Hashing 

weitere Einzelheiten: 

– kann mit TLB kombiniert werden 

– Clustering: mehrer Pages werden zu einem Cluster zusammengefaßt. 


318

Hashed Page Table 


319

7.6.3 Inverted Page Table 

Adreßraum: 32 und 64 Bits (Page Size: 2 12 = 4K Byte) 

• 32 Bits: 2 20 · 4 Byte = 4 MByte (noch machbar) 

• 64 Bits: 2 52 · 8 Byte = 32 Millionen GByte (unmöglich) 

Ansatz: eine einzige Page Table für alle Prozesse 

• Vorteil: weniger Speicherplatz 

• Nachteil: mehr Aufwand bei Adreßkonvertierung: 

– Eintrag: (pid,p,d) 

– Suche nach (pid,p) 

• Effizienzsteigerung: 

– Verwendung eines TLB 

– Hash Table 


320

Inverted Page Table Architecture 


321

7.7 Segmentierung 

• Sicht des Programmierers: 

Programm besteht aus verschiedenen Teilen (= Segmenten), z.B.: 

– Hauptprogramm 

– Subroutinen 

– Stack 

– lokale Variable 

– globale Variable 

– Tabellen 

– (große) Arrays 

• Ergebnis: 

logischer Adressraum ist zweidimensional: (segment, offset) 


322

Segmentierung: Sicht des Programmierers 


323

Segmentierung 

Abbildung der Programmierer-Sicht auf eindimensionalen Adreßraum: 

3 

1 

4 

2 

user space physical memory space 


324 

1 

4 

2 

3

Segmentation Hardware 

• logische Adresse: (s,d) 

s= Segment-Nummer 

d= Verschiebung (Displacement oder Offset) 

• Segment Table: Adreßkonvertierung in physikalische Adressen 

– limit: Länge des Segmentes 

– base: Startadresse des Segmentes 

• zwei Register für die Segment Table: 

– STBR: segment table base register 

– STLR: segment table length register 


325

Segmentation Hardware 


326

Example of Segmentation 


327

Vergleich: Paging und Segmentierung 

• Zweck der Methode: 

– Paging: großer linearer logischer Adreßraum 

– Segmentierung: Zerlegung des Programms in logisch unabhängige Teile 

• Hat der Programmierer sich darum zu kümmern? 

– Paging: Nein, Segmentierung: Ja 

• Wieviele lineare Adreßräume gibt es? 

– Paging: 1, Segmentierung: mehrere 

• Kann der logische Adreßraum größer sein als der physikalische? 

– Paging: Ja, Segmentierung: Ja 


328

7.8 Beispiel: Intel Pentium 

Segmentierung, Paging und Kombination dieser Methoden: 

• Segmentierung: 

– 8 private Segmente: ’private for each process’ 

– 8 globale Segmente: ’shared among all processes’ 

• Paging mit 32-Bit-Adresse: 

zwei Größen der Pages: 

– 4 MByte: einstufiges Paging: 10 + 22 

– 4 KByte: zweistufiges Paging: 10 + 10 + 12 


329

Logical-to-Physical Address Translation in Pentium 


330

Segmentation on Pentium 


331

Pentium Paging Architecture 


332

Linux unterstützt Segmentierung nur begrenzt; 

es verwendet 6 Segmente: 

• kernel code 

• kernel data 

• user code 

• user data 

Pentium und Linux 

• state-task segment 

(hardware context during context switches for each process) 

• local descriptor table (LDT) (i.d.R. nicht benutzt) 


333

Linear Address in Linux 

Pentium-Hardware: 

– hat nur zweistufiges Paging 

– middle directory: 0 Bits 

Pentium und Linux 


334

Three-Level Paging in Linux 


335

Hauptspeicherverwaltung - Www I6 Informatik Rwth Aachen

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?