10. Vorlesung Betriebssysteme

Transkript

1 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS1213 1/ Vorlesung Betriebssysteme Dr. Christian Baun Hochschule Mannheim Fakultät für Informatik

2 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS1213 2/63 Heute Gemeinsamer Speicher (Shared Memory) Nachrichtenwarteschlangen (Message Queues) Pipes Sockets Semaphor Mutex 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)

3 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS1213 3/63 Gemeinsamer Speicher Shared Memory Prozesskommunikation über einen gemeinsamen Speicher (Shared Memory) bezeichnet man auch als speicherbasierte Kommunikation Gemeinsame Speicher-Segmente sind Speicherbereiche, auf die mehrere Prozesse direkt zugreifen können Diese Speicherbereiche liegen im Adressraum mehrerer Prozesse shmget() registriert einen Speicherbereich als gemeinsames Speicher-Segment Die Prozesse müssen die Zugriffe selbst koordinieren und sicherstellen, dass ihre Speicherzugriffe sich gegenseitig ausschließen Der lesende Prozess darf nichts aus dem gemeinsamen Speicher lesen, bevor der schreibende Prozess fertig geschrieben hat Ist die Koordinierung der Zugriffe nicht sorgfältig, kommt es zu Inkonsistenzen

4 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS1213 4/63 Gemeinsamer Speicher unter Linux/UNIX Unter Linux/UNIX speichert eine Shared Memory Tabelle die Informationen über die existierenden gemeinsamen Speicher-Segmente Zu diesen Informationen gehören: Anfangsadresse im Speicher, Größe, Besitzer (Benutzername und Gruppe) und Zugriffsrechte Ein gemeinsames Speicher-Segment wird immer über seine Indexnummer in der Shared Memory-Tabelle angesprochen

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

6 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS1213 6/63 Nachrichtenwarteschlangen - Message Queues Nachrichtenwarteschlangen (Message Queues) sind verketteten Listen mit Nachrichten Nachrichtenwarteschlangen arbeiten immer nach dem Prinzip FIFO Prozesse können Daten in der Nachrichtenwarteschlangen ablegen, die von anderen Prozessen abgeholt werden können Jede Nachrichtenwarteschlange hat eine eindeutige Kennung zur Identifikation Nachrichtenwarteschlangen sind vergleichbar mit Mailboxen für Prozesse Ein Vorteil von Nachrichtenwarteschlangen: Die Daten in einer Nachrichtenwarteschlange verbleiben auch nach der Beendigung des Erzeuger-Prozesses in der Nachrichtenwarteschlange

7 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS1213 7/63 Mit Nachrichtenwarteschlangen arbeiten Linux/UNIX-Betriebssysteme stellen vier Systemaufrufe für die Arbeit mit Nachrichtenwarteschlangen bereit: msgget(): Nachrichtenwarteschlange erzeugen oder auf bestehende Nachrichtenwarteschlange zugreifen msgsnd(): Nachrichten in Nachrichtenwarteschlange schreiben (schicken) msgrcv(): Nachrichten aus Nachrichtenwarteschlange lesen (empfangen) msgctl(): Status (u.a. Zugriffsrechte) einer Nachrichtenwarteschlange abfragen, ändern und Message Queues löschen Informationen über bestehende Nachrichtenwarteschlangen liefert das Kommando ipcs

8 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS1213 8/63 Mit Nachrichtenwarteschlangen entwickeln (in C) Eine Nachrichtenwarteschlange erzeugen // Nachrichtenwarteschlange erzeugen // Mit IPC_CREAT wird eine neue Nachrichtenwarteschlange erzeugt // Mit IPC_EXCL werden existierende Warteschlangen mit gleichem Schlüssel überschrieben // Mit 0600 werden die Zugriffsrechte auf die Nachrichtenwarteschlange festgelegt message_queue_id = msgget ( testqueue, IPC_CREAT IPC_EXCL 0600); if ( message_queue_id <0) { printf (" Die Nachrichtenwarteschlange konnte nicht erstellt werden.\n") exit ( EXIT_FAILURE ); } else printf (" Die Nachrichtenwarteschlange testqueue wurde angelegt.\n"); Nachrichtenwarteschlange löschen // Nachrichtenwarteschlange löschen msgctl ( message_queue_id, IPC_RMID, NULL );

