Download

Speicherverwaltung
Memory Management
Teil 2
WS 2011/2012
IAIK 1

Invertierte Seitentabelle
• Gewönliche Seitentabelle
• Größe abhängig von der Größe des
virtuellen Adressraums
• Immer nur ein (kleiner) Teil davon im
RAM – verschwendet Platz
• Invertierte Seitentabelle
IAIK 2

Invertierte Seitentabelle
IAIK 3

Invertierte Seitentabelle
• sparen Speicherplatz
• wenn virtuelle Adressraum größer als
physischer Speicher
• Nachteil: Aufwand der Abbildung
höher
• virtuelle Seitennummer nicht als
Index verwendbar
• Suche nach (p,n) nötig – bei jedem
Speicherzugriff! Inpraktikabel
IAIK 4

Invertierte Seitentabelle
• Lösung:
TLB!
• alle vielbenutzten Seiten im TLB:
Umrechnung genauso schnell
• TLB-Fehler: invertierte Tabelle per SW
durchsucht werden
• virtuelle Adresse als Hash-Wert zur
Beschleunigung der Suche
IAIK 5

Seitenersetzungsalgorithmen
• Seitenfehler welche Seite muss
raus?
• wenn die zu ersetzende Seite
modifiziert wurde: auf Festplatte
zurückschreiben
• falls Programmcode:
zurückschreiben nicht nötig
• nun aber: welche Seite…
IAIK 6

Seitenersetzungsalgorithmen
• zufällige Seite?
• besser Seiten, die nur selten
benutzt werden
• vielbenutzte müssten bald wieder
eingelagert werden
• ähnliches Problem auch bei Caches
(Memory oder Webserver)
IAIK 7

optimal
• leicht zu beschreiben, schwer zu
implementieren
• markiere alle Seiten mit der Anzahl der
Befehle, die bis zum nächsten Zugriff auf
diese Seite ausgeführt werden
• entferne die Seite mit der höchsten Zahl
• nur leider…
• zum Vergleich geeignet
IAIK 8

Not Recently Used
• wenn wir schon nicht in die
Zukunft schauen können…
• … können wir aus der
Vergangenheit lernen?
• wenn eine Seite in der letzten Zeit
nicht verwendet wurde…
• … wird sie vielleicht auch in der
nächsten Zeit nicht gebraucht
IAIK 9

Not Recently Used
• Statusbits: R – M
• werden von der Hardware gesetzt und
bei jedem Speicherzugriff aktualisiert
• bleibt auf 1 bis von BS zurückgesetzt
R
M
IAIK 10

Not Recently Used
• was, wenn die HW das nicht kann?
• Alle PTE auf ausgelagert markieren
• erster Zugriff auf die Seite erzeugt
Seitenfehler BS setzt R-Bit,
Schutz auf read-only, führt Befehl
noch einmal aus
• Schreibzugriff: weiterer
Seitenfehler, M-Bit und r/w setzen
IAIK 11

Not Recently Used
• Prozess gestartet, alle M und R-
Bits auf 0
• regelmäßig: alle R-bits löschen
• nur bei kürzlich referenzierten
Seiten ist R-Bit gesetzt
IAIK 12

Not Recently Used
• Seitenfehler tritt auf
• Einteilung der Seiten in vier Kategorien
• Klasse 0: nicht ref., nicht modif.
• Klasse 1: nicht ref., modif.
• Klasse 2: ref., nicht modif.
• Klasse 3: referenziert und modifiziert
• NRU entfernt eine zufällige Seite aus
der niedrigsten nicht leeren Klasse
• Leistung nicht optimal, aber oft
ausreichend
IAIK 13

FIFO
• Liste aller Seiten
• am Kopf die älteste Seite
• Seitenfehler:
• entferne Seite am Kopf der Liste
• neue Seite am Ende anhängen
• kann genau die falschen Seiten
rauswerfen
• selten unverändert eingesetzt
IAIK 14

Second Chance
• Variante von FIFO
• R-Bit gelöscht: seite wählen
• R-Bit gesetzt: R-Bit löschen und Seite
ans Ende der Liste hängen
• sucht nach einer möglichst alten Seite,
auf die im letzten Intervall nicht
zugegriffen wurde
• Im Grenzfall (alle R-Bits gesetzt) FIFO
IAIK 15

Second Chance
IAIK 16

Clock
• alle Seiten in
einer
ringförmigen Liste
• Zeiger auf älteste
• Seitenfehler:
• nimm Seite auf
die Zeiger zeigt
• Alternativ: R-Bit
berücksichtigen
Second Chance
IAIK 17

