PROGRAMMIEREN MIT UNIX/LINUX-SYSTEMAUFRUFEN

Transkript

1 PROGRAMMIEREN MIT UNIX/LINUX-SYSTEMAUFRUFEN 11. UNIX/Linux-Semaphore Wintersemester 2016/17

2 Semaphore * wurden 1965 von E.W. DIJKSTRA (NL) als BS-gestützter Mechanismus zur Realisierung von Koordinationsaufgaben eingeführt zum Begriff: Semaphor... Signalmast bei der Eisenbahn bzw. in der Schifffahrt Vervollständigung des Konzepts: (normalerweise)wird eine Warteschlange von Prozessen, die momentan den Semaphor nicht passieren können, als Teil des Semaphorkonzepts gesehen weiterhin: WARTEN(BV) wird ersetzt durch: P(Semaphor_x) P-Operation (von Passeren (holländisch) = (dt.) Passieren) SIGNALISIEREN(BV) durch: V(Semaphor_x) V-Operation (von Vriegeven (holländisch) = (dt.) Freigeben) ws2016/17 H.-A. Schindler Folie: 11-2

3 Diese sind dem BS zugängliche (binäre) Variable, die nurdie Werte 0 oder 1 annehmen können. P- und V-Operation sind als Systemaufrufe implementiert Binäre Semaphore Damit ist ein einfaches Koordinationsproblem folgendermaßen darstellbar (einschließlich Anfangswert): Binäre Variable P1 P2 Zeiger auf Prozesse Sem... Warteschlange von Prozessen P(Sem) B A V(Sem) Semaphor Sem Anfangszustand: Sem := 0 Struktur eines binären Semaphors (nach /Nehmer+98/ S. 164) ws2016/17 H.-A. Schindler Folie: 11-3

4 Allgemeine Semaphore ( Zählsemaphore )... sind eine Verallgemeinerung binärer Semaphore: 1. Die binäre Variable wird durch eine ganzzahlige Zählvariableersetzt. Deren Anfangswertgibt die Anzahl von Prozessen an, die sich gleichzeitig in einem durch den Semaphor geschützten Bereich aufhalten dürfen. 2. jede P-Operationen( Warten ) überprüft, ob noch Eintreten in den geschützten Bereich möglich ist (Zählvariable > 0). In diesem Fall kann der Prozess passieren, und die Zählvariable wird dekrementiert. Anderenfalls befindet sich bereits zulässige Menge von Prozessen im geschützten Bereich und tatsächliches Warten des aufrufenden Prozesses ist erforderlich: Es erfolgt ein Einketten in die zugehörige Prozesswarteschlange. (Bei Verlassen der Warteschlange muss Zählvariable natürlich ebenfalls dekrementiert werden.) ws2016/17 H.-A. Schindler Folie: 11-4

5 3. jede V-Operationen( Signalisieren ) inkrementiert Zählvariable... Ist der Wert 0 überschritten, kann der erste wartende Prozess die von ihm aufgerufene P-Operation passieren (falls ein solcher existiert). Es erfolgt ein Ausketten aus der zugehörigen Prozesswarteschlange, und der Wert der Zählvariablen muss wieder dekrementiert werden. Zählvariable Zeiger auf Prozesse... Warteschlange von Prozessen Struktur eines Zählsemaphors (nach /Nehmer+98/ S. 164) ws2016/17 H.-A. Schindler Folie: 11-5

6 UNIX/Linux-Semaphor-Konzept... geht (weit) über allgemeines Semaphorkonzept hinaus Charakteristika: 1. Ein Aufruf kann ganze Gruppe von Semaphoren anlegen. 2. Semaphore können um größere Werte als um 1 erhöht oder erniedrigt werden. 3. Für eine Gruppe von Semaphoren kann eine Folge von jeweils atomaren Operationen definiert werden. 4. Semaphore besitzen Eigentümer- und Zeiteinträge sowie Zugangsmodi. Diese Erweiterungen übersteigen im Normalfall das, was Programmierer wirklich braucht! ws2016/17 H.-A. Schindler Folie: 11-6