9 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS1213 9/63 Mit Nachrichtenwarteschlangen entwickeln (in C) Nachrichten in Nachrichtenwarteschlange schreiben // Template für den Puffer für msgsnd und msgrcv Systemaufrufe struct msgbuf { long mtype ; // Nachrichtentyp char mtext [80]; // Sendepuffer } msg ; msg. mtype = 1; strcpy (msg.mtext, " Testnachricht "); // Nachricht in den Sendepuffer schreiben // Nachricht schreiben if ( msgsnd ( message_queue_id, &msg, strlen (msg. mtext ), 0) == -1) { printf ("In die Nachrichtenwarteschlange konnte nicht geschrieben werden.\n") exit ( EXIT_FAILURE ); } Der Nachrichtentyp wird durch den Benutzer definiert und hat den Wert einer positiven ganzen Zahl

10 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Mit Nachrichtenwarteschlangen entwickeln (in C) Nachrichten aus der Nachrichtenwarteschlange lesen // Template für den Puffer für msgsnd und msgrcv Systemaufrufe struct msgbuf { long mtype ; // Nachrichtentyp char mtext [80]; // Empfangspuffer } msg ; // Die erste Nachricht in der Nachrichtenwarteschlangen empfangen mtype = 0 if (size = msgrcv ( message_queue_id, &msg, 80, mtype, 0)) == -1) { printf (" Aus der Nachrichtenwarteschlange konnte nicht gelesen werden.\n") exit ( EXIT_FAILURE ); // Die erste erste Nachricht vom Nachrichtentyp 1 empfangen mtype = 1 if (size = msgrcv ( message_queue_id, &msg, 80, mtype, 0)) == -1) { printf (" Aus der Nachrichtenwarteschlange konnte nicht gelesen werden.\n") exit ( EXIT_FAILURE ); } Ist mtype = 0, wird die erste Meldung aus der Queue gelesen Ist mtype positiv, wird die erste Meldung dieses Typs gelesen Ist mtype negativ, wird die erste Meldung gelesen, deren Typ kleiner oder gleich dem absoluten Wert von mtype ist

11 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Pipes (1/4) Eine Pipe ist wie ein Kanal bzw. eine Röhre, die einen gepufferten, unioder bidirektionalen Datenstrom zwischen zwei Prozessen ermöglicht Eine Pipe kann immer nur zwischen zwei Prozessen tätig sein Pipes funktionieren immer nach dem Prinzip FIFO (First In First Out) 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 Pipes werden mit dem Systemaufruf pipe() angelegt Dabei wird ein Inode auf der Festplatte und zwei Zugriffskennungen, die sogenannten Handles erzeugt Ein Inode ist ein Dateisystemeintrag, der Metadaten einer Datei enthält 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 Prozess X "abc..." Pipe "abc..." Prozess Y Schreib-Prozess enthält den Bytestrom Lese-Prozess

12 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Pipes (2/4) Bei der Erzeugung von Kindprozessen mit fork() erben die Kindprozesse auch den Zugriff auf die Zugriffskennungen Man unterscheidet anonyme Pipes und benannte Pipes Anonyme Pipes ermöglichen Prozesskommunikation nur zwischen eng verwandten Prozessen Anonyme Pipes kann man nur in eine Richtung verwenden (= unidirektional) Nur Prozesse, die via fork() eng verwandt sind, können über anonyme Pipes kommunizieren Mit der Beendigung des letzten Prozesses, der Zugriff auf eine anonyme Pipe hat, wird diese vom Betriebssystem beendet