Least Recently Used
• wenn wir schon nicht in die
Zukunft schauen können…
• … können wir aus der
Vergangenheit lernen?
• wenn eine Seite sehr lange nicht
mehr verwendet wurde…
• … wird sie vielleicht auch in der
nächsten Zeit nicht gebraucht
IAIK 18

Least Recently Used (LRU)
• realisierbar, aber nicht billig
• verkettete Liste aller Seiten
• bei jedem Zugriff aktualisiert
• Approximationen
IAIK 19

Approximation 1
• 64-Bit Zähler
• nach jedem Maschinenbefehl
erhöht
• PTE: Feld für Zähler
• Speicherzugriff: speichert Zähler in
PTE
• Seitenfehler: Liste nach
niedrigstem Zähler durchsuchen
IAIK 20

Approximation 2
• Matrix aus n*m Bits, anfangs 0
• Zugriff auf Seite k: Bits der Zeile k auf 1, Bits
der Spalte k auf 0
• die Zeile mit dem niedrigsten Binärwert ist die
am längsten nicht benutzte
IAIK 21

LRU durch Software
• LRU ohne Hardware nicht
realisierbar
• Hardware kaum vorhanden
• Softwarelösung: NFU – Not
Frequently Used
• Zähler pro Seite
• Timerinterrupt erhöht den Zähler
um R-Bit
IAIK 22

NFU
• Problem: vergisst nix. Oft
verwendete Seiten bleiben
erhalten auch wenn nicht mehr
benötigt
• Modifikation:
• vor Addition Rechtsverschiebung
• R-Bit beim höchstwertigen Bit
addieren
IAIK 23

Aging
IAIK 24

Aging versus LRU
• Unterscheidung innerhalb eines
Intervalls nicht möglich
• endliche Anzahl von Bits, wenn
Zähler 0 dann nicht unterscheidbar
ob vor 9 oder vor 1000 Intervallen
• 8 bits reichen bei 20msec meist
aus
IAIK 25

Demand Paging
• Starten eines Prozesses…
• … wie viele Seiten soll der
bekommen?
• Eine Strategie: Demand Paging
(Einlagern bei Bedarf)
• Starten mit 0 Seiten im
Hauptspeicher
IAIK 26

Demand Paging
• Laden des Befehlscodes des ersten
Befehls page fault
• Weitere Seitenfehler für Stack und
Datenbereich
• Nach einiger Zeit: alle Seiten
eingelagert, die Prozess benötigt
• Lokalitätsprinzip macht das machbar!
IAIK 27

Working Set
• Menge der Seiten, die ein Prozess zu
einem bestimmten Zeitpunkt benötigt
• Working Set im Speicher keine
pagefaults
• Verfügbarer Speicher kleiner als
working set viele pagefaults
• Thrashing (system lagert fast nur mehr
ein/aus)
IAIK 28

Swapping
• Prozesse auslagern – normalerweise auf
Festplatte
• Oft eigene Partition oder nur große
Datei
• Idealerweise kontinuierlich auf der
Platte – Geschwindigkeit
• Auslagern: Nur Daten mit dirty=1
• Programmcode von executable file
einlagern
IAIK 29

Swapping
• Wie gehen wir vor wenn Prozess
wieder eingelagert wird?
• Eigentlich brauchen wir nichts tun
– pagefaults bis working set
eingelagert
• Kostet aber CPU-Zeit für die
Behandlung der pagefaults
IAIK 30

Working-Set-Modell
• BS merkt sich das working set
eines Prozesses
• Working set wird vor weiterer
Ausführung des Prozesses wieder
geladen
• prepaging
IAIK 31

Überlegungen zum ws
• Speicherzugriffe über Adressraum
nicht gleich verteilt – konzentrieren
sich auf einige wenige
• w(k,t) Menge der Seiten die in
den letzten k Speicherzugriffen vor
dem Zeitpunkt t referenziert
wurden
• Monoton steigende Funktion
IAIK 32

workingset
IAIK 33

Überlegungen zum ws
• Arbeitsbereich eines Prozesses
ändert sich nur langsam – Seiten
die Prozess nach Einlagern braucht
zT vorhersehbar prepaging
funktioniert
IAIK 34

Implementierung WS
• BS muss wissen, welche Seiten im
working set liegen.
• Seitenersetzungsalgorithmus: bei
pagefault – finde Seite die nicht im
working set, und lagere sie aus.
• wann ist aber eine Seite nicht im
working set?
IAIK 35