7 Systemaufrufe semget(...) legt neue Semaphorgruppe an oder greift auf bereits bestehende zu semop(...) semctl(...) ändert die Werte der Semaphore einer Gruppe, indem eine oder mehrere P- oder V-Operationen ausgeführt werden; alle Operationen werden atomar in einem Block ausgeführt führt verschiedene Steuerungsfunktionen auf Semaphore aus, wie Setzen (Initialisieren) und Auslesen der Werte, Löschen von Semaphoren u.a. ws2016/17 H.-A. Schindler Folie: 11-7

8 Strukturen semid_ds und sem Verwaltungsstruktur für jede Semaphorengruppe struct semid_ds { struct ipc_perm sem_perm; /* Zugriffsberechtigungen, Eigentümer, Gruppe etc. */ struct sem *sem_base; /* Zeiger auf 1.Semaphor einer Gruppe */ unsigned short sem_nsems; /* Anzahl der Semaphoren in Gruppe */ }; time_t sem_otime; /* Zeitpunkt des letzten semop(..) */ time_t sem_ctime; /* Zeitpunkt, zu dem diese Struktur zuletzt geändert */ Verwaltungsstruktur für jeden Semaphor einer Gruppe struct sem { unsigned short semval; /* aktueller Wert des Semaphors */ }; pid_t sempid; /* Nummer des Prozesses, der letzte Operation ausgeführt hat */ unsigned short semncnt; /* Anzahl der Prozesse, die auf semval > currval warten */ unsigned short semzcnt; /* Anzahl der Prozesse, die auf semval = 0 warten */ ws2016/17 H.-A. Schindler Folie: 11-8

9 Struktur ipc_perm ( ipc permissions ) spezifiziert Zugriffsrechte struct ipc_perm { uid_t uid; /* effektive Benutzernummer des Eigentümers */ gid_t gid; /* effektive Gruppennummer des Eigentümers */ uid_t cuid; /* effektive Benutzernummer des Erzeugers */ gid_t cgid; /* effektive Gruppennummer des Erzeugers */ }; mode_t mode; /* Zugriffsmodus */ unsigned long seq; /* Zähler der Verwendung der IPC-Struktur */ key_t key; /* Schlüssel */ ws2016/17 H.-A. Schindler Folie: 11-9

10 Systemaufruf semget(..) legt neue Semaphor-Gruppe an oder greift auf bereits bestehende zu Verwendung im Programm (Prinzip): int <id_sem>; * <id_sem> = semget(<key>, <nsems>, <flag>); Konkretes Beispiel: int id; * id = semget(15, 10, IPC_CREATE 0700); Parameter Symbol Typ Bedeutung Wert <id_sem> int Rückkehrwert Interpretation 0 O.K. auf <id_sem>: Identifikator d -1 Feh- Systemaufruf fehlgeschlagen ler <key> long numerischer Schlüssel mögliche Einträge: Zahl, Variable, symbolische Konstante; IPC_PRIVATE bei Angabe IPC_PRIVATE: UNIX/Linux erzeugt selbst einen Schlüssel <nsems> int Anzahl der Semaphore in der Gruppe ws2016/17 H.-A. Schindler Folie: 11-10

11 Systemaufruf semget(..) <id_sem> = semget(<key>, <nsems>, <flag>); Parameter Symbol Typ Bedeutung Wert Interpretation <flag> int Wirkung Beispieleintrag: IPC_CREATE 0644 des Aufrufs Anlegen neuer Semaphor-Gruppe mit Zugriffsrechten: rw r - - r - - wichtig: Zugriffsrechte unbedingt spezifizieren Beispieleintrag: 0 (Null) Zugriff auf vorhandene Semaphor-Gruppe ws2016/17 H.-A. Schindler Folie: 11-11