13 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Pipes (3/4) 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 nennt man häufig einfach FIFO Benannte Pipes ermöglichen Vollduplexbetrieb zwischen Prozessen (= bidirektional) Daten können gleichzeitig in beide Richtungen ausgetauscht werden Jeder Prozess, der den Namen kennt, kann über diesen die Verbindung zur Pipe herstellen und darüber mit anderen Prozessen kommunizieren Benannte Pipes werden mit dem Systemaufruf mknod() erzeugt

14 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Pipes (4/4) Pipes sind ein mächtiges Werkzeug um Befehle sequentiell abzuarbeiten Wechselseitiger Ausschluss ist durch das Betriebssystem garantiert Dieses überwacht, dass immer nur ein Prozess zu einem Zeitpunkt auf eine Pipe zugreifen kann Eine Pipe sorgt dafür, dass die Ausgabe eines Prozesses in die Eingabe eines anderen gelangt und wird auf der Shell mit erzeugt. z.b. cat /pfad/zu/datei.txt grep Suchmuster

15 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Mit Pipes entwickeln (in C) Eine Pipe anlegen // Pipe testpipe anlegen if (pipe ( testpipe ) < 0) { // Falls die Pipe nicht angelegt werden konnte, wird das Programm beendet printf (" Das Anlegen der Pipe testpipe ist fehlgeschlagen.\n") exit ( EXIT_FAILURE ); } else printf (" Die Pipe testpipe wurde angelegt.\n"); Pipe zum Schreiben vorbereiten (Danach kann sie Daten aufnehmen) close ( testpipe [0]); // Lesekanal der Pipe testpipe blockieren open ( testpipe [1]); // Schreibkanal der Pipe testpipe öffnen Pipe zum Lesen vorbereiten (Danach kann sie ausgelesen werden) close ( testpipe [1]); // Schreibkanall der Pipe testpipe blockieren open ( testpipe [0]); // Lesekanal der Pipe testpipe öffnen Aus einer Pipe lesen und in eine Pipe schreiben read ( testpipe [0], & puffervariable, sizeof ( puffervariable )) write ( testpipe [1], & puffervariable, sizeof ( puffervariable ))

16 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Sockets Sockets sind Endpunkte einer bidirektionalen Software-Schnittstelle zur Kommunikation zwischen Prozessen in verteilten Systemen Vollduplexfähige Alternative zu Pipes und gemeinsamem Speicher Ein Socket kann von mehreren Rechner-Systemen verwendet werden Sockets sind die plattformunabhängige, standardisierte Schnittstelle zwischen der Implementierung der Netzwerkprotokolle im Betriebssystem 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

17 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Prinzip von Sockets Zur Kommunikation über Sockets werden Ports verwendet Die Vergabe der Portnummern erfolgt beim Verbindungsaufbau Portnummern werden meistens vom Betriebssystem beliebig vergeben Ausnahmen sind Ports bekannter Anwendungen, die immer gleich sind, wie z.b. HTTP (80), SMTP (25), Telnet (23), SSH (22), FTP (21), POP3 (110),... Einsatz von Sockets ist blockierend (synchron) und nicht-blockierend (asynchron) möglich

18 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Verschiedene Arten von Sockets Verbindungslose Sockets (bzw. Datagram Sockets) Verwenden das Transportprotokoll UDP Vorteile: UDP ermöglicht eine höhere Geschwindigkeit Grund: Geringer Mehraufwand (Overhead) für das Protokoll Nachteile: Daten werden in Pakete aufgeteilt und einzeln versandt Pakete können einander überholen oder verloren gehen Verbindungsorientierte Sockets (bzw. Stream Sockets) Verwenden das Transportprotokoll 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 Grund: Höherer Mehraufwand (Overhead) für das Protokoll

19 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Sockets nutzen Praktisch alle gängigen Betriebssystemen unterstützen Sockets Vorteil: Bessere Portabilität der Anwendungen Folgende Operationen sind für die Kommunikation via Sockets nötig: Erstellen eines Sockets socket() Anbinden eines Sockets an das Netzwerk bind(), listen(), accept() und connect() Senden/Empfangen von Nachrichten über den Socket send(), sendto(), recv() und recvfrom() Schließen eines Sockets shutdown() oder close() Übersicht der Sockets unter Linux/UNIX: netstat -n

