Systeme 1. Kapitel 6. Nebenläufigkeit und wechselseitiger Ausschluss

Transkript

1 Systeme 1 Kapitel 6 Nebenläufigkeit und wechselseitiger Ausschluss

2 Threads Die Adressräume verschiedener Prozesse sind getrennt und geschützt gegen den Zugriff anderer Prozesse. Threads sind leichtgewichtige Prozesse kein gegenseitiger Schutz somit mit gemeinsamem Adressraum (aber eigener Kellerspeicher (Stack)) teilen geöffnete Dateien und andere Ressourcen => Annahme: Threads kooperieren untereinander weniger Overhead im Vergleich zu (schwergewichtigen) Prozessen

3 Nebenläufigkeit Nebenläufigkeit = potentieller Parallelismus Nebenläufige Prozesses können parallel auf mehreren Prozessoren ausgeführt werden. Sie können aber auch pseudo-parallel auf einem Prozessor ausgeführt werden. Grundlegende Fragestellungen: Zugriff auf gemeinsame Ressourcen? Koordination, Kommunikation Bei Zugriff auf gemeinsame Ressourcen muss häufig wechselseitiger Ausschluss garantiert werden Zum Beispiel geteilter Speicher bei Threads

4 Beispiel void echo() chin = getchar(); /* Zeichen einlesen, speichern in Variable chin */ putchar (chin); /* Zeichen ausgeben */ Annahme: 2 Threads führen (u.a.) diesen Code aus. chin liegt im gemeinsam genutzen Speicherbereich

5 Beispiel void echo() chin = getchar(); /* Zeichen einlesen, speichern in Variable chin */ putchar (chin); /* Zeichen ausgeben */ Mögliche Ausführungsfolge: Thread 1 liest Zeichen, wird unterbrochen -> Thread 2 zb. T1: chin = 'a'; Thread 2 führt Prozedur komplett aus. zb. T2: chin = 'b'; Ausgabe: 'b' Thread 1 führt Rest der Prozedur aus. T1: Ausgabe: 'b', da chin jetzt b (gemeinsam genutzter Speicher)

6 Nebenläufigkeit Grundlegende Fragen bei Nebenläufigkeit Betriebssystem muss Ressourcen der aktiven Prozesse verwalten. OS muss wechselseitigen Ausschluss bei gemeinsamen Ressourcen garantieren können. Die Korrektheit des Ergebnisses muss unabhängig von der relativen Ausführungsgeschwindigkeit der einzelnen Prozesse sein. 3 Kontrollprobleme Wechselseitiger Ausschluss, d.h. jeweils nur ein Prozess im kritischen Abschnitt (= der Teil des Programms, der auf gemeinsame, exklusive Ressourcen zugreift) Verhindere Deadlocks (Blockierung aller Prozesse) Verhindere Livelocks (obwohl ein Prozess nicht blockiert ist, geht sein Ablauf nie voran.)

7 Anforderungen an wechselseitigen Ausschluss 1. Höchstens ein Prozess im kritischen Abschnitt. 2. Jeder Prozess hält sich nur endliche Zeit im kritischen Abschnitt auf. 3. Wenn ein Prozess in den kritischen Abschnitt will, so muss er nur endliche Zeit darauf warten. 4. Wenn kein Prozess im kritischen Abschnitt ist, so wird ein interessierter Prozess ohne Verzögerung akzeptiert. 5. Alles funktioniert unabhängig von der relativen Ausführungsgeschwindigkeit der Prozesse.

8 Softwarelösungen: Versuch 1 Voraussetzung 2 Prozesse konkurrieren um eine Ressource Beide Prozesse können auf eine gemeinsame Variable turn zugreifen und über diese kommunizieren. turn ist mit beliebigem Wert initialisiert (zb. turn = 0). /* Prozess 0 */ wiederhole solange (turn 0) (*) tue nichts; /* kritischer Abschnitt */ turn := 1; /* nichtkrit. Abschnitt */ /* Prozess 1 */ wiederhole solange (turn 1) tue nichts; /* kritischer Abschnitt */ turn := 0; (**) /* nichtkrit. Abschnitt */

9 Softwarelösungen: Versuch 1 Satz: Es sind nie zwei Prozesse gleichzeitig im kritischen Abschnitt. Beweis: Angenommen es gibt einen Zeitpunkt, zu dem beide Prozesse im kritischen Abschnitt sind. Es muss also einen Zeitpunkt t1 geben, zu dem ein Prozess im kritschen Abschnitt ist (z.b. Prozess 1) und der andere Prozess (Prozess 0) betritt gerade den kritischen Abschnitt. D.h. Prozess 0 verlässt die solange Schleife (*) wegen trun = 0. Es muss einen Zeitpunkt t0 gegeben haben, zu dem der Prozess 1 zum letzten Mal die solange Schleife verlassen und den kritischen Abschnitt betreten hat. D.h. zum Zeitpunkt t0 muss turn = 1 gegolten haben.

10 Softwarelösungen: Versuch 1 Beweis Fortsetzung: Dann muss aber zwischen t0 und t1 turn auf 0 gesetzt worden sein. turn = 0 kann aber nur bei der Initialisierung oder durch Prozess 1 and der Stelle (**) (nach dem kritischen Abschnitt) erfolgt sein. Zwischen t0 und t1 ist Prozess 1 die ganze Zeit im kritischen Abschnitt (nach Annahme). D.h. turn = 0 kann nicht erfolgt sein