working set
• w(k,t) Menge der Seiten die in den letzten k
Speicherzugriffen vor dem Zeitpunkt t referenziert
wurden
• Aber wie implementieren?
• Schieberegister, bei jedem
Speicherzugriff Seitennummer
reinschieben? … nicht effizient
• Annäherungen möglich
• statt „letzte k“ „letzte m msec“
IAIK 36

Approximation
• working-set-Zeit relative
Prozesszeit
• 100 msec absolut, aber nur 20
msec für Prozess – virtuelle Zeit!
• workingset: die Menge der Seiten,
auf die der Prozess in den letzten τ
msec virtueller Zeit zugegriffen hat
IAIK 37

Approximation
• Hardware muss R/M setzen
• periodisch: R bits gelöscht
• bei Seitenfehler
• alle PTE‘s durchsuchen
• R-Bit == 1?
• aktuelle virtuelle Zeit in Feld für Zeit des
letzten Zugriffs eintragen
• Seite liegt im Arbeitsbereich
IAIK 38

Approximation
• R-Bit == 0
• Seite seit letzter Unterbrechung nicht
verwendet Kandidat für Auslagerung
• Alter bestimmen: gespeicherte Zeit –
aktueller virtueller Zeit
• zu alt: aus workingset nehmen
• „zu jung“: meist verschonen. Nur wenn alle
Seiten im Arbeitsbereich, älteste auslagern
• Rest der Tabelle durchlaufen um
Zugriffszeiten zu aktualisieren
• Alle R-Bits = 1? Pech. Irgendeine
nehmen…
IAIK 39

Approximation
IAIK 40

WSClock
• einfacher Algorithmus umständlich
• durchläuft pagetable bei jedem
pagefault bis Kandidat gefunden
• Kombination aus Clock und
Workingset: WSClock
• in realen Systemen weit verbreitet
• Wie Clock ringförmige Liste
IAIK 41

WSClock
IAIK 42

WSClock
• Untersuche Seite auf die Zeiger
zeigt
• R=1 kein idealer Kandidat
• R 0
• Zeiger vorrücken
• continue
IAIK 43

WSCLock
• R=0
• Alter > T nicht im Workingset
• M=0 Seite kann freigegeben werden
• M=1 vormerken, dass Seite auf Platte
geschrieben werden muss. Aber
weitersuchen, um Prozesswechsel zu
vermeiden
IAIK 44

WSCLock
• Wieder am Anfang?
• es wurde eine Seite vorgemerkt
• weiterlaufen, irgendwann wird
vorgemerkte im Hintergrund
zurückgeschrieben
• es wurde keine Seite vorgemerkt
• alle Seiten im Arbeitsbereich
irgendeine Seite auslagern (am besten
irgendeine saubere Seite merken, dann
gibt’s die jetzt schon).
IAIK 45

Zusammenfassung
IAIK 46

Modellierung
• FIFO
neueste Seite
älteste Seite
0 1 2 3 0 1 4 0 1 2 3 4
0 1 2 3 0 1 4 4 4 2 3 3
0 1 2 3 0 1 1 1 4 2 2
0 1 2 3 0 0 0 1 4 4
P P P P P P P P P
IAIK 47

Keller-Algorithmen
• Jeder Prozess erzeugt
Folge von
Speicherzugriffen auf
virtuelle Seiten
• Speicherzugriffe als
Liste von
Seitennummern
darstellbar
• Referenzkette –
reference string
IAIK
Modellierung
• FIFO
0 1 2 3 0 1 4 0 1 2 3 4
neueste Seite
älteste Seite
0 1 2 3 0 1 4 4 4 2 3 3
0 1 2 3 0 1 1 1 4 2 2
0 1 2 3 0 0 0 1 4 4
P P P P P P P P P
IAIK 48

Annahmen
• ein Rechner
• ein Prozess
• eine deterministische Referenzkette pro
Rechner
• Paging-System charakterisiert durch
• Seitenersetzungsalgorithmus
• Anzahl m der physischen Seitenrahmen
• Referenzkette des Prozesses
IAIK 49

Simulation über Interpreter
• enthält interne Tabelle M –
repräsentiert Zustand des Speichers
• M hat n Einträge, einen pro virtuelle
Seite des Prozesses
• M hat zwei Teile
• oberer Teil, m Einträge: Seiten, die im
Speicher liegen
• unterer Teil, n-m Einträge: Seiten, die
ausgelagert wurden
• M zu Beginn leer
IAIK 50