12 Beispielprogramm sema1.c #include <stdio.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> main() { int id_sem; } id_sem = semget(ipc_private, 5, IPC_CREAT 0732); printf("\nid_sem = %d\n\n", id_sem); ws2016/17 H.-A. Schindler Folie: 11-12

13 Erforderliche #include-dateien Zur Arbeit mit Semaphoren werden benötigt: #include <stdio.h> // zur Ausführung von E/A-Operationen #include <sys/types.h> // wegen der Definition spezieller Datentypen // siehe z.b. in den Datenstrukturen semid_ds // und sem #include <sys/ipc.h> // allgemeine Definitionen für UNIX-IPC #include <sys/sem.h> // spezielle Definitionen zu Semaphoren ws2016/17 H.-A. Schindler Folie: 11-13

14 Systemaufruf semop(...) ( semaphore operation ) ändert die Werte der Semaphore einer Gruppe, indem eine oder mehrere P- oder V-Operationen ausgeführt werden. Alle Operationen werden atomar in einem Block ausgeführt. Verwendung im Programm (Prinzip): int <result>; * <result> = semop(<id_sem>, <sops>, <nsops>); Konkretes Beispiel: (siehe sema2.c) int res; * res = semop(id, &DOWN, 1); Parameter Symbol Typ Bedeutung Wert Interpretation <result> int Rückkehrwert 0 O.K. fehlerfreie Ausführung -1 Feh- Systemaufruf fehlgeschlagen ler <id_sem> int Identifikator der Semaphor- Gruppe [siehe semget(..)] ws2016/17 H.-A. Schindler Folie: 11-14

15 Systemaufruf semop(...) <id_sem> = semget(<key>, <nsems>, <flag>); Parameter Symbol Typ Bedeutung Wert <sops> struct sembuf* <nsops> int Folge der auszuführenden Semaphor- Operationen Anzahl der Operationen in der Folge Interpretation Beschreibung der Operationen durch Datenstruktur sembuf{} (siehe folgende Folie) ws2016/17 H.-A. Schindler Folie: 11-15

16 Datenstruktur sembuf{..} [zu Systemaufruf semop(...)] Definition der Datenstruktur: struct sembuf { short sem_num; /* Nummer des Semaphors in der Gruppe */ short sem_op; /* spezifiziert auszuführende Operation, siehe unten */ short sem_flg; /* steuert genaue Ausführung der Operation, siehe unten */ }; sem_op auszuführende Operation: sem_op > 0 atomare V-Operation;Semaphor wird um angegebenen Wert erhöht sem_op < 0 atomare P-Operation;Semaphor wird um angegebenen Wert vermindert sem_flg zur Steuerung der Operation: IPC_NOWAIT Funktion kehrt ohne Warten (meist mit Fehlerangabe) zurück SEM_UNDO Korrektur des Semaphorwerts unter bestimmten Bedingungen ws2016/17 H.-A. Schindler Folie: 11-16

17 Beispiele zur Anwendung von semop(...) Anlegen und füllen einer Datenstruktur sembuf : // Datenstruktur anlegen zur Ausführung einer [up-]operation struct sembuf sem_up;... // Definition der [up-]operation durch Füllen der Datenstruktur sem_up.sem_num = 0; // Nummer des Semaphors in der Gruppe, hier 1. Semaphor sem_up.sem_op = 1; // auszuführende Operation, hier up (= V-Operation) sem_up.sem_flg = 0; // Flag zur Beeinflussung der Operation... // Ausführen der definierten Operation auf Semaphor semop(<id>, &sem_up, 1); // Ausführen der definierten Operation auf Semaphor struct sembuf sem_xyz[n]; // zur Ausführung von insgesamt n Operationen sem_up.sem_num[0] = * * sem_up.sem_num[1]= * K semop(<id>, &sem_xyz, n); // Ausführen der Operationen auf Semaphor ws2016/17 H.-A. Schindler Folie: 11-17

