5 Speicherverwaltung Pufferspeicher cache realer Speicher PrimrspeicherArbeitsspeicher memory

5 Speicherverwaltung Pufferspeicher (cache) realer Speicher Primärspeicher/Arbeitsspeicher (memory) Sekundärspeicher/Hintergrundspeicher (backing store) Tertiärspeicher/Archivspeicher Adressraum (address space) bs-5 1

5. 1 Elementare Adressraumverwaltung Zur Erinnerung – Arbeitsspeicher und Prozessor: Speicheradresse, reale Adresse (memory/physical address) identifiziert Arbeitsspeicherzelle (location) Programmadresse, virtuelle Adresse (program/virtual address) = vom Prozessor formulierbare Adressraum des Prozessors (processor address space) = alle Programmadressen bs-5 2

5. 1. 1 Adressumsetzung ist Aufgabe der Hardware: Adressumsetzer (memory management unit, MMU) bildet Programmadressen auf Speicheradressen ab: Prozessor MMU Speicherzugriff 4711 2503476 bs-5 Arbeitsspeicher 3

MMU für zusammenhängende Speicherbereiche: Basisregister (base register), enthält Basisadresse, Längenregister (length register), enthält Länge. bs-5 4

MMU für zusammenhängende Speicherbereiche: Basisregister (base register), enthält Basisadresse, Längenregister (length register), enthält Länge. Adressumsetzung für eine Programmadresse address: if address < length then location = base + address else address fault trap Arbeitsspeicher 0 address (Programmadressen) location (Speicheradressen) length bs-5 base 5

Basisadresse und Länge werden üblicherweise in größeren Einheiten gemessen (z. B. units, blocks, . . . ) Vereinfachende Voraussetzung: Block im Speicher entspricht Sektor/Block im Hintergrundspeicher (Platte) bs-5 6

„Adressraum“ wird auch in anderer Bedeutung gebraucht: aktueller Adressraum des Prozessors = alle aktuell erlaubten Programmadressen, z. B. bei obiger MMU alle address < length Adressraum eines Prozesses = gemäß einem Prozessattribut length alle address < length oder auch = Inhalt (Code + Daten) eines Prozesses oder auch = Code+Daten-Paket, das einmal Inhalt eines Prozesses werden kann bs-5 7

Prozessormodus (processor mode) (Bits im PSW) – z. B. user/system oder user/supervisor/kernel oder. . . – bestimmt Zulässigkeit privilegierter Befehle, evtl. Unterbrechungsunterdrückung, aktuellen Adressraum des Prozessors, z. B. im Benutzermodus: Adressumsetzung wie oben, im Systemmodus: Adressumsetzung abgeschaltet (!) oder Adressumsetzung mit anderem Registersatz bs-5 8

Adressraumwechsel bei Wechsel des Prozessormodus im PSW, d. h. bei Unterbrechung bei IRET/RTI Merke: Beachte: bs-5 Eine Unterbrechung führt i. d. R. zu einem neuen Adressraum – das muss aber nicht notwendig so sein (BS bestimmt neues PSW!). Der neue Adressraum kann sich mit dem alten überlappen oder kann von diesem völlig disjunkt sein. 9

5. 1. 2 Adressraumumschaltung Betriebssystem profitiert von der Adressumsetzung: Verschieblichkeit (relocatability) von Prozessen: Programm kann an beliebige Stelle des Speichers geladen werden, ohne dass dabei Adressen im Programm (z. B Sprungadressen) entsprechend angepasst werden müssten; Prozesse können ohne Modifikation verschoben werden. Speicherschutz (memory protection): Prozess kann weder absichtlich noch unabsichtlich auf andere als die ihm zugeordneten Speicherzellen zugreifen. bs-5 10

Inhalt der MMU-Register ist Teil des Prozessorstatus und damit auch Teil des Prozessstatus ! Betriebssystem ist zuständig für geeignetes Laden der MMU-Register bei Aktivierung eines Prozesses (vgl. 3. 2 und 3. 5. 2 2) mit privilegiertem Befehl oder über spezielle Adressen. ! Unterscheide also zwischen Adressraumumschaltung als Teil der Prozessumschaltung tatsächlichem Adressraumwechsel (Unterbrechung, RTI). bs-5 11

