5.3 Prozessumlagerung (process) swapping

Transkript

1 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 auslagern (swap out) einlagern (swap in) Auslagerungsbereich (swap area) (so im Ur-Unix; bei alten IBM-Systemen der 1960/70er: roll-in/roll-out ) bs-5.3 1

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

3 Entwurf der Speicherverwaltung (vgl. 4.2 ): Aufrufe/Aufträge, z.b. durch fork, brk,... Operationen Umlagerer (swapper) Verwaltungsdaten (Speicherbelegung,...) hochpriorisierter, speicherresidenter Systemprozess, regelmäßig aktiv nach Ablauf eines Zeitquantums (quantum >> timeslice) bs-5.3 3

4 5.3.1 Verwaltungsdaten Speicherverwaltung führt Buch über Arbeitsspeicherbelegung (5.2, S. 2 ) Allocation memory Belegung des Auslagerungsbereichs Allocation swaparea eingelagerte Prozesse SwapoutList present ausgelagerte Prozesse SwapinList absent bs-5.3 4

5 Auch bei der Umlagerung ist wichtig die Trennung von Mechanismen ( 5.3.2) und Strategien ( 5.3.3) (mechanisms vs. policies) Auslagerungstrategie wird bestimmt durch die Implementierung von present.remove() Einlagerungstrategie wird bestimmt durch die Implementierung von absent.remove() bs-5.3 5

6 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. bs-5.3 6

7 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); } Arbeitsspeicheradresse Eine Zeitgeber-Verwaltung erlaubt die Erzeugung von virtuellen Zeitgebern ("Weckern") mit Schnittstelle interface Timer { void wait(int time); } (Übung: Timer implementieren) bs-5.3 7

8 Die Klasse Process wird um Operationen start/stop erweitert: 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 die Prozessverwaltung. Die E/A-Operationen der übrigen Prozesse werden über Pufferbereiche des E/A-Systems abgewickelt, nie direkt zwischen Gerät und Prozess-Adressraum. bs-5.3 8

9 class SwappableProcess extends Process { static final Driver disk =...; int backupbase; // Auslagerungsadresse int backuplength;// Anzahl der Blöcke int swaptime; // letzte Umlagerung boolean stopped = true; public void swapout() { stopped = true; disk.output(backupbase, backuplength, status.base); } // (5.1.1 ) public void swapin() { disk.input (backupbase, backuplength, status.base); stopped = false; } } bs-5.3 9

10 public SwappableProcess(SwappableProcess p){ super(p); if(p!= null){ status = p.status; // including base/length backuplength = p.backuplength; } } (Konstruktor erlaubt Klonen zum Zwecke von fork - s.u.) Bemerkung: die im Pseudocode eingesetzte Vererbung class SwappableProcess extends Process {...} hat in realen Systemen die folgende Entsprechung: entweder die Prozesstabelle enthält bereits die erweiterten Deskriptoren oder die Speicherverwaltung führt eine eigene Tabelle der Erweiterungen (so in MINIX) bs

11 class Swapper { static final int priority =...; static final Sema mutex = new Sema(1); static final Timer timer = new VirtualTimer(); static final int quantum =...; static final int freememory =...; static final Allocation memory = new LinkedAlloc(freeMemory); static final int freedisk =...; static final Allocation swaparea = new BitlistAlloc(freeDisk); // synchronized - see p. 14 static final SwapoutList present = new SwapoutList(); static final SwapinList absent = new SwapinList(memory); // synchronized - see p. 15 bs

12 static { Process swapper = new Process(); INITIALIZE_status(swapper); // RUN etc. } static void RUN(){ while(true) { // swapper permanent loop SwappableProcess victim, lucky; timer.wait(quantum); victim = present.remove(); if(victim == null) continue; mutex.p(); // prevent interference // with fork system call swapout(victim); // siehe unten mutex.v(); } } do { lucky = absent.remove(); if(lucky == null) break; swapin(lucky); // siehe unten while(true); bs

13 static void swapout(swappableprocess victim){ victim.swapout(); // swapper blocks until done memory.deallocate(victim.status.base, victim.status.length); absent.add(victim); } static void swapin(swappableprocess lucky){ present.add(lucky); lucky.status.base = memory.allocate( lucky.status.length); lucky.swapin(); // swapper blocks until done } bs

14 static public int fork(){ // from 1.-level trap handler // NO interrupt inhibition // several forks may proceed concurrently! SwappableProcess parent = (SwappableProcess)Process.current(); SwappableProcess child = new SwappableProcess(parent); // has new pid, is ready but stopped child.backupbase = swaparea.allocate(parent.backuplength); if(child.backupbase == 0){ // swap area overflow readylist.delete(child);// non-interruptible! return 11; // EAGAIN // else: bs

15 child.status.gpr.eax = 0; // child gets result 0 int prio = parent.priority;// save current priority parent.priority = priority;// prevent priority inversion mutex.p(); // prevent swapout child.status.base = parent.status.base; child.swapout(); // effectively creates the copy! mutex.v(); parent.priority = prio; // restore priority absent.add(child); return child.pid; // parent gets result pid } // via trap handler } // end of Swapper bs

16 Übung: Wie sieht exit() aus? Wie wait()? bs

17 5.3.3 Umlagerungsstrategien verbergen sich in der Implementierung von SwapoutList present (eingelagerte Prozesse) SwapinList absent (ausgelagerte Prozesse) Ziel Effizienz/Ressourcennutzung: möglichst viele bereite Prozesse im Arbeitsspeicher! kleine bereite Prozesse bevorzugen, hochpriorisierte Prozesse möglichst nicht auslagern Fairness nicht vergessen: bereite Prozesse rotierend umlagern bs

18 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, Zwei Arten von Blockaden unterscheiden, Mechanismen entsprechend erweitern und mit der Strategie ausnutzen! bs

19 Und andererseits nicht vergessen: Arbeitsspeicher ist manchmal so groß, dass gar kein Auslagern erforderlich ist. bs