18 Systemaufruf semctl(...) ( semaphore control ) führt verschiedene Steuerungs-Operationen auf Semaphoren aus Verwendung im Programm (Prinzip): int <result>; * <result> = semctl(<id_sem>, <nsem>, <cmd>, <arg>); Konkretes Beispiel: (sema2.c: löschen Sema) int res; * res = semctl(id, 1, IPC_RMID, 0); Parameter Symbol Typ Bedeutung Wert <result> int Rückkehrwert Interpretation 0 O.K. fehlerfreie Ausführung <id_sem> int Identifikator der Semaphor- Gruppe [siehe semget(..)] <nsem> int Index eines Semaphors innerhalb der Gruppe -1 Feh- Systemaufruf fehlgeschlagen ler ws2016/17 H.-A. Schindler Folie: 11-18

19 Systemaufruf semctl(...) <result> = semctl(<id_sem>, <nsem>, <cmd>, <arg>); Parameter Symbol Typ Bedeutung Wert <cmd> int auszuführendes Kommando (siehe folg. Folien) Interpretation <arg> union semun Parameterpuffer Ist Puffer, in den die Parameter zur Ausführung des Kommandos übertragen werden. <arg> ist kein Zeiger sondern die union selbst!! Konkrete Form von semun vom Kommando abhängig (siehe folgende Folie) ws2016/17 H.-A. Schindler Folie: 11-19

20 Union semun{..} [zu Systemaufruf semctl(...)] Definition union semun { int val; /* für SETVAL */ struct semid_ds *buf; /* für IPC_STAT und IPC_SET */ unsigned short *array; /* für GETALL und SETALL */ }; Parameter cmd : gibt an, welcher von 10 möglichen Befehlen auf Semaphorengruppe mit dem Identifikator id_sem [Systemaufruf semget(..)] ausgeführt wird 5 Befehle davon greifen jeweils nur auf einen Semaphor einer Gruppe zu. Diese spezifizieren in nsem einen Semaphor einer Semaphorengruppe. nsem kann Werte zwischen 0 und (nsems 1) [Systemaufruf semget(..)] annehmen. ws2016/17 H.-A. Schindler Folie: 11-20

21 Zum Parameter <cmd> [zu Systemaufruf semctl(...)] Beispiele: IPC_STAT IPC_SET Werte insemid_ds setzen IPC_RMID Semaphor-Gruppe löschen GETVAL SETVAL GETPID Wert von semid_ds für diese Gruppe ermitteln und in Struktur speichern, auf die arg.buf zeigt liefert Wert von semval für Element semnum setzt Wert von semval liefert Wert von von semnum GETNCNT liefert Wert von semnct für semnum GETZCNT liefert Wert von semznct für semnum GETALL SETALL ermittelt alle Semaphorwerte der Gruppe setzt alle Semaphorwerte der Gruppe ws2016/17 H.-A. Schindler Folie: 11-21

22 Beispielprogramm sema2.c /* Dieses Programm zeigt notwendige Definitionen zur Arbeit mit */ /* UNIX/Linux-Semaphoren, sowie die Definition von DOWN- und UP- */ /* Operation (identisch mit P- bzw. V-Operation) */ /* */ /* UP- und DOWN-Operation werden anschließend einer einfachen */ /* Funktionskontrolle unterzogen * */ #include <stdlib.h> #include <stdio.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> intmain() { int xyz = 96; // Identifikator (Bezeichnung) des benutzten Semaphors int id; // zur Definition von UP- bzw. DOWN-Funktion struct sembuf UP, DOWN; ws2016/17 H.-A. Schindler Folie: 11-22

23 Beispielprogramm sema2.c //Rückkehrwerte von Semaphor-Operationen int result_up; int result_down; int result_init; int result_read; printf( * SEMAPHOR-TESTPROGRAMM *"); // Definition der Semaphor-Operationen // UP-Operation (= V- bzw. signal-operation) UP.sem_num= 0; UP.sem_op = 1; // UP-Operation UP.sem_flg= IPC_NOWAIT; // DOWN-Operation (= P- bzw. wait-operation) DOWN.sem_num= 0; DOWN.sem_op = (-1); // DOWN-Operation DOWN.sem_flg= IPC_NOWAIT; ws2016/17 H.-A. Schindler Folie: 11-23