20 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Verbindungslose Kommunikation mit Sockets UDP Client Socket erstellen (socket) Daten senden (sendto) und empfangen (recvfrom) Socket schließen (close) Server Socket erstellen (socket) Socket an einen Port binden (bind) Portnummer registrieren Daten senden (sendto) und empfangen (recvfrom) Socket schließen (close)

21 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Verbindungsorientierte Kommunikation mit Sockets TCP Client Socket erstellen (socket) Client mit Server-Socket verbinden (connect) Daten senden (send) und empfangen (recv) Socket schließen (close) Server Socket erstellen (socket) Socket an einen Port binden (bind) Socket empfangsbereit machen (listen) Richtete eine Warteschlange für Verbindungen mit Clients ein Server akzeptiert Verbindungsanforderung (accept) Daten senden (send) und empfangen (recv) Socket schließen (close)

22 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Einen Socket erzeugen: socket (1/2) int socket(int domain, int type, int protocol); Ein Aufruf von socket() liefert einen kleinen Integerwert zurück, ähnlich einem Dateideskriptor Der Wert wird als Socket-Deskriptor oder socket file descriptor bezeichnet domain: Beschreibt die Protokollfamilie. Einige Möglichkeiten sind: PF_UNIX: Lokale Prozesskommunikation unter Linux/UNIX PF_INET: IPv4 Internet-Protokolle PF_INET6: IPv6 Internet-Protokolle type: Legt den Typ des Sockets (und damit auch teilweise das Protokoll) fest: SOCK_STREAM: Stream Socket (TCP) SOCK_DGRAM: Datagram Socket (UDP) SOCK_RAW: RAW-Socket (IP)

23 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Einen Socket erzeugen: socket (2/2) protocol: Hier wird das genaue Protokoll festgelegt: IPPROTO_TCP: TCP-Protokoll (SOCK_STREAM) IPPROTO_UDP: UDP-Protokoll (SOCK_DGRAM) IPPROTO_RAW: RAW-IP-Protokoll (SOCK_RAW) IPPROTO_ICMP: ICMP-Protokoll (SOCK_RAW) Die Angabe des Protokolls mit protocol ist meistens nicht nötig In den meisten Fällen kann der Wert Null angegeben werden Einen Socket mit socket() erzeugen: sd = socket ( PF_INET, SOCK_STREAM, 0); if (sd < 0) { perror (" Der Socket konnte nicht erzeugt werden "); return 1; }

24 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Adresse und Portnummer binden: bind int bind(int sd, struct sockaddr *address, int addrlen); Die Operation bind() bindet den neu erstellen Socket (sd) an die Adresse (address) des Servers sd ist der Socket-Deskriptor aus dem vorhergehenden Aufruf von socket() address ist eine Datenstruktur, die sowohl die IP-Adresse des Server, als auch eine Portnummer enthält addrlen ist die Länge der Datenstruktur, die die Adresse und Portnummer enthält

25 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Server empfangsbereit machen: listen int listen(int sd, int backlog); Die Operation listen() definiert, wie viele Verbindungen (Anfragen) am Socket (socket) anstehen (gepuffert werden) können Ist die listen()-warteschlange voll, werden weitere Verbindungswünsche von Clients abgewiesen sd ist der Socket-Deskriptor aus dem vorhergehenden Aufruf von socket() backlog steht für die Anzahl der möglichen Verbindungsanforderungen, die maximal in die Warteschlange gestellt werden können Normalerweise ist der Wert fünf Ein Server für Datagrame (UDP) braucht listen() nicht aufzurufen, da er keine Verbindungen zu Clients einrichtet