Prozess-Start
• Prozess gibt Seiten seiner
Referenzkette aus.
• Interpreter prüft, ob Seite im
Speicher. Wenn nicht –
Seitenfehler.
• falls leerer Seitenrahmen
vorhanden: dort laden (nur zu
Beginn möglich)
IAIK 51

Speicher voll
• voll: oberer Teil von M enthält m
Einträge
• Seitenersetzungsalgorithmus
aufrufen, entfernt Seite aus
Speicher verschieben in unteren
Teil
• neue Seite laden oder von unteren
in oberen verschieben
IAIK 52

IAIK 53
Beispiel
P
P
P
P
P
P
P
P
P
P
P
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
0
0
6
6
6
6
6
6
6
6
1
1
1
1
1
1
1
1
2
2
0
1
4
3
1
7
1
1
1
3
5
5
3
3
7
4
7
3
6
4
5
3
1
2
0
5
5
4
4
4
4
4
4
6
6
6
5
5
5
5
5
1
1
2
0
7
7
5
5
5
7
7
7
4
4
4
6
6
6
6
4
5
3
1
2
0
3
1
7
3
3
5
5
5
7
7
7
4
4
3
3
6
4
5
3
1
2
0
4
3
1
7
1
3
3
3
5
3
3
7
7
4
7
3
6
4
5
3
1
2
0
1
4
3
1
7
1
1
1
3
5
5
3
3
7
4
7
3
6
4
5
3
1
2
0

Modellierung
• FIFO
neueste Seite
älteste Seite
0 1 2 3 0 1 4 0 1 2 3 4
0 1 2 3 0 1 4 4 4 2 3 3
0 1 2 3 0 1 1 1 4 2 2
0 1 2 3 0 0 0 1 4 4
P P P P P P P P P
IAIK 54

FIFO – 4 Frames
0 1 2 3 0 1 4 0 1 2 3 4
0 1 2 3 3 3 4 0 1 2 3 4
0 1 2 2 2 3 4 0 1 2 3
0 1 1 1 2 3 4 0 1 2
0 0 0 1 2 3 4 0 1
P P P P P P P P P P
IAIK 55

Algorithmen
• Algorithmen mit der Eigenschaft
M ( m,
r)
⊆ M ( m + 1, r)
sind besonders interessant…
• nach r Speicherzugriffen ist der obere Teil
von M für einen Speicher von m Seiten
Teilmenge des oberen Teils von M
Speichers von m+1 Seiten
IAIK 56

Kelleralgorithmen –
stack-algorithms
• Algorithmen mit der Eigenschaft
M ( m,
r)
⊆ M ( m + 1, r)
heißen Kelleralgorithmen.
• LRU ist ein Kelleralgorithmus
• FIFO nicht
• Keller-Algorithmen sind nicht für
Belady‘s Anomalie anfällig
IAIK 57

Distanzkette
• Repräsentation der Referenzkette
in abstrakterer Form zur
Evaluierung der Verfahren
• Seitenbezeichnung durch Abstand
der Seite vom oberen Ende des
Stack
• Seiten, auf die noch nicht
zugegriffen wurde: Abstand ∞
IAIK 58

IAIK 59
Distanzkette
3
5
3
2
4
1
1
6
2
1
5
1
3
2
∞ 4
∞ ∞ ∞ ∞ ∞ ∞ ∞ 4
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
0
0
6
6
6
6
6
6
6
6
1
1
1
1
1
1
1
1
2
2
0
1
4
3
1
7
1
1
1
3
5
5
3
3
7
4
7
3
6
4
5
3
1
2
0
5
5
4
4
4
4
4
4
6
6
6
5
5
5
5
5
1
1
2
0
7
7
5
5
5
7
7
7
4
4
4
6
6
6
6
4
5
3
1
2
0
3
1
7
3
3
5
5
5
7
7
7
4
4
3
3
6
4
5
3
1
2
0
4
3
1
7
1
3
3
3
5
3
3
7
7
4
7
3
6
4
5
3
1
2
0
1
4
3
1
7
1
1
1
3
5
5
3
3
7
4
7
3
6
4
5
3
1
2
0

Distanzkette
• hängt ab von
• Referenzkette
• Seitenersetzungsalgorithmus
• statistische Eigenschaften der
Distanzkette beeinflussen
Leistungsfähigkeit des Algorithmus
IAIK 60

Distanzkette
wenige Seitenfehler bei k Seitenrahmen
„Pech gehabt“ – keine
Anzahl an Frames passt
(außer n)
IAIK 61