24 Beispielprogramm sema2.c // Semaphor-Anfangswert einstellen unsigned short initial; //fuer Semaphor-Anfangswert unsigned short ausgabe; //fuer Kontrolle des Anfangswerts initial = 1; //Semaphor-Anfangswert // Erzeugen eines Semaphors * id = semget(xyz, 10, IPC_CREAT); printf("\nsemaphor erzeugt, Identifikator = %d\n", id); // Einstellen eines Anfangswertes result_init = semctl(id, 1, SETALL, &initial); printf("\nanfangswerteingestellt, vorgegebener Wert = %d\n", initial); // Erfolgskontrolle: semctl erfolgreich ausgefuehrt? printf("\nerfolgskontrolle: Rueckkehrwert von *semctl*: %d\n", result_init); ws2016/17 H.-A. Schindler Folie: 11-24

25 Beispielprogramm sema2.c // Erfolgskontrolle: gewuenschter Anfangswert korrekt eingestellt? printf("erfolgskontrolle: eingestellter Wert->dazu: Lesen des Sem.wertes\n"); // Lesen des Semaphorwertes result_read = semctl(id, 1, GETALL, &ausgabe); printf( RUECKKEHRWERT LESE-Op.= %d\n gesetzter Anfangswert des Semaphors: %d \ \n, result_read, ausgabe); // TEST: DOWN-OPERATION printf("\n\ntest: DOWN-OPeration\n********************\n"); result_down = semop(id, &DOWN, 1); //ATOMARE DOWN-OPERATION // Erfolgskontrolle: semop erfolgreich ausgefuehrt? printf("\nerfolgskontrolle: Rueckkehrwert von *DOWN*: %d\n", result_down); // Erfolgskontrolle: DOWN korrekt ausgefuehrt? printf("\nerfolgskontrolle: eingest. Wert -> dazu: Lesen Semaphorwert\n"); ws2016/17 H.-A. Schindler Folie: 11-25

26 Beispielprogramm sema2.c // Lesen des Semaphorwertes result_read = semctl(id, 1, GETALL, &ausgabe); printf( RUECKKEHRWERT LESE-Operation = %d\n Wert des Sem. jetzt: %d \n"\, result_read, ausgabe); // TEST: DOWN-OPERATION printf("\ntest: UP-OPeration\n******************\n"); result_up = semop(id, &UP, 1); //ATOMARE UP-OPERATION // Erfolgskontrolle: semop erfolgreich ausgefuehrt? printf("\nerfolgskontrolle: Rueckkehrwert von *UP*: %d\n,result_up); // Erfolgskontrolle: UP korrekt ausgefuehrt? printf("erfolgskontrolle: eingest. Wert -> dazu: Lesen des Semaphorwertes\n"); // Lesen des Semaphorwertes result_read = semctl(id, 1, GETALL, &ausgabe); printf( RUECKKEHRWERT LESE-Operation = %d\n Wert des Semaphors jetzt: %d \n"\, result_read, ausgabe); ws2016/17 H.-A. Schindler Folie: 11-26

27 Beispielprogramm sema2.c // Am Ende: Semaphor loeschen semctl(id, 1, IPC_RMID, 0); printf("\n\nsemaphor geloescht\n"); printf("\n\n**********************************************\n\semaphor-testprog. vollst. durchlaufen\n**********************************************\n\n\n"); } return 0; ws2016/17 H.-A. Schindler Folie: 11-27