26 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Verbindung über einen Socket akzeptieren: accept int accept(int sd, struct sockaddr *address, int *addrlen); Mit accept() holt der Server die erste Verbindungsanforderung aus der Warteschlange accept() nimmt die erste Anforderung in der Warteschlange, dupliziert den als Parameter übergebenen Socket-Deskriptor und gibt das Duplikats als Rückgabewert zurück Über den neuen Socket-Deskriptor wird die Verbindung zum Client hergestellt Der Rückgabewert ist die Socket-ID des Clients (der neue Socket) Stehen keine Verbindungsanforderungen mehr an (die Warteschlange ist leer), ist der Prozess blockiert, bis eine Verbindungsanforderung eintrifft address enthält die Adresse des Clients Nachdem ein Client mit accept() angenommen wurde, ist die Verbindung vollständig aufgebaut

27 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Verbindung durch den Client herstellen int connect(int sd, struct sockaddr *servaddr, socklen_t addrlen); Durch den connect()-aufruf stellt der Client eine Verbindung mit einem Server-Socket her Client muss die Adresse (Hostname und Port) des Servers kennen sd ist der Socket-Deskriptor servaddr ist die Adresse des Servers addrlen ist die Länge der Datenstruktur, die die Adresse enthält

28 Datenaustausch: send und recv int send(int sd, char *buffer, int nbytes, int flags); int recv(int sd, char *buffer, int nbytes, int flags); Mit send() und recv() werden über eine bestehende Verbindung Daten ausgetauscht send() sendet eine Nachricht (buffer) über den Socket (sd) recv() empfängt eine Nachricht vom Socket sd und legt diese in den Puffer (buffer) sd ist der Socket-Deskriptor buffer enthält die zu sendenden bzw. empfangenen Daten nbytes gibt die Anzahl der Bytes im Puffer an Der Wert von flags ist in der Regel Null Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63

29 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Verbindungsorientierter Datenaustausch: sendto und recvfrom int sendto(int sd, char *buffer, int nbytes, int flags, struct sockaddr *to, int addrlen); int recvfrom(int sd, char *buffer, int nbytes, int flags, struct sockaddr *from, int addrlen); Weiß ein Prozess, an welche Adresse (Host und Port), also an welchen Socket er Daten senden soll, verwendet er dafür sendto() sendto() übermittelt mit den Daten immer die lokale Adresse sd ist der Socket-Deskriptor buffer enthält die zu sendenden bzw. empfangenen Daten nbytes gibt die Anzahl der Bytes im Puffer an to enthält die Adresse des Empfängers from enthält die Adresse des Senders addrlen ist die Länge der Datenstruktur, die die Adresse enthält

30 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Verbindungsloser Datenaustausch: read und write int read(int sd, char *buffer, int nbytes); int write(int sd, char *buffer, int nbytes); Unter UNIX könnten im Normalfall auch read() und write() zum Empfangen und Senden über einen Socket verwendet werden Der Normalfall ist, wenn der Parameter flags bei send() und recv() den Wert Null hat. Die folgenden beiden Aufrufe haben das gleiche Ergebnis: send(socket,"hello World",11,0); write(socket,"hello World",11);

31 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Socket schließen: close int shutdown(int sd, int how); Eine bidirektionale Socket-Verbindung kann mit der Operation shutdown() geschlossen werden Der Parameter how legt fest, ob künftig keine Daten mehr empfangen werden sollen (how=0), keine mehr gesendet werden (how=1), oder beides (how=2) int close(int sd); Wird die Systemfunktion close() anstatt shutdown() benutzt, entspricht dies einem shutdown(sd,2)

32 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Sockets via UDP Beispiel (Server) #!/ usr /bin /env python # -*- coding : iso *- # Server : Empfängt eine Nachricht via UDP import socket # Stellvertretend für alle Schnittstellen des Hosts HOST = PORT = # Erzeugt den Socket und liefert den Socket Deskriptor zurück sd = socket. socket ( socket.af_inet, socket. SOCK_DGRAM ) try : # Weist einem noch unbekannten Socket eine Adresse zu sd. bind (HOST, PORT ) while True : # Empfange Daten data = sd. recvfrom (1024) print Empfangen :, repr ( data ) finally : # Schließt einen Socket sd. close ()