Seitenfehlerrate vorhersagen
• mit Hilfe der Distanzkette möglich
• Ziel: einmal Distanzkette
durchlaufen und mit den
gesammelten Infos vorhersagen,
wie viele Seitenfehler bei k Frames
vorkommen (k=1…n)
IAIK 62

Algorithmus
• durchläuft
Distanzkette
• zählt Abstände
∞∞∞∞∞∞∞ 4 ∞ 4 2 3 1 5 1 2 6 1 1 4 2 3 5 3
C 1 4
C 2 3
C 3 3
C 4 3
C 5 2
C 6 1
C∞ 8
IAIK 63

Algorithmus
F
m
=
n
∑
C
k = m+
1
k
+ C
F m = Anzahl der
Seitenfehler für
gegebene
Distanzkette und
m Seitenrahmen
∞
C 1 4
C 2 3
C 3 3
C 4 3
C 5 2
C 6 1
C∞ 8
F 1 20
F 2 17
F 3 14
F 4 11
F 5 9
F 6 8
F∞ 8
IAIK 64

Design-Kriterien
• Bisher: Mechanik
• wie funktioniert Paging
• welche Algorithmen für
Seitenersetzung gibt es
• wie modelliert man diese
• reicht nicht
• jetzt: was ist für ein
leistungsstarkes System nötig?
IAIK 65

Lokal – Global ?
• A erzeugt
pagefault
• Welche Seiten für
Ersetzung in
Betracht ziehen?
• Nur die von A –
lokale Strategie ?
• Alle – globale
Strategie?
IAIK 66

Lokal - Global
• lokal: fester Speicherbereich pro
Prozess
• global: dynamische Verteilung,
Anzahl der Frames eines Prozesses
variabel
IAIK 67

Lokal - Global
• Im Allgemeinen: global Strategien
besser – besonders wenn sich die
Größe des Workingset ändert
• Speicherbedarf wächst – thrashing
(obwohl Seiten „woanders“
verfügbar)
• Speicherbedarf schrumpft – Seiten
verschwendet
IAIK 68

Lokal - Global
• manche Seitenersetzungsalgorithmen
für lokale und globale
Strategien anwendbar (FIFO, LRU)
• andere nicht (Workingset,
WSClock)
IAIK 69

Global
• Globale Strategie entscheidet
ständig über die Anzahl der
Seitenrahmen
• Möglichkeiten:
• Aging-Bits – eventuell zu grob
• Frames zu gleichen Teilen auf alle
Prozesse (regelmäßig anpassen) –
nicht sinnvoll, wenn Prozesse
unterschiedlich groß
IAIK 70

Global
• Im Verhältnis zur Prozessgröße?
• Minimum kann notwendig sein
(Befehl könnte bis zu 6 Seiten im
Speicher benötigen)
• Starten mit Seitenzahl im
Verhältnis zur Größe, danach
dynamische Anpassung
IAIK 71

PFF-Algorithmus
• Page-Fault-Frequency Algorithmus
• bestimmt nur, wie viel Speicher ein
Prozess bekommt
• Pagefault-Rate indirekt-proportional zur
Speichergröße
IAIK 72

PFF-Algorithmus
IAIK 73

PFF-Algorithmus
• zu hohe Seitenfehlerrate: mehr
Speicher zuteilen
• zu niedrige Seitenfehlerrate:
Speicher wegnehmen
IAIK 74

Laststeuerung
• wenn working-set aller Prozesse
größer als Hauptspeicher - es wird
immer zu viele Seitenfehler geben!
• PFF-Algorithmus könnte das
anzeigen: mehrere zu wenig,
keiner zu viel
• Lösung: Prozesse auslagern
IAIK 75

Laststeuerung
• Wenn danach die Fehlerrate sinkt
– ok
• sonst: noch einen auslagern – bis
sich Erfolg einstellt
• Swapping also auch bei pagingsystemen
sinnvoll!
• Kann auch wichtig sein, welche
Prozesse man auslagert
IAIK 76

Seitengröße
• Oft einstellbarer Parameter
• keine optimale Lösung
• große Seiten – mehr interne
Fragmentierung: wieviele Bytes bleiben
in Seitenrahmen ungenutzt?
• kleine Seiten: viele Seiten, große
Seitentabellen, mehr Verwaltung,
Transfer kleiner Seiten dauert fast
gleich lange wie großer Seiten
IAIK 77

Seitengröße
• Platzverbrauch kann mathematisch
analysiert werden
• Durchschnittliche Prozessgröße s
• Seitengröße p, PTE e Bytes, s/p-Seiten
• Speicherverbrauch für Seitentabelle und
Fragmentierung
V=se/p+p/2
• Optimum wenn -se/p 2 +1/2 = 0
p = 2se
IAIK 78

