Mutual Exclusion und Synchronisation. Peter Puschner Institut für Technische Informatik 1
|
|
|
- Heini Beltz
- vor 5 Jahren
- Abrufe
Transkript
1 Mutual Exclusion und Synchronisation Peter Puschner Institut für Technische Informatik 1
2 Gemeinsame Ressourcen BS und Prozesse, parallel laufende Prozesse verwenden die selben Daten bzw. Ressourcen (Shared Memory, Files, Geräte) tauschen Daten aus und kooperieren daher brauchen wir: disziplinierten Zugriff auf gemeinsame Daten/ Ressourcen geordnete Abarbeitung verteilter Aktionsfolgen sonst Fehlverhalten: Inkonsistenz bzw. Abhängigkeit der Ergebnisse von Abfolge der Abarbeitungsschritte der einzelnen Prozesse Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 2
3 Beispiel 1 Prozess A a = a + 1; mov A, a inc A mov a, A Prozess B a = a 1; mov B, a dec B mov a, B a neu : parallele Ausführung von A u. B Fall 1 mov A, a inc A mov a, A mov B, a dec B mov a, B Fall 2 mov A, a mov B, a dec B mov a, B inc A mov a, A Fall 3 mov B, a dec B mov A, a inc A mov a, A mov a, B a alt a alt + 1 a alt 1 Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 3
4 Beispiel 2 Prozess A t := 0; loop ShM := t; t := (t+1) mod 10; end loop Prozess B loop t := ShM; print(t); end loop parallele Ausführung von A u. B ShM: 0 ShM: 1 print: 1 print: 1 ShM: 2 print: 2 ShM: 0 print: 0 ShM: 1 ShM: 2 print: 2 print: 2 ShM: 0 print: 0 ShM: 1 print: 1 ShM: 2 print: 2 Ausgabe: Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 4
5 Überblick Begriffe und Ziele Mutual Exclusion Condition Synchronization Programmierung v. Mutual Exclusion und Bedingungssynchronisation Semaphore Sequencer und Eventcounts Monitor, Nachrichten, NBW Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 5
6 Interaktion von Prozessen Wechselseitiger Ausschluss (Mutual Exclusion) Verhindern des gleichzeitigen Zugriffs auf Ressourcen (Atomicity) Ziel: Konsistenthalten der Daten Bedingungssynchronisation (Condition Synchronisation) Warten auf das Eintreten einer Bedingung Ziel: bestimmte Reihenfolge von Operationen Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 6
7 Mutual Excl. und Cond. Sync. Orthogonale Konzepte Vier mögliche Kombinationen MutEx. + + CondSync. + + Ziel unabhängige Aktionen vorgegebene Abfolge Konsistenthaltung Konsistenz und Abfolge Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 7
8 Begriffe: Mutual Exclusion P 1 P 2 kritischer Abschnitt gemeinsame Ressource, gemeinsamer Datenbereich kritischer Abschnitt Daten kritische Region Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 8
9 Kritischer Abschnitt Ein Prozess befindet sich im kritischen Abschnitt, wenn er auf gemeinsame Daten bzw. Ressourcen zugreift Wechselseitiger Ausschluss (mutual exclusion): zu jedem Zeitpunkt darf sich höchstens ein Prozess in seinem kritischen Abschnitt befinden Eintritt in kritischen Abschnitt muss geregelt erfolgen Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 9
10 Prozessstruktur für krit. Abschnitt kein Prozess darf in seinen kritischen Abschnitt eintreten, wenn sich bereits ein Prozess in seinem k.a. befindet Prozessstruktur... Prolog k.a. kritischer Abschnitt Epilog k.a.... Eintrittsprotokoll Austrittsprotokoll Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 10
11 Anforderungen für k.a. Lösung Mutual Exclusion Progress wenn sich kein Prozess im k.a. befindet und Prozesse in den k.a. eintreten möchten, darf die Entscheidung über den nächsten Prozess nicht unendlich lange verzögert werden Bounded Waiting Nachdem ein Prozess einen Request für den k.a. abgegeben hat, ist die Anzahl der Eintritte in den k.a. durch andere Prozesse abgeschrankt Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 11
12 Arten von Lösungen Softwarelösungen Annahmen: Atomizität einer Lese- bzw. Schreiboperation auf dem Speicher Hardwareunterstützte Lösungen Verwendung spezieller Maschineninstruktionen Höhere Synchronisationskonstrukte stellen dem Programmierer Funktionen und Datenstrukturen zur Verfügung Semaphore, Monitor, Message Passing, Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 12
13 Mutual Exclusion in Software Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 13
14 Softwarelösungen Zunächst 2 Prozesse, P0 und P1 dann Generalisierung auf n Prozesse, Pi, wobei Pi <> Pj für i <> j Synchronisation über globale Variable Busy Waiting: Warten auf das Eintreten einer Bedingung durch ständiges Testen (busy benötigt CPU-Zeit) while Bedingung true do nothing Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 14
15 Dekker-Algorithmus, 1. Versuch global: Prozess Pi: var turn: 0.. 1; while turn <> i do nothing; critical section turn = j; remainder section Mutual Exclusion gegeben Prozesse können nur abwechselnd in k.a. Wenn ein Prozess terminiert, wird der andere Prozess endlos blockiert Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 15
16 Dekker-Algorithmus, 2. Versuch global: var flag: array [0..1] of boolean; Prozess Pi: while flag[ j] do nothing; flag[i] := true; critical section flag[i] := false; remainder section Initialisierung: flag[i] := false; flag[ j] := false; Wenn ein Prozess terminiert, kann der andere Prozess weiterarbeiten Mutual Exclusion nicht garantiert Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 16
17 Dekker-Algorithmus, 3. Versuch global: Prozess Pi: var flag: array [0..1] of boolean; flag[i] := true; while flag[ j] do nothing; critical section flag[i] := false; remainder section Mutual Exclusion gesichert aber: Deadlock möglich Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 17
18 Dekker-Algorithmus, 4. Versuch Prozess Pi: flag[i] := true; while flag[ j] do begin flag[i] := false; wait for a short time; flag[i] := true; end; critical section flag[i] := false; remainder section Mutual Exclusion gesichert, kein Deadlock aber: Lifelock, Prozessoraktivität ohne Produktivität Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 18
19 Dekker-Algorithmus flag[i] := true; while flag[ j] do if turn = j then begin flag[i] := false; while turn = j do nothing; flag[i] := true; end; critical section turn := j; flag[i] := false; remainder section flag Zustand der beiden Prozesse turn bestimmt die Reihenfolge des Eintretens in den k.a. im Falle von völligem Gleichlauf (siehe 4. Versuch) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 19
20 Peterson-Algorithmus eleganter, leichter zu durchschauen als Dekker Alg. Prozess Pi: loop flag[i] := true; turn := j; while flag[ j] and turn = j do nothing; critical section flag[i] := false; remainder section end loop Initialisierung: flag[i] := false; flag[ j] := false; Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 20
21 Peterson-Algorithmus Mutual Exclusion P0 setzt flag[0] auf true à P1 blockiert P1 im k.a. à flag[1] = true à P0 blockiert kein endloses gegenseitiges Blockieren Annahme: P0 blockiert in while-schleife (d.h. flag[1] = true und turn = 1 ) P1 will nicht in k.a. >< flag[1] = true P1 wartet auf k.a. >< turn = 1 P1 monopolisiert k.a. >< P1 muss turn vor neuerlichem Eintritt in k.a. auf 0 setzen Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 21
22 Bakery Algorithm Lösung des k.a.-problems für n Prozesse Nummernvergabe für k.a.; Prozess mit der niedrigsten Nummer (>0) tritt als erstes ein Nummer 0 keine Anforderung für k.a. Pi und Pj mit gleichen Nummern: Pi kommt vor Pj in k.a., wenn i < j es gilt stets: neu vergebene Nummer >= vorher vergebene Nummern var choosing: array [0..n-1] of boolean; number: array [0..n-1] of integer; Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 22
23 loop choosing [i] := true; number [i] := 1 + max(number [0],, number [n-1]); choosing [i] := false; for j := 0 to n-1 do begin while choosing [ j] do nothing; while number [ j] <> 0 and (number [ j],j) < (number [i],i) do nothing; end; critical section number [i] := 0; remainder section end loop Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 23
24 Hardwareunterstützte Lösungen Interrupt Disabling für Uniprozessorsystem geeignet aber: Einschränkung des BS beim Dispatching anderer Tasks Rückgabe der Kontrolle an das BS? Schutz von Instruktionssequenzen im BS Spezielle Maschineninstruktionen Test and Set Exchange (Swap) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 24
25 Test and Set Hardwareinstruktion, die zwei Aktionen atomar (d.h. ununterbrechbar) ausführt à Mutual Exclusion function testset (var i: integer): boolean; begin if i = 0 then begin i := 1; testset := true; end; else testset := false; end. Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 25
26 Test and Set für k.a. globale Var.: Prozess Pi: var b: integer; b := 0; while not testset (b) do nothing; critical section b := 0; remainder section Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 26
27 Sicherung des k.a. mit exchange globale Var.: var b: integer; b := 0; Prozess Pi: var key: integer; key := 0; key := 1; do exchange (key, b) while key = 1; critical section exchange (key, b); remainder section einfacher Prolog für den k.a. für beliebig viele Prozesse erfordert Busy Waiting Starvation von Prozessen möglich Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 27
28 Semaphore Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 28
29 Semaphore Synchronisationsmechanismus, der kein Busy Waiting notwendig macht (vom BS zur Verfügung gestellt) Semaphore S: Integer-Variable, auf die nach der Initialisierung nur mit zwei atomaren Funktionen, wait und signal, zugegriffen werden kann statt Busy Waiting: Blockieren der wartenden Prozesse in Blocked Queues (siehe Abschnitt Prozesse ) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 29
30 Semaphore Ziel: Verwendung von Semaphoren zum Sichern eines kritischen Abschnitts auf einfache Art wait (S); critical section signal (S); remainder section Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 30
31 Semaphore - Datenstruktur Semaphore ist ein Record: type semaphore = record value: integer; queue: list of process; end; Auf einen Semaphor S wartende Prozesse werden in die Blocked Queue von S (S.queue) gestellt Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 31
32 Semaphore - Operationen init (S, val): S.value := val; S.queue := empty list; wait (S): S.value := S.value - 1; if S.value < 0 then add this process to S.queue and block it; signal (S): S.value := S.value + 1; if S.value <= 0 then remove a process P from S.queue and place P on ready queue; Semaphore müssen auf einen nicht-negativen Wert (für Mutual Exclusion auf 1) initialisiert werden Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 32
33 Wechselseitiger Ausschluss Initialisierung: Prozess Pi: init (S, 1) wait (S); critical section signal (S); remainder section Maximal ein Prozess im k.a. Reihenfolge, in der Prozesse in den k.a. eintreten, ist nicht a-priori festgelegt (hängt von Behandlung der Queue ab, typischer Weise FIFO à Bounded Waiting, Fairness) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 33
34 Semaphore - Implementierung wait und signal müssen als atomare Operationen ausgeführt werden Sichern der Semaphoroperationen (= k.a.) mit Test and Set zusätzliche Record-Komponente flag in der Semaphordatenstruktur Vor k.a.: Busy Waiting mit Test von flag da wait und signal sehr kurz sind, kommt es kaum zum Busy Waiting; daher ist der Overhead vertretbar Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 34
35 Semaphore - Bemerkungen S.count >= 0: Anzahl der Prozesse, die hintereinander ein wait ausführen können, ohne warten zu müssen Initialisierung von S mit Wert n à n Prozesse können gleichzeitig in den k.a. S.count < 0: S.count Prozesse in der Queue von S blockiert (in gezeigter Implementierung) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 35
36 Semaphore - Bemerkungen Binary Semaphore: nimmt nur die Werte 0 oder 1 an Counting Semaphore: kann beliebige (nicht negative) ganzzahlige Werte annehmen - implementierungsabhängig Operationen wait und signal werden in der Literatur auch als P und V bezeichnet Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 36
37 Bedingungssynchronisation Verschiedene Prozesse: P1 und P2 Codeabschnitt C1 in P1 muss vor Abschnitt C2 in P2 ausgeführt werden Semaphore für Bedingungssynchronisation (Condition Synchronisation) Initialisierung: init (S, 0) P1: C1; signal (S); P2: wait (S); C2; Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 37
38 Abwechselnder Zugriff Beispiel: Datentransfer von P1 an P2 P1 schreibt, P2 liest Shared Memory kein Duplizieren bzw. Verlust von Daten Init.: init ( P1: loop gen. data; P2: loop read ShM; write ShM; use data; end loop end loop Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 38
39 Abwechselnder Zugriff Beispiel: Datentransfer von P1 an P2 P1 schreibt, P2 liest Shared Memory kein Duplizieren bzw. Verlust von Daten Init.: init (S1, 1); init (S2, 0); P1: loop gen. data; wait (S1); write ShM; signal (S2); end loop P2: loop wait (S2); read ShM; signal (S1); use data; end loop Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 39
40 Semaphore -- Beispiele Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 40
41 Aufgabe Gegeben: 3 zyklische Prozesse, A, B, C A produziert Daten und schreibt sie auf ShM B und C lesen die Daten vom ShM (ohne Einschränkung der Parallelität) Datenaustausch findet immer wieder statt Jeder von A geschriebene Datensatz soll von B und C genau einmal gelesen werden??? Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 41
![über einen Puffer an den Konsumenten übergeben Producer Consumer b[0] b[1] b[2]](/docs-images/97/133418991/images/42-2.jpg "b[3] Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.")
42 Producer-Consumer Problem Produzent generiert Information, die vom Konsumenten gelesen wird Beispiel: Druckaufträge an einen Drucker Einzelne Datensätze werden über einen Puffer an den Konsumenten übergeben Producer Consumer b[0] b[1] b[2] b[3] Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 42
43 P-C mit unbegrenztem Puffer Produzent kann jederzeit ein Datenelement schreiben Konsument muss auf Daten warten in zeigt auf nächstes freies Puffer-Element out zeigt auf nächstes zu lesendes Element b[0] b[1] b[2] b[3] b[4] out in Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 43
44 P-C: Semaphore Mutual Exclusion: zu jedem Zeitpunkt darf nur ein Prozess auf den Puffer zugreifen (Semaphore S ) Bedingungssynchronisation: der Konsument darf nur dann lesen, wenn mindestens ein ungelesenes Datenelement im Puffer steht (Counting Semaphore N spiegelt Anzahl der Elemente im Puffer wieder) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 44
45 P-C: Implementierung Initialisierung: init (S, 1); init(n, 0); in := out := 0; append (v): b[in] := v; in := in + 1; take ( ): w := b[out]; out := out + 1; return w; Producer: loop produce (v); P (S); append (v); V (S); V (N); end loop Consumer: loop P (N); P (S); w := take ( ); V (S); consume (w) end loop Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 45
46 P-C mit Ringpuffer Begrenzter Puffer mit K Elementen Lesen: mind. ein neuer Wert notwendig Schreiben: mind. ein Element beschreibbar b[0] b[1] b[2] b[3] b[4] b[k-1] out in b[0] b[1] b[2] b[3] b[4] b[k-1] in out Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 46
47 Ringpuffer: Semaphore Semaphore wie bei unbegrenztem Puffer Mutual Exclusion: zu jedem Zeitpunkt darf nur ein Prozess auf den Puffer zugreifen (S) Bedingungssynchronisation: der Konsument darf nur dann lesen, wenn mindestens ein ungelesenes Datenelement im Puffer steht (N) Bedingungssynchronisation: der Produzent darf nur dann schreiben, wenn mindestens ein leerer Speicherbereich vorhanden ist (E) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 47
48 P-C Ringpuffer-Implementierung Initialisierung: init (S, 1); init (N, 0); init (E, K ); in := out := 0; append (v): b[in] := v; in := (in + 1) mod K; take ( ): w := b[out]; out := (out + 1) mod K; return w; Producer: loop produce (v); P (E); P (S); append (v); V (S); V (N); end loop Consumer: loop P (N); P (S); w := take ( ); V (S); V (E); consume (w) end loop Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 48
49 Reihenfolge von P und V Reihenfolge von V-Operationen beliebig Achtung: Abfolge von P-Operationen ist relevant! Producer: produce (v); P (E); P (S); append (v); Consumer: P (S); P (N); w := take (); vertauscht! falsch!!! Systemverklemmung (Deadlock), wenn Consumer bei leerem Puffer (N=0) in k.a. eintritt. Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 49
50 Reader-Writer Problem Es gibt Lese- und Schreibeprozesse, die auf eine gemeinsame Ressource zugreifen Beliebig viele Leser dürfen parallel lesen Schreiber benötigen exklusiven Zugriff Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 50
51 Reader-Writer Problem init (x, 1); init (y, 1); init (z, 1); init (wsem, 1); init (rsem, 1); rc := 0; wc := 0; Reader: loop P (x); rc := rc + 1; if rc = 1 then P (wsem); V (x); read; P (x); rc := rc - 1; if rc = 0 then V (wsem); V (x); end loop Writer: loop P (wsem); write; V (wsem); end loop Leser haben Priorität Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 51
52 Reader-Writer Problem Reader: loop P (z); P (rsem); P (x); rc := rc + 1; if rc = 1 then P (wsem); V (x); V (rsem); V (z); read; P (x); rc := rc - 1; if rc = 0 then V (wsem); V (x); end loop Writer: loop P (y); wc := wc + 1; if wc = 1 then P (rsem); V (y); P (wsem); write; V (wsem); P (y); wc := wc - 1; if wc = 0 then V (rsem); V (y); end loop Schreiber haben Priorität Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 52
53 Dining Philosophers Problem klassisches Problem der Synchronisation 5 Philosophen denken und essen jeder braucht zum Essen zwei Gabeln gesucht: Lösung ohne Deadlock und Starvation Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 53
54 Dining Philosophers Problem Jedem Philosophen entspricht ein Prozess Ein Semaphore pro Gabel fork: array[0..4] of semaphore; foreach i in [0..4] init (fork[i], 1); Erster Versuch: Prozess Pi: loop think; P (fork[i]); P (fork[(i+1) mod 5]); eat; V (fork[(i+1) mod 5]); V (fork[i]); end loop Erster Versuch: Deadlock, wenn alle Philosophen gleichzeitig die erste Gabel aufnehmen Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 54
55 Dining Philosophers: Lösungen Zusätzlicher Semaphore, der maximal 4 Philosophen gleichzeitig das Aufnehmen einer Gabel erlaubt Mindestens ein Prozess nimmt die Gabeln in umgekehrter Reihenfolge auf atomare P-Operation für mehrere Semaphore mp (fork[i], fork[(i+1) mod 5]); Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 55
56 P und V für mehrere Semaphore mp, mv: atomare Operationen P und V für eine Menge von Semaphoren mp (S1, S2,, Sn): blockiert solange, bis alle Semaphore S1 bis Sn größer als 0 sind Löst Problem der Reihung von P-Operationen mv (S1, S2,, Sn): erhöht alle Semaphore S1 bis Sn um eins Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 56
57 Spinlocks Mehrwertige Semaphore mittels Busy Waiting realisiert Sicherung kurzer kritischer Abschnitte auf Multiprozessorsystemen CPU-Overhead, aber kein Process Switch P (S): S := S - 1; while S < 0 do nothing; V (S): S := S + 1; Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 57
58 Sequencer und Eventcounts Mechanismen zur direkten Steuerung der Reihenfolge von Aktionen (Cond.Sync.) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 58
59 Eventcounts Ereigniszähler Eventcount E: ganzzahlige Variable zum Zählen der Vorkommnisse von Ereignissen. Der Anfangswert von E ist 0. advance (E): erhöht E um 1 await (E, val): blockiert Prozess bis E >= val Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 59
60 Beispiel Eventcounts Nach jedem 10ten Vorkommnis eines Events E1 soll die Aktion S1 durchgeführt werden. Bei jedem Auftreten von E1: advance (E); P1: t := 0; loop t := t+10; await (E, t); S1; end loop Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 60
61 Sequencer Sequencer S: ganzzahlige Variable mit Anfangswert 0, auf der die Operation ticket definiert ist. ticket (S): atomare Aktion, liefert den Wert des Sequencers S und erhöht anschließend den Wert von S um 1. Eventcounts und Sequencer: vgl. Ausgabe von Nummern und Warten auf Aufruf an einem Schalter (Behörde, Arzt, etc.) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 61
62 E und S: Mutual Exclusion Sicherung eines k.a. sequencer: S; eventcount: E; await (E, ticket (S)); critical section; advance (E); vgl.: semaphore: S; init (S, 1); P (S); critical section; V (S); Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 62
63 E und S: Producer-Consumer sequencer: Pticket, Cticket; eventcount: In, Out; Producer: loop produce (v); t := ticket (Pticket); -- nur ein Producer await (In, t); -- schreibbares Element await (Out, t-k+1); b[ t mod K ] := v; -- Element geschrieben -- nächster Producer advance (In); end loop Consumer: loop u := ticket (Cticket); -- nur ein Consumer await (Out, u); -- lesbare Daten await (In, u+1); w := b[ u mod K ]; -- Daten gelesen -- nächster Consumer advance (Out); consume (w) end loop Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 63
64 Eventcounts mit/ohne Sequencer Eventcounts mit Sequencern, wenn sich neu ankommende Prozesse mit den laufenden Prozessen aufsynchronisieren müssen (z.b., Server mit mehreren Clients) Verwendung von Eventcounts ohne Sequencer Bedingungssynchronisation fixe Menge von parallelen Prozessen vordefiniertes (ev. zyklisches) Synchronisationsmuster Ablaufsteuerung durch eine State Machine Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 64
65 Eventcounts ohne Sequencer loop S0; end loop loop S1; end loop loop S2; end loop t := 0; loop await (E, t); S0_act; advance (E); t := t+3; end loop t := 1; loop await (E, t); S1_act; advance (E); t := t+3; end loop t := 2; loop await (E, t); S2_act; advance (E); t := t+3; end loop Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 65
66 Distributed Mutual Exclusion Rechner Rechner Rechner Rechner Interface Zugriff auf gemeinsame Ressource: Lokale Kopie von E auf jedem Knoten ticket (S): Ticket vom Master anfordern advance (E): Nachricht an alle Knoten, dass die lokale Kopie des Eventcounts zu erhöhen ist await (E, val): unverändert Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 66
67 Probleme mit Sync-Konstrukten Semaphoroperationen bzw. Operationen mit Eventcounts und Sequencern sind über Prozesse verteilt, daher unübersichtlich Operationen müssen in allen Prozessen korrekt verwendet werden Ein fehlerhafter Prozess bewirkt Fehlverhalten aller Prozesse, die zusammenarbeiten Monitore Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 67
68 Monitor, Nachrichten und NBW Protokoll Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 68
69 Monitor Softwaremodul, bestehend aus: Prozeduren Lokalen Daten Initialisierungscode Eigenschaften Zugriff auf lokale Variable: Monitorprozeduren Eintritt von Prozessen in den Monitor über Monitorprozeduren max. 1 Prozess zu jedem Zeitpunkt im Monitor Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 69
70 Monitor Monitor sorgt für Mutual Exclusion, kein explizites Programmieren Gemeinsamer Speicher ist im Monitorbereich anzulegen Prozesssynchronisation über Monitorvariable Programmierung von Wartebedingungen für Bedingungsvariable (Condition Variables) Monitoreintritt, wenn Wartebedingungen der Bedingungsvariablen erfüllt sind Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 70
71 Condition Variables Lokal im Monitor (Zugriff nur im Monitor) Zugriff nur über die Zugriffsfunktionen cwait (c): blockiert aufrufenden Prozess bis Bedingung(svariable) c den Wert true annimmt csignal (c): Setze einen Prozess, der auf die Bedingung c wartet, fort wenn mehrere Prozesse warten, wähle einen aus wenn kein Prozess wartet, keine Aktion keine speichernde Wirkung (< > Semaphore-wait) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 71
72 Monitor Entering Processes Cond. c1 Cond. cn Urgent Queue cwait (c1) cwait (cn) csignal Waiting Area Local Data Cond. Var. Procedure Prozedur Prozedur Init. Code Monitor Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 72
73 Monitor: Producer-Consumer monitor ProducerConsumer b: array[0..k-1] of items; In := 0, Out := 0, cnt := 0 : integer; notfull, notempty: condition; append (v): if (cnt = K) cwait (notfull); b[in] := v; In := (In + 1) mod K; cnt := cnt + 1; csignal (notempty); take (v): if (cnt = 0) cwait (notempty); v := b[out]; Out := (Out + 1) mod K; cnt := cnt - 1; csignal (notfull); Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 73
74 Message Passing Methode zur Interprozesskommunikation (IPC) für einzelne Computer und verteilte Systeme Mechanismus für Synchronisation und Mutual Exclusion Eine Nachricht ist eine atomare Datenstruktur Funktionen zum Senden und Empfangen send (destination, message) receive (source, message) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 74
75 Charakteristika von Nachrichten Synchronisation send: blocking, non-blocking receive: blocking, non-blocking, test for arrival Datenverwaltung Warteschlange (Queue) Empfangene Daten überschreiben alte Werte Adressierung 1:1 vs. 1:N physikalisch, logisch; direkt, indirekt (Mailbox, Portadressierung) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 75
76 Mailbox und Portadressierung P 1 Mailbox Q 1 P n Q n P 1 Port Q P n Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 76
77 Ereignis- vs. Zustandsnachricht Ereignisnachricht (Event Message) send: Queue für neue Nachrichten (blocking oder non-blocking) receive: Konsumieren beim Lesen (Queue) Zustandsnachricht (State Message) send: nicht-blockierendes Senden eines Speicherinhalts receive: Überschreiben der alten Datenwerte, Lesen ist nicht konsumierend Semantik ähnlich Variablensemantik Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 77
78 Ereignisnachricht für MutEx Prozesse verwenden eine gemeinsame Mailbox mutex und eine Nachricht (Token) Blocking receive, (non-blocking) send Prozess Pi: loop receive (mutex, msg); critical section; send (mutex, msg); remainder section; end loop Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 78
79 Non-Blocking Write Protokoll Bisher genannte Mechanismen für Mutual Exclusion führen zum Blockieren von Prozessen Blockieren kann in speziellen Situationen Probleme verursachen Beispiel: Schreiber möchte die Uhrzeit aktualisieren, aber ein Leser niedriger Priorität wird im kritischen Abschnitt (beim Lesen der Uhrzeit) von einem Prozess höherer Priorität unterbrochen. Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 79
80 NBW-Protokoll Annahmen Verteiltes System Kommunikation über gemeinsamen Speicher (shared Memory) Es gibt genau einen Schreiber mit einem eigenen Prozessor (kein Wettstreit um CPU) Es gibt mehrere Leser (auf einer oder mehreren anderen CPUs) Schreibintervalle sind groß im Vergleich zur Dauer eines Schreibzugriffs Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 80
81 NBW - Forderungen Konsistenz: Ergebnisse von Leseoperationen müssen konsistent sein Non-Blocking Property: Der Schreiber darf nicht von Lesern blockiert werden Timeliness: Die Verzögerung von Prozessen, die Leseoperationen ausführen, muss zeitlich abschrankbar sein Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 81
82 NBW-Protokoll Beschreibung Initialisierung: CCF := 0; /* concurrency control flag */ Writer: CCF_old := CCF; CCF := CCF_old + 1; write; CCF := CCF_old + 2; Reader: do CCF_begin := CCF; read; CCF_end := CCF; while CCF_end <> CCF_begin or CCF_begin mod 2 = 1 CCF Arithmetik in Praxis: Restklassenarithmetik modulo (2 * bign) Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 82
83 NBW-Protokoll Korrektheit Folgende Szenarien sind zu untersuchen: Read Write Read Write Write Read Write Read Read Write Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 83
84 Zusammenfassung Anforderungen paralleler Prozesse Konsistenter Zugriff auf gemeinsame Daten Vorgegebene Reihenfolge von Aktionen Mutual Exclusion à Konsistenz Condition Synchronization à Reihenfolge Kritischer Abschnitt Aktionen, die gemeinsame Daten manipulieren mit Konstrukten zur Synchronisation gesichert Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 84
85 Zusammenfassung Sicherung des kritischen Abschnitts Lösungen abhängig vom Instruction Set Unterstützung durch Betriebssystem kein Busy Waiting! Semaphore init, wait und signal, bzw. P und V Achtung: Reihenfolge der wait Operationen Eventcounts und Sequencer await, advance, ticket Offene vs. klar vordefinierte Synchronisationsfolge Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 85
86 Zusammenfassung Monitor Kapselung von gemeinsamen Objekten, Zugriffsfunktionen und Bedingungsvariablen Messages Atomare Datenstruktur Synchronisationssemantik Non-Blocking Write Protokoll Peter Puschner, TU Wien Vorlesung Betriebssysteme, Mutex & Sync.; WS 11/12 86
Mutual Exclusion und Synchronisation. Peter Puschner 1
Mutual Exclusion und Synchronisation Peter Puschner 1 Gemeinsame Ressourcen BS und Prozesse,,parallel laufende Prozesse verwenden die selben Daten bzw. Ressourcen (Shared Memory, Files, Geräte) tauschen
Mutual Exclusion und Synchronisation. Peter Puschner Institut für Technische Informatik
Mutual Exclusion und Synchronisation Peter Puschner Institut für Technische Informatik peter@vmars.tuwien.ac.at Gemeinsame Ressourcen BS und Prozesse, parallel laufende Prozesse verwenden die selben Daten
Mutual Exclusion und Synchronisation. Peter Puschner Institut für Technische Informatik peter@vmars.tuwien.ac.at
Mutual Exclusion und Synchronisation Peter Puschner Institut für Technische Informatik peter@vmars.tuwien.ac.at 1 Gemeinsame Ressourcen BS und Prozesse, parallel laufende Prozesse verwenden die selben
Betriebssysteme. G: Parallele Prozesse. (Teil B: Klassische Problemstellungen, Mutual Exclusion, kritische Regionen)
Betriebssysteme G: Parallele Prozesse (Teil B: Klassische Problemstellungen, Mutual Exclusion, kritische Regionen) 1 Allgemeine Synchronisationsprobleme Wir verstehen ein BS als eine Menge von parallel
Erzeuger/Verbraucher-Problem: gemeinsamer Puffer Programm für Erzeuger. Kapitel IV
Kapitel IV Prozesssynchronisation Erzeuger/Verbraucher-Problem: gemeinsamer Puffer Programm für Erzeuger Repeat produziere Datum in nextp while counter == n; buffer[in]=nextp; in = (in+1) % n; counter++;
Kapitel IV. Prozesssynchronisation. VO Betriebssysteme
Kapitel IV Prozesssynchronisation 1 Motivation: Nebenläufigkeit Zentrale Bedeutung der Verwaltung von Prozessen und Threads Mehrprogrammbetrieb: : mehrere Prozesse in einem sequentiellen Einprozessorsystem
Übersicht. Nebenläufige Programmierung: Praxis und Semantik. Synchronisation (4) Eine untere Schranke für den Platzbedarf
Übersicht Komplexitätsresultate Aktuelle Themen zu Informatik der Systeme: Nebenläufige Programmierung: Praxis und Semantik Synchronisation (4) Drei Komplexitätsresultate Eine genaue Schranke für den Platzbedarf
Betriebssysteme Teil 11: Interprozess-Kommunikation
Betriebssysteme Teil 11: Interprozess-Kommunikation 19.12.15 1 Übersicht Grundbegriffe Shared Memory Pipelines Messages Ports Sockets 2 Grundbegriffe Interprocess-Kommunikation = Austausch von Daten über
JJ Prozesse und Nebenläufigkeit
1 Wiederholung: Algorithmus von Peterson boolean ready0=false, ready1=false; int turn=0; JJ Prozesse und Nebenläufigkeit (Auszug aus der Vorlesung) while( 1 ) Prozess 0 ready0 = true; turn = 1; while(
Übung zu Grundlagen der Betriebssysteme. 10. Übung 18.12.2012
Übung zu Grundlagen der Betriebssysteme 10. Übung 18.12.2012 Aufgabe 1 a) Was versteht man unter einem kritischen Abschnitt oder kritischen Gebiet (critical area)? b) Welche Aufgabe hat ein Semaphor? c)
Betriebssysteme. Vorlesung im Herbstsemester 2010 Universität Mannheim. Kapitel 6: Speicherbasierte Prozessinteraktion
Betriebssysteme Vorlesung im Herbstsemester 2010 Universität Mannheim Kapitel 6: Speicherbasierte Prozessinteraktion Felix C. Freiling Lehrstuhl für Praktische Informatik 1 Universität Mannheim Vorlesung
Fakultät für Informatik der Technischen Universität München. Nebenläufigkeit. Probleme
Nebenläufigkeit Probleme 175 Race Conditions: Probleme Situationen, in denen zwei oder mehrere Threads/Prozesse, die gleichen geteilten Daten lesen oder schreiben und das Resultat davon abhängt, wann genau
Deadlock. Peter Puschner Institut für Technische Informatik
Deadlock Peter Puschner Institut für Technische Informatik peter@vmars.tuwien.ac.at Deadlock Permanentes Blockieren einer Menge von Prozessen, die um Ressourcen konkurrieren oder miteinander kommunizieren
Softwarelösungen: Versuch 4
Softwarelösungen: Versuch 4 Nichtstun in Schleife wird ersetzt durch zeitweilige Zurücknahme der Anforderung, um es anderen Prozessen zu erlauben, die Ressource zu belegen: /* Prozess 0 */ wiederhole flag[0]
Die Anweisungen zweier Prozesse werden parallel bearbeitet, wenn die Anweisungen unabhängig voneinander zur gleichen Zeit ausgeführt werden.
7 Parallelität und Nebenläufigkeit Mehrere Prozessen oder Threads Parallelität Die Anweisungen zweier Prozesse werden parallel bearbeitet, wenn die Anweisungen unabhängig voneinander zur gleichen Zeit
Vorlesung "Verteilte Systeme" Sommersemester Verteilte Systeme. Verteilte Systeme, Sommersemester 1999 Folie 7.2
Verteilte Systeme 7. Verteilter wechselseitiger Ausschluß Inhalt I. Was ist wechselseitiger Ausschluß II. Wechselseitiger Ausschluß mit State-Variablen III. Wechselseitiger Ausschluß mit Nachrichten Verteilte
Systeme I: Betriebssysteme Kapitel 5 Nebenläufigkeit und wechselseitiger Ausschluss. Wolfram Burgard
Systeme I: Betriebssysteme Kapitel 5 Nebenläufigkeit und wechselseitiger Ausschluss Wolfram Burgard Version 09.11.2016 1 Begrüßung Heute ist Tag der offenen Tür Willkommen allen Schülerinnen und Schülern!
leave: mov flag, 0 ; 0 in flag speichern: Lock freigeben ret
Sep 19 14:20:18 amd64 sshd[20494]: Accepted rsa for esser from ::ffff:87.234.201.207 port 61557 Sep 19 14:27:41 amd64 syslog-ng[7653]: STATS: dropped 0 Sep 20 01:00:01 amd64 /usr/sbin/cron[29278]: (root)
Literatur. Betriebssysteme WS 2015/16 - Teil 8/Synchronisation I
Literatur [8-1] Werner, Dieter: Theorie der Betriebssysteme. Hanser, 1992 [8-2] Dannegger, Christian; Geugelin-Dannegger, Patricia: Parallele Prozesse unter UNIX. Hanser, 1991 [8-3] Siegert, Hans-Jürgen;
Erstes Leser-Schreiber-Problem
Erstes Leser-Schreiber-Problem Szenario: mehrere Leser und mehrere Schreiber gemeinsamer Datenbereich Schreiber haben exklusiven Zugriff Leser können parallel zugreifen (natürlich nur, wenn kein Schreiber
Leser-Schreiber-Realisierung mit Semaphoren
Leser-Schreiber-Realisierung mit Semaphoren Reader: down(semwriter); down(semcounter); rcounter++; up(semwriter); read(); down(semcounter); rcounter--; Writer: Problem: down(semwriter); Busy Waiting siehe
Systeme I: Betriebssysteme Kapitel 5 Nebenläufigkeit und wechselseitiger Ausschluss. Maren Bennewitz
Systeme I: Betriebssysteme Kapitel 5 Nebenläufigkeit und wechselseitiger Ausschluss Maren Bennewitz Version 18.12.2013 1 Inhalt Vorlesung Aufbau einfacher Rechner Überblick: Aufgabe, Historische Entwicklung,
Verteilte Systeme CS5001
Verteilte Systeme CS5001 Th. Letschert TH Mittelhessen Gießen University of Applied Sciences Client-Server-Anwendungen: Vom passiven (shared state) Monitor zum aktiven Monitor Monitor (Hoare, Brinch-Hansen,
Lösungsvorschlag Serie 7 Parallelität
7 (1/6) Lösungsvorschlag Serie 7 Parallelität 1. Es sei die folgende Situation vorgegeben: 4 D 3 C 2 E 5 1 B A Im Folgenden sind vier Methoden zur Lösung des Problems dargestellt: (a) Intelligente Kontrolleinheit
Hans-Georg Eßer, FH München Betriebssysteme I, WS 2006/07, 2007/01/24 Zusammenfassung (2/2) Folie 2
/home/esser/daten/dozent/folien/bs-esser-24.odp Sep 19 14:20:18 amd64 sshd[20494]: Accepted rsa for esser from ::ffff:87.234.201.207 port 61557 Sep 19 14:27:41 amd64 syslog-ng[7653]: STATS: dropped 0 Sep
WS Parallele Prozesse. Prof. Hannelore Frank. Parallele Prozesse. PetriNetze. Synchronisation UNIX. Wettbewerb PC Krit.Abschnitt Spinlocks
WS 2007 Überblick 1 2 Petri-Netze als Entwurfshilfsmittel 3 nebenläufiger 4 -Systemfunktionen Literatur Eduard Glatz: Betriebssysteme. Grundlagen, Konzepte, Systemprogrammierung dpunkt.verlag, 2006, ISBN
Erzeuger-Verbraucher-Problem
Erzeuger-Verbraucher-Problem Hier: Puffer der Größe 1, Erzeuger, Verbraucher Zwei Semaphore werden eingesetzt, um zwischen Threads "Ereignisse zu melden" Man kann Semaphore auch verwenden, um Ereignisse
Domänenmodell: Fadenkommunikation und -synchronisation
Domänenmodell: Fadenkommunikation und -synchronisation Alexander Humphreys, Reinhard Rösch, Fabian Scheler 15. Mai 2003 Inhaltsverzeichnis 1 Domänendefinition 1 2 Domänenlexikon 1 3 Konzeptmodelle 4 4
( Faire ) Zuteilung eines Prozesses an den Prozessor (Entscheidung über Swapping) Wartende Prozesse in einer (FIFO-) Warteschlange organisieren
22 2.2 Prozesse Prozess-Scheduling Scheduler: ( Faire ) Zuteilung eines Prozesses an den Prozessor (Entscheidung über Swapping) Scheduling-Verfahren Round Robin (einfach und häufig verwendet) Wartende
Klausur zur Vorlesung Grundlagen der Betriebssysteme
Prof. Dr. L. Wegner Dipl.-Math. K. Schweinsberg Klausur zur Vorlesung Grundlagen der Betriebssysteme 19.2.2004 Name:... Vorname:... Matrikelnr.:... Studiengang:... Hinweise: Bearbeitungszeit 2 Stunden.
Übung Betriebssysteme 11
Übung Betriebssysteme 11 Christian Motika Christian-Albrechts-Universität zu Kiel Institut für Informatik AG Echtzeitsysteme / Eingebettete Systeme Kiel, Germany 29-JAN-2013 CAU - WS 2012/13 Übung Betriebssysteme
Übersicht. Nebenläufige Programmierung: Praxis und Semantik. Synchronisation (5) Bisher. Jetzt. Aktuelle Themen zu Informatik der Systeme: WS 2011/12
Stand der Folien: 15. November 2011 Übersicht Aktuelle Themen zu Informatik der Systeme: Nebenläufige Programmierung: Praxis und Semantik Synchronisation (5) 1 Übersicht über die Operationen Mutual-Exclusion
Inhaltsverzeichnis. Carsten Vogt. Nebenläufige Programmierung. Ein Arbeitsbuch mit UNIX/Linux und Java ISBN:
Inhaltsverzeichnis Carsten Vogt Nebenläufige Programmierung Ein Arbeitsbuch mit UNIX/Linux und Java ISBN: 978-3-446-42755-6 Weitere Informationen oder Bestellungen unter http://www.hanser.de/978-3-446-42755-6
Aufgabenblatt 7 Musterlösung
Prof. Dr. rer. nat. Roland Wismüller Aufgabenblatt 7 Musterlösung Vorlesung Betriebssysteme I Wintersemester 2017/18 Aufgabe 1: Steuerung eines Warenautomaten (Bearbeitung zu Hause) Anleitung wie man solche
Verhaltensbeschreibung und Spezifikationssprachen
TECHNISCHE UNIVERSITÄT ILMENAU Integrierte Kommunikationssysteme http://www.tu-ilmenau.de/iks Verhaltensbeschreibung und Spezifikationssprachen Verhaltensmodelle Zustandsautomaten (FSM) Nicht-deterministische
Klausur Nichtsequentielle Programmierung. Nachname: Bachelor Magister. Vorname: Master Lehramt
Klausur Nichtsequentielle Programmierung Prof. Dr. Marcel Kyas 5. Oktober 2009 Nachname: Bachelor Magister Vorname: Master Lehramt Diplom Hinweise zur Klausur Bitte überprüfen Sie, dass Sie alle Seiten
Info B VL 17: Deadlocks
Info B VL 17: Deadlocks Objektorientiere Programmierung in Java 2003 Ute Schmid (Vorlesung) Elmar Ludwig (Übung) FB Mathematik/Informatik, Universität Osnabrück Info B VL 17: Deadlocks p.327 Conditional
Vorlesung "Verteilte Systeme" Sommersemester 1999. Verteilte Systeme. Adreßraum. Rechner. Verteilte Systeme, Sommersemester 1999 Folie 19.
Verteilte Systeme 19. Distributed Shared Memory Sharing!! No Sharing! Sharing? Evolution der Berechnungsmodelle Vergangenheit Gemeinsamer Speicher Einzelrechner Gegenwart Nachrichtenkommunikation Verteilte
Systeme I: Betriebssysteme Kapitel 5 Nebenläufigkeit und wechselseitiger Ausschluss. Maren Bennewitz
Systeme I: Betriebssysteme Kapitel 5 Nebenläufigkeit und wechselseitiger Ausschluss Maren Bennewitz Version 12.12.2012 1 Nachtrag zu letzter Vorlesung Hauptspeicher reicht nur für begrenzte Anzahl von
librtipc - Bibliothek für echtzeitfähige Interprozesskommunikation
librtipc - Bibliothek für echtzeitfähige Interprozesskommunikation Josef Raschen Diplomarbeit: Hardwareunabhängige Interprozesskommunikation für Echtzeitanwendungen Lehrstuhl für Betriebssysteme RWTH Aachen
Aufgaben Semaphore Übersicht (Dijkstra)
Übersicht (Dijkstra) Einsatz von Semaphoren: Wechselseitiger Ausschluss (INIT = 1): REQ. Kritischer Bereich. REL Zählende Semaphore (INIT = N): Bis zu N verschiedene Prozesse dürfen in den kritischen Bereich
Verteilte Anwendungen. Teil 3: Synchronisation
Verteilte Anwendungen Teil 3: Synchronisation 08.04.18 1 Literatur [3-1] Werner, Dieter: Theorie der Betriebssysteme. Hanser, 1992 [3-2] Dannegger, Christian; Geugelin-Dannegger, Patricia: Parallele Prozesse
Wechselseitiger Ausschluss in verteilten Systemen / Elektionsalgorithmen. Özden Urganci Ulf Sigmund Ömer Ekinci
Wechselseitiger Ausschluss in verteilten Systemen / Elektionsalgorithmen Özden Urganci Ulf Sigmund Ömer Ekinci Inhaltsangabe 1 Einleitung 2 Prinzipien des verteilten wechselseitigen Ausschlusses 2.1 Anforderungen
2.3 Prozessverwaltung
Realisierung eines Semaphors: Einem Semaphor liegt genau genommen die Datenstruktur Tupel zugrunde Speziell speichert ein Semaphor zwei Informationen: Der Wert des Semaphors (0 oder 1 bei einem binären
Single- und Multitasking
Single- und Multitasking Peter B. Ladkin ladkin@rvs.uni-bielefeld.de Peter B. Ladkin Command Interpreter (ComInt) läuft wartet auf Tastatur-Eingabe "liest" (parst) die Eingabe (für Prog-Name) Macht "Lookup"
Parallele Prozesse. Prozeß wartet
Parallele Prozesse B-66 Prozeß: Ausführung eines Programmes in seinem Adressraum (zugeordneter Speicher) Parallele Prozesse: gleichzeitig auf mehreren Prozessoren laufende Prozesse p1 p2 verzahnte Prozesse:
Systeme 1. Kapitel 6. Nebenläufigkeit und wechselseitiger Ausschluss
Systeme 1 Kapitel 6 Nebenläufigkeit und wechselseitiger Ausschluss Threads Die Adressräume verschiedener Prozesse sind getrennt und geschützt gegen den Zugriff anderer Prozesse. Threads sind leichtgewichtige
Klausur Nichtsequentielle Programmierung
Klausur Nichtsequentielle Programmierung Prof. Dr. Marcel Kyas 22. Juli 2009 Nachname: Bachelor Magister Vorname: Master Lehramt Diplom Hinweise zur Klausur Bitte überprüfen Sie, dass Sie alle Seiten dieser
Literatur. VA SS Teil 5/Messages
Literatur [5-1] https://en.wikipedia.org/wiki/message-oriented_middleware [5-2] https://en.wikipedia.org/wiki/advanced_message_queuing_protocol http://www.amqp.org/specification/0-10/amqp-org-download
1.1 Transitionssysteme Produkte von Transitionssystemen Kripkestrukturen Verifikation und Model-Checking...
Transitionssysteme und Verifikation 3. Transitionssysteme.................................. 3. Produkte von Transitionssystemen......................... 9.3 Automaten und reguläre Sprachen.........................
Betriebssysteme G: Parallele Prozesse ( Teil C: SpinLock, Semaphore, Monitore)
Betriebssysteme G: Parallele Prozesse ( Teil C: SpinLock, Semaphore, Monitore) 1 Hardwareunterstützung Uniprozessor-System Verbiete Interrupts während des Aufenthalts in einer CR disable interrupt CR(bzw:
Info B VL 16: Monitore und Semaphoren
Info B VL 16: Monitore und Semaphoren Objektorientiere Programmierung in Java 2003 Ute Schmid (Vorlesung) Elmar Ludwig (Übung) FB Mathematik/Informatik, Universität Osnabrück Info B VL 16: Monitore und
Synchronisation und Kommunikation über Nachrichten
Synchronisation und Kommunikation über Nachrichten meist bei verteiltem Speicher, kein gemeinsamer Speicher -> keine globalen Variablen keine zu schützenden Datenbereiche Kommunikation über Kanäle und
Prozeß-Interaktion u. -Kommunikation
Definitionen: Prozeß: (Vorgang der) Programmausführung Interaktion: aufeinander bezogenes Handeln Kommunikation: Bidirektionaler (allg.: multidirektionaler) Austausch von Information Information: Daten,
Verteilte Systeme. 7. Verteilter wechselseitiger. Ausschluß. Wechselseitiger Ausschluß (mutual. exclusion)
Verteilte Systeme 7. Verteilter wechselseitiger Ausschluß Wechselseitiger Ausschluß (mutual exclusion) Aufgabenstellung Mehrere Prozesse möchten etwas tun, wobei garantiert sein muß, daß es zu einem Zeitpunkt
Extended Scope. Events und Mailboxen. Florian Franzmann Tobias Klaus Florian Korschin Florian Schmaus Peter Wägemann
Extended Scope Events und Mailboxen Florian Franzmann Tobias Klaus Florian Korschin Florian Schmaus Peter Wägemann Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl Informatik 4 (Verteilte Systeme
Prozeß P1 Prozeß P2. Zur Synchronisation stehen den beiden Prozessen binäre Semaphore und die beiden Funktionen
Seite 8 A UFGABE 11 INTERP ROZEßKOMMUNIKATION Das folgende Petrinetz zeigt zwei verkoppelte Prozesse P1 und P2. Die Transitionen a und b beschreiben Aktionen von P1, die Transitionen c und d Aktionen von
Aufgabenblatt 8 Musterlösung
Prof. Dr. rer. nat. Roland Wismüller Aufgabenblatt 8 Musterlösung Vorlesung Betriebssysteme I Wintersemester 2017/18 Aufgabe 1: Erzeuger-Verbraucher Synchronisation (Bearbeitung in der Übungsstunde) Erzeuger-Verbraucher-Problem:
RTOS Einführung. Version: Datum: Autor: Werner Dichler
RTOS Einführung Version: 0.0.1 Datum: 20.07.2013 Autor: Werner Dichler Inhalt Inhalt... 2 RTOS... 3 Definition... 3 Anforderungen... 3 Aufgaben... 3 Eigenschaften... 4 Einteilung der Betriebssysteme...
Proseminar Nichtsequentielle Programmiersprachen WS 2011/2012 Monitore
Fachbereich Mathematik und Informatik Institut für Informatik Proseminar Nichtsequentielle Programmiersprachen WS 2011/2012 Monitore Sascha Kretzschmann 2. November 2011 Inhaltsverzeichnis 1 Einleitung
Mutual Exclusion. Annika Külzer Florian Störkle Dennis Herzner
Mutual Exclusion Annika Külzer Florian Störkle Dennis Herzner Gliederung 1 Mutual Exclusion allgemein 2 Lock-Algorithmen 2.1 LockOne 2.2 LockTwo + Beweis 2.3 Peterson Lock 2.4 Lamport's Bakery Lock-Algorithmus
Vorlesung Betriebssysteme II
1 / 15 Vorlesung Betriebssysteme II Thema 3: IPC Robert Baumgartl 20. April 2015 2 / 15 Message Passing (Nachrichtenaustausch) Prinzip 2 grundlegende Operationen: send(), receive() notwendig, wenn kein
Threads Einführung. Zustände von Threads
Threads Einführung Parallelität : Zerlegung von Problemstellungen in Teilaufgaben, die parallelel ausgeführt werden können (einfachere Strukturen, eventuell schneller, Voraussetzung für Mehrprozessorarchitekturen)
C-Code-Fragment Bankautomat. Vorlesung Betriebssysteme I II. Möglicher (typischer) Ablauf. Begriff der Race Condition
C-Code-Fragment Bankautomat Vorlesung Betriebssysteme I II Thema 0: Synchronisation Robert Baumgartl 6. März 05 Unterbrechung /* gemeinsam genutzte Variable */ int guthaben = 3000; /* Dublonen */ int abheben
Einführung in die technische Informatik
inführung in die technische Informatik hristopher Kruegel chris@auto.tuwien.ac.at http://www.auto.tuwien.ac.at/~chris etriebssysteme ufgaben Management von Ressourcen Präsentation einer einheitlichen Schnittstelle
Rechnerarchitektur und Betriebssysteme (CS201): Semaphor, Monitor, Deadlocks, Re-Entrance
Rechnerarchitektur und Betriebssysteme (CS201): Semaphor, Monitor, Deadlocks, Re-Entrance 5. November 2013 Prof. Dr. Christian Tschudin Departement Mathematik und Informatik, Universität Basel Repetition
Hans-Georg Eßer, Hochschule München Betriebssysteme I, SS Synchronisation (1) Folie 3
Sep 19 14:20:18 amd64 sshd[20494]: Accepted rsa for esser from ::ffff:87.234.201.207 port 61557 Sep 19 14:27:41 amd64 syslog-ng[7653]: STATS: dropped 0 Sep 20 01:00:01 amd64 /usr/sbin/cron[29278]: (root)
#define N 5 // Anzahl der Philosophen. while (TRUE) { // Der Philosoph denkt
Sep 19 14:20:18 amd64 sshd[20494]: Accepted rsa for esser from ::ffff:87.234.201.207 port 61557 Sep 19 14:27:41 amd64 syslog-ng[7653]: STATS: dropped 0 Sep 20 01:00:01 amd64 /usr/sbin/cron[29278]: (root)
Was machen wir heute? Betriebssysteme Tutorium 3. Organisatorisches. Prozesskontrollblock (PCB) Programmieraufgaben. Frage 3.1.a
Was machen wir heute? Betriebssysteme Tutorium 3 Philipp Kirchhofer philipp.kirchhofer@student.kit.edu http://www.stud.uni-karlsruhe.de/~uxbtt/ Lehrstuhl Systemarchitektur Universität Karlsruhe (TH) 1
Betriebssysteme 1 BS1-E SS Prof. Dr.-Ing. Hans-Georg Eßer Fachhochschule Südwestfalen. Foliensatz E: Synchronisation Deadlocks. v1.
BS1-E Betriebssysteme 1 SS 2016 Prof. Dr.-Ing. Hans-Georg Eßer Fachhochschule Südwestfalen Foliensatz E: Synchronisation Deadlocks v1.0, 2016/06/05 05.06.2016 Betriebssysteme 1, SS 2016, Hans-Georg Eßer
Betriebssysteme 1. Einführung (2) Synchronisation: Probleme mit gleichzeitigem Zugriff auf Datenstrukturen Beispiel: Zwei Threads erhöhen einen Zähler
BS1-E Einführung (2) Betriebssysteme 1 SS 2018 Synchronisation: Probleme mit gleichzeitigem Zugriff auf Datenstrukturen Beispiel: Zwei Threads erhöhen einen Zähler Prof. Dr.-Ing. Hans-Georg Eßer Fachhochschule
Synchrone Botschaften
Synchrone Botschaften PPJ-84 Prozesse kommunizieren und synchronisieren sich direkt miteinander, bzw. über Kanäle, die höchstens eine Botschaft aufnehmen. Operationen: send (b): receive (v): blockiert
Weitere Verbesserungen
Weitere Verbesserungen Welcher Cache liefert aktuellen Block falls mehrere Caches Block im Zustand S halten? Lösung: Einführung eines weiteren Zustands O (Owner) Zustand O besagt: Eigentümer des Blocks
6. Juni VO Prüfung Betriebssysteme. Ges.)(100) 1.)(35) 2.)(20) 3.)(45) Bitte verwenden Sie nur dokumentenechtes Schreibmaterial!
VO 8. Prüfung Betriebssysteme. Juni KNr. MNr. Zuname, Vorname Ges.)().)().)().)() Zusatzblätter: Bitte verwenden Sie nur dokumentenechtes Schreibmaterial! Synchronisation mit Semaphoren () Eine Parkgarage
Anwendung (2. Versuch:-) Entkopplung der Locks
Gut gemeint aber leider fehlerhaft... Jeder Producer benötigt zwei Locks gleichzeitig, um zu produzieren: 1. dasjenige für den Puffer; 2. dasjenige für einen Semaphor. Musser fürden Semaphor einwait()
Kapitel 6. Verklemmungen (Deadlocks)
Seite 1 Kapitel 6 Verklemmungen (Deadlocks) Prof. Dr. Rolf Hennicker 16.06.2016 6.1 Charakterisierung von Deadlocks Seite 2 Eine Verklemmung entsteht, wenn alle Prozesse in einem System blockiert (d.h.
9. Vorlesung Betriebssysteme
Dr. Christian Baun 9. Vorlesung Betriebssysteme Hochschule Mannheim WS1213 1/39 9. Vorlesung Betriebssysteme Dr. Christian Baun Hochschule Mannheim Fakultät für Informatik wolkenrechnen@gmail.com Dr. Christian
Nicht-blockierende Synchronisation für Echtzeitsysteme
Nicht-blockierende Synchronisation für Echtzeitsysteme Seminar Mobile Systeme Florian Schricker 15. März 2005 Seminarleiter: Prof. Dr. Dieter Zöbel 1 INHALTSVERZEICHNIS INHALTSVERZEICHNIS Inhaltsverzeichnis
Aufgaben zum Thema Threads (Prozesse)
Aufgaben zum Thema Threads (Prozesse) T1. Erläutern Sie zwei Methoden, mit denen ein Prozeß seinen kritischen Abschnitt schützen kann! Geben Sie jeweils eine Implementationsmöglichkeit (in Pseudocode)
Nebenläufige und verteilte Programme CS2301
Nebenläufige und verteilte Programme CS2301 Th. Letschert TH Mittelhessen Gießen University of Applied Sciences Netze mit aktiven und reaktiven Knoten Produzent Konsument: aktiv / passiv / reaktiv
Speicherbasierte Kommunikation (T) Realisierung von Semaphoren (T) Shared Memory (P) Synchronisation mittels Semaphoren (P)
Systempraktikum im Wintersemester 2009/2010 (LMU): Vorlesung vom 26.11. Foliensatz 5 Speicherbasierte Kommunikation (T) Realisierung von Semaphoren (T) Shared Memory (P) Synchronisation mittels Semaphoren
Verteilte Systeme Teil 2
Distributed Computing HS 2012 Prof. Dr. Roger Wattenhofer, Dr. Thomas Locher C. Decker, B. Keller, S. Welten Prüfung Verteilte Systeme Teil 2 Freitag, 8. Februar 2013 9:00 12:00 Die Anzahl Punkte pro Teilaufgabe
Systeme I: Betriebssysteme Kapitel 4 Prozesse. Wolfram Burgard
Systeme I: Betriebssysteme Kapitel 4 Prozesse Wolfram Burgard Version 18.11.2015 1 Inhalt Vorlesung Aufbau einfacher Rechner Überblick: Aufgabe, Historische Entwicklung, unterschiedliche Arten von Betriebssystemen
Verteilte Algorithmen TI5005
Verteilte Algorithmen TI5005 Th. Letschert TH Mittelhessen Gießen University of Applied Sciences Prozess-Netze mit Aktoren Produzent / Konsument / Pipeline Client-Server Abstraktion der Partner Produzent
Technische Informatik II. SoSe 2013. Jörg Kaiser IVS EOS
Synchronisation SoSe 2013 Jörg Kaiser IVS EOS Otto-von-Guericke-Universität Magdeburg 1 1 Prozessinteraktion: Kommunikation, Koordination, Kooperation Problemformulierung Das Problem: Nebenläufigkeit +
Objektorientierte Programmierung
Objektorientierte Programmierung Ausnahmebehandlung und Nebenläufigkeit 9. Vorlesung am 15. Dezember 2010 Ausnahmebehandlung in Java class A { void foo() throws Help, SyntaxError {... class B extends A
Pthreads. David Klaftenegger. Seminar: Multicore Programmierung Sommersemester
Seminar: Multicore Programmierung Sommersemester 2009 16.07.2009 Inhaltsverzeichnis 1 Speichermodell 2 3 Implementierungsvielfalt Prioritätsinversion 4 Threads Speichermodell Was sind Threads innerhalb
Klausur zur Vorlesung Grundlagen der Betriebssysteme WS 2010 / 2011
Name: Matrikelnummer: Studiengang: INF CV IM Lehramt BSc MSc BEd MEd Diplom Klausur zur Vorlesung Grundlagen der Betriebssysteme WS 2010 / 2011 Montag, den 21. Februar 2011, 14:15 Uhr 15:45 Uhr Prof. Dr.
Einführung: Zustandsdiagramme Stand:
Einführung: Zustandsdiagramme Stand: 01.06.2006 Josef Hübl (Triple-S GmbH) 1. Grundlagen Zustandsdiagramme Zustände, Ereignisse, Bedingungen, Aktionen 2. Verkürzte Darstellungen Pseudozustände 3. Hierarchische
Lösung von Übungsblatt 9. (Interprozesskommunikation)
Lösung von Übungsblatt 9 Aufgabe 1 (Interprozesskommunikation) 1. Was ist ein kritischer Abschnitt? Mehrere Prozesse greifen lesend und schreibend auf gemeinsame Daten zu. 2. Was ist eine Race Condition?
Übung zu Grundlagen der Betriebssysteme. 11. Übung
Übung zu Grundlagen der Betriebssysteme 11. Übung 08.01.2012 Organisation Anmeldung zur Klausur Klausur Grundlagen der Betriebssysteme Datum: 05.02.2013 Raum F414 (steht aber noch nicht sicher fest) Anmeldung
Reihungen. Prof. Dr. Christian Böhm. In Zusammenarbeit mit Gefei Zhang. WS 07/08
Reihungen Prof. Dr. Christian Böhm In Zusammenarbeit mit Gefei Zhang http://www.dbs.ifi.lmu.de/lehre/nfinfosw WS 07/08 2 Ziele Die Datenstruktur der Reihungen verstehen: mathematisch und im Speicher Grundlegende
Wintersemester 2009/10 Helmut Seidl Institut für Informatik TU München
Informatik2 Wintersemester 2009/10 Helmut Seidl Institut für Informatik TU München 1 0 Allgemeines Inhalt dieser Vorlesung: Nebenläufigkeit in Java; Funktionales Programmieren mit OCaml :-) 2 1 Threads
Verklemmungen - Deadlocks
Verklemmungen - Deadlocks Betriebsmittel Verklemmung Vogelstrauss Algorithmus Erkennung und Auflösung Vermeidung SS2001 Prof. H.D. Clausen - unisal 1 Kritische Betriebsmittel Beispiele Drucker Magnetbandgeräte
Verbessertes Konzept: Monitore
Verbessertes Konzept: Monitore Ein Nachteil von Semaphoren ist die Notwendigkeit zur expliziten Anforderung P und Freigabe V des kritischen Bereiches durch den Programmierer Vergißt der Entwickler z.b.