33 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Sockets via UDP Beispiel (Client) #!/ usr /bin /env python # -*- coding : iso *- # Client : Schickt eine Nachricht via UDP import socket HOST = localhost PORT = MESSAGE = Hallo Welt # Erzeugt den Socket und liefert den Socket Deskriptor zurück sd = socket. socket ( socket.af_inet, socket. SOCK_DGRAM ) # Sendet die Nachricht an sd. sendto (MESSAGE, (HOST, PORT )) # Schließt einen Socket sd. close ()

34 # Schließt den Socket conn. close () Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Sockets via TCP Beispiel (Server) #!/ usr /bin /env python # -*- coding : iso *- # Echo Server via TCP import socket # ist stellvertretend für alle Schnittstellen HOST = PORT = # Erzeugt den Socket und liefert den Socket Deskriptor zurück sd = socket. socket ( socket.af_inet, socket. SOCK_STREAM ) # Dem Socket eine Adresse zuweisen sd. bind (HOST, PORT ) # Socket empfangsbereit machen sd. listen (1) # Socket akzeptiert Verbindungen conn, addr = sd. accept () print Connected by, addr while 1: # Empfange Daten data = conn. recv (1024) if not data : break # Sende empfangene Daten zurück conn. send ( data )

35 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Sockets via TCP Beispiel (Client) #!/ usr /bin /env python # -*- coding : iso *- # Echo Client via UDP import socket HOST = localhost PORT = # Erzeugt den Socket und liefert den Socket Deskriptor zurück sd = socket. socket ( socket.af_inet, socket. SOCK_STREAM ) # Mit Server - Socket verbinden sd. connect (HOST, PORT ) # Sende Daten sd. send ( Hello, world ) # Empfange Daten data = sd. recv (1024) # Schließt den Socket sd. close () print Empfangen :, repr ( data )

36 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Blockierende und nicht-blockierende Sockets Wird ein Socket erstellt, ist er standardmäßig im blockierenden Modus Alle Methodenaufrufe warten, bis die von ihnen angestoßene Operation durchgeführt wurde z.b. blockiert ein Aufruf von recv() so lange den Prozess, bis Daten eingegangen sind und aus dem internen Puffer des Sockets gelesen werden können Die Methode setblocking() ändert den Modus eines Sockets sd.setblocking(0) = Versetzt in den nicht-blockierenden Modus sd.setblocking(1) = Versetzt in den blockierenden Modus Es ist möglich, während des Betriebs den Modus umzuschalten z.b. könnte man die Methode connect() blockierend und anschließend read() nicht-blockierend verwenden Quelle: Peter Kaiser, Johannes Ernesti. Python Das umfassende Handbuch. Galileo (2008)

37 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Nicht-blockierende Sockets Auswirkungen Versetzt man einen Socket in den nicht-blockierenden Modus, hat das Auswirkungen auf die Socket-Operationen recv() und recvfrom() Die Methoden geben nur dann Daten zurück, wenn sich diese bereits im internen Puffer des Sockets befinden Sind keine Daten im Puffer, werfen die Methoden eine Exception und geben den Kontrollfluss wieder ab send() und sendto() Die Methoden versenden die angegebenen Daten nur, wenn sie direkt in den Ausgangspuffer des Sockets geschrieben werden können Ist der Puffer schon voll, werfen die Methoden eine Exception und geben den Kontrollfluss wieder ab connect() Die Methode sendet eine Verbindungsanfrage an den Zielsocket und wartet nicht, bis diese Verbindung zustande kommt Wird connect() aufgerufen, während die Verbindungsanfrage noch läuft, wird eine Exception geworfen