Seitengröße
• s=1MB
• e=8 Byte
• optimale Seitengröße 4KB
• übliche Seitengrößen heute 4 oder
8 KB
IAIK 79

getrennte Programm- und
Datenbereiche
IAIK 80

Gemeinsame Seiten
shared pages
• mehrere Benutzer benutzen das
gleiche Programm
• Effizienter, Seiten gemeinsam zu
nutzen
• geht aber nur für Code, nicht für
Daten!
IAIK 81

Gemeinsame Seiten
• getrennte
Adressräume für
Code und Daten –
gemeinsamen
Adressraum für
Code, getrennten
für Daten
IAIK 82

Gemeinsame Seiten
• Betriebssystem muss gemeinsame
Seiten berücksichtigen
• Auslagern von einem Prozess –
zweiter Prozess lagert wieder alle ein?
• Beenden eines Prozesses – Seiten
müssen eventuell erhalten bleiben
IAIK 83

Gemeinsame Seiten
• Daten gemeinsam zu benutzen etwas
komplizierter
• zB nach UNIX-fork
• Beide lesen: kein Problem
• Schreiben:
• Seiten auf R/O setzen
• Schreibzugriff: Seite kopieren – jeder Prozess
eigene Kopie und auf R/W setzen
• copy-on-write
• Seiten die nie beschrieben werden, müssen nicht
kopiert werden
IAIK 84

Freigabe-Strategien
• Paging funktioniert am besten
wenn genügend Seitenrahmen frei
• Wenn alle Pageframes voll sind
und einer gebraucht wird –
unangenehm.
• Eventuell muss freizumachende
Seite noch zurückgeschrieben
werden. Das dauert!
IAIK 85

Freigabe-Strategien
• Daher: Vorbeugen
• Paging-Daemon
• meist inaktiv
• wacht regelmäßig auf und prüft
Speicherzustand
• nicht genug freie Rahmen wählt
Seiten aus und beginnt sie
auszulagern
IAIK 86

Paging-Daemon
• Inhalt der Seiten bleibt erhalten
falls doch noch benötigt, ist nichts
verloren
• Bei einem Pagefault ist dann
immer ein freier Rahmen
verfügbar
Performancesteigerung
IAIK 87

Implementierungsprobleme
• Auswahl der Strategien ist eine
Sache
• praktische Probleme bei der
Implementierung eine andere
IAIK 88

Betriebssystemaufgaben bei
Paging
• vier Punkte wo das BS Arbeit
leisten muss
• Erzeugung des Prozesses
• Ausführung des Prozesses
• Seitenfehler
• Terminierung des Prozesses
IAIK 89

Erzeugung des Prozesses
• Größe des Programmcodes und der
Daten feststellen
• Seitentabelle für Prozess erzeugen
• Speicher zuteilen und initialisieren
• Platz für ausgelagerte Seiten auf
der Platte reservieren
• ev. Swapping-Bereich mit Code
und Daten initialisieren
IAIK 90

Ausführung des Prozesses
• MMU auf neuen Prozess einstellen
• TLB leeren
• aktuelle Seitentabelle auf Tabelle
des Neuen Prozesses setzen
• eventuell prepaging
IAIK 91

Seitenfehler
• Hardware-Register auslesen um
festzustellen, welche Adresse Fehler
verursacht hat
• finden der benötigten Seite
• freien Seitenrahmen suchen
• eventuell alte Seite auslagern
• neue Seite einlesen
• Programmzähler auf Befehl
zurücksetzen, der den Seitenfehler
verursacht hat
IAIK 92

Terminierung des Prozesses
• Seitentabelle, Seitenrahmen und
Plattenplatz freigeben
• gemeinsam benutzte nur, wenn
der letzte Prozess terminiert
IAIK 93

Behandlung von
Seitenfehlern
1. Hardware
PC Stack, Sprung in Kernel
2. Interrupt-Serviceroutine
sichern von Registern und anderer
Informationen
3. OS
welche virtuelle Adresse hat Fehler
ausgelöst?
HW-Register, oder Befehl
interpretieren!
IAIK 94

Behandlung von
Seitenfehlern
4. Prüfen der Adresse auf Gültigkeit
Schutzverletzung Abbruch
sonst: freien Seitenrahmen finden.
keiner da? Ersetzungsalgorithmus
starten.
5. Seitenrahmen modifiziert Seite auf
Platte schreiben lassen, Prozess
suspendieren und anderen laufen
lassen.
Seitenrahmen als belegt markieren!
IAIK 95