11 Softwarelösungen: Versuch 1 Analyse Vorteil: Wechselseitiger Ausschluss ist garantiert. Nachteil: Busy waiting = aktives Warten ( solange (turn 0) tue nichts; ) => Verschwendung von Rechenzeit beim Warten Nur abwechselnder Zugriff auf kritischen Abschnitt

12 Softwarelösungen: Versuch 1 Beispiel für kritische Situation Prozess 0 ist schnell, Prozess 1 ist sehr langsam z.b. sehr langer, nicht kritischer Abschnitt (*) /* Prozess 0 */ wiederhole solange (turn 0) tue nichts; /* kritischer Abschnitt */ turn := 1; /* nichtkrit. Abschnitt */ /* Prozess 1 */ wiederhole solange (turn 1) tue nichts; /* kritischer Abschnitt */ turn := 0; /* nichtkrit. Abschnitt */(*)

13 Softwarelösungen: Versuch 1 Ungünstiges Szenario Prozess 0 (schnell) geht in kritischen Abschnitt und setzt anschließend turn = 1. Dann geht Prozess 1 in den kritischen Abschnitt und setzt anschließend turn = 0. Prozess 0 geht in den nicht kritischen Abschnitt (schnell) dann in den kritischen Abschnitt und setzt turn = 1 und bearbeitet anschließend den nicht kritischen Abschnitt (schnell). Prozess 1 berabeitet währenddessen immer noch seinen nicht kritischen Abschnitt. Prozess 0 muss jetzt so lange warten, bis Prozess 1 seinen (langen) nicht kritischen Abschitt beendet hat, seinen kritischen Abschnitt bearbeitet hat und turn = 0 setzt.

14 Softwarelösungen: Versuch 1 Anforderungen an wechselseitigen Ausschluss 4.) Wenn kein Prozess im kritischen Abschnitt ist, so wird ein interessierter Prozess ohne Verzögerung akzeptiert. Hier: Prozess 1 will nicht den kritischen Abschnitt. Prozess 0 will in den kritischen Abschnitt, muss aber warten. => Widerspruch zu Anforderung 4.)

15 Softwarelösungen: Versuch 2 Jetzt 2 gemeinsame Variablen zur Kommunikation: Prozess 0 schreibt auf flag[0], liest beide Prozess 1 schreibt auf flag[1], liest beide Bedeutung von flag[i] = true: Prozess i will in den kritischen Abschnitt Initialisierung: flag[0] := false; flag[1] := false; /* Prozess 0 */ wiederhole solange (flag[1] = true) tue nichts; flag[0] := true; /* kritischer Abschnitt */ flag[0] := false; /* nichtkrit. Abschnitt */ /* Prozess 1 */ wiederhole solange (flag[0] = true) tue nichts; flag[1] := true; /* kritischer Abschnitt */ flag[1] := false; /* nichtkrit. Abschnitt */

16 Softwarelösungen: Versuch 2 Vorteil: Nachteil: Auch nicht-alternierender Zugriff auf kritischen Abschnitt Busy waiting ( solange (flag[i] = true) tue nichts; ) Wechselseitiger Ausschluss nicht garantiert Beispiel für Fehlersituation : flag[0] = flag[1] = false Prozess 0 schließt Schleife ( solange (flag[1] = true) tue nichts; ) ab, gibt CPU ab Prozess 1 schließt Schleife ( solange (flag[0] = true) tue nichts; ) ab Jetzt können beide Prozesse ungehindert den kritischen Abschnitt betreten: Prozess 1 betritt kritischen Abschnitt, gibt CPU ab Prozess 0 betritt kritischen Abschnitt

17 Softwarelösungen: Versuch 3 Anforderung des kritischen Abschnittes wird vorgezogen, um das gezeigte Problem zu verhindern: Versuch 2 ging schief, weil die Anforderung für die kritische Region zu spät erfolgte. -> Vertausche Reihenfolge von (**) nach (*) /* Prozess 0 */ wiederhole flag[0] := true; (*) solange (flag[1] = true) tue nichts; (**) /* kritischer Abschnitt */ flag[0] := false; /* nichtkrit. Abschnitt */ /* Prozess 1 */ wiederhole flag[1] := true; solange (flag[0] = true) tue nichts; /* kritischer Abschnitt */ flag[1] := false; /* nichtkrit. Abschnitt */

18 Softwarelösungen: Versuch 3 Vorteil: Auch nicht-alternierender Zugriff auf kritischen Abschnitt Wechselseitiger Ausschluss garantiert Nachteil: Busy waiting ( solange (flag[i] true) tue nichts; ) Es kann aber trotzdem ein Problem auftreten: flag[0] = flag[1] = false Prozess 0 setzt flag[0] := true und gibt CPU ab Prozess 1 setzt flag[1] := true Jetzt werden beide Prozesse ihre Schleife solange (flag[i] true) tue nichts; nie verlassen Eine solche Situation nennt man Deadlock.

19 Softwarelösungen: Zwischenergebnis Anforderung zu früh Deadlock (Versuch 3) Anforderung zu spät kein wechselseitiger Ausschluss, kritischer Wettlauf (Versuch 2)