28 Informationen über Semaphore: Kommando ipcs Formen : ipcs -s semaphorearrays (allgemeine Angaben) ipcs -st t: time (alle Zeitangaben) ipcs -sc c: creator(erzeuger und Eigentümer der Strukturen) ipcs -su u: summary(zusammenfassende Informationen) ipcs -sl l: limits (Maximalwerte für diese UNIX-Implementation) ipcs -s -i <id> Ausg. nur für durch Identifizierer <id> spez. Ressource ipcs -h -h help(infos über Kommandobenutzung) ws2016/17 H.-A. Schindler Folie: 11-28

29 Löschen von Semaphoren: Kommando ipcrm Formen : ipcrm s <id> ipcrm S <key> durch Angabe des Identifizierers(Rückkehrwert) durch Angabe des Schlüssels (key) ws2016/17 H.-A. Schindler Folie: 11-29

30 Auf den folgenden Folien: Anwendungsbeispiele für Semaphore ws2016/17 H.-A. Schindler Folie: 11-30

31 Kritische Abschnitte Ein Prozess kann seine Arbeit im kritischen Abschnitt zeitweise unterbrechen, weil er z.b. vom Prozessor verdrängt wird oder auf ein Ereignis warten muss. Jedoch muss unbedingt verhindert werden, dass weitere Prozesse in ihren kritischen Abschnitt bezüglich des gleichen Problems eintreten, bevorder vorhergehende Prozess ihn wieder verlassen hat. Erst danach darf ein weiterer Prozess in seinen kritischen Abschnitt bezüglich des gleichen Problems (!) - eintreten. Diese Reihenfolge muss durch Koordinationsoperationen erzwungen werden! Vorliegende Problematik ist als gegenseitiger Ausschluss (engl. mutual exclusion) oder Sperrsynchronisation bekannt. Unter den Aufgaben von Betriebssystemen gibt es Reihe von Situationen mit äquivalenter Problemstellung. ws2016/17 H.-A. Schindler Folie: 11-31

32 Kritische Abschnitte Benutzung eines Gerätes... stellt ein gleichartiges Problem dar, wenn es sich um exklusivnutzbare, nicht entziehbare Gerätehandelt (d.h. solche, die jeweils nur von einem Prozess [sinnvoll] genutzt werden können... Beispiel: Drucker) Hier entspricht Benutzung der Geräteregister Arbeit mit Variablen im vorigen Beispiel... Allgemeinen gilt: Die Benutzung jedes exklusiv nutzbaren, nicht entziehbaren Betriebsmittels stellt einen kritischen Abschnitt dar, der entsprechend durch Sperrsynchronisation geschützt werden muss. In diesem Sinne auch Auftragstabelle des Printer-Spoolers ein solches exklusivnutzbares, nichtentziehbares (Software-)-Betriebsmittel... Anmerkung: Auch mit entziehbaren, exklusiv nutzbaren Betriebsmitteln wie z.b. dem Prozessor kann nicht sorglos umgegangen werden. Hier wurden die Geräteregister (hier: Prozessorregister) gerettet bevor anderer Prozess zugeordnet werden konnte... ws2016/17 H.-A. Schindler Folie: 11-32

33 Sperrsynchronisation Realisierung Sperrsynchronisation kann ebenfalls mittels des beschriebenen binären Elements BE bzw. einem Semaphor realisiert werden: Jeder Prozess muss vor Eintritt in seinen kritischen Abschnitt eine Operation WARTEN(BE) bzw. P(Semaphor) platzieren, sowie nach Verlassen desselben eine Operation SIGNALISIEREN(BE) bzw. V(Semaphor), die sich alle auf das gleiche BE bzw. den gleichen Semaphor beziehen. Prozess P1 WARTEN(BE) Kritischer Abschnitt SIGNALIS.(BE) Prozess P2 WARTEN(BE) Kritischer Abschnitt SIGNALIS.(BE)... Binäres Element BE (Semaphor) Anfangszustand: BE := gesetzt bzw. Semaphor:= 0 Prozess P n WARTEN(BE) Kritischer Abschnitt SIGNALIS.(BE) ws2016/17 H.-A. Schindler Folie: 11-33

34 Sperrsynchronisation Realisierung Funktionsprüfung: 1. Da binäres Element zunächst gesetzt (Anfangszustand!), darf der erste Prozess eintreten und löscht BE. 2. Alle weiteren Prozesse finden BE gelöscht und können somit vorläufig nicht in ihren kritischen Abschnitt eintreten Nach Verlassen des kritischen Abschnittes setzt der erste Prozess wiederum BE(Signalisierungs-Operation!) 4. Jetzt kann ein weiterer Prozess in seinen kritischen Abschnitt eintreten usw. Wirkung: Die Sperrsynchronisation erzwingt durch die Koordinationsoperationen Serialisierung des Durchlaufsdurch die kritischen Abschnitte der verschiedenen Prozesse... ws2016/17 H.-A. Schindler Folie: 11-34

35 Sperrsynchronisation Prozess P1 WARTEN(BE) Kritischer Abschnitt Prozess P2 WARTEN(BE) Kritischer Abschnitt... Prozess P n WARTEN(BE) Kritischer Abschnitt SIGNALIS.(BE) SIGNALIS.(BE) SIGNALIS.(BE) a) Serialisierung des Durchlaufs durch kritische Abschnitte Warteschlange von Lokomotiven Ampel ( binäres Element ) Kritischer Abschnitt Bahnhof binäres Element c) Exklusiv nutzbares, nicht entziehbares Betriebsmittel b) Benutzung eines gemeinsamen Schienenstrangs durch mehrere Loks ws2016/17 H.-A. Schindler Folie: 11-35

36 Reader-Writer-Problem (Produzenten-Konsumenten-Schema) Genauer lauten die Koordinationsbedingungenfür die Verwaltung des gemeinsamen Speicherbereichs: 1. Der Bereich sei zu Beginn leer. 2. Der Produzent darf schreiben, solange der Bereich nicht voll ist. 3. Der Konsument darf lesen, solange der Bereich nicht leer ist. 4. Gleichzeitiges Lesen und Schreiben ist verboten. Damit erhalten wir als Blockdiagramm: Produzent Bereich schreiben signalisiere( voll ) warte(bis voll ) Bereich lesen Konsument warte(bis leer ) signalisiere( leer ) ws2016/17 H.-A. Schindler Folie: 11-36

37 In Semaphor-Notation: P(LEER) Bereich schreiben V(VOLL) Produzent Semaphor LEER Binäre Variable bv Anfangszustand: LEER.bv := 1 Semaphor VOLL Binäre Variable bv Anfangszustand: VOLL.bv := 0 Konsument P(VOLL) Bereich lesen V(LEER) ws2016/17 H.-A. Schindler Folie: 11-37

38 Aufgabenstellung (Anregungen) 1. Verwenden Sie Beispielprogramm sema1.c welches eine Gruppe ( Array ) von Semaphoren erzeugt. Wie viele Semaphore enthält das Array? (Warum?) Durch welchen Identifikatorbzw. welchen Schlüssel kann es identifiziert werden? Was passiert bei mehrmaligem Aufruf des gleichen Programms? Wie kann der Wert für den Schlüssel (key) selbst festgelegt werden und wozu wird der Schlüssel verwendet? 2. Lassen Sie jetzt beim flag-parameter die Spezifikation der Zugriffsrechte weg! Was passiert? (Untersuchen Sie die erzeugten Semaphore mit ipcs s auch im Superuser-Modus (sudo i).) Was passiert, wenn nur Zugriffsrechte spezifiziert sind? 3. Beschäftigen Sie sich mit binären Semaphoren. Verwenden Sie dazu das Programmbeispiel sema2.c 4. Das Programm sema3.c demonstriert den gegenseitigen Ausschluss an kritischen Abschnitten. Sehen Sie sich diese Demo an. 5. Löschen Sie alle von Ihnen erzeugten IPC-Strukturen (mit ipcrm bzw. semctl(..) )! ws2016/17 H.-A. Schindler Folie: 11-38