Behandlung von
Seitenfehlern
6. Wenn Seitenrahmen sauber:
laden der Seite von Platte.
Prozess bleibt oder wird
suspendiert.
7. Seite angekommen (Interrupt
durch Festplatte): Seitentabelle
anpassen. Seitenrahmen als
„normal“ markieren
IAIK 96

Behandlung von
Seitenfehlern
8. Befehl der Unterbrechung verursacht
hat, in den Anfangszustand versetzen
und PC mit Adresse dieses Befehls
laden
9. Prozess zur Ausführung auswählen;
zurück in Assemblerroutine
10.Wiederherstellen der Register und des
Zustandes und Wechsel in Benutzer-
Modus
IAIK 97

Befehlsunterbrechung
• Bei Pagefaults: Befehl „mittendrin“
unterbrochen, Sprung ins BS
• Nach Laden der Seite muss Befehl
neu gestartet werden
• Das klingt einfacher als es ist.
IAIK 98

Ein Beispiel
MOVE.L #6(A1),#2(A0)
• Befehl mit zwei Adressen
• Ladet ein Datum vom Typ Long
von A von M[A1+6] auf M[A0+2]
• Befehl selbst ist 6 Byte lang
IAIK 99

Ein Beispiel
IAIK 100

Ein Beispiel
• Pagefault
• Befehl neu starten: was ist das
erste Byte des Befehls?
• Wert des PC abhängig vom
Operanden und der
Implementierung im Microcode der
CPU
• PC: 1000, 1002, 1004
IAIK 101

Ein Beispiel
• Noch schlimmer:
• Adressierungsmodi mit
Predecrement
• MOVEM.L D0-D3/D6/D7,A0-A5,-(SP)
• D0SP-4
• D1SP-8
• D2SP-12
• …
IAIK 102

Was tun?
• Hilfe durch HW nötig
• Info über Originalwert des
PC/Register
• Instruktion an der unterbrochenen
Stelle fortführbar
IAIK 103

Sperren von Seiten
• Prozess fordert I/O-Operation an
• Beispiel: lesen in Puffer
• Prozess wird suspendiert
• Andere Prozesse erzeugen pagefaults
• Seite des Puffers könnte ersetzt werden
• DMA-Transfer in falschen Speicher
• Seite muss daher gesperrt werden
(pinning) oder über Kernel transferiert
IAIK 104

Hintergrundspeicher
• Auslagern – fein. Aber wohin?
• Einrichtung eines speziellen Swap-
Bereichs
• Eigene Partition auf Festplatte
• Spezieller File im Filesystem
• Jeder Prozess bekommt Block
seiner Größe
IAIK 105

Hintergrundspeicher
• Prozesstabelle enthält
Plattenadresse des Swap-Bereichs
• Berechnung einfach: Addition
• Initialisierung: entweder gesamtes
Image laden und auf Swap
schreiben oder nach Bedarf
auslagern
IAIK 106

Hintergrundspeicher
• Problem: dynamischer Speicher
• Alternative: nichts reservieren,
und für jede Seite eigenen Block
anfordern
• Mehr Verwaltungsaufwand
IAIK 107

Hintergrundspeicher
IAIK 108

Segmentierung
• Virtueller Speicher bisher
eindimensional
• Alle Adressen zwischen 0 und max
• Oft Trennung in mehrere
Adressräume nützlich
IAIK 109

Beispiel Compiler
• Braucht diverse Datenbereiche
• Quellcode
• Symboltabelle
• Tabelle für Konstanten
• Strukturbaum
• Stack
Wachsen ständig!
IAIK 110

Eindimensional
IAIK 111

Lösung?
• Abbruch wenn Bereich zu klein
• Nicht elegant
• Reallocation
• Mühsam
• Besser: mehrere Adressräume
• Segmente
IAIK 112

Segment
• Lineare Folge von Adressen (0..max)
• Verschieden groß
• Größe kann sich unabhängig von
anderen Segmenten ändern
• Adresse hat zwei Teile:
Segmentnummer, Adresse im Segment
IAIK 113

Beispiel
IAIK 114

Hinweise
• Segment ist logische Einheit
• Programmierer berücksichtigt es
• Schutzmaßnahmen auf
Segmentbasis
• Jede Prozedur in eigenes Segment:
Linken wird stark vereinfacht
• Startadresse jeder Prozedur:
(Segmentnummer,0)
IAIK 115