38 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Vergleich der Kommunikations-Systeme Vorteile nachrichtenbasierter Kommunikation sind: Nachrichtenbasierte Kommunikation ist komfortabel Das Betriebssystem entlastet bei nachrichtenbasierter Kommunikation die Benutzerprozesse von allen Verwaltungsaufgaben, insbesondere von Synchronisationsproblemen Nachrichtenbasierte Kommunikation kann auch in verteilten Systemen eingesetzt werden, in denen kein gemeinsam zugreifbarer Hardwarespeicher vorhanden ist Portabilität der Anwendungen ist besser als bei speicherbasierter Kommunikation 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

39 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Möglichkeiten der Interprozesskommunikation Gemeinsamer Nachrichten- Pipes Sockets Speicher warteschlangen Art der Kommunikation Speicherbasiert Objektbasiert Datenstrombasiert Nachrichtenbasiert Bidirektional ja nein bei benannten Pipes ja Plattformunabhäng nein nein nein ja Prozesse müssen nein nein bei anonymen Pipes nein verwandt sein Kommunikation über nein nein nein ja Rechnergrenzen Bleiben ohne gebundenen ja ja nein nein Prozess erhalten Automatische nein ja ja ja Synchronisierung Speicher kann über Netzwerkverbindungen eingebunden werden und so wird speicherbasierte Kommunikation möglich Das Problem der Synchronisation der Zugriffe besteht aber auch hier

40 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Kooperation Kooperation Semaphor Mutex 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)

41 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Semaphore Zur Sicherung (Sperrung) kritischer Abschnitte können außer den bekannten Sperren auch Semaphore eingesetzt werden Semaphore wurden 1965 durch den niederländischen Informatiker Edsger Wybe Dijkstra eingeführt Ein Semaphor ist eine Zählersperre S mit den Operationen P(S) und V(S) V kommt vom holländischen verhogen = erhöhen P kommt vom holländischen proberen = versuchen (zu verringern) Die Zugriffsoperationen sind atomar = 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 Die korrekte Grammatik ist das Semaphor, Plural die Semaphore

42 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Semaphor: Arbeitsweise Folgendes Szenario macht die Arbeitsweise deutlich: 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, sind also 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

43 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 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 befinden 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

44 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 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 ;

45 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Drei Zugriffsoperationen sind möglich (2) P-Operation (verringern): Diese Operation prüft, 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;

46 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Drei Zugriffsoperationen sind möglich (3) V-Operation (erhöhen): 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 deblockiert if ( < SEM - Warteraum ist nicht leer > ) < deblockiere einen wartenden Prozess >

47 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Aufbauschema des Semaphors

48 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Erzeuger/Verbraucher-Beispiel (1/3) Ein Erzeuger soll Daten an einen Verbraucher schicken Ein endlicher Zwischenspeicher (Puffer) soll die Wartezeiten des Verbrauchers minimieren Daten werden vom Erzeuger in den Puffer gelegt und vom Verbraucher aus diesem entfernt Gegenseitiger Ausschluss ist notwendig, um Inkonsistenzen zu vermeiden Ist der Puffer voll, muss der Erzeuger blockieren Ist der Puffer leer, muss der Verbraucher blockieren

49 Quelle: Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63

50 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Erzeuger/Verbraucher-Beispiel (2/3) Zur Synchronisation der Zugriffe werden drei Semaphore verwendet: leer voll mutex Semaphore voll und leer werden gegenläufig zueinander eingesetzt leer zählt die freien Plätze im Puffer, wird vom Erzeuger (P-Operation) erniedrigt und vom Verbraucher (V-Operation) erhöht voll zählt die Datenpakete (belegte Plätze) im Puffer, wird vom Erzeuger (V-Operation) erhöht und vom Verbraucher (P-Operation) erniedrigt leer = 0 = Puffer vollständig belegt = Erzeuger blockieren voll = 0 = Puffer leer = Verbraucher blockieren Semaphor mutex ist für den wechselseitigen Ausschluss zuständig