5. 1. 3 Adressraumänderung Prozessattribute base/length : Initialisierung ? Änderung ? ! Muss notwendig von der Speicherverwaltung ausgehen, die über die Speicherbelegung Buch führt ( 5. 2) 2 Varianten: Speicherverwaltung greift direkt auf Prozessdeskriptor zu – falls im gleichen Adressraum wie Prozessverwaltung – Speicherverwaltung benutzt entsprechende Operation der Prozessverwaltung bs-5 12

Prozessattribute base/length werden gesetzt beim Initialisieren eines Prozesses (fork) – length kopieren vom Erzeuger, base gemäß Speicherbelegung Laden eines Programms (exec) – length gemäß Angabe in Datei, base gemäß Speicherbelegung Verschieben des Prozesses – base gemäß Speicherbelegung bs-5 Verändern der Adressraumgröße (brk u. ä. ) – length ändern, eventuell auch base , falls Verschieben erforderlich 13

5. 2 Elementare Arbeitsspeicherverwaltung für zusammenhängende Speicherbereiche, ohne Umlagerungen: Aufruf impliziert fork Belegung (allocation, Zuweisung) für neuen Prozess [Alloziierung – falsche Übersetzung] exec Vergrößern/Verkleinern des Prozessbereichs brk Vergrößern/Verkleinern des Prozessbereichs exit Freigabe (deallocation) des Prozessbereichs bs-5 14

