26.10.2013 Aufrufe

Kapitel 8 Speicherverwaltung

Kapitel 8 Speicherverwaltung

Kapitel 8 Speicherverwaltung

MEHR ANZEIGEN
WENIGER ANZEIGEN

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

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!