Shared Libraries
• Gemeinsame Bibliotheken
• Viele Routinen die von fast allen
Programmen benötigt werden
• Gemeinsame Nutzung spart Platz
• Library in ein Segment laden, kann
von allen gemeinsam genutzt
werden
IAIK 116

Vergleich
Paging/Segmentierung
IAIK 117

Implementierung
• Wichtiger Unterschied:
• Seiten haben fixe Größe
• Segmente nicht!
IAIK 118

Segmentierung mit Paging
• Kombination nutzt Vorteile beider
Systeme
• MULTICS war das erste System
• Jedes Programm bis zu 2 18
Segmente a 65536 Worte (36 Bit)
• Jedes Segment war virtueller
Speicher
IAIK 119

VM-MULTICS
• Segmenttabelle, bis zu 250.000
Einträge selbst Segment und kann
ausgelagert werden
• Segmenddeskriptor zeigt an ob
Segment ausgelagert oder nicht
• Teil des Segments im Speicher: gilt als
Segment im Speicher und seine
pagetable auch
• Deskriptor hat Zeiger auf pagetable
IAIK 120

VM-MULTICS
IAIK 121

Adressen in MULTICS
IAIK 122

Speicherzugriff MULTICS
• Laden des Segmentdeskriptors
• Ist pagetable im Speicher.
• Nein: Segmentfehler
• Pagetable untersuchen
• Eventuell pagefault
• Offset dazu
• Speicherzugriff
IAIK 123

Speicherzugriff MULTICS
IAIK 124

Geschwindigkeit
• MULTICS-HW hatte 16 Einträge großen
TLB
IAIK 125

MULTICS
• … vor etwa 30 Jahren entstanden
• Viele wegweisende Ansätze
• Letzter Systemshutdown
31.10.2000 !
• www.multicians.org
IAIK 126

Intel Pentium
• Virtueller Speicher ähnlich
MULTICS
• Segmentierung und Paging
• 16K Segmente, bis zu einer
Milliarde 32bit-Worte
• Größe wichtiger: öfter große
Segmente und selten sehr viele
IAIK 127

LDT - GDT
• Local Descriptor Table
• Für jedes Programm
• Lokale Segmente (u.a. Code, Daten,
Stack)
• Global Descriptor Table
• Systemsegmente
• Darunter das Betriebssystem
IAIK 128

Segmentregister
• Sechs Segmentregister
• CS: Selektor für Code Segment
• DS: Selektor für Datensegment
• Selektor
IAIK 129

Segmentregister
• Selektor 0 verboten – bedeutet:
nicht verfügbar
• Selektor in Segmentregister:
Deskriptor aus LDT oder GDT in
internen Register gespeichert
IAIK 130

Deskriptor
IAIK 131

Adressumsetzung
(Selektor, Offset)
• Mikroprogramm findet passenden
Deskriptor in internen Registern
• Selektor 0 oder ausgelagert:
Interrupt
• Offset überschreitet
Segmentgröße: Interrupt
IAIK 132

Adressumsetzung
• Limit: 20 Bit
• G bestimmt Granularität
• 0: Limit in Byte
• 1: Limit in Seiten
• Addiert Basisfeld zum Offset
• Ergebnis 32 Bit lineare Adresse
• Paging abgeschaltet: lineare
Adresse = physische Adresse
IAIK 133

Segmentierung
IAIK 134

Paging
• Paging enabled: lineare Adresse ist
virtuelle Adresse
• Über pagetables in physische
Adresse abbilden
• Fixe Seitengröße 4KB eine
Million Seiten zweistufige
Seitentabellen
IAIK 135

Paging
IAIK 136

Paging
• Seitenverzeichnis oder Page
Directory
• 1024 32bit-Einträge
• Adresse in globalen Register
• Jeder Eintrag zeigt auf eine
Seitentabelle mit 1024 Einträgen
IAIK 137

Paging
• TLB vorhanden
• Ein Selektor in alle
Segmentregister: Ergebnis ist
normales Paging
• Ist bei allen gängigen
Betriebssystemen der Fall
• Nur OS/2 hat Features des
Pentium voll ausgenutzt
IAIK 138

Speicherschutz
• Vier Schutzebenen
• Zugriff auf Daten höherer Ebene
legal
• Zugriff auf Daten niedrigerer
Ebene Schutzverletzung
• Aufruf einer Prozedur nur über Call
Gates
IAIK 139

Speicherschutz
• Konzept der
Schutzringe an
MULTICS
angelehnt
• Zugriffe auf
höhere Ebene ok
• Aufrufe auf
niedrigere Ebenen
über Call-Gates
IAIK 140