51 Erzeuger/Verbraucher-Beispiel (3/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 Zugriff auf kritische Bereiche void erzeuger ( void ) { int daten ; while ( TRUE ) { // Endlosschleife erzeugedatenpaket ( daten ); // erzeuge Datenpaket P( leer ); // Zähler " leere Plätze " erniedrigen P( mutex ); // in 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 } } void verbraucher ( void ) { int daten ; while ( TRUE ) { // Endlosschleife P( voll ); // Zähler " volle Plätze " erniedrigen P( mutex ); // in 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 } } Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63

52 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Beispiel zu Semaphore: PingPong Die beiden Endlosprozesse Ping und Pong geben endlos PingPong, PingPong, PingPong aus // Initialisierung der Semaphore 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 ;

53 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Beispiel zu Semaphore: Drei Läufer (1/3) Drei Läufer sollen hintereinander eine bestimmte Strecke laufen Der zweite Läufer darf erst starten, wenn der erste Läufer im Ziel ist Der dritte Läufer darf erst starten, wenn der zweite Läufer im Ziel ist Vorgeschlagen wird nebenstehende Lösung Ist die Lösung korrekt? // Initialisierung der Semaphore s_init (Sema, 0); task Erster is < laufen > V( Sema ); task Zweiter is P( Sema ); < laufen > V( Sema ); task Dritter is P( Sema ); < laufen >

54 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Beispiel zu Semaphore: Drei Läufer (2/3) 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?

55 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Beispiel zu Semaphore: Drei Läufer (3/3) Lösungsmöglichkeit: Zweiten 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 Semaphore 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 >

56 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Binäre Semaphore Binäre Semaphore sind Semaphore, die mit dem Wert 1 initialisiert werden und garantieren, 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

57 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Starke und schwache Semaphore Für Semaphore und binäre Semaphore wird eine Warteschlange eingesetzt, die die wartenden Prozesse aufnimmt Die Reihenfolge, in der Prozesse aus dieser Warteschlange geholt werden, lässt sich unterschiedlich regeln Die fairste Vorgehensweise ist das Prinzip FIFO (First In First Out) Starke Semaphore arbeiten nach dem Prinzip FIFO Typische Form des Semaphor, die vom Betriebssystem bereitgestellt werden Vorteil: Es kann nicht zum Verhungern kommen Schwache Semaphore legen die Reihenfolge, in der die Prozesse aus der Warteschlange geholt werden, nicht fest Beim Echtzeitbetrieb werden schwache Semaphore eingesetzt, da das Deblockieren von Prozessen sich an deren Priorität und nicht am Zeitpunkt der Blockierung orientiert

58 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Semaphore unter Linux/UNIX (1/3) Das Konzept der Semaphore unter Linux/UNIX-Betriebssystemen weicht ein wenig vom Konzept der Semaphor nach Dijkstra ab Unter Linux/UNIX 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 Linux/UNIX-Betriebssysteme führen im Kernel eine Semaphortabelle, die Verweise auf Arrays mit Semaphore enthält Jedes Array beschreibt eine Gruppe von Semaphoren, die über den Index der Semaphortabelle identifiziert wird

59 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Semaphore unter Linux/UNIX (2/3) 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

60 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Semaphore unter Linux/UNIX (3/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 ein Semaphor löschen semop(): P- und V-Operationen auf Semaphoren durchführen

61 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Mutexe (1/2) Wird die Möglichkeit eines Semaphors zu zählen nicht benötigt, 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 Es ist nur ein Bit nötig, um die Information darzustellen In der Realität wird häufig eine ganze Zahl 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

62 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 Mutexe (2/2) Mutexe sind effizienter und einfacher zu realisieren als Semaphore 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

63 Dr. Christian Baun 10. Vorlesung Betriebssysteme Hochschule Mannheim WS /63 IPC-Objekte löschen Die einfachste Möglichkeit, Semaphore, gemeinsame Speichersegmente und Nachrichtenwarteschlangen 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 SemaphorID ipcrm msg MessageQueueID