Systemsoftware (SYS)

Transkript

1 10.Vorlesung Systemsoftware (SYS) Christian Baun Hochschule Mannheim Fakultät für Informatik Institut für Robotik

2 Heute Interprozesskommunikation Kritische Abschnitte Wettlaufsituationen (Race Conditions) Kommunikation vs. Kooperation Synchronisation von Prozessen Aktives Warten, blockieren, deblockieren, Barrieren, Sperren Kommunikation von Prozessen Shared Memory, Message Queues, Pipes, Sockets Kooperation von Prozessen Semaphor, Mutex 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 2

3 Prozessinteraktionsarten Prozesse, die zusammen an einer gemeinsamen Aufgabe arbeiten, müssen nicht nur Operationen auf Daten ausführen, sonden auch: sich gegenseitig aufrufen aufeinander warten sich abstimmen kurz gesagt: Sie müssen miteinander interagieren. Prozesse haben eine Eingabe und eine Ausgabe und müssen in den meisten Fällen ständig mit anderen Prozessen kommunizieren. Eine Pipe beispielsweise sorgt dafür, dass die Ausgabe einen Prozesses in die Eingabe eines anderen Prozesses weitergeleitet wird. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 3

4 Interprozesskommunikation Bei der Interprozesskommunikation sind drei Punkte interessant: 1. Wie kann ein Prozess Informationen an einen anderen weiterreichen? 2. Wie kann sichergestellt werden, dass zwei oder mehr Prozesse, die auf die gleiche Ressource zugreifen wollen, sich nicht in die Quere kommen? 3. Wie können Prozesse mit Abhängigkeiten sauber durchlaufen? Frage: Wie verhält es sich hier mit Threads? Im Bezug auf Threads gelten praktisch die gleichen Herrausforderungen der Interprozesskommunikation (IPC). Nur die Kommunikation zwischen den Threads eines Prozesses ist unproblematisch, da sie im gleichen Adressraum agieren. Ansonsten gelten die Probleme und Lösungen der Interprozesskommunikation für Threads genau so wie für Prozesse. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 4

5 Kritische Abschnitte Auf allen Systemen, auf denen mehrere Prozesse laufen, müssen die Prozesse Daten austauschen und Ressourcen gemeinsam nutzen. laufen mehrere parallel ausgeführte Prozesse, unterscheidet man: Unkritische Abschnitte: Die Prozesse greifen nicht oder nur lesend auf gemeinsame Daten zu. Kritische Abschnitte: Die Prozesse greifen nicht nur lesend auf gemeinsame Daten zu. Damit Prozesse auf gemeinsam genutzten Speicher zugreifen können, ist wechselseiteiger Ausschluss (Mutual Exclusion) notwendig. Kritische Abschnitte dürfen nicht von mehreren Prozessen gleichzeitig durchlaufen werden. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 5

6 Kritische Abschnitte Beispiel: Drucker-Spooler (1) 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 6

7 Kritische Abschnitte Beispiel: Drucker-Spooler (2) Prozess X Prozess Y next free slot = in; (7) Speichere Eintrag in next free slot; (7) in = next free slot + 1; (8) Prozesswechsel Prozesswechsel next free slot = in; (7) Speichere Eintrag in next free slot; (7) in = next free slot + 1; (8) Das Spooler-Verzeichnis ist zwar konsistent, aber der Eintrag von Prozess Y wurde von Prozess X überschrieben und ist verloren gegangen. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 7

8 Race Conditions Eine Race Condition (Wettlaufsituation) bezeichnet eine Konstellation, bei der das Ergebnis eines Prozesses von der Reihenfolge oder dem zeitlichen Ablauf anderer Ereignisse abhängt. Eine Race Conditions ist eine unbeabsichtigten Wettlaufsituation zweier Prozesse, die auf die gleiche Speicherstelle schreibend zugreifen wollen. Häufiger Grund für schwer auffindbare Programmfehler. Hauptproblem: Das Auftreten und die Symptome sind von unterschiedlichen Ereignissen und ihrem Verhalten abhängen. Bei jedem Testdurchlauf können die Symptome komplett verschieden sein oder verschwinden. Race Conditions können u.a durch Semaphore vermieden werden. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 8

9 Beispiel einer Race Condition (1) Angenommen, der Wert einer Speicherstelle ist 5. Zwei voneinander unabhängige Prozesse wollen auf die Speicherstelle zugreifen und jeweils den gespeicherten Wert um 2 erhöhen. Eine Ausführungsreihenfolge mit korrektem Ergebnis wäre z.b: 1. Prozess X liest Wert in internen Speicher = X=5 2. Prozess X erhöht intern den Wert um 2 = X=7 3. Prozess X schreibt neuen Wert in den Speicher = Speicher=7 4. Prozess Y liest Wert in internen Speicher = Y=7 5. Prozess Y erhöht intern den Wert um 2 = Y=9 6. Prozess Y schreibt neuen Wert in den Speicher = Speicher=9 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 9