Typische Schnittstelle der Buchführung über Speicherbelegung: interface Allocation { int allocate(int length); // belegt Bereich der Größe length // und liefert dessen Adresse, // sofern verfügbar, sonst 0 void deallocate(int base, int length); // gibt Bereich der Größe length frei, // der bei base beginnt } bs-5 15

Typische Implementierungen wie für die Halde (ALP 3!): Repräsentation: Bitliste verkettete Liste Belegungsstrategien: first-fit, . . . Problem: Speicherverschnitt, extern/intern (fragmentation) Externer Verschnitt kann im Prinzip durch Kompaktifizierung (compaction) beseitigt werden (wenig üblich). bs-5 16

Verschiebung einzelner Prozesse ist aber unvermeidlich, wenn Vergrößern unterstützt werden soll, wenn dadurch für neuen Prozess Platz geschaffen werden kann, der sonst nicht vorhanden ist Dank der MMU ist Verschiebung einfach realisierbar ! (Übung: implementiere Kompaktifizierung !) bs-5 17

5. 3 Prozessumlagerung (process) swapping = Umlagerung des Adressraums eines Prozesses zwischen Arbeitsspeicher und Hintergrundspeicher, falls Arbeitsspeicher zu klein für alle Prozesse (aber groß genug für jeden einzelnen Prozess!) Arbeitsspeicher bs-5 auslagern (swap out) einlagern (swap in) (so im Ur-Unix; bei alten IBM-Systemen: „roll-in/roll-out“) Auslagerungsbereich (swap area) 18

Zustände eines Prozesses (vgl. 1. 1. 2 ), bezogen auf den Besitz der Betriebsmittel 1. 2. 3. Prozessor, Arbeitsspeicher, 3. Ressource: Prozessor aktiv Arbeitsspeicher blockiert bereit 3. Ressource schlafend bs-5 wartend 19

Entwurf der Speicherverwaltung (vgl. 4. 2 ): Aufrufe/Aufträge, z. B. durch fork, brk, . . . Operationen Umlagerer (swapper) Verwaltungsdaten hochpriorisierter, speicherresidenter Systemprozess, regelmäßig aktiv nach Ablauf eines Zeitquantums (quantum time. Slice) bs-5 20

5. 3. 1 Verwaltungsdaten Speicherverwaltung führt Buch über • Arbeitsspeicherbelegung (wie in 5. 2 ) Allocation memory • Belegung des Auslagerungsbereichs Allocation swaparea • eingelagerte Prozesse Swapout. List present • ausgelagerte Prozesse Swapin. List absent bs-5 21

Auch bei der Umlagerung ist wichtig die Trennung von Mechanismen und Strategien: Auslagerungstrategie wird bestimmt durch die Implementierung von present. remove() Einlagerungstrategie wird bestimmt durch die Implementierung von absent. remove() bs-5 22

5. 3. 2 Umlagerungsmechanismen Achtung: nicht alle Prozesse müssen auslagerbar sein; z. B. können dringliche Systemprozesse grundsätzlich speicherresident sein. Jedem auslagerbaren Prozess ist eine physikalisch zusammenhängende Folge von Blöcken/Sektoren im Auslagerungsbereich zugeordnet. Die Nummer des ersten Blocks heißt Auslagerungsadresse. Die Basisadresse base eines ausgelagerten Prozesses ist 0. bs-5 23

Voraussetzungen: Für den Zugriff auf den Auslagerungsbereich gibt es einen Plattentreiber mit Schnittstelle (statt IO(4. 2)) interface Driver { void input (int base, int length, int addr); void output(int base, int length, int addr); } Eine Klasse Timer erlaubt die Erzeugung von virtuellen Zeitgeber-Objekten: class Timer {. . . public wait(int time); } bs-5 24

Die Klasse Process verfügt über Operationen start/stop : stop versetzt einen Prozess in einen Zustand, in dem er bei der Auswahl aus der Bereitliste ignoriert wird; start erlöst ihn aus diesem Zustand. Der Umlagerungsprozess befindet sich im gleichen Adressraum wie der Kern. Ein/Ausgabe der Prozesse wird über Pufferbereiche des E/A-Systems abgewickelt, nie direkt zwischen Gerät und Prozess-Adressraum. bs-5 25

class Swappable. Process extends Process { static final Driver disk =. . . ; final int backup. Base; // Auslagerungsadresse final int backup. Length; // Anzahl der Blöcke final int swap. Time; // letzte Umlagerung public void swapout() { disk. output(backup. Base, backup. Length, status. base); }// (3. 1 ) public void swapin() { disk. input (backup. Base, backup. Length, status. base); } } bs-5 26

public Swappable. Process(Swappable. Process p){ super(); if(p != null){ status = p. status; backup. Length = p. backup. Length; } } (Konstruktor erlaubt „Klonen“ zum Zwecke von fork) bs-5 27

process Swapper { static final Timer timer = new Timer(); static final int free. Memory =. . . ; static final Allocation memory = new Allocation(free. Memory); static final int free. Disk =. . . ; static final Allocation swaparea = new Allocation(free. Disk); static final Swapout. List present = new Swapout. List(); static final Swapin. List absent = new Swapin. List(memory); bs-5 28

static{while(true) { // swapper permanent loop timer. wait(quantum); Process victim = present. remove(); if(victim == null) continue; swapout(victim); // siehe unten do {Process lucky = absent. remove(); if(lucky == null) break; swapin(lucky); // siehe unten while(true); } bs-5 29

private void swapout(Process victim){ victim. stop(); victim. swapout(); // swapper blocks! memory. deallocate(victim. base, victim. length); absent. add(victim); } private void swapin(Process lucky){ present. add(lucky); lucky. base = memory. allocate(lucky. length); lucky. swapin(); // swapper blocks! lucky. start(); } bs-5 30

public int fork(){//from first-level trap handler Swappable. Process parent = (Swappable. Process)Process. current(); Swappable. Process child = new Swappable. Process(parent); // has new pid, is ready but stopped child. backup. Base = swaparea. allocate(current. backup. Length); if(child. backup. Base == 0) return – 11; //EAGAIN // swap area overflow, child becomes garbage child. status. EAX = 0; // child gets result 0 child. swapout(); absent. add(child); return child. pid; // parent gets result } // via trap handler } // end of Swapper 31

5. 3. 3 Umlagerungsstrategien verbergen sich in der Implementierung von Swapout. List present (eingelagerte Prozesse) Swapin. List absent (ausgelagerte Prozesse) Ziel Effizienz/Ressourcennutzung: möglichst viele bereite Prozesse im Arbeitsspeicher ! kleine bereite Prozesse bevorzugen, hochpriorisierte Prozesse möglichst nicht auslagern Nicht vergessen Fairness: bereite Prozesse rotierend umlagern bs-5 32

Zusätzliches Problem: ein langzeitig blockierender Prozess – z. B. beim Warten auf Eingabe von der Tastatur – sollte auch vor Ablauf seines Quantums ausgelagert werden, wenn es ausgelagerte, bereite Prozesse gibt. ein kurzzeitig blockierender Prozess aber – z. B. beim Warten auf Leeren eines Ausgabepuffers – sollte nicht unbedingt ausgelagert werden, bs-5 - letzte Folie Zwei Arten von Blockaden unterscheiden, Mechanismen entsprechend erweitern und mit der Strategie ausnutzen ! 33