Betriebssysteme. Agenda. Tafelübung 3. Deadlock. Olaf Spinczyk.

Transkript

1 Betriebssysteme Tafelübung 3. Deadlock Olaf Spinczyk AG Eingebettete Systemsoftware Informatik 12, TU Dortmund Agenda Besprechung Aufgabe 2: Threadsynchronisation Aufgabe 3: Deadlock Semaphore Problemvorstellung Erkennen von Verklemmungen Auflösen von Verklemmungen Pthreads abbrechen Enumeration und Signal-Handler Alte Klausuraufgabe zu Semaphoren 2

2 Besprechung Aufgabe 2 Foliensatz Besprechung 3 Wiederholung Mutex Mutex dienen zum Schutz von kritischen Abschnitten Nebenläufige Prozesse können hierdurch auf eine gemeinsame Datenstruktur zugreifen, ohne das der Zustand der Datenstruktur inkonsisten wird. /* Schlossvariable (Initialwert 0) */ pthread_mutex_t rangmutex; int main(void){ pthread_mutex_init(&rangmutex, NULL); void* run(void* arg) { pthread_mutex_lock(&rangmutex); rangliste[rang++] = team; pthread_mutex_unlock(&rangmutex); Kritische Abschnitte können auch durch Semaphore geschützt werden. Dazu müssen wir aber zunächst wissen, was Semaphore sind und wie wir sie benutzen können. 4

3 Mutexe vs. Semaphoren Mit beiden können kritische Abschnitte geschützt werden. Beim Mutex kann immer nur ein Thread den kritischen Abschnitt betreten. Mit Semaphoren können n Threads den kritischen Abschnitt betreten. Nützlich für Betriebssystemressourcen, bei denen eine bestimmte Anzahl zur Verfügung steht. Für n=1 verhält sich ein Semaphor ähnlich wie ein Mutex. Semaphoren können aber prinzipiell auch von unterschiedlichen Prozessen freigegeben werden. 5 Semaphoren Ein Sempahor ist eine Betriebssystemabstraktion zum Austausch von Synchronisationssignalen zwischen nebenläufig arbeitenden Prozessen. Steht für Signalgeber E. Dijkstra: Eine nicht-negative ganze Zahl, für die zwei unteilbare Operationen definiert sind: P (holländisch prolaag, erniedrige ; auch down oder wait) hat der Semaphor den Wert 0, wird der laufende Prozess blockiert ansonsten wird der Semaphor um 1 dekrementiert V (holländisch verhoog, erhöhe ; auch up oder signal) auf den Semaphor ggf. blockierter Prozess wird deblockiert ansonsten wird der Semaphor um 1 inkrementiert 6

4 Eselsbrücken zu Semaphoren Mit P wartet man auf eine Ressource und belegt diese dann. Eselsbrücke: p(b)elegen, ggfs. vorher warten Es sind danach weniger Ressourcen verfügbar, also wird runtergezählt. Mit V gibt man eine Ressource wieder frei, ggfs. wird der nächste wartende Thread benachrichtigt. Eselsbrücke: v(f)reigeben, ggfs. benachrichtigen Es sind danach wieder mehr Ressourcen verfügbar, also wird hochgezählt. 7 Semaphor Komplexere Interaktion Das erste Leser/Schreiber-Problem aus der Vorlesung In diesem Beispiel ein kritischer Abschnitt geschützt werden. Es gibt zwei Klassen von konkurrierenden Prozessen: Schreiber: Sie ändern Daten und müssen daher gegenseitigen Ausschluss garantiert bekommen. Leser: Da sie nur Lesen, dürfen mehrere Leser auch gleichzeitig den kritischen Abschnitt betreten 8

5 Semaphor Komplexes Beispiel Das erste Leser/Schreiber-Problem aus der Vorlesung /* gem. Speicher */ Semaphore rcmutex; Semaphore wrtmutex; int readcount; /* Initialisierung */ rcmutex = 1; wrtmutex = 1; readcount = 0; /* Schreiber */ p(&wrtmutex);... schreibe v(&wrtmutex); /* Leser */ p(&rcmutex); readcount++; /* Der erste Leser sperrt wrtmutex */ if (readcount == 1) p(&wrtmutex); v(&rcmutex);... lese p(&rcmutex); readcount--; /* Der Letzte gibt wrtmutex frei */ if (readcount == 0) v(&wrtmutex); v(&rcmutex): 11 POSIX Semaphoren int sem_init(sem_t *sem, int pshared, unsigned int value); Anlegen einer Semaphore Parameter sem: Adresse des Semaphor-Objekts pshared: 0, falls nur zwischen Threads eines Prozesses verwendet value: Initalwert der Semaphore, entspricht dem n Rückgabewert: #include <semaphore.h> 0, wenn erfolgreich -1 im Fehlerfall Bsp.: sem_t semaphor; if (sem_init(&semaphor, 0, 1) == -1) { /* Fehlerbehandlung */ 12

6 POSIX Semaphoren Belegen einer Semaphore (P), ggfs. müssen wir vorher warten: int sem_wait(sem_t *sem); Freigeben einer Semaphore (V), ggfs. wird der nächste Thread benachrichtigt: int sem_post(sem_t *sem); Entfernen einer Semaphore: Parameter int sem_destroy(sem_t *sem); sem: Adresse des Semaphor-Objekts Rückgabewert: 0, wenn erfolgreich -1 im Fehlerfall 13 POSIX Semaphore Beispiel: Gegenseitiger Ausschluss mit Semaphore #include <semaphore.h> /* Konsumierbare Rangsemaphore */ sem_t rangsemaphore;... int main(void){ sem_init(&rangsemaphore, 0, 1);... sem_destroy(&rangsemaphore); return 0; void* run(void* arg) {... sem_wait(&rangsemaphore); rangliste[rang++] = team; sem_post(&rangsemaphore);... globale Deklaration, damit auch Threads Zugriff haben Fehlerbehandlung! 14

7 Problemstellung Das Szenario: Zwei Mitarbeiter (bei uns PThreads) teilen sich die Arbeit eine Klausur zu korrigieren. Hierzu unterbrechen sie regelmäßig ihre andere Arbeit. Es gibt also zwei Pthreads: Thread 1: mitarbeiter_a_thread Thread 2: mitarbeiter_b_thread Um die Klausuren zu korrigieren benötigen sie folgende Ressourcen, die jeweils nur einmal vorhanden sind: Ressource 1: Karton mit Klausuren, als Semaphore implementiert Ressource 2: Liste für die Noten, als Semaphore implementiert 15 Problemstellung Die Threads führen folgende Aufgaben regelmäßig durch: Mitarbeiter A Mitarbeiter B Andere Arbeit erledigen Andere Arbeit erledigen Semaphore Klausuren belegen Semaphore Liste belegen Semaphore Liste belegen Semaphore Klausuren belegen Korrigieren Korrigieren Klausuren und Liste freigeben Klausuren und Liste freigeben Weiter mit Schritt 1 Weiter mit Schritt 1 16

8 Problemstellung Die Mitarbeiter können immer nur dann korrigieren, wenn folgende Bedingungen erfüllt sind: Beide Ressourcen (die beiden Semaphoren Klausuren und Liste) konnten von einer Person reserviert werden. Ist die zweite benötigte Ressource nicht frei, wird solange gewartet, bis die benötigte Ressource vom anderen Mitarbeiter freigegeben wird. Dabei behält jeder Mitarbeiter die zuerst reservierte Ressource (Klausuren/Liste). Sind beide Ressourcen erfolgreich reserviert wird korrigiert. Im Anschluss an die Korrektur werden beide Betriebsmittel wieder zurückgegeben freigegeben. 17 Problemstellung: Verklemmung Zwischen den Mitarbeitern kann es immer wieder zu konkurrierenden Situationen kommen: Nachdem ein Betriebsmittel vom Mitarbeiter reserviert wurde, wird auch das andere Betriebsmittel benötigt! Haben beide Mitarbeiter jeweils ein Betriebsmittel, brauchen sie das Betriebsmittel des anderen. Beide Mitarbeiter geben Betriebsmittel nicht freiwillig ab! Und so warteten sie und warteten ist belegt von A Ressource 1 Thread: A Thread: B Ressource 2 wird benötigt von A wird benötigt von B ist belegt von B 18

9 Problemstellung: Zustände 4 Zustände: andere_arbeit, hole_klausuren, hole_liste und korrigieren Ablauf für Mitarbeiter A Betriebsmittel 2 belegen hole klausuren hole liste Betriebsmittel 1 belegen andere arbeit Beide Betriebsmittel freigeben korrigieren 19 Deadlock-Voraussetzungen Die notwendigen Bedingungen für eine Verklemmung: 1. mutual exclusion die umstrittenen Betriebsmittel sind nur unteilbar nutzbar 20

10 Deadlock-Voraussetzungen Die notwendigen Bedingungen für eine Verklemmung: 1. mutual exclusion die umstrittenen Betriebsmittel sind nur unteilbar nutzbar 2. hold and wait die umstrittenen Betriebsmittel sind nur schrittweise belegbar 21 Deadlock-Voraussetzungen Die notwendigen Bedingungen für eine Verklemmung: 1. mutual exclusion die umstrittenen Betriebsmittel sind nur unteilbar nutzbar 2. hold and wait die umstrittenen Betriebsmittel sind nur schrittweise belegbar 3. no preemption die umstrittenen Betriebsmittel sind nicht rückforderbar 22

11 Deadlock-Voraussetzungen Die notwendigen Bedingungen für eine Verklemmung: 1. mutual exclusion die umstrittenen Betriebsmittel sind nur unteilbar nutzbar 2. hold and wait die umstrittenen Betriebsmittel sind nur schrittweise belegbar 3. no preemption die umstrittenen Betriebsmittel sind nicht rückforderbar Erst wenn zur Laufzeit eine weitere Bedingung eintritt, liegt tatsächlich eine Verklemmung vor: 4. circular wait eine geschlossene Kette wechselseitig wartender Prozesse 23 Deadlock-Voraussetzungen 4. circular wait eine geschlossene Kette wechselseitig wartender Prozesse ist belegt von A Ressource 1 Thread: A Thread: B Ressource 2 wird benötigt von A wird benötigt von B ist belegt von B 24

12 Erkennen von Verklemmungen Analyse der Zustände beider Mitarbeiter mögliche Art der Deadlockerkennung Die Zustände der beiden Mitarbeiter werden in einem globalen Feld abgelegt Mitarbeiter setzen ihre Zustände; Der Elternprozess liest die Daten aus dem Feld Was ist das Problem? 25 Erkennen von Verklemmungen Analyse der Zustände beider Mitarbeiter mögliche Art der Deadlockerkennung Die Zustände der beiden Mitarbeiter werden in einem globalen Feld abgelegt Mitarbeiter setzen ihre Zustände; Der Elternprozess liest die Daten aus dem Feld Problem: Race-Conditions durch fehlende Synchronisation Aufpassen: Während der Elternprozess einen Zustand ausliest, kann ein Mitarbeiter seinen Zustand im Feld verändern Die Sicht des Elternprozesses wird inkonsistent! 26

13 Erkennen von Verklemmungen Analyse der Zustände beider Mitarbeiter mögliche Art der Deadlockerkennung Die Zustände der beiden Mitarbeiter werden in einem globalen Feld abgelegt Mitarbeiter setzen ihre Zustände; Der Elternprozess liest die Daten aus dem Feld Problem: Race-Conditions durch fehlende Synchronisation Lösung: Zugriff zusätzlich mit einem Semaphor absichern keine Race-Condition mehr! 27 Auflösen von Verklemmungen Der Elternprozess kann also einen Deadlock erkennen, indem die Zustände beider Mitarbeiter geeignet überprüft werden. Wie kann eine Deadlock-Situation aufgelöst werden? Aufgabe d) Beschreibt eine Lösung Optionale Aufgabe: Implementiert eure Gedankengänge 28

14 Pthreads abbrechen int pthread_cancel(pthread_t thread); Sendet eine Anfrage zum Abbrechen des Pthreads Parameter Rückgabewert: thread: Thread-Objekt 0, wenn erfolgreich eine Fehlernummer ungleich 0 im Fehlerfall Wann der Thread auf den Abbruch reagiert hängt vom: gesetzten Abbruchzustand (enabled oder disabled) und dem gesetzten Abbruchtyp ab (asynchronous oder deferred). 29 Enumeration enum ist ein benutzerdefinierter Aufzählungstyp eine mittels enum definierte Variable ist vom Typ int intern Ganzzahl, aber durch Wertbezeichner visualisiert kann dort verwendet werden, wo ein int erlaubt ist #include <stdio.h> enum farbpalette {ROT, GRUEN, BLAU, GELB; enum farbpalette farbe; int main(void) { farbe = GRUEN; printf("gewaehlte Farbe: %d\n", farbe); return 0; mm@ios:~$./enum gewaehlte Farbe: 1 30

15 Signal-Handler, sigaction(2) int sigaction(signalnr, *neueakt, *alteakt); Im eigenen Prozess Signale verarbeiten (SIGINT, SIGCHLD, etc.) Parameter SignalNr = das Signal das behandelt werden soll *neueakt = Pointer auf struct sigaction mit den Informationen zum neuen Handler (Eingabe!) *alteakt = Pointer auf struct sigaction mit den Informationen zum vorherigen Handler (Ausgabe!), ignoriert bei Übergabe von NULL Benötigt <signal.h> Rückgabewerte: -1: Fehler bei der Ausführung, Fehlercode in errno 0: Erfolgreiche Ausführung 31 Signal-Handler struct sigaction { void (*sa_handler)(int); /* Zeiger auf die Handler-Funktion */ sigset_t sa_mask; /* Ignorierte Signale während Behandlung */ int sa_flags; /* Optionen */ void (*sa_restorer)(void); /* veraltet -> IGNORIEREN */ #include <signal.h>... /* die Handler Funktion für unser Signal */ void handle_abbruch(int sig) { printf("sigint gefangen: %d!\n", SIGINT==sig); exit(2); int main() { struct sigaction action; action.sa_handler = &handle_abbruch; /* die Adresse des Handlers angeben */ action.sa_flags = 0; /* keine besonderen Flags */ sigemptyset(&action.sa_mask); /* keinerlei Signale ignorieren */ if (sigaction(sigint, &action, NULL)) { /* SIGINT Handler registrieren */ perror( sigaction ); return 1; /* Rückgabewert!= 0 => Fehler! */ while(1); return 0; 32

16 Klausuraufgabe: Synchronisierung Initialwerte der Semaphore: S1 = chicken1() { S2 = chicken2() { S3 = printf("get"); printf("to"); chicken3() { printf("to"); printf("the"); printf("other"); printf("side"); 33 Klausuraufgabe: Synchronisierung Initialwerte der Semaphore: chicken1() { printf("to"); V(S2); P(S1); printf("to"); V(S3); P(S1); printf("other"); V(S3); S1 = 0 S2 = 0 chicken2() { P(S2); printf("get"); V(S1); chicken3() { P(S3); printf("the"); V(S1); P(S3); printf("side"); S3 = 0 34

17 Klausuraufgabe: Synchronisierung 35