10 Beispiel einer Race Condition (2) Wenn beide Prozesse gleichzeitig auf die Speicherstelle zugreifen wollen, kommt es zu einer Race Condition und einem fehlerhaften Ergebnis. 1. Prozess X liest Wert in internen Speicher = X=5 2. Prozess Y liest Wert in internen Speicher = Y=5 3. Prozess X erhöht intern den Wert um 2 = X=7 4. Prozess Y erhöht intern den Wert um 2 = Y=7 5. Prozess X schreibt neuen Wert in den Speicher = Speicher=7 6. Prozess Y schreibt neuen Wert in den Speicher = Speicher=7 Um eine Race Condition zu verhindern, muss bei einem Zugriff auf den Wert der Speicherstelle diese bis zum Abschluss des Zugriffs gesperrt werden. In diesem Fall muss Prozess Y warten, bis Prozess X den neuen Wert in die Speicherstelle geschrieben hat. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 10

11 Kommunikation vs. Kooperation Die Prozessinteraktion besitzt zwei Aspekte: Funktionaler Aspekt: Kommunikation und Kooperation. Zeitlicher Aspekt: Synchronisation. Kommunikation (= expliziter Datentransport) Prozess 1 Prozess 2 Kooperation (= Zugriff auf gemeinsame Daten) Prozess 1 Prozess 2 Daten 1 Daten 2 Kopieren Daten 1 gemeinsamer Teil Daten 2 (gerichtete Beziehung) (symmetrische Beziehung) 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 11

12 Interaktionsformen Kommunikation und Kooperation basieren alle auf der Synchronisation. Die Synchronisation ist die elementarste Form der Intaraktion, denn Kommunikation und Kooperation benötigen alle eine zeitliche Abstimmung zwischen den Intaraktionspartnern. Aus diesem Grund müssen wir zu erst die Synchronisation behandeln. Kommunikation Kooperation Synchronisation 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 12

13 Synchronisation Synchronisation Signalisierung (aktives Warten) Signalisierung (blockieren, deblockieren) Wechselseitige Synchronisierung Gruppensignalisierung Barrieren Kritische Abschnitte Sperren 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 13

14 Signalisierung Die Signalisierung ist eine spezielle Art der Synchronisation. Bei der Signalisierung wird eine Reihenfolgebeziehung hergestellt. Ein Beispiel: Abschnitt X von Prozess 1 soll vor Abschnitt Y von Prozess 2 ausgeführt werden. Mit den Operationen signal und wait kann signalisiert werden, wenn Prozess 1 den Abschnitt X abgearbeitet hat. Prozess 2 muss zur Laufzeit eventuell auf das Signal von Prozess 1 warten. Prozess 1 Prozess 2 X signal(s) wait(s) Y 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 14

15 Grundform der Signalisierung (aktives Warten) In der einfachsten Form sehen die Operationen zur Signalisierung so aus: signal(s) wait(s) set s is s set? no reset s Diese Vorgehensweise ist aktives Warten an der Signalisierungsvariablen s und das bedeutet, dass Rechenzeit der CPU verschwendet wird, da diese immer wieder von dem Prozess belegt wird. Diese Technik wird auch als Spinlock oder Warteschleife bezeichnet. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 15

16 Signalisierung (blockieren, deblockieren) Besser ist es, den wartenden Prozess zu blockieren, bis Prozess 1 Abschnitt X abgearbeitet hat. Diese Vorgehensweise würde die CPU deutlich entlasten. Nachteil: Beim Signalisieren mit Wartezustand kann immer nur ein Prozess warten. signal(s) wait(s) set s is s set? no yes process waiting? block process yes no deblock process reset s 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 16

17 blockieren, deblockieren unter JAVA class Signal { private boolean set = false; // Signalvariable public synchronized void signal() { set = true; notify(); // deblockiert den wartenden Prozess } } public synchronized void wait() { if (!set) wait(); // wartet auf das Signal set = false; } Mit wait() wird ein Prozess in seiner Ausführung blockiert. Mit notify() wird ein wartender Prozess deblockiert. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 17

18 Wechselseitige Synchronisierung Werden wait() und signal() (bzw. unter JAVA: notify()) symmetrisch ausgeführt, führt das dazu, dass die Abschnitte X1 und Y1 vor den Abschnitten X2 und Y2 ausgeführt werden. Prozess 1 Prozess 2 X1 signal(s) wait(s) X2 Y1 signal(s) wait(s) Y2 In einem solchen Fall spricht man davon, dass die Prozesse 1 und 2 synchronisieren. Es kommt zu einem Rendezvous bzw. Handshake. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 18

19 Wechselseitige Synchronisierung sync() Die Operation sync() fasst die Operationen wait() und signal() (unter JAVA: notify()) zusammen. Prozess 1 Prozess 2 X1 Y1 sync(s) sync(s) X2 Y2 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 19

20 Implementierung einer Synchronisierung unter JAVA class Synchronisierung { private boolean set = false; } public synchronized void sync() { if (set == false) { // ich bin der erste Prozess set = true; // die Bereitschaft signalisieren wait(); // auf den anderen Prozess warten } else { // ich bin der zweite Prozess set = false; // Signalvariable zurücksetzen notify(); // deblockiert den wartenden Prozess } } 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 20

21 Gruppensignalisierung An einer Signalisierung können mehr als zwei Prozesse beteiligt sein. In einem solchen Fall spricht man von Gruppensignalisierung. Zwei Beispiele für Gruppensignalisierung sind: UND-Signalisierung: Ein Prozess darf in seiner Abarbeitung erst weiterlaufen, wenn mehrere Prozesse ein Signal gesetzt haben. In diesem Fall liegt eine UND-Verknüpfung auf Signalisierungsseite vor. ODER-Signalisierung: Mehrere Prozesse warten auf ein Signal. Erfolgt das Signal, wird einer der wartenden Prozesse deblockiert. In diesem Fall liegt eine ODER-Verknüpfung auf der Seite der wartenden Prozesse vor. Alle möglichen Kombinationen der beiden Arten von Gruppensignalisierungen sind denkbar. Bei Gruppensignalisierung sind in der Signalimplementierung entsprechende Kapazitäten bzgl. der Signalvariablen notwendig. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 21

22 UND-Signalisierung Prozess 1 signal(s1) Prozess 4 Prozess 2 wait(s1) wait(s2) wait(s3) signal(s2) Prozess 3 signal(s3) 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 22

23 ODER-Signalisierung Prozess 2 Prozess 1 wait(s) Prozess 3 signal(s) wait(s) Prozess 4 wait(s) 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 23

24 Gruppensynchronisierung mit Barriere Mit einer Barriere synchronisieren die beteiligten Prozesse an einer Stelle. Die Prozesse dürfen erst dann in seiner Abarbeitung weiterlaufen, wenn alle Prozesse die Synchronisationsstelle erreicht haben. Prozess 1 Prozess 2 Prozess 3 Prozess 4 X1 sync(s) X1 sync(s) X1 X1 sync(s) X2 X2 X2 sync(s) X2 In einem solchen Fall spricht man von einer Synchronisationsbarriere, Barrierensynchronisation oder Gruppenrendezvous. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 24

25 Implementierung einer Barriere unter JAVA (1) class BarrierenSynchronisation { private int summe = p; private int zaehler = 0; // Anzahl Prozesse // Anzahl wartende Prozesse } public synchronized void sync() { zaehler = zaehler + 1; if (zaehler < summe) { // es fehlen noch Prozesse wait(); // auf die fehlenden Prozesse warten } else { // es sind alle Prozesse eingetroffen notifyall(); // alle wartenden Prozesse deblockieren zaehler = 0; } } 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 25

26 Implementierung einer Barriere unter JAVA (2) Das Schlüsselwort synchronized sorgt unter JAVA für den gegenseitigen Ausschluss aller damit gekennzeichneten Methoden eines Objekts. Die JAVA-Methode wait() blockiert die Ausführung des Prozesses, bis dieser deblockiert wird. Die JAVA-Methode notify() deblockiert einen wartenden Prozess. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 26

27 Sperren Mit Sperren werden kritische Abschnitte gesichert. Prozess 1 Prozess 2 X lock(s) unlock(s) lock(s) Y unlock(s) Durch Sperren können wir dafür sorgen, dass es bei der Abarbeitung zweier krischer Abschnitte wie X von Prozess 1 und Y von Prozess 2 keine Überlappung gibt. Die Ausführungen der Prozesse 1 und 2 schließen sich gegenseitig aus. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 27

28 Sperren und Freigeben Die Signalvariable s wird bei lock() anders als bei signal() in einer Schleife abgefragt, da zwischen dem Deblockieren des wartenden Prozesses und dem Setzen der Sperre ein anderer Prozess die Sperre setzen könnte. unlock(s) lock(s) reset s is s set? yes no prozess waiting? block process yes no deblock prozess set s 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 28

29 Unterschied zwischen Signalisierung und Sperren Bei der Signalisierung wird eine Reihenfolgebeziehung zwischen Prozessen festgelegt. Beispiel: Abschnitt A von Prozess P 1 soll vor Abschnitt B von P 2 ausgeführt werden. Bei einer Sperre werden kritische Abschnitte gesichert. Die Reihenfolge, in der die Prozesse bei einer Sperre ihre kritische Abschnitte abarbeiten, ist nicht festgelegt! Es soll bei einer Sperre nur sichergestellt sein, dass es keine Überlappung in der Ausführung der kritischen Abschnitte gibt. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 29

30 Implementierung einer Sperre unter JAVA class Sperre { private boolean gesperrt = false; public synchronized void sperre() { while(gesperrt) wait(); // auf die fehlenden Prozesse warten gesperrt = true; // den Prozess sprerren } } public synchronized void entsperren() { gesperrt = false; // die Sperre für den Prozess aufheben notify(); // alle wartenden Prozesse benachrichtigen } 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 30

31 Probleme, die durch Sperren entstehen Verhungern (Starving) Wenn ein Prozess eine Sperre nicht wieder aufhebt, müssen die anderen Prozesse unendlich lange auf die Freigabe warten. In einem solchen Fall spricht man vom Verhungern (englisch: to starve) der Prozesse. Deadlock Wenn zwei Prozesse gegenseitig auf die von ihnen gesperrten Ressourcen warten, sperren sich die Prozesse gegenseitig. Es kommt zu einer Verklemmung (Deadlock). Da alle am Deadlock beteiligten Prozesse warten, kann keiner ein Ereignis auslösen, so dass ein anderer geweckt wird. Beim Deadlock warten alle beteiligten Prozesse ewig. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 31

32 Ein schematisches Deadlock-Beispiel 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 32

33 Ein Deadlock-Beispiel aus der realen Welt 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 33

34 Bedingungen für Deadlocks Damit ein Deadlock überhaupt entstehen kann, müssen die folgenden vier Bedingungen alle erfüllt sein: 1. Wechselseitiger Ausschluss: Jede Ressource wird von genau einem Prozess belegt oder ist verfügbar. 2. Anforderung weiterer Betriebsmittel: Ein Prozess, der bereits Ressourcen besitzt, kann weitere anfordern. 3. Ununterbrechbarkeit: Die Ressourcen, die ein Prozess besitzt, können nicht von außen entzogen, sondern nur durch ihn selbst freigegeben werden. 4. Zyklische Wartebedingung: Es gibt eine zyklische Kette von Prozessen. Jeder Prozess fordert eine Ressource an, die der nächste Prozess in der Kette besitzt. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 34

35 Kommunikation Kommunikation Shared Memory Message Queues Pipes Sockets 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 35

36 Shared Memory (1) Prozesskommunikation über einen gemeinsamen Speicher (Shared Memory) bezeichnet man auch als speicherbasierte Kommunikation. Shared Memory Segmente sind Speicherbereiche, auf die mehrere Prozesse direkt zugreifen können. Diese Speicherbereiche liegen im Adressraum mehrere Prozesse. Um einen Speicherbereich zu einem Shared Memory Segment zu machen, muss eine bestimmte Funktion shmget() des Betriebssystems aufgerufen werden und der Speicherbereich wird als Shared Memory Segment registriert. Die Prozesse, die auf ein Shared Memory Segment zugreifen, müssen die Schreib- und Lesezugriffe selbst koordinieren und sicherstellen, dass ihre Speicherzugriffe sich gegenseitig ausschließen. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 36

37 Shared Memory (2) Der lesende Prozess (Empfänger) darf nichts aus dem gemeinsamen Speicher lesen, bevor der schreibende Prozess (Sender) etwas fertig in den gemeinsamen Speicher geschrieben hat. Geschieht die Koordinierung der Zugriff nicht mit Sorgfalt, kommt es zu Inkonsistenzen. Prozess X (Sender) exklusiv nutzbarer Speicher Shared Memory gemeinsam nutzbarer Speicher Prozess Y (Empfänger) exklusiv nutzbarer Speicher 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 37

38 Shared Memory unter Linux/UNIX Bei Linux/UNIX-Betriebssystemen speichert eine Shared Memory Tabelle die Informationen über die aktuell existierenden Shared Memory Segmente. Zu diesen Informationen gehören: Anfangsadresse im Speicher Größe Besitzer (Username und Gruppe) Zugriffsrechte Ein Shared Memory Segment wird immer über seine Indexnummer in der Shared Memory Tabelle angesprochen und entspricht einem Anschnitt im Speicher. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 38

39 Prinzip von Shared Memory unter Linux/UNIX Shared Memory Tabelle 0 Segment 0 Kopie durch shmat() Adressraum von Prozess X (virtueller Adressraum) Seite Segment 1 Segment 2 virtuelle Adresse virtuelle Adresse Seite 1 Seite Segment 3 Segment 4 Memory Management Unit (MMU) Seite 3 Seite 4 5 Segment 5 Seite 5 Index enthält Informationen zum jeweiligen Segment reale Adresse im Hauptspeicher 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 39

40 Mit Shared Memory arbeiten Linux/UNIX-Betriebssysteme stellen vier Systemaufrufe für die Arbeit mit gemeinsamem Speicher bereit: shmget(): Shared Memory Segmente erzeugen oder auf bestehende Shared Memory Segmente zugreifen. shmat(): Shared Memory Segmente an Prozesse binden. shmdt(): Shared Memory Segmente von Prozessen lösen/freigeben. shmctl(): Status (u.a. Zugriffsrechte) von Shared Memory Segmenten abfragen, ändern und Shared Memory Segmente löschen. Informationen über bestehende Shared Memory Segmente liefert das Kommando ipcs. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 40

41 Message Queues Message Queues sind Nachrichten, die in Form einer verketteten Liste verwaltet werden. Prozesse können Daten in der Message Queue ablegen, die von anderen Prozessen abgeholt werden können. Jede Message Queue hat eine eindeutige Kennung zur Identifikation. Message Queues sind vergleichbar mit Mailboxen für Prozesse. Vorteil von Message Queues: Die Daten in einer Message Queue verbleiben auch nach der Beendigung des Erzeuger-Prozesses in der Message Queue. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 41

42 Mit Message Queues arbeiten Linux/UNIX-Betriebssysteme stellen vier Systemaufrufe für die Arbeit mit Message Queues bereit: msgget(): Message Queues erzeugen oder auf bestehende Message Queues zugreifen. msgsnd(): Nachrichten in Message Queues schreiben (schicken). msgrcv(): Nachrichten aus Message Queues lesen (empfangen). msgctl(): Status (u.a. Zugriffsrechte) von Message Queues abfragen, ändern und Message Queues löschen. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 42

43 Pipes (1) Eine Pipe ist wie ein Kannal bzw. eine Röhre, die einen gepufferten, unioder bidirektionalen Datenstrom zwischen zwei Prozessen ermöglicht. Man unterscheidet Anonyme Pipes und Benannte Pipes. Eine Pipe kann immer nur zwischen zwei Prozessen tätig sein. Eine Anonyme Pipe kann nur in eine Richtung verwendet werden. Pipes funktionieren immer nach dem FIFO (First In First Out) Prinzip. Pipes werden von einem Prozess mit dem Systemaufruf pipe() angelegt. Dabei wird ein Inode auf der Festplatte und zwei Zugriffskennungen, die sogenannten Handles erzeugt. Prozess X "abc..." Pipe "abc..." Prozess Y Schreib-Prozess enthält den Bytestrom Lese-Prozess 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 43

44 Pipes (2) Auf die Zugriffskennungen wird vom Prozess mit read() und write()- Systemaufrufen zugegriffen, um Daten aus der Pipe zu lesen bzw. um Daten in die Pipe zu schreiben. Bei der Erzeugung von Kindprozessen mit fork() erben die Kindprozesse auch den Zugriff auf die Zugriffskennungen. Nachteil: Nur Prozesse, die mittels fork() eng verwandt sind, können über Pipes miteinander kommunizieren. Mit der Beendigung des letzten Prozesses, der Zugriff auf eine aktive Pipe hat, wird die Pipe vom Betriebssystem beendet. Pipes, die nur Prozesskommnikation zwischen eng verwandten Prozessen ermöglichen, werden auch als Anonyme Pipes bezeichnet. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 44

45 Pipes (3) Damit auch nicht eng miteinander verwandte Prozesse miteinander kommunizieren können, gibt es Benannte Pipes (Named Pipes). Auf diese Pipes kann mit Hilfe ihres Namens zugegriffen werden. Benannte Pipes können auch zur Kommunikation von Prozessen auf unterschiedlichen Rechnern innerhalb eines Netzwerkes eingesetzt werden. Benannte Pipes ermöglichen den Vollduplexbetrieb zwischen Prozessen. Daten können gleichzeitig in beide Richtungen ausgetauscht werden. Jeder Prozess, der den Namen einer benannten Pipe kennt, kann über den Namen die Verbindung zur Pipe herstellen und darüber mit anderen Prozessen kommunizieren. Benannte Pipes können unter Linux/UNIX-Betriebssystemen mit dem Systemaufruf mknod() erzeugt werden. Benannte Pipes werden häufig einfach als FIFO bezeichnet. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 45

46 Pipes (4) Pipes haben eine begrenzte Kapazität. Ist eine Pipe voll, wird der in die Pipe schreibende Prozess blockiert. Ist eine Pipe leer, wird der aus der Pipe lesende Prozess blockiert. Unter UNIX sind Pipes ein mächtiges Werkzeug um Befehle sequentiell abzuarbeiten. Eine Pipe sorgt dafür, dass die Ausgabe eines Prozesses in die Eingabe eines anderen gelangt und wird auf der Shell mit dem senkrechten Balken erzeugt. z.b. cat /pfad/zu/datei.txt grep Suchmuster 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 46

47 Sockets Sockets sind Endpunkte einer bi-direktionalen Software-Schnittstelle zu Kommunikation zwischen Prozessen in verteilten Systemen. Sockets sind die vollduplexfähige Alternative zu Pipes und speicherbasierter Kommunikation (Shared-Memory). Ein Socket kann von mehreren Rechner-Systemen verwendet werden. Sockets bilden eine standardisierte Schnittstelle zwischen der Netzwerkprotokollimplementierung des Betriebssystems und den Benutzerprozessen. Ein Benutzerprozess kann einen Socket vom Betriebssystem anfordern, und über diesen anschließend Daten verschicken und empfangen. Das Betriebssystem verwaltet alle benutzten Sockets und die zugehörigen Verbindungsinformationen. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 47

48 Prinzip von Sockets Zur Kommunikation über Sockets werden Ports verwendet. Die Vergabe der Portnummern erfolgt beim Verbindungsaufbau. Die Portnummern werden großteils vom Betriebssystem beliebig vergeben. Ausnahmen sind Ports bekannter Anwendungen, die immer gleich sind. Bekannte Beispiele sind: HTTP (80), SMTP (25), Telnet (23), SSH (22), FTP (21), POP3 (110),... Der Einsatz von Sockets ist blockierend (synchron) und nicht-blockierend (asynchron) möglich. Prozess X send recv Socket Socket send recv Prozess Y Rechner 1 Rechner 2 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 48

49 Verschiedene Arten von Sockets Verbindungsorienterte Sockets (bzw. Stream Sockets) Kommunizieren über einen kontinuierlichen Zeichen-Datenstrom. Verwenden meistens TCP. Vorteile: Hohe Verlässlichkeit. Daten können nicht verloren gehen. Daten kommen immer in der korrekten Reihenfolge an. Nachteile: TCP bietet eine geringere Geschwindigkeit als UDP. Verbindungslose Sockets (bzw. Datagram Sockets) Basieren auf dem Senden von einzelnen Nachrichten (Pakete). Verwenden meistens UDP. Vorteile: UDP ermöglicht eine höhere Geschwindigkeit. Nachteile: Daten werden in Pakete aufgeteilt und einzeln versandt. Pakete können einander überholen oder verloren gehen. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 49

50 Vergleich der Kommunikations-Systeme Nachrichtebasierte Kommunikation ist komfortabler als speicherbasierte Kommunikation über Shared Memory. Die Vorteile von nachrichtebasierter Kommunikation sind: Das Betriebssystem entlastet bei nachrichtebasierter Kommunikation die Benutzerprozesse von allen Verwaltungsaufgaben, insbesondere von Synchronisationsproblemen. Nachrichtebasierte Kommunikation kann auch in verteilten Systemen eingesetzt werden, in denen kein gemeinsam zugreifbarer Hardwarespeicher vorhanden ist. Speicher kann über Netzwerkverbindungen eingebunden werden und so wird speicherbasierte Kommunikation möglich. Aus Sicht der Software ist dadurch im gesamten Rechnernetz ein einheitlicher Speicher vorhanden. Das Problem der Synchronisation der Zugriffe besteht aber auch hier. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 50

51 Kooperation Kooperation Semaphor Mutex 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 51

52 Semaphore (1) Zur Sicherung (Sperrung) kritischer Abschnitte können außer den bekannten Sperren auch Semaphore eingetzt werden. Semaphore wurden 1965 durch E.W.Dijkstra eingeführt. Ursprünglich ist ein Semaphor eine einfache Zählersperre S mit den Operationen P(S) und V(S). Die Zugriffsoperationen sind atomar, also nicht unterbrechbar (unteilbar). Semaphore (Zählsperren) können auch mehreren Prozessen das Betreten des kritischen Abschnitts erlauben. Im Gegensatz zu Semaphore können Sperren immer nur einem Prozess das Betreten des kritischen Abschnitts erlauben. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 52

53 Semaphore (2) Die Arbeitsweise von Semaphoren wird ersichtlich, wenn man sich folgendes Szenario vor Augen hält. In einem Geschäft steht neben dem Ein-/Ausgang ein Stapel mit Einkaufskörben. Jeder Kunde, der in das Geschäft will, muss sich einen Einkaufskorb vom Stapel nehmen. Jeder Kunde, der mit dem Einkauf fertig ist und an der Kasse bezahlt hat, muss seinen Einkaufskorb wieder auf den Stapel am Eingang zurückstellen. Ist der Stapel leer, also sind alle Einkaufskörbe vergeben, kann so lange kein neuer Kunde den Laden betreten, bis ein Einkaufskorb für ihn frei ist und auf dem Stapel liegt. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 53

54 Ein Semaphor besteht aus zwei Datenstrukturen COUNT: Eine ganzzahlige, nichtnegative Zählvariable. Die Variable gibt an, wie viele Prozesse das Semaphor aktuell ohne Blockierung passieren dürfen. Der Wert entspricht, gemäß dem einführenden Beispiel, der Anzahl der Körbe, die sich aktuell auf dem Stapel neben dem Ein-/Ausgang des Ladens befnden. Ein Warteraum für die Prozesse, die darauf warten, das Semaphor passieren zu dürfen. Die Prozesse sind im Zustand blockiert und warten darauf, vom Betriebssystem in den Zustand bereit überführt zu werden, wenn das Semaphor den Weg freigibt. Das Semaphor gibt den Weg frei, wenn wieder Körbe frei sind. Die Länge der Warteschlange entspricht der Anzahl der Kunden, die vor dem Laden warten, weil keine Körbe mehr frei sind. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 54

55 Drei Zugriffsoperationen sind möglich (1) Initialisierung: Zuerst wird ein Semaphor erzeugt oder, ein bestehendes Semaphor geöffnet. Bei einem neuen Semaphor wird zu Beginn die Zählvariable mit einem nichtnegativen Anfangswert initialisiert. Dieser Wert ist die Anzahl der Körbe, die bei Ladenöffnung am Ein- /Ausgang des Ladens bereitgestellt werden. // Operation INIT auf Semaphor SEM anwenden SEM.INIT(unsigned int init_wert) { } // Variale COUNT des Semaphors SEM mit einem // nichtnegativen Anfangswert initialisieren SEM.COUNT = init_wert; 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 55

56 Drei Zugriffsoperationen sind möglich (2) P-Operation (passieren): Diese Operation prüft zu allererst, ob der Wert der Zählvariable gleich 0 ist, also ob keine Körbe mehr frei sind. Ist der Wert 0, also sind keine Körbe mehr vor der Tür, wird der Prozess blockiert. Der Kunde muss jetzt vor dem Laden in der Schlange warten. Ist der Wert größer 0, wird er um 1 erniedrigt, also ein Korb entnommen. SEM.P() { // Prüfen, ob die Zählvariable gleich 0 ist if (SEM.COUNT == 0) < blockiere > } // Wenn die Zählvariable größer 0 ist, wird die // Zählvariable unmittelbar um 1 erniedrigt SEM.COUNT = SEM.COUNT - 1; 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 56

57 Drei Zugriffsoperationen sind möglich (3) V-Operation (freigeben): Diese Operation erhöht als erstes den Wert der Zählvariable um 1. Es wird ein Korb auf den Stapel zurückgelegt. Befinden sich Prozesse im Warteraum, wird ein Prozess deblockiert. Dem Beispiel nach kann sich ein Kunde jetzt einen Korb holen. Der gerade deblockierte Prozess setzt dann seine P-Operation fort und erniedrigt als erstes die Zählvariable. Der Kunde nimmt sich einen Korb. SEM.V() { // Die Zählvariable wird um 1 erhöht SEM.COUNT = SEM.COUNT + 1; } // Sind Prozesse im Warteraum, wird einer entblockiert if ( < SEM-Warteraum ist nicht leer > ) < entblockiere einen wartenden Prozess > 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 57

58 Aufbauschema des Semaphpors COUNT > 0 P-Operation COUNT == 0 Warteraum COUNT - 1 kein Prozess wartet V-Operation COUNT + 1 ein Prozess wartet entblockiere Prozess Quelle: Carsten Vogt, Betriebssysteme, Spektrum Verlag 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 58

59 Erzeuger/Verbraucher-Beispiel (1) Ein Erzeuger soll Daten an einen Verbraucher schicken. Ein endlicher Zwischenspeicher (Puffer) soll die Wartezeiten des Verbrauchers minimieren. Daten können vom Erzeuger in den Puffer gelegt werden und vom Verbraucher aus diesem wieder entfernt werden. Gegenseitiger Ausschluss ist notwendig, um Inkonsistenzen zu vermeiden. Der Erzeuger muss blockieren, wenn der Puffer voll ist. Der Verbraucher muss blockieren, wenn der Puffer leer ist, also keine Daten vorliegen. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 59

60 Erzeuger/Verbraucher-Beispiel (2) Zur Synchronisation der Zugriffe werden drei Semaphore verwendet: voll: zählt die belegten Plätze im Puffer leer: zählt die freien Plätze im Puffer mutex: zuständig für den gegenseitigen Ausschluss 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 60

61 Erzeuger/Verbraucher-Beispiel (3) #define N 8 // Plätze im Puffer typedef int semaphore; // Semaphore sind von Typ Integer semaphore voll = 0; // zählt die belegten Plätze im Puffer semaphore leer = N; // zählt die freien Plätze im Puffer semaphore mutex = 1; // steuert den Zugriff auf kritische Bereiche void erzeuger (void) { int daten; } while (TRUE) { // Endlosschleife erzeugedatenpaket(daten); // erzeuge Datenpaket P(leer); // Zähler für leere Plätze erniedrigen P(mutex); // in den kritischen Bereich eintreten einfuegendatenpaket(daten); // Datenpaket in den Puffer schreiben V(mutex); // kritischen Bereich verlassen V(voll); // Zähler für volle Plätze erhöhen } 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 61

62 Erzeuger/Verbraucher-Beispiel (4) void verbraucher (void) { int daten; } while (TRUE) { // Endlosschleife P(voll); // Zähler für volle Plätze erniedrigen P(mutex); // in den kritischen Bereich eintreten entfernedatenpaket(daten); // Datenpaket aus dem Puffer holen V(mutex); // kritischen Bereich verlassen V(leer); // Zähler für leere Plätze erhöhen verbrauchedatenpaket(daten); // Datenpaket nutzen } 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 62

63 Erzeuger/Verbraucher-Beispiel (5) Die Semaphore voll und leer werden gegenläufig zueinander eingesetzt. Das Semaphor leer zählt die Anzahl der freien Plätze im Puffer und wird vom Erzeuger in einer P-Operation erniedrigt und vom Verbraucher in einer V-Operation erhöht. Das Semaphor voll zählt die Anzahl der Datenpakete (belegten Plätze) im Puffer und wird vom Erzeuger in einer V-Operation erhöht und vom Verbraucher in einer P-Operation erniedrigt. Ist der Puffer vollständig belegt, also das Semaphor leer gleich 0, wird der Erzeuger blockiert. Sind keine Datenpakete im Puffer, also das Semaphor voll gleich 0, wird der Verbaucher blockiert. Das Semaphor mutex ist für den wechselseitigen Ausschluss zuständig. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 63

64 Binäre Semaphore Als binäre Semaphore bezeichnet man Semaphore, die mit dem Wert 1 initialisiert werden und sicherstellen sollen, dass zwei oder mehr Prozesse nicht gleichzeitig in ihre kritischen Bereiche eintreten können. Ein Beispiel für ein binäres Semaphor ist das Semaphor mutex aus dem Erzeuger/Verbraucher-Beispiel. Um den wechselseitigen Ausschluss zu garantieren, muss jeder Prozess: Kurz bevor er in seine kritische Region eintritt, das binäre Semaphor mit einer P-Operation erniedrigen Nachdem er die kritische Region verlassen hat, das binäre Semaphor mit einer V-Operation erhöhen. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 64

65 Semaphoren-Beispiel: Ping-Pong Fügen Sie in den beiden Endlosprozessen Ping und Pong Semaphorenoperationen P und V so ein, dass die Prozesse endlos PingPong, PingPong, PingPong ausgeben. Geben Sie bitte auch die Initialisierung der Semaphoren an. // Initialisierung der Semaphoren s_init (Sema_Ping, 1); s_init (Sema_Pong, 0); task Ping is task Pong is begin begin loop loop P(Sema_Ping); P(Sema_Pong); print( "Ping"); print("pong, "); V(Sema_Pong); V(Sema_ping); end loop; end loop; end Ping; end Pong; 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 65

66 Semaphoren-Beispiel: Drei Läufer (1) Drei Läufer sollen hintereinander eine bestimmte Strecke laufen. Der zweite Läufer darf erst starten, wenn der erste Läufer im Ziel angekommen ist. Der dritte Läufer darf erst starten, wenn der zweite Läufer im Ziel angekommen ist. Vorgeschlagen wird nebenstehende Lösung. // Initialisierung der Semaphoren s_init (Sema, 0); task Erster is < laufen > V(Sema); task Zweiter is P(Sema); < laufen > V(Sema); task Dritter is P(Sema); < laufen > Ist diese Lösung korrekt? 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 66

67 Semaphoren-Beispiel: Drei Läufer (2) Die Lösung ist nicht korrekt! Es existieren zwei Reihenfolgebeziehungen: Läufer 1 vor Läufer 2 Läufer 2 vor Läufer 3 Beide Reihenfolgebeziehungen verwenden das gleiche Semaphor. Es ist nicht ausgeschlossen, dass Läufer 3 mit seiner P-Operation vor Läufer 2 das Semaphor um den Wert 1 erniedrigt. Wie könnte eine korrekte Lösung aussehen? 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 67

68 Semaphoren-Beispiel: Drei Läufer (3) Lösungsmöglichkeit: Ein zweites Semaphor einführen. Das zweites Semaphor wird ebenfalls mit dem Wert 0 initialisiert. Läufer 2 erhöht mit seiner V-Operation das zweite Semaphor und Läufer 3 erniedrigt dieses mit seiner P-Operation. // Initialisierung der Semaphoren s_init (Sema1, 0); s_init (Sema2, 0); task Erster is < laufen > V(Sema1); task Zweiter is P(Sema1); < laufen > V(Sema2); task Dritter is P(Sema2); < laufen > 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 68

69 Semaphore unter Linux/UNIX (1) Das Konzept der Semaphoren unter Linux/UNIX-Betriebssystemen weicht ein wenig vom Konzept der Semaphoren nach Dijkstra ab. Unter Linux/UNIX-Betriebssystemen kann die Zählvariable eines Semaphors mit einer P-Operation bzw. einer V-Operation um mehr als 1 erhöht bzw. erniedrigt werden. Es können mehrere Zugriffsoperationen auf verschiedenen Semaphoren atomar, also unteilbar, durchgeführt werden. Mehrere P-Operationen können z.b. zusammengefasst und nur dann durchgeführt werden, wenn keine der P-Operationen blockiert. Unter Linux/UNIX-Betriebssystemen führt das Betriebssystem im Kernel eine Semaphorentabelle, die Verweise auf Arrays mit Semaphoren enthält. Jedes Array beschreibt eine Gruppe von Semaphoren, die über den Index der Semaphorentabelle identifiziert wird. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 69

70 Semaphore unter Linux/UNIX (2) Gruppennummer Semaphorennummer innerhalb der Gruppe Semaphorentabelle S 00 S 01 S 02 S 03 S 04 S S 10 S 20 S 11 S 21 S 22 einzelnes Semaphor 3... S 30 S 31 S 32 S 33 S 34 n leer Semaphorengruppe Quelle: Carsten Vogt, Betriebssysgteme, Spektrum Verlag 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 70

71 Semaphore unter Linux/UNIX (3) Einzelne Semaphore werden über den Tabellenindex und die Position in der Gruppe (beginnend bei 0) angesprochen. Atomare Operationen auf mehreren Semaphoren können nur dann durchgeführt werden, wenn alle betreffenden Semaphore der gleichen Gruppe angehören. Linux/UNIX-Betriebssysteme stellen drei Systemaufrufe für die Arbeit mit Semaphoren bereit: semget(): Neues Semaphor oder eine Gruppe von Semaphoren erzeugen oder ein bestehendes Semaphor öffnen. semctl(): Wert eines existierenden Semaphors oder einer Semaphorengruppe abfragen, ändern oder einen Semaphor löschen. semop(): P- und V-Operationen auf Semaphoren durchführen. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 71

72 IPC-Objekte löschen Die einfachste Möglichkeit, Semaphore, Shared Memory Segmente und Message Queues auf der Kommandozeile zu löschen, ist das Kommando ipcrm. ipcrm [-m shmid] [-q msqid] [-s semid] [-M shmkey] [-Q msgkey] [-S semkey] oder alternativ einfach... ipcrm shm SharedMemoryID ipcrm sem SemaphorenID ipcrm msg MessageQueueID 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 72

73 Mutexe (1) Wenn die Möglichkeit eines Semaphors zu zählen nicht benötigt wird, kann man die vereinfachte Version eines Semaphors, Mutexe, vorziehen. Mutexe (abgeleitet von Mutual Exclusion = wechselseitiger Ausschluss) dienen dem Schutz kritischer Abschnitte, auf denen zu jedem Zeitpunkt immer nur ein Prozess zugreifen darf. Mutexe sind einfacher als Semaphore, da sie nur zwei Zustände annehmen können, nämlich belegt und nicht belegt. Folglich wird nur ein Bit benötigt, um die Information darzustellen. In der Realität wird häuig eine Ganzzahl verwendet, bei der 0 nicht belegt und jeder andere Wert belegt bedeutet. Mutexe haben die gleiche Funktionalität wie binäre Semaphore. Die beiden Zustände belegt und nicht belegt sind vergleichbar mit den Werten 0 und 1 der Zählvariable von Semaphoren. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 73

74 Mutexe (2) Mutexe sind im Vergleich zu Semaphoren effizienter und einfacher zu realisieren. Zwei Funktion werden mit Mutexen verwendet: mutex_lock = Entspricht der P-Operation mutex_unlock = Entspricht der V-Operation Will ein Prozess auf einen kritischen Abschnitt zugreifen, ruft er mutex_lock auf. Ist der kritische Abschnitt gerade nicht gesperrt, ist der Aufruf erfolgreich und der Prozess kann in den kritischen Abschnitt eintreten. Ist der kritische Abschnitt bereits gesperrt, wird der Prozess so lange blockiert, bis der Prozess im kritischen Abschnitt fertig ist und mutex_unlock aufruft. Warten mehrere Prozesse auf den kritischen Abschnitt, entscheidet der Zufall. 10.Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 74

75 Nächste Vorlesung: Vorlesung Systemsoftware (SYS) Hochschule Mannheim Folie 75