Kapitel 8 Speicherverwaltung
Kapitel 8 Speicherverwaltung
Kapitel 8 Speicherverwaltung
Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.
YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.
<strong>Kapitel</strong> 8<br />
<strong>Speicherverwaltung</strong><br />
RW-Systemarchitektur Kap. 8<br />
1
Überblick Betriebssysteme<br />
6 Einführung<br />
7 Prozesse, Fäden (threads), Scheduling<br />
8. <strong>Speicherverwaltung</strong><br />
8.1 Anforderungen an die <strong>Speicherverwaltung</strong><br />
8.2 Grundlegende Methoden der <strong>Speicherverwaltung</strong><br />
8.2.1 Partitionierung<br />
8.2.2 Verlagerung<br />
8.2.3 Seitenadressierung und Seitenaustausch<br />
8.2.4 Segmentierung<br />
8.2.5 Seiten und Segmente<br />
9. Dateisysteme<br />
10. Ein- und Ausgabe<br />
Nebenläufigkeit und wechselseitiger Ausschluss – Inhalt der<br />
Vorlesung „Nebenläufige Programmierung“<br />
Deadlocks - dito<br />
RW-Systemarchitektur Kap. 8<br />
2
8 <strong>Speicherverwaltung</strong><br />
• <strong>Speicherverwaltung</strong>:<br />
– Aufteilung des verfügbaren Hauptspeichers zwischen<br />
• Betriebssystem<br />
• verschiedenen Prozessen<br />
• <strong>Speicherverwaltung</strong> erfordert enges Zusammenspiel von<br />
– Hardware und<br />
– Betriebssystem.<br />
• Hardwareaspekte (virtueller Speicher):<br />
– kurz in <strong>Kapitel</strong> 4 behandelt<br />
• Jetzt:<br />
– Betriebssystemaspekte<br />
– Ausführliche Behandlung des Zusammenspiels Hardware /<br />
Betriebssystem<br />
RW-Systemarchitektur Kap. 8<br />
3
Speicher<br />
• Funktion – Aufbewahrung für Programme und Daten<br />
• Organisation – meist eine “Hierarchie”<br />
Inhalte/Struktur<br />
Befehle/Adressen/./Operanden<br />
Blöcke<br />
Seiten<br />
Dateien<br />
CPU-Register<br />
Cache<br />
Speicher<br />
Festplatte<br />
Band<br />
RW-Systemarchitektur Kap. 8<br />
Besitzer/Verwalter<br />
Größe<br />
Programm<br />
1-8 Bytes<br />
Cache Controller<br />
8-128 Bytes<br />
Betriebssystem<br />
512-4K bytes<br />
Bnutzer/Operator<br />
Mbytes<br />
oben<br />
unten<br />
schnell,<br />
klein<br />
langsam,<br />
groß<br />
4
8.1 Anforderungen an die <strong>Speicherverwaltung</strong><br />
Anforderungen an die <strong>Speicherverwaltung</strong> von der Betriebssystemseite<br />
• Bereitstellung von Speicher für Betriebssystem und Prozesse<br />
• Ziel wg. Mehrprogrammbetrieb (Multiprogramming):<br />
Möglichst viele Prozesse im Speicher vorhanden<br />
Anforderungen nach Lister/Eager: Fundamentals of Operating Systems<br />
1. Verlagerbarkeit (relocatability)<br />
2. Schutz (protection)<br />
3. Gemeinsame Nutzung (sharing)<br />
4. Logische Organisation<br />
5. Physikalische Organisation<br />
RW-Systemarchitektur Kap. 8<br />
5
Verlagerung (relocation)<br />
• Motivation:<br />
– Mehrere Prozesse gleichzeitig im System<br />
– Auslagern und Wiedereinlagern ganzer Prozesse aus dem<br />
Hauptspeicher ermöglichen<br />
– Ort der Einlagerung zum Zeitpunkt der Programmentwicklung /<br />
Programmübersetzung unbekannt!<br />
– Bindung an alten Ort beim Wiedereinlagern sehr ungünstig!<br />
⇒ Problem: Speicherreferenzen innerhalb des Programms:<br />
– Absolute Sprungbefehle<br />
– Datenzugriffsbefehle<br />
RW-Systemarchitektur Kap. 8<br />
6
Verlagerung (relocation)<br />
Beginn Prozesskontrollinformationen<br />
Einsprungstelle ins Programm<br />
Programmende<br />
• Übersetzung der Speicherreferenzen im Programmcode in physikalische<br />
Speicheradressen durch<br />
– Prozessorhardware<br />
– Betriebssystemsoftware<br />
• Ausnahme: Paging mit virtuellem Speicher (einfacher Fall ohne dynamisch<br />
gebundene Module)<br />
RW-Systemarchitektur Kap. 8<br />
Prozesskontrollblock<br />
Programm<br />
Daten<br />
Sprungbefehl<br />
Referenz<br />
auf Daten<br />
Zunehmende<br />
Adresswerte<br />
7
Schutz (Protection)<br />
• Schutz von Prozessen gegen beabsichtigte oder unbeabsichtigte<br />
Störungen durch andere Prozesse<br />
⇒ Überprüfung aller Speicherzugriffe<br />
• Schwierigkeit: Effektive Adresse (berechnet aus Registerinhalten<br />
und Offsets z.B. d(A n , I x ) ) nicht zur Übersetzungszeit eines<br />
Programms überprüfbar.<br />
• Grund:<br />
– effektive Adressen werden erst zur Ausführungszeit berechnet<br />
– (dynamische) Verlagerung<br />
⇒ Dynamische Überprüfung nötig,<br />
• braucht Hardwareunterstützung,<br />
• wird zusammen mit Verlagerung gelöst.<br />
RW-Systemarchitektur Kap. 8<br />
8
Gemeinsame Nutzung (Sharing)<br />
• Gemeinsame Nutzung = kontrollierter Zugriff mehrerer Prozesse auf<br />
gemeinsam genutzte Bereiche des Speichers<br />
• Anwendungsbeispiele:<br />
– Ausführung des gleichen Programms durch eine Reihe von Prozessen<br />
⇒ Code nur einmal im Speicher<br />
– Benutzung gemeinsamer Module (z.B. dynamisch gelinkte Bibliotheken)<br />
– Kooperation von Prozessen über gemeinsam genutzten Datenspeicher<br />
(„shared memory“)<br />
RW-Systemarchitektur Kap. 8<br />
9
Logische Organisation<br />
• Hauptspeicher ist lineares Feld von Bytes<br />
(Wörtern)<br />
• Dagegen: Logischer Aufbau großer<br />
Programme:<br />
– Sammlung verschiedener Module<br />
– Unabhängig übersetzt; Referenzen erst zur<br />
Laufzeit aufgelöst<br />
– Verschiedene Module mit verschiedenem<br />
Schutz (z. B. nur lesen / ausführen)<br />
– Gemeinsame Nutzung von Modulen durch<br />
verschiedene Prozesse<br />
• Z.B. auch dynamisch gebundene<br />
Bibliotheken<br />
• Betriebssystem muss mit Modulen<br />
umgehen können.<br />
Code Daten<br />
RW-Systemarchitektur Kap. 8<br />
schreibgeschützt<br />
Programm A<br />
Programm B<br />
10
Physikalische Organisation<br />
• Hier betrachtet:<br />
– 2 Ebenen:<br />
• Hauptspeicher (schnell, teuer, flüchtig)<br />
• Hintergrundspeicher (langsam, billig, nicht<br />
flüchtig)<br />
• Grundproblem: Organisation des<br />
Informationsflusses zwischen Haupt- und<br />
Sekundärspeicher<br />
– Prinzipiell möglich: in Verantwortung des<br />
Programmierers<br />
– Aufwändig, erschwert durch<br />
Mehrprogrammbetrieb (multiprogramming)<br />
– Deshalb: Verwaltung durch das<br />
Betriebssystem<br />
RW-Systemarchitektur Kap. 8<br />
Hauptspeicher<br />
Sekundärspeicher - Festplatte<br />
11
8.2 Grundlegende Methoden der<br />
<strong>Speicherverwaltung</strong><br />
• Partitionierung<br />
– Für Speicheraufteilung zwischen verschiedenen Prozessen eher<br />
veraltetes Konzept<br />
– Betriebssysteminterne Nutzung von Partitionierung<br />
• Paging<br />
– Aufteilung des Adressraums in Seiten und virtuelle Adressen<br />
– Kombiniert mit Seitenaustausch<br />
• Segmentierung<br />
– Einfache Segmentierung<br />
– Kombiniert mit Konzept des virtuellen Speichers<br />
RW-Systemarchitektur Kap. 8<br />
12
8.2.1 Partitionierung<br />
• Partitionierung:<br />
– Aufteilung des Speichers in Bereiche mit festen Grenzen<br />
– Fester, zusammenhängender Teil des Hauptspeichers für<br />
Betriebssystem<br />
– Pro Prozess ein zusammenhängender Teil des Speichers<br />
• Verschiedene Varianten:<br />
– Statische Partitionierung<br />
– Dynamische Partitionierung<br />
– Buddy-Verfahren<br />
• Probleme: Speicherverschnitt/Fragmentierung<br />
– interne Fragmentierung – innerhalb der zugeteilten Speicherbereiche<br />
– externe Fragmentierung – außerhalb der zugeteilten Speicherbereiche<br />
RW-Systemarchitektur Kap. 8<br />
13
Statische Partitionierung (1)<br />
• Einteilung des Speichers in feste Anzahl von Partitionen<br />
• 2 Varianten:<br />
Alle Partitionen mit gleicher Länge Partitionen mit unterschiedlicher Länge<br />
Betriebssystem<br />
8 Mbyte<br />
8 Mbyte<br />
8 Mbyte<br />
8 Mbyte<br />
8 Mbyte<br />
8 Mbyte<br />
8 Mbyte<br />
RW-Systemarchitektur Kap. 8<br />
Betriebssystem<br />
8 Mbyte<br />
2 Mbyte<br />
2 Mbyte<br />
4 Mbyte<br />
8 Mbyte<br />
12 Mbyte<br />
16 Mbyte<br />
14
Statische Partitionierung (2)<br />
• Probleme:<br />
– Programm zu groß für Partition ⇒ Programmerstellung mit Overlays<br />
nötig (aufwändig und fehleranfällig!)<br />
– Interne Fragmentierung: Platzverschwendung, wenn Programm<br />
kleiner als Größe der zugeordneten Partition<br />
– Fest vorgegebene Anzahl von Prozessen im Speicher<br />
• Bei Laden von Prozessen in den Speicher: evtl. Auslagern von<br />
anderen Prozessen<br />
• Zuweisung von Partitionen an Prozesse:<br />
– Bei Bereichen mit gleicher Länge: trivial<br />
– Bei Bereichen mit variabler Länge: Kleinste verfügbare Partition die<br />
gerade noch ausreicht?<br />
• Wenn Speicherbedarf nicht feststellbar, dann helfen nur Overlays oder<br />
virtueller Speicher!<br />
RW-Systemarchitektur Kap. 8<br />
15
Dynamische Partitionierung (1)<br />
• Einteilung des Speichers in Partitionen<br />
– variabler Länge und<br />
– variabler Anzahl<br />
• Prozesse erhalten exakt passende Speicherbereiche<br />
• Ein- und Auslagern führt zu externer Fragmentierung!<br />
(vgl. auch <strong>Kapitel</strong> Dateisysteme)<br />
RW-Systemarchitektur Kap. 8<br />
16
Dynamische Partitionierung (2)<br />
BS, 8 MB BS, 8 MB<br />
56 MB<br />
BS, 8 MB<br />
Prozess1<br />
20 MB<br />
Prozess 3<br />
18 MB<br />
Prozess1<br />
20 MB<br />
36 MB<br />
BS, 8 MB<br />
Prozess1<br />
20 MB<br />
P. 4, 8 MB<br />
Prozess 3<br />
18 MB<br />
BS, 8 MB<br />
Prozess1<br />
20 MB<br />
Prozess 2<br />
14 MB<br />
22 MB<br />
BS, 8 MB<br />
20 MB<br />
P. 4, 8 MB<br />
Prozess 3<br />
18 MB<br />
4 MB<br />
4 MB<br />
4 MB<br />
RW-Systemarchitektur Kap. 8<br />
BS, 8 MB<br />
Prozess1<br />
20 MB<br />
Prozess 2<br />
14 MB<br />
Prozess 3<br />
18 MB<br />
4 MB<br />
BS, 8 MB<br />
Prozess 2<br />
14 MB<br />
6 MB<br />
P. 4, 8 MB<br />
6 MB 6 MB 6 MB<br />
Prozess 3<br />
18 MB<br />
4 MB<br />
17
Dynamische Partitionierung (3)<br />
• Defragmentierung erforderlich!<br />
– Aufwändig<br />
– Speicherverdichtung nur erfolgreich, wenn dynamische Verlagerung<br />
möglich (Speicherreferenzen werden nicht ungütig!)<br />
• Speicherzuteilungsalgorithmen:<br />
– Best Fit:<br />
• Suche kleinsten Block, der ausreicht<br />
– First Fit:<br />
• Suche beginnend mit Speicheranfang bis ausreichender Block gefunden<br />
– Next Fit:<br />
• Suche beginnend mit der Stelle der letzten Blockzuweisung<br />
RW-Systemarchitektur Kap. 8<br />
18
Dynamische Partitionierung (4)<br />
• Analyse von Speicherzuteilungsalgorithmen:<br />
– Im Schnitt ist First Fit am besten!<br />
– Next Fit:<br />
• Etwas schlechter<br />
• Typischer Effekt: Schnelle Fragmentierung des größten freien<br />
Speicherblocks am Ende des Speichers<br />
– Best Fit:<br />
• Am schlechtesten<br />
• Produziert schnell eine Reihe von sehr kleinen Fragmenten, die ohne<br />
Defragmentierung nie mehr benutzt werden können<br />
• Zudem: langsames Verfahren<br />
RW-Systemarchitektur Kap. 8<br />
19
Buddy-System (1)<br />
• Nachteil statische Partitionierung:<br />
– Beschränkte Anzahl nicht-ausgelagerter Prozesse<br />
– Interne Fragmentierung<br />
• Nachteil dynamische Partitionierung:<br />
– Defragmentierung nötig wegen externer Fragmentierung<br />
• Buddy-System (Halbierungsverfahren):<br />
– Kompromiss zwischen statischer und dynamischer Partitionierung<br />
– Eigenschaften:<br />
• Anzahl nicht-ausgelagerter Prozesse dynamisch<br />
• Interne Fragmentierung beschränkt<br />
• Keine explizite Defragmentierung<br />
RW-Systemarchitektur Kap. 8<br />
20
Buddy-System (2)<br />
Prinzip:<br />
– Verwalte Speicherblöcke der Größe 2 K , L ≤ K ≤ U,<br />
ausgerichtet an nx 2 K -Grenzen<br />
•2 L = Größe des kleinsten zuteilbaren Blocks<br />
•2 U = Größe des größten zuteilbaren Blocks (z.B. Gesamtgröße des<br />
Speichers)<br />
– Zu Beginn:<br />
• Es existiert genau ein Block der Größe 2 U .<br />
• Anforderung eines Blocks der Größe s:<br />
–Bei 2 U-1 < s ≤ 2 U : Weise gesamten Speicher zu<br />
– Sonst: Teile auf in 2 Blöcke der Größe 2 U-1<br />
– Bei 2 U-2 < s ≤ 2 U-1 : Weise einen der beiden Blöcke zu<br />
– Sonst: Wähle einen der beiden Blöcke aus und teile<br />
–…<br />
– Fahre fort bis zu Block der Größe 2 K mit 2 K-1 < s ≤ 2 K<br />
• Bei resultierendem Block ist der „Verschnitt“ kleiner als die halbe Blockgröße<br />
RW-Systemarchitektur Kap. 8<br />
21
Buddy-System (3)<br />
– Verwalte f.a. L ≤ K ≤ U Listen mit freien Blöcken der Größe 2 K<br />
– Allgemeiner Fall:<br />
Anforderung eines Blocks der Größe 2 i-1 < s ≤ 2 i :<br />
• Vergebe Block aus Liste i, wenn vorhanden<br />
• Sonst: Wähle Block aus nächst größerer nichtleerer Liste<br />
• Teile rekursiv auf, bis ein Block der Größe 2i vorhanden<br />
– Wenn nach Freigabe eines Blocks der Größe 2K der entsprechende<br />
Partnerblock der Größe 2K ebenfalls frei war:<br />
• Verschmelze die Blöcke zu einem Block der Größe 2K+1 • Mache rekursiv mit Verschmelzen weiter<br />
RW-Systemarchitektur Kap. 8<br />
22
Buddy-System (4)<br />
• Beispiel:<br />
– Speicher der Größe 1 GB<br />
– Folge von Anforderungen und Freigaben:<br />
• A fordert 100 MB an.<br />
• B fordert 240 MB an.<br />
• C fordert 64 MB an.<br />
• D fordert 256 MB an.<br />
• Freigabe B<br />
• Freigabe A<br />
• E fordert 75 MB an.<br />
• Freigabe C<br />
• Freigabe E<br />
• Freigabe D<br />
RW-Systemarchitektur Kap. 8<br />
1 GB<br />
23
Buddy-System (5)<br />
1 GB<br />
…<br />
RW-Systemarchitektur Kap. 8<br />
24
Buddy-System (5)<br />
Nach Anforderung A: 100 MB, d.h. Block der Größe 128 MB:<br />
1 GB<br />
A:128MB<br />
Es folgt Anforderung B: 240 MB, d.h. Block der Größe 256 MB.<br />
RW-Systemarchitektur Kap. 8<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 1<br />
256 MB: 1<br />
128 MB: 1<br />
64 MB: 0<br />
25
Buddy-System (5)<br />
Nach Anforderung B: 240 MB, d.h. Block der Größe 256 MB.<br />
1 GB<br />
A:128MB B:256MB<br />
Es folgt Anforderung C: 64 MB, d.h. Block der Größe 64 MB.<br />
RW-Systemarchitektur Kap. 8<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 1<br />
256 MB: 0<br />
128 MB: 1<br />
64 MB: 0<br />
26
Buddy-System (5)<br />
Nach Anforderung C: 64 MB, d.h. Block der Größe 64 MB.<br />
1 GB<br />
A:128MB C:64MB<br />
B:256MB<br />
Es folgt Anforderung D: 256 MB, d.h. Block der Größe 256 MB.<br />
RW-Systemarchitektur Kap. 8<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 1<br />
256 MB: 0<br />
128 MB: 0<br />
64 MB: 1<br />
27
Buddy-System (5)<br />
Nach Anforderung D: 256 MB, d.h. Block der Größe 256 MB.<br />
1 GB<br />
Es folgt Freigabe B.<br />
A:128MB C:64MB B:256MB<br />
D:256MB<br />
RW-Systemarchitektur Kap. 8<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 0<br />
256 MB: 1<br />
128 MB: 0<br />
64 MB: 1<br />
28
Buddy-System (5)<br />
Nach Freigabe B:<br />
1 GB<br />
Es folgt Freigabe A.<br />
A:128MB C:64MB D:256MB<br />
RW-Systemarchitektur Kap. 8<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 0<br />
256 MB: 2<br />
128 MB: 0<br />
64 MB: 1<br />
29
Buddy-System (5)<br />
Nach Freigabe A:<br />
1 GB<br />
C:64MB D:256MB<br />
Es folgt Anforderung E: 75 MB, d.h. Block der Größe 128 MB.<br />
RW-Systemarchitektur .<br />
Kap. 8<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 0<br />
256 MB: 2<br />
128 MB: 1<br />
64 MB: 1<br />
30
Buddy-System (5)<br />
Nach Anforderung E: 75 MB, d.h. Block der Größe 128 MB:<br />
1 GB<br />
E:128MB<br />
C:64MB D:256MB<br />
Es folgt Freigabe C.<br />
RW-Systemarchitektur Kap. 8<br />
.<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 0<br />
256 MB: 2<br />
128 MB: 0<br />
64 MB: 1<br />
31
Buddy-System (5)<br />
Bei Freigabe C:<br />
1 GB<br />
„Buddies“<br />
E:128MB<br />
RW-Systemarchitektur Kap. 8<br />
D:256MB<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 0<br />
256 MB: 2<br />
128 MB: 0<br />
64 MB: 2<br />
32
Buddy-System (5)<br />
Nach Freigabe C:<br />
1 GB<br />
E:128MB<br />
Es folgt Freigabe E.<br />
RW-Systemarchitektur .<br />
Kap. 8<br />
D:256MB<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 0<br />
256 MB: 2<br />
128 MB: 1<br />
64 MB: 0<br />
33
Buddy-System (5)<br />
Bei Freigabe E:<br />
1 GB<br />
„Buddies“<br />
RW-Systemarchitektur Kap. 8<br />
D:256MB<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 0<br />
256 MB: 2<br />
128 MB: 2<br />
64 MB: 0<br />
34
Buddy-System (5)<br />
Bei Freigabe E:<br />
1 GB<br />
„Buddies“<br />
RW-Systemarchitektur Kap. 8<br />
D:256MB<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 0<br />
256 MB: 3<br />
128 MB: 0<br />
64 MB: 0<br />
35
Buddy-System (5)<br />
Nach Freigabe E:<br />
1 GB<br />
Es folgt Freigabe D.<br />
RW-Systemarchitektur Kap. 8<br />
.<br />
D:256MB<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 1<br />
256 MB: 1<br />
128 MB: 0<br />
64 MB: 0<br />
36
Buddy-System (5)<br />
Bei Freigabe D:<br />
1 GB<br />
RW-Systemarchitektur Kap. 8<br />
„Buddies“<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 1<br />
256 MB: 2<br />
128 MB: 0<br />
64 MB: 0<br />
37
Buddy-System (5)<br />
Bei Freigabe D:<br />
1 GB<br />
RW-Systemarchitektur Kap. 8<br />
„Buddies“<br />
Freie Blöcke:<br />
1 GB: 0<br />
512 MB: 2<br />
256 MB: 0<br />
128 MB: 0<br />
64 MB: 0<br />
38
Buddy-System (5)<br />
Nach Freigabe D:<br />
1 GB<br />
Gesamter Speicher wieder als 1 Block verfügbar.<br />
RW-Systemarchitektur Kap. 8<br />
Freie Blöcke:<br />
1 GB: 1<br />
512 MB: 0<br />
256 MB: 0<br />
128 MB: 0<br />
64 MB: 0<br />
39
8.2.2 Verlagerung (1)<br />
• Nach Aus- und Wiedereinlagern von Prozessen liegen<br />
Programmcode bzw. Daten an anderer Stelle.<br />
• Absolute Sprungbefehle und Datenzugriffsbefehle sollen weiterhin<br />
funktionieren.<br />
• Unterscheidung:<br />
– Logische Adresse: Bezug auf eine Speicherstelle unabhängig von der<br />
aktuellen Zuteilung von Daten im Speicher<br />
– Relative Adresse:<br />
• Spezialfall einer logischen Adresse<br />
• Adresse relativ zu einem bekannten Punkt (meist Programmanfang)<br />
ausgedrückt<br />
– Physikalische bzw. absolute Adresse: konkrete Stelle im<br />
Hauptspeicher<br />
RW-Systemarchitektur Kap. 8<br />
40
Verlagerung (2)<br />
• Berechnung von absoluten Adressen aus relativen Adressen durch<br />
Hardware.<br />
• Beim Einlagern eines Prozesses:<br />
• …<br />
– Adresse des Programmanfangs in Basisregister.<br />
– Zusätzlich: Zur Realisierung von Speicherschutz enthält Grenzregister<br />
die höchste erlaubte Speicheradresse – eine Schtzmaßnahme gegen<br />
„Pufferüberlauf“ (buffer overflow)<br />
RW-Systemarchitektur Kap. 8<br />
41
Verlagerung (3)<br />
Basisregister<br />
Grenzregister<br />
Addierer<br />
Vergleicher<br />
Unterbrechung an<br />
Betriebssystem<br />
RW-Systemarchitektur Kap. 8<br />
Absolute Adresse<br />
Relative Adresse<br />
Prozesskontrollblock<br />
Programm<br />
Daten<br />
Stapel<br />
Prozessabbild im<br />
Hauptspeicher<br />
42
8.2.3 Seitenadressierung (Paging)<br />
• Seitenadressierung<br />
• Seitenaustauschverfahren mit virtuellem Speicher<br />
• Erfinder:<br />
– Fritz-Rudolf Güntsch, Dissertation 1957<br />
– Fotheringham, 1961 in ATLAS Computer, Univ. Manchester<br />
RW-Systemarchitektur Kap. 8<br />
43
Seitenadressierung (Paging)<br />
• Wie bisher (im Gegensatz zu virtuellem Speicherkonzept): Prozesse sind<br />
entweder ganz im Speicher oder komplett ausgelagert.<br />
• Im Gegensatz zu Partitionierung werden Prozessen nicht<br />
notwendigerweise zusammenhängende Speicherbereiche zugeordnet.<br />
• Hauptspeicher aufgeteilt in viele gleichgroße Seitenrahmen.<br />
• Speicher eines Prozesses aufgeteilt in Seiten derselben Größe.<br />
• Zuordnung von Seiten zu Seitenrahmen beim Laden von Prozessen<br />
– Logische Adressen der Form „Seitennummer, Offset“<br />
– Pro Prozess eine „Seitentabelle“<br />
– Seitentabelle übersetzt Seitennummern in Nummern von Seitenrahmen im<br />
physikalischen Speicher<br />
• Interne Fragmentierung nur bei letzter Seite eines Prozesses<br />
RW-Systemarchitektur Kap. 8<br />
44
Seitenadressierung (2)<br />
• Beispiel:<br />
Rahmennummer<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
Hauptspeicher<br />
RW-Systemarchitektur Kap. 8<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
Hauptspeicher<br />
A.0<br />
A.1<br />
A.2<br />
A.3<br />
Prozess A<br />
geladen<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
Hauptspeicher<br />
A.0<br />
A.1<br />
A.2<br />
A.3<br />
B.0<br />
B.1<br />
B.2<br />
Prozess B<br />
geladen<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
Hauptspeicher<br />
A.0<br />
A.1<br />
A.2<br />
A.3<br />
B.0<br />
B.1<br />
B.2<br />
C.0<br />
C.1<br />
C.2<br />
C.3<br />
Prozess C<br />
geladen<br />
Prozess D<br />
mit 6 Seiten<br />
soll jetzt<br />
geladen<br />
werden!<br />
45
Seitenadressierung (3)<br />
• Beispiel:<br />
Rahmennummer<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
Hauptspeicher<br />
A.0<br />
A.1<br />
A.2<br />
A.3<br />
C.0<br />
C.1<br />
C.2<br />
C.3<br />
Prozess B<br />
ausgelagert<br />
RW-Systemarchitektur Kap. 8<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
Hauptspeicher<br />
A.0<br />
A.1<br />
A.2<br />
A.3<br />
D.0<br />
D.1<br />
D.2<br />
C.0<br />
C.1<br />
C.2<br />
C.3<br />
D.3<br />
D.4<br />
Prozess D<br />
geladen<br />
Datenstrukturen zum aktuellen Zeitpunkt:<br />
0<br />
1<br />
2<br />
3<br />
0<br />
1<br />
2<br />
3<br />
Seitentabelle<br />
Prozess A<br />
0 7<br />
1 8<br />
2 9<br />
3 10<br />
Seitentabelle<br />
Prozess C<br />
13<br />
14<br />
0 -<br />
1 -<br />
2 -<br />
Seitentabelle<br />
Prozess B<br />
0 4<br />
1 5<br />
2 6<br />
3 11<br />
4 12<br />
Seitentabelle<br />
Prozess D<br />
Liste der freien<br />
Rahmen<br />
46
Seitenadressierung (4)<br />
• Berechnung von physikalischen Adressen aus logischen Adressen:<br />
– Voraussetzung: Länge der Seiten ist eine Zweierpotenz<br />
– Logische Adresse besteht aus Seitennummer und Offset.<br />
– Absolute Adresse wird durch Hardware auf Grundlage der<br />
Seitentabelle des Prozesses berechnet.<br />
– …<br />
RW-Systemarchitektur Kap. 8<br />
47
Seitenadressierung (5)<br />
• Bsp.: logische Adresse der Länge 16 Bit<br />
0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0<br />
6-Bit-Seitennummer 10-Bit-Offset<br />
– Der Prozess kann somit bis zu 26 verschiedene Seiten haben, die über<br />
die Seitentabelle des Prozesses auf Seitenrahmen im Hauptspeicher<br />
abgebildet werden.<br />
– Jede Seite besteht aus 210 = 1024 Bytes.<br />
– Berechnung der physikalischen Adresse:<br />
…<br />
RW-Systemarchitektur Kap. 8<br />
48
Seitenadressierung (6)<br />
6-Bit-Seitennummer 10-Bit-Offset<br />
0 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0<br />
0 10010010<br />
1 10010011<br />
2 11011001<br />
3 11111010<br />
Seitentabelle<br />
des Prozesses<br />
Seitenrahmen Nr. 147<br />
(=)<br />
RW-Systemarchitektur Kap. 8<br />
…<br />
…<br />
…<br />
…<br />
Speicherzelle Nr. 478<br />
(= )<br />
innerhalb des<br />
Seitenrahmens.<br />
⇒ Reale Adresse:<br />
10010011|0111011110<br />
49
Seitenadressierung (7)<br />
• Entfernen eines Prozesses aus dem Speicher:<br />
– Lagere Prozess auf Hintergrundspeicher aus (z.B. Festplatte).<br />
– Über Seitentabelle kann man feststellen, welche Seitenrahmen dem<br />
Prozess gehören.<br />
– Füge diese Rahmen zur Liste der freien Rahmen hinzu.<br />
– (Keine zusätzlichen Datenstrukturen des Betriebssystems benötigt.)<br />
RW-Systemarchitektur Kap. 8<br />
50
Seitenadressierung mit virtuellem Speicher (1)<br />
• Grundidee:<br />
– Nur Teile der Daten von Prozessen im Hauptspeicher halten.<br />
– Programmausführung auf Code und Daten im Speicher.<br />
– Bei Zugriff auf ausgelagerte Speicherbereiche muss nachgeladen werden.<br />
• Bezeichnungen:<br />
– Hauptspeicher = realer Speicher<br />
– Hauptspeicher + Hintergrundspeicher = virtueller Speicher<br />
• Vorteile:<br />
– Mehr aktive Prozesse im Speicher (⇒ Pseudoparallelismus!)<br />
– Tatsächlicher Speicherplatzbedarf eines Prozesses muss nicht von vornherein<br />
feststehen.<br />
– Adressraum eines Prozesses kann größer sein als verfügbarer Hauptspeicher.<br />
• Nachteil:<br />
– Bei Zugriff auf Code/Daten, die nicht im Hauptspeicher vorhanden sind, muss<br />
das Betriebssystem die entsprechenden Seiten nachladen.<br />
– Dabei müssen evtl. andere Seiten ausgelagert werden, um Platz zu schaffen.<br />
RW-Systemarchitektur Kap. 8<br />
51
Lokalität<br />
• Kann das überhaupt effizient funktionieren?<br />
– Antwort: ja!<br />
– Grund: Räumliche und zeitliche Lokalität von Programmen, d.h.<br />
Abarbeitung während kürzerer Zeit bewegt sich häufig in engen<br />
Adressbereichen.<br />
• Abarbeitung von Schleifen<br />
• In zeitlich engem Abstand Zugriff auf gleiche Daten<br />
• Zugriffe auf benachbarte Daten<br />
RW-Systemarchitektur Kap. 8<br />
52
Lokalität<br />
• Bsp.:<br />
RW-Systemarchitektur Kap. 8<br />
53
Lokalität<br />
• Seitenaustauschverfahren mit virtuellem Speicher ist nur dann<br />
effizient, wenn Lokalität gegeben.<br />
• Falls nicht:<br />
– Ständiges Aus- und Einlagern von Seiten zwischen Hauptspeicher und<br />
Festplatte<br />
– Bezeichnung: Seitenflattern („thrashing“)<br />
RW-Systemarchitektur Kap. 8<br />
54
Technische Realisierung<br />
• Technische Realisierung von Seitenaustauschverfahren mit<br />
virtuellem Speicher:<br />
– Die Daten des Prozesses befinden sich im Hintergrundspeicher<br />
(Festplatte), bei nicht komplett ausgelagerten Prozessen<br />
zusätzlich noch Teile im Speicher<br />
– Trennung der logischen Adressen in Seitennummer und Offset,<br />
z.B.:<br />
0 0 … 0 1 0 1 1 1 0 0 1 1 1 0<br />
22-Bit-Seitennummer 10-Bit-Offset<br />
– Im Gegensatz zu nur Seitenadressierung:<br />
• Logische Adressen überdecken kompletten virtuellen Adressraum,<br />
z.B. 32-Bit- / 64-Bit-Adressen<br />
– Pro Prozess eine Seitentabelle zur Übersetzung<br />
Seitennummer ⇒ Seitenrahmen<br />
RW-Systemarchitektur Kap. 8<br />
55
Technische Realisierung<br />
– Logische Adresse:<br />
– Seitentabelleneintrag:<br />
0 0 … 0 1 0 1 1 1 0 0 1 1 1 0<br />
22-Bit-Seitennummer 10-Bit-Offset<br />
• Present-Bit P: „Seite ist im Hauptspeicher“<br />
• Modify-Bit M: „Seite wurde verändert“<br />
• Weitere Bits für Schutzrechte und gemeinsame Nutzung<br />
– Seitentabelle liegt im Hauptspeicher<br />
– Umsetzung der virtuellen Adressen in reale Adressen mit<br />
Hardwareunterstützung<br />
(Memory Managment Unit (MMU) des Prozessors)<br />
RW-Systemarchitektur Kap. 8<br />
P M Weitere Bits Seitenrahmennummer<br />
56
Adressumsetzung<br />
Virtuelle Adresse<br />
Seitennr. Offset<br />
Register<br />
Seitentabellenzeiger<br />
RW-Systemarchitektur Kap. 8<br />
+<br />
Seitennummer<br />
Seitentabelle<br />
Reale Adresse<br />
Rahmennr. Offset<br />
Rahmennr.<br />
Programm Paging-Verfahren Hauptspeicher<br />
Offset<br />
… …<br />
Seitenrahmen<br />
57
Seitentabelle<br />
Seite 0<br />
Seite 1<br />
Seite 2<br />
Seite 3<br />
Seite 4<br />
Seite 5<br />
Seite 6<br />
Seite 7<br />
virtueller<br />
Adressraum<br />
Seitennr<br />
.<br />
0<br />
RW-Systemarchitektur Kap. 8<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
P<br />
0<br />
0<br />
1<br />
0<br />
1<br />
0<br />
0<br />
0<br />
Seitenrahmen 0<br />
Seitenrahmen 1<br />
Seitenrahmen 2<br />
Seitenrahmen 3<br />
Hauptspeicher<br />
Rahmennr.<br />
Seitentabelle des Prozesses im Hauptspeicher<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
0<br />
3<br />
58
Seitenfehler<br />
Zugriff auf eine nicht im Hauptspeicher befindliche Seite:<br />
– Hardware (MMU) stellt anhand des present bits fest, dass angefragte<br />
Seite nicht im Hauptspeicher ist (⇒ „Seitenfehler“ bzw. „page fault“).<br />
– Auslösen einer Unterbrechung („Interrupt“) durch die Hardware<br />
– Behandlung des Interrupts:<br />
• Laufendes Programm wird unterbrochen, Sichern des aktuellen<br />
Programmzustandes durch Hardware (Stand des Programmzählers!)<br />
• Routine zur Interruptbehandlung wird aufgerufen<br />
– Feststellen des Grundes der Unterbrechung (hier: page fault)<br />
– Behandlung abhängig vom Grund der Unterbrechung, hier:<br />
» Betriebssystem lädt die entsprechende Seite von der Festplatte in<br />
einen freien Seitenrahmen<br />
» Wenn kein Seitenrahmen frei: Verdrängen eines belegten<br />
Seitenrahmens<br />
» Aktualisierung der Seitentabelle<br />
• Danach: Laufendes Programm wird wieder fortgesetzt<br />
RW-Systemarchitektur Kap. 8<br />
59
Seitenfehler<br />
• Welche Informationen benötigt das Betriebssystem zum<br />
Einlagern von Seiten (d.h. während der Behandlung einer<br />
Unterbrechung wegen eines page faults)?<br />
– Abbildung Seitennummer → Festplattenadresse, um die<br />
gesuchte Seite auf der Festplatte zu finden<br />
– Liste freier Seitenrahmen<br />
RW-Systemarchitektur Kap. 8<br />
60
Seitenfehler<br />
Seite 0<br />
Seite 1<br />
Seite 2<br />
Seite 3<br />
Seite 4<br />
Seite 5<br />
Seite 6<br />
Seite 7<br />
virtueller<br />
Adressraum<br />
Seitennr<br />
.<br />
0<br />
RW-Systemarchitektur Kap. 8<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
P<br />
0<br />
0<br />
1<br />
0<br />
1<br />
0<br />
0<br />
0<br />
Seitenrahmen 0<br />
Seitenrahmen 1<br />
Seitenrahmen 2<br />
Seitenrahmen 3<br />
Hauptspeicher<br />
Rahmennr.<br />
Seitentabelle des Prozesses im Hauptspeicher<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
0<br />
3<br />
Festplatten-Adresse<br />
A<br />
D<br />
B<br />
X<br />
Y<br />
C<br />
E<br />
F<br />
61
Verdrängung<br />
• Wenn kein freier Seitenrahmen vorhanden: Verdrängen von Seitenrahmen<br />
auf die Festplatte.<br />
• Je nach Betriebssystem:<br />
– Alle Seitenrahmen sind Kandidaten für Verdrängung oder<br />
– Nur Seitenrahmen des eigenen Prozesses<br />
• Entscheidung unter diesen Kandidaten gemäß Verdrängungsstrategie<br />
(Ziel: gute Ausnutzung von Lokalität).<br />
• Ist das Modify-Bit M gesetzt, dann muss Seite im entsprechenden Rahmen<br />
auf Festplatte zurückgeschreiben werden.<br />
• Nach Verdrängen eines Seitenrahmens muss die Seitentabelle des<br />
zugehörigen Prozesses aktualisiert werden.<br />
• Da Seitentabellen meist nur dünn besetzt:<br />
– Suchen des verdrängten Seitenrahmens in Seitentabelle des Prozesses<br />
ineffizient<br />
– Abbildung Seitenrahmennummer → (Prozessnummer, Seitennummer) hilfreich<br />
RW-Systemarchitektur Kap. 8<br />
62
Verdrängung<br />
Seite 0<br />
Seite 1<br />
Seite 2<br />
Seite 3<br />
Seite 4<br />
Seite 5<br />
Seite 6<br />
Seite 7<br />
virtueller<br />
Adressraum<br />
Prozess 1<br />
Seite<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
P<br />
0<br />
0<br />
1<br />
0<br />
1<br />
0<br />
0<br />
0<br />
Seitenrahmen 0<br />
Seitenrahmen 1<br />
Seitenrahmen 2<br />
Seitenrahmen 3<br />
Rahmen<br />
Hauptspeicher<br />
RW-Systemarchitektur Kap. 8<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
Seitentabelle von Prozess 1<br />
0<br />
3<br />
Seite<br />
0<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
P<br />
0<br />
0<br />
1<br />
0<br />
0<br />
0<br />
0<br />
0<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
…<br />
Rahmen<br />
Seitentabelle von Prozess 1<br />
1<br />
2<br />
Seite 0<br />
Seite 1<br />
Seite 2<br />
Seite 3<br />
Seite 4<br />
Seite 5<br />
Seite 6<br />
Seite 7<br />
virtueller<br />
Adressraum<br />
Prozess 2<br />
63
Verdrängung<br />
Seite 0<br />
Seite 1<br />
Seite 2<br />
Seite 3<br />
Seite 4<br />
Seite 5<br />
Seite 6<br />
Seite 7<br />
virtueller<br />
Adressraum<br />
Prozess 1<br />
Rahmen<br />
Seitenrahmen 0<br />
Seitenrahmen 1<br />
Seitenrahmen 2<br />
Seitenrahmen 3<br />
Hauptspeicher<br />
RW-Systemarchitektur Kap. 8<br />
0<br />
1<br />
2<br />
3<br />
Prozess Seite<br />
1<br />
2<br />
2<br />
1<br />
Abbildung Seitenrahmennummer ⇒ (Prozessnummer, Seitennummer)<br />
2<br />
2<br />
6<br />
4<br />
Seite 0<br />
Seite 1<br />
Seite 2<br />
Seite 3<br />
Seite 4<br />
Seite 5<br />
Seite 6<br />
Seite 7<br />
virtueller<br />
Adressraum<br />
Prozess 2<br />
64
Größe von Seitentabellen<br />
• Problem: Größe der Seitentabelle<br />
• Bsp.:<br />
– 32-Bit-Adressraum<br />
– 20 Bit Seitennummer, 12 Bit Offset<br />
⇒ 220 Seiten der Größe 212 Byte<br />
– Seitentabelle mit 220 Zeilen ⇒ 4 MB für Seitentabelle bei 4 Byte pro<br />
Zeile, d.h. 210 Seiten<br />
– Für jeden Prozess!<br />
– Noch schlimmer bei 64-Bit-Adressraum …<br />
• Abhilfe:<br />
– Zweistufige Seitentabellen<br />
– „Invertierte Seitentabellen“<br />
RW-Systemarchitektur Kap. 8<br />
65
Zweistufige Seitentabellen<br />
• „Hierarchische Seitentabelle“ (vgl. Pentium)<br />
• Idee: Speichere auch Seitentabelle im virtuellen Speicher<br />
• Im Beispiel:<br />
– 2 20 Seiten mit jeweils 2 12 Byte, pro Eintrag 4 Byte ⇒ 2 22 Byte für<br />
Seitentabelle, d.h. 2 10 Seiten für Seitentabelle benötigt<br />
– Führe „Hauptseite“ (212 Byte) ein, die immer im Speicher liegt.<br />
– Hauptseite enthält 210 Verweise auf Seiten der<br />
„Benutzerseitentabelle“, indiziert mit ersten 10 Bit der Adresse<br />
– Wenn gesuchte Seite der Benutzerseitentabelle nicht im Speicher:<br />
Lade in einen freien Seitenrahmen<br />
– Benutze 10 mittlere Bit, um in „Untertabelle“ den gesuchten<br />
Seitenrahmen zu finden (evtl. Nachladen von Festplatte)<br />
– Restliche 12 Bit wie üblich als Offset innerhalb des Seitenrahmens<br />
RW-Systemarchitektur Kap. 8<br />
66
Adressumsetzung<br />
Virtuelle Adresse<br />
10 Bit 10 Bit 12 Bit<br />
Register<br />
Hauptseitentabellenzeiger<br />
Hauptseitentabelle<br />
(2 10 Einträge)<br />
RW-Systemarchitektur Kap. 8<br />
+<br />
Reale Adresse<br />
Rahmennr. Offset<br />
Programm Paging-Verfahren Hauptspeicher<br />
+<br />
Untertabelle<br />
(2 10 Einträge)<br />
…<br />
Seitenrahmen<br />
…<br />
67
Invertierte Seitentabellen<br />
• Siehe Power PC, IBM AS/400<br />
• Beobachtung:<br />
– Sei n die Zahl der Seiten im virtuellen Adressraum, m die Zahl der einem<br />
Prozess zugeordneten Seitenrahmen. Dann ist üblicherweise n >> m.<br />
⇒ Seitentabellen sind meist nur sehr dünn besetzt<br />
– Seitentabelle zur Abbildung<br />
Seitennummer → Seitenrahmennummer verschwendet Speicherplatz.<br />
• Allgemeines Problem:<br />
– Gegeben Schlüssel k1 , …, km ∈ {0, …, n-1} oder allgemein k1 , …, km ∈ U mit<br />
|U| = n.<br />
– Gesucht ist eine Methode, die jedem Schlüssel ki einen Wert vi zuordnet.<br />
– Die Zuordnung soll speicher- und laufzeiteffizient sein.<br />
RW-Systemarchitektur Kap. 8<br />
68
Invertierte Seitentabellen<br />
• Methoden aus Gebiet „Algorithmen und Datenstrukturen“<br />
• Bei „Invertierten Seitentabellen“ benutzt: Hashing<br />
– Schlüssel k i sind Seitennummern<br />
– Wert v i sind Seitenrahmennummern<br />
– Benutze Tabellen der Länge m (Anzahl der Seitenrahmen) (oder auch etwas größer)<br />
– Benutze „Hash-Funktion“<br />
• h : {0, …, n-1} → {0, …, m-1} zur Abbildung von Seitennummern auf „Plätze in der<br />
Hashtabelle“<br />
• Einfaches Beispiel: h(k i ) = k i mod m<br />
• Bei Vergabe eines neuen Seitenrahmens v i :<br />
Speichere an Platz h(k i ) das Paar (k i , v i ) ab.<br />
• Problem: Hashkollisionen<br />
– An Stelle h(k i ) kann sich schon ein Eintrag (k j , v j ) befinden mit k i ≠ k j , aber h(k i ) = h(k j ).<br />
– Zur Überprüfung muss k i bei (k i , v i ) mitgespeichert werden!<br />
⇒ Lösung z.B. durch „Überläuferketten“<br />
• Suche mit Schlüssel k i : Nachschauen an Stelle h(k i )<br />
– Wenn Stelle belegt, überprüfe, ob Schlüssel übereinstimmt<br />
– Sonst: Verfolge Überläuferkette<br />
• Löschen von Einträgen: analog<br />
RW-Systemarchitektur Kap. 8<br />
69
Invertierte Seitentabellen – Prinzipieller Aufbau<br />
Virtuelle Adresse<br />
Seitennr. Offset<br />
k i<br />
Hashfunktion<br />
RW-Systemarchitektur Kap. 8<br />
h<br />
h(k i )<br />
Seitennr. Eintrag<br />
k j<br />
k i<br />
Reale Adresse<br />
Rahmennr. Offset<br />
Invertierte<br />
Seitentabelle<br />
v j<br />
Rahmennr.<br />
Zeiger<br />
Überläuferkette<br />
70
Translation Lookaside Buffer (TLB)<br />
• Effizienzproblem:<br />
– Bei Paging zieht ein Speicherzugriff auf Code / Daten einen<br />
zusätzlichen Zugriff auf die Seitentabelle im Speicher nach sich<br />
(sogar zwei bei zweistufiger Seitentabelle).<br />
– Doppelte (dreifache) Zugriffszeit<br />
⇒ Hardwaremäßige Beschleunigung durch einen zusätzlichen<br />
Cache für Adressübersetzung:<br />
Translation Lookaside Buffer (TLB) =<br />
„Adressumsetzungspuffer“<br />
• Ablauf:<br />
– Nachsehen, ob Eintrag zu virtueller Adresse in TLB<br />
– Wenn ja: Lese Seitenrahmennummer aus TB<br />
– Sonst: Nachsehen in Seitentabelle<br />
– Evtl. Seite von Festplatte nachladen<br />
RW-Systemarchitektur Kap. 8<br />
71
Translation Lookaside Buffer (TLB)<br />
Virtuelle Adresse<br />
Seitennr. Offset<br />
TLB-<br />
Fehlschlag<br />
Seitenfehler<br />
TLB<br />
Seitentabelle<br />
TLB-Treffer<br />
Rahmennr. Offset<br />
Reale Adresse<br />
RW-Systemarchitektur Kap. 8<br />
Hauptspeicher Sekundärspeicher<br />
Offset<br />
… …<br />
Seitenrahmen<br />
}<br />
Seite<br />
laden<br />
{<br />
…<br />
…<br />
}<br />
72
Translation Lookaside Buffer (TLB)<br />
• Der TLB ist ein Hardware-Cache.<br />
• Meist realisiert als assoziativer Speicher:<br />
– Einträge der Form (Seitennummer, Seitentabelleneintrag)<br />
– Angefragte Seitennummer wird durch Hardware parallel mit allen<br />
Einträgen in TLB verglichen.<br />
– Ausgabe:<br />
• Vorhanden, Seitentabelleneintrag<br />
• Nicht vorhanden<br />
– Bei Eintrag: Verdrängungsstrategien notwendig …<br />
– Teuerste Realisierungsmöglichkeit eines Caches!<br />
RW-Systemarchitektur Kap. 8<br />
73
Translation Lookaside Buffer (TLB)<br />
Virtuelle Adresse<br />
Seitennr. Offset<br />
5 502<br />
…<br />
Seitentabellen-<br />
Seitennr. einträge<br />
19<br />
128<br />
Adressumsetzungspuffer<br />
RW-Systemarchitektur Kap. 8<br />
1<br />
5<br />
90<br />
…<br />
37<br />
37 502<br />
Rahmennr. Offset<br />
Reale Adresse<br />
74
TLB und Caches<br />
virtuelle Adresse<br />
MMU<br />
physikalische Adresse<br />
Cache<br />
Hauptspeicher<br />
RW-Systemarchitektur Kap. 8<br />
• Zusätzlich noch Caches für<br />
Programme und Daten:<br />
– Caches für Programme und Daten<br />
sind TLB / MMU nachgeschaltet.<br />
– Verwenden physikalische<br />
Adressen.<br />
75
Virtuelle Cache-Adressierung<br />
virtuelle Adresse<br />
MMU<br />
Cache<br />
physikalische Adresse<br />
Hauptspeicher<br />
RW-Systemarchitektur Kap. 8<br />
• Alternative: Cache mit der virtuellen Adresse<br />
adressieren.<br />
• Vorteil:<br />
– Adressumsetzung und<br />
Cachezugriff parallel<br />
• Nachteil:<br />
– Verschiedene Prozesse benutzen gleiche virtuelle<br />
Adresse für verschiedene reale Adressen.<br />
⇒ Daten- / Programmcache bei Prozesswechsel ungültig<br />
– Abhilfe bei Single-Prozessor-Umgebungen:<br />
• Trage zusätzlich zur virtuellen Adresse auch PID<br />
(process identifier)-Tag ein<br />
• Schwierig in Zusammenhang mit Konsistenz von Caches<br />
bei Multiprozessoren<br />
⇒ Meist physikalische Cache-Adressierung<br />
verwendet.<br />
76
Seitengröße<br />
• Wahl der Seitengröße sehr wichtig für Systemleistung<br />
• Kleine Seiten:<br />
– Wenig „Verschnitt“ (interne Fragmentierung)<br />
• Große Seiten:<br />
– Kleinere Seitentabellen, weniger Verwaltungsaufwand<br />
• „Moderne“ Probleme:<br />
– Objektorientierte Techniken mit vielen kleinen, verstreuten Programmund<br />
Datenmodulen ⇒ Schwächung der Lokalität<br />
– Multithreading-Anwendungen wirken Lokalität entgegen.<br />
• In Realität: Seitengrößen um 4 Kbyte, teilweise auch variierbar (z.B.<br />
Pentium bis 4 Mbyte)<br />
RW-Systemarchitektur Kap. 8<br />
77
8.2.4 Segmentierung<br />
• Im Gegensatz zu Partitionierung werden Prozessen nicht<br />
notwendigerweise zusammenhängende Speicherbereiche zugeordnet.<br />
• Speicher eines Prozesses aufgeteilt in Segmente, deren Größe im<br />
Gegensatz zu den Seiten beim Paging verschieden sein kann.<br />
• Keine interne Fragmentierung, aber externe Fragmentierung (wie bei<br />
dynamischer Partitionierung.<br />
• Segmentierung ist für Programmierer / Übersetzer sichtbar.<br />
• Aufteilung in Codesegmente, Datensegmente, …<br />
• Einfache Segmentierung: Prozesse sind entweder ganz im Speicher oder<br />
komplett ausgelagert.<br />
RW-Systemarchitektur Kap. 8<br />
78
Segmentierung<br />
• Logische Adresse besteht aus Segmentadresse und Offset.<br />
• Berechnung der realen Adresse durch Addition von<br />
– Basisadresse des Segments<br />
– Offset<br />
• Segmenttabelle enthält pro Segment<br />
– Basisadresse des Segments (Startadresse im Speicher)<br />
– Segmentlänge<br />
RW-Systemarchitektur Kap. 8<br />
79
Segmentierung<br />
• Bsp.: logische Adresse mit 16 Bit<br />
4-Bit-Segmentnummer 12-Bit-Offset<br />
0 0 0 1 0 0 1 0 1 1 1 1 0 0 0 0<br />
0<br />
1<br />
2<br />
Prozesssegmenttabelle<br />
001011101110 0000010000000000<br />
011110011110 0010010000100000<br />
000110010100 0011010100000000<br />
Länge Basis<br />
RW-Systemarchitektur Kap. 8<br />
+<br />
0 0 1 1 0 1 1 1 0 0 0 1 0 0 0 0<br />
16-Bit physikalische Adresse<br />
80
Segmentierung<br />
• Segmentierung mit virtuellem Speicher<br />
– Nicht alle Segmente eines nicht komplett ausgelagerten Prozesses<br />
müssen im Speicher vorhanden sein.<br />
– Restliche Segmente auf Festplatte<br />
– Segmenttabelleneintrag:<br />
P M Weitere Bits Länge Basis<br />
• Present-Bit P: „Seite ist im Hauptspeicher“<br />
• Modify-Bit M: „Seite wurde verändert“<br />
• Weitere Bits für Schutzrechte und gemeinsame Nutzung<br />
• Schutz und gemeinsame Nutzung auf Segmentbasis einfach zu<br />
regeln<br />
• Größe der Segmente unterschiedlich und dynamisch festlegbar<br />
• Bei Segmentvergrößerung:<br />
– Allokieren von nachfolgendem Speicher oder<br />
– Verschiebung in einen größeren freien Bereich oder<br />
– Auslagerung<br />
RW-Systemarchitektur Kap. 8<br />
81
8.2.5 Seiten und Segmente<br />
• Vorteile Paging:<br />
– Für den Nutzer transparent<br />
– Feste Seitengrößen ⇒ leistungsfähige <strong>Speicherverwaltung</strong>salgorithmen<br />
• Vorteile Segmentierung:<br />
– Anpassung an dynamischen Speicherbedarf von Prozessen<br />
– Gemeinsame Nutzung und Schutz auf Grundlage „natürlicher<br />
Organisationseinheiten“<br />
⇒ Kombination beider Verfahren:<br />
– Prozesse aufgeteilt in Segmente, pro Prozess eine Segmenttabelle<br />
– Segmente aufgeteilt in Seiten, pro Segment eine Seitentabelle<br />
• Aufbau einer Adresse:<br />
– Für den Programmierer besteht Adresse aus Segmentnummer und<br />
Offset Segmentierung .<br />
– Offset Segmentierung wird beim Paging interpretiert als (Seitennummer,<br />
Offet Paging ).<br />
RW-Systemarchitektur Kap. 8<br />
82
Segmentnr<br />
Segmentierung und Paging kombiniert -<br />
Adressumsetzung<br />
Virtuelle Adresse<br />
Seitennr.<br />
Offset<br />
Register<br />
Segmenttabellenzeiger<br />
Segmenttabelle<br />
RW-Systemarchitektur Kap. 8<br />
+<br />
Reale Adresse<br />
Rahmennr. Offset<br />
Programm Segmentierung<br />
Paging Hauptspeicher<br />
+<br />
Seitentabelle<br />
…<br />
Seitenrahmen<br />
…<br />
83
Betriebssystemaufgaben bei <strong>Speicherverwaltung</strong><br />
• Festlegung verschiedener Strategien:<br />
– Abrufstrategie (Fetch Policy) - Wann wird eine Seite in den Hauptspeicher<br />
geladen?<br />
• „Demand Paging“<br />
• „Prepaging“<br />
– Speicherzuteilungsstrategie (Placement Policy):<br />
Wo im Speicher wird ein Prozessteil abgelegt?<br />
• Nur wichtig bei Segmentierung / Partitionierung, nicht bei Paging<br />
• Z.B. Best-Fit, Next-Fit, First-Fit<br />
– Austauschstrategie (Replacement Policy):<br />
Welche Seite soll ausgelagert werden, wenn alle Seitenrahmen belegt sind?<br />
• Gesperrte Seiten sind ausgenommen!<br />
• Vielzahl von Verfahren, z.B.<br />
– LRU (Least Recently Used)<br />
– FIFO (First In First Out)<br />
– Clock-Algorithmus<br />
• Strategien arbeiten auf der Grundlage von Daten, die durch die Hardware gesammelt<br />
werden müssen.<br />
RW-Systemarchitektur Kap. 8<br />
84
Betriebssystemaufgaben bei <strong>Speicherverwaltung</strong><br />
• Festlegung verschiedener Strategien:<br />
– Strategie zur Verwaltung des „Resident Set“:<br />
Welchem Prozess wird wie viel Platz im Hauptspeicher zugeteilt?<br />
• Feste oder variable Zuteilung von Speicher an Prozesse<br />
• Variable Zuteilung meist auf Grundlage der Seitenfehlerrate (mit<br />
Hardwareunterstützung gemessen / abgeschätzt)<br />
• Lokale oder globale Austauschstrategie (nur Seiten des eigenen Prozesses<br />
ausgelagert oder auch von anderen)<br />
– Cleaning-Strategie:<br />
Wann lagert man eine geänderte Seite in den Sekundärspeicher aus?<br />
• Demand Cleaning<br />
• Precleaning (Motivation: Schreiben mehrerer Seiten in Gruppen)<br />
– Strategie zur Lastkontrolle:<br />
Wieviele Prozesse werden gleichzeitig zugelassen (teilweise im Speicher)<br />
• Ab welcher Zahl von Prozessen beginnt man mit Suspendieren von Prozessen?<br />
• Welche Prozesse werden suspendiert?<br />
RW-Systemarchitektur Kap. 8<br />
85
Zusammenfassung<br />
• <strong>Speicherverwaltung</strong>sstrategien sind extrem wichtig die Effizienz des<br />
Gesamtsystems.<br />
• Moderne Betriebssysteme arbeiten mit virtuellem Speicher.<br />
• Lokalität ist die Grundvoraussetzung für das effiziente<br />
Funktionieren virtueller Speicherkonzepte.<br />
– In der Praxis meist vorhanden.<br />
• Paging unterteilt den Speicher in viele gleich große Teile.<br />
• Segmentierung unterteilt in verschieden große Teile, deren Größe<br />
variabel ist.<br />
• Es ist auch möglich, Paging und Segmentierung zu kombinieren.<br />
RW-Systemarchitektur Kap. 8<br />
86