Einführung in die Systemprogrammierung

Transkript

1 Einführung in die Systemprogrammierung Prof. Dr. Christoph Reichenbach Fachbereich 12 / Institut für Informatik 9. Juli 2015

2 Rationale Zahlen Wie können wir Rationale Zahlen im Rechner repräsentieren?

3 Rationale Zahlen Wie können wir Rationale Zahlen im Rechner repräsentieren? Festkommazahlen Brüche Fließkommazahlen

4 Festkommazahlen Idee: wir speichern die Zahl als Zweierkomplementzahl mit multiplikativem Bias Beispiel: Zwei Dezimal-Nachkommastellen: repr(n) = n 100 n repr(n) ,99 499

5 Festkommazahlen Idee: wir speichern die Zahl als Zweierkomplementzahl mit multiplikativem Bias Beispiel: Zwei Dezimal-Nachkommastellen: repr(n) = n 100 n repr(n) , Addition/Subtraktion: Wie bei Zweierkomplement

6 Festkommazahlen Idee: wir speichern die Zahl als Zweierkomplementzahl mit multiplikativem Bias Beispiel: Zwei Dezimal-Nachkommastellen: repr(n) = n 100 n repr(n) , Addition/Subtraktion: Wie bei Zweierkomplement Multiplikation: repr(repr(x) repr(y)) = x y 100

7 Division von Festkommazahlen Vorsicht bei der Division! ( ) repr(x) repr = x repr(y) y 100 0,4 0,3 :

8 Division von Festkommazahlen Vorsicht bei der Division! ( ) repr(x) repr = x repr(y) y 100 0,4 0,3 : Erst Division: 100 * (40 / 30) = 100 * 1 = 100 = repr(1)

9 Division von Festkommazahlen Vorsicht bei der Division! ( ) repr(x) repr = x repr(y) y 100 0,4 : 0,3 Erst Division: 100 * (40 / 30) = 100 * 1 = 100 = repr(1) Erst Multiplikation: (100 * 40) / 30 = 4000 / 30 = 133 = repr(1,33) Integer-Division schneidet Nachkommastellen ab!

10 Division von Festkommazahlen Vorsicht bei der Division! ( ) repr(x) repr = x repr(y) y 100 0,4 : 0,3 Erst Division: 100 * (40 / 30) = 100 * 1 = 100 = repr(1) Erst Multiplikation: (100 * 40) / 30 = 4000 / 30 = 133 = repr(1,33) Integer-Division schneidet Nachkommastellen ab! Schneller: Bit-Schiebeoperationen statt langsamer Division, aber nur für Binärnachkommastellen

11 Festkommazahlen: Eigenschaften Vorteile: Festkommazahlen sind exakt bei Addition, Subtraktion (modulo Überlauf) Festkommazahlen sind effizient bei Addition, Subtraktion Mit existierenden Mitteln einfach zu implementieren Nachteile: Festkommazahlen sind ungenau bei Multiplikation, Division Festkommazahlen arbeiten immer mit festem Multiplikator (100, in unserem Beispiel)

12 Festkommazahlen: Eigenschaften Vorteile: Festkommazahlen sind exakt bei Addition, Subtraktion (modulo Überlauf) Festkommazahlen sind effizient bei Addition, Subtraktion Mit existierenden Mitteln einfach zu implementieren Nachteile: Festkommazahlen sind ungenau bei Multiplikation, Division Festkommazahlen arbeiten immer mit festem Multiplikator (100, in unserem Beispiel) Fester Multiplikator ist für naturwissenschaftliche Zwecke nicht flexibel genug!

13 Fließkommazahlen: Die Idee Naturwissenschaftler: Wir brauchen Zahlen mit sehr unterschiedlichen Größenordnungen! flexibler multiplikativer Bias! Repräsentierungsbeispiel: 4, ,

14 Fließkommazahlen: Die Idee Naturwissenschaftler: Wir brauchen Zahlen mit sehr unterschiedlichen Größenordnungen! flexibler multiplikativer Bias! Repräsentierungsbeispiel: 4, als 420, 23 1, als 115, 8 Wir speichern den Exponenten der Zahl zusammen mit einer Annäherung der signifikanten Ziffern (Mantisse)

15 Fließkommazahlen: Die Idee Naturwissenschaftler: Wir brauchen Zahlen mit sehr unterschiedlichen Größenordnungen! flexibler multiplikativer Bias! Repräsentierungsbeispiel: 4, als 420, 23 1, als 115, 8 Wir speichern den Exponenten der Zahl zusammen mit einer Annäherung der signifikanten Ziffern (Mantisse) Im Rechner sind Zweierexponenten effizienter als Zehnerexponenten

16 Fließkommarepräsentierung Vorzeichen Exponent Mantisse Zahl getrennt in Vorzeichenbit, Exponent, Mantisse Exponent mit Bias gespeichert Falls die Zahl 0, muß Binärmantisse immer mit 1 beginnen, daher ist dieses Bit implizit. Beispiel: 8 Bits Exponent, Bias 127, Mantisse 23 Bits

17 Fließkommarepräsentierung: Beispiel Vorzeichen Exponent Mantisse Beispiel: 8 Bits Exponent, Bias=127, Mantisse 23 Bits

18 Fließkommarepräsentierung: Beispiel Vorzeichen Exponent Mantisse Beispiel: 8 Bits Exponent, Bias=127, Mantisse 23 Bits Vorzeichen v = 0

19 Fließkommarepräsentierung: Beispiel Vorzeichen Exponent Mantisse Beispiel: 8 Bits Exponent, Bias=127, Mantisse 23 Bits Vorzeichen v = 0 Exponent e = = 9

20 Fließkommarepräsentierung: Beispiel Vorzeichen Exponent Mantisse Beispiel: 8 Bits Exponent, Bias=127, Mantisse 23 Bits Vorzeichen v = 0 Exponent e = = 9 Mantisse m = 1, =

21 Fließkommarepräsentierung: Beispiel Vorzeichen Exponent Mantisse Beispiel: 8 Bits Exponent, Bias=127, Mantisse 23 Bits Vorzeichen v = 0 Exponent e = = 9 Mantisse m = 1, = v 2 e m = = 1000

22 IEEE 754: Fließkommazahlen Standardisierte Repräsentierung: IEEE-754 Format Exponent Bias (Exponent) Mantisse binary32 8 Bits Bits binary64 11 Bits Bits Unterstützt von handelsüblicher Hardware, z.b. dem MIPS-Coprozessor #1 binary32 auch als Fließkommazahl mit einfacher Präzision bezeichnet (C/C++/Java: float) binary64 auch als Fließkommazahl mit doppelter Präzision bezeichnet (C/C++/Java: double)

23 IEEE 754: Besondere Zahlen Bestimmte Bitmuster haben spezielle Bedeutungen. Hier für binary32: IEEE 754-Zahlen nehmen besondere Bedeutungen an, wenn der Exponent nur aus 0- oder 1-Bits besteht.

24 IEEE 754: Besondere Zahlen Bestimmte Bitmuster haben spezielle Bedeutungen. Hier für binary32: IEEE 754-Zahlen nehmen besondere Bedeutungen an, wenn der Exponent nur aus 0- oder 1-Bits besteht. Exponent = 0...0: 0x repräsentiert 0 0x repräsentiert 0 Allgemein: 1 v m (ohne 1,-Erweiterung)

25 IEEE 754: Besondere Zahlen Bestimmte Bitmuster haben spezielle Bedeutungen. Hier für binary32: IEEE 754-Zahlen nehmen besondere Bedeutungen an, wenn der Exponent nur aus 0- oder 1-Bits besteht. Exponent = 0...0: 0x repräsentiert 0 0x repräsentiert 0 Allgemein: 1 v m (ohne 1,-Erweiterung) Exponent = 1...1: 0x7f repräsentiert 0xff repräsentiert Andere Werte für NaN, not a number: Bei 0 0 Bei 1...

26 Fließkomma-Multiplikation xor Verschiebung (δ) Normalisierung Hier nur für normale Fließkommazahlen beschrieben Vorzeichen, Exponent: multiplizieren Mantisse: ( 1 ): mit fühender 1, erweitern, multiplizieren Normalisieren: um δ verschieben, bis genau eine 1, vor dem Komma δ auf Exponent addieren Auf Überlauf prüfen

27 Fließkomma-Addition 0 e 0 m e 1 m 1 Annahme: positiv, e 0 > e 1. Andere Fälle analog. m m 1 e 0 e 1 0 e 0 m c

28 Fließkomma-Addition 0 e 0 m e 1 m 1 Annahme: positiv, e 0 > e 1. Andere Fälle analog. m m 1 e 0 e 1 0 e 0 m c Exponent ist der größere (e 0 ) Hintere Bits von m 1 werden abgeschnitten, Resultat der Mantissenaddition nach m c Überlauf um 1 Bit möglich

29 Risiken bei Fließkommazahlenarithmetik Zahlenrepräsentierung notwendigerweise ungenau Addition/Subtraktion von Zahlen verschiedener Größenordnung verwirft Nachkommastellen Wenn Differenz zwischen Exponenten größer ist als Mantisse, ist Addition/Subtraktion komplett wirkungslos!

30 Risiken bei Fließkommazahlenarithmetik Zahlenrepräsentierung notwendigerweise ungenau Addition/Subtraktion von Zahlen verschiedener Größenordnung verwirft Nachkommastellen Wenn Differenz zwischen Exponenten größer ist als Mantisse, ist Addition/Subtraktion komplett wirkungslos! Vorsicht beim Aggregieren von Zahlen!

31 Fließkommaregister auf MIPS binary32: $f0 $f1... $f30 $f31 binary64: $f0... $f30 MIPS: Fließkommazahlen in Coprozessor #1 32 binary32-fließkommaregister $f0 bis $f31 Je zwei konsekutive Register $fx,$fx+1 können als binary64-register zusammengeschaltet werden Erstes Register muß geradezahlig sein $f0, $f2,... binary64-register hat gleichen Namen wie erstes Register

32 Fließkommaarithmetik auf MIPS Befehl Bedeutung Register add.s $z, $x, $y binary32 $z := $x + $y add.d $z, $x, $y binary64 sub.s $z, $x, $y binary32 $z := $x $y sub.d $z, $x, $y binary64 mul.s $z, $x, $y binary32 $z := $x $y mul.d $z, $x, $y binary64 div.s $z, $x, $y $z := $x binary32 div.d $z, $x, $y $y binary64 sqrt.s $z, $x $z := binary32 $x sqrt.d $z, $x binary64 Alle Grundrechenoperationen und die Quadratwurzel als binary32 (.s) oder binary64 (.d)

33 MIPS-Fließkommas: Kopieren, Konvertieren Konvertierungen: cvt.s.d $z, $x: Konvertiere binary64 nach binary32 cvt.s.w $z, $x: Konvertiere Zweierkomplementzahl nach binary32 cvt.d.w,s: Konvertiere nach binary64 cvt.w.s,d: Konvertiere nach Zweierkomplement Kopieren zwischen Hauptprozessor und Koprozessor #1: mtc1 $z, $x: CPU Koprozessor z.b.: mtc1 $f0, $v0 mfc1 $z, $x: Koprozessor CPU z.b.: mfc1 $v0, $f0

34 MIPS-Fließkommas: Kopieren, Konvertieren Konvertierungen: cvt.s.d $z, $x: Konvertiere binary64 nach binary32 cvt.s.w $z, $x: Konvertiere Zweierkomplementzahl nach binary32 cvt.d.w,s: Konvertiere nach binary64 cvt.w.s,d: Konvertiere nach Zweierkomplement Kopieren zwischen Hauptprozessor und Koprozessor #1: mtc1 $z, $x: CPU Koprozessor z.b.: mtc1 $f0, $v0 mfc1 $z, $x: Koprozessor CPU z.b.: mfc1 $v0, $f0 Weitere Operationen: Vergleich, Runden,...

35 Zusammenfassung: Fließkommazahlen v e m Vorzeichen Exponent Mantisse Fließkommazahl besteht aus Vorzeichen v, Exponent e, Mantisse m Wert: meist 1 v 2 e 1,m Sonderwerte wenn alle Bits im Exponenten 0 oder 1 sind Ermöglichen effizientes Arbeiten mit Zahlen in unterschiedlichen Größenordnungen Vorsicht: Addition/Subtraktion impräzise bei ungleichen Exponenten

36 Zusammenfassung: Rationale Zahlen Repräsentierung per Fixkommazahlen: Fester multiplikativer Bias Einfach zu implementieren (keine Zusatzhardware nötig) Verwendet Standardregister Repräsentierung per Bruchzahlen (per Softwarebibliothek) Repräsentierung per Fließkommazahlen Multiplikativer Bias je nach Zahl unterschiedlich Benötigt Zusatzhardware, aber auf fast allen modernen Prozessoren verfügbar Verwendet meist Zusatzregister

37 Parallele Ausführung 1000 Transistoren MHz SPECint-Performanz

38 Parallele Ausführung 1000 Transistoren MHz SPECint-Performanz Seit 2001 Performanzsteigerung durch parallele Ausführung

39 Parallele Ausführung vor Multicore Wir haben schon zwei Arten von paralleler Ausführung kennengelernt: Pipeline-Parallelismus Superskalare Ausführung

40 Parallele Ausführung vor Multicore Wir haben schon zwei Arten von paralleler Ausführung kennengelernt: Pipeline-Parallelismus Superskalare Ausführung Parallele Ausführung hat viele Formen

41 Die Flynn-Taxonomie Singuläres Datum Mehrere Daten Singuläre Instruktion SISD SIMD Vektoroperationen Graphikprozessoren (GPUs) Mehrere Instruktion MISD (Spezialechner) MIMD Superskalarrechner Mehrere Kerne Mehrere Prozessoren Mehrere Systeme

42 Formen der parallelen Ausführung Parallele Instruktionen (instruction-level parallelism, ILP) Hardware-Pipelining Superskalare Ausführung (Spekulative Ausführung) (Befehlsumordnung (out-of-order execution))

43 Formen der parallelen Ausführung Parallele Instruktionen (instruction-level parallelism, ILP) Hardware-Pipelining Superskalare Ausführung (Spekulative Ausführung) (Befehlsumordnung (out-of-order execution)) Parallele Datenbearbeitung (data-level parallelism)

44 Formen der parallelen Ausführung Parallele Instruktionen (instruction-level parallelism, ILP) Hardware-Pipelining Superskalare Ausführung (Spekulative Ausführung) (Befehlsumordnung (out-of-order execution)) Parallele Datenbearbeitung (data-level parallelism) Parallele Aufgabenbearbeitung (task-level parallelism)

45 Parallele Datenvearbeitung Vektoroperationen Trivial-parallele Bearbeitung (embarrassingly parallel programs) Fork-Join-Bearbeitung Parallelisierungsarchitekturen, z.b. Map-Reduce

46 Parallele Datenvearbeitung Vektoroperationen Trivial-parallele Bearbeitung (embarrassingly parallel programs) Fork-Join-Bearbeitung Parallelisierungsarchitekturen, z.b. Map-Reduce Grundidee: Unabhängige Berechnungen

47 Vektoroperationen: Beispiel (C) #include<stdbool.h>... bool a[32]; bool b[32]; bool c[32]; for (int i=0; i<32; i++) { c[i] = a[i] b[i]; }

48 Vektoroperationen: Beispiel (C) #include<stdbool.h>... bool a[32]; bool b[32]; bool c[32]; for (int i=0; i<32; i++) { c[i] = a[i] b[i]; } Idee: Kodiere a[i] als ites Bit von av Nutze Parallelismus des Bitweise-Oder-Operators av = bv = cv =

49 Vektoroperationen: Beispiel (C) #include<stdbool.h>... bool a[32]; bool b[32]; bool c[32]; for (int i=0; i<32; i++) { c[i] = a[i] b[i]; }... unsigned int av; unsigned int bv; unsigned int cv; // Alle Bits gleichzeitig: cv = av bv; Idee: Kodiere a[i] als ites Bit von av Nutze Parallelismus des Bitweise-Oder-Operators av = bv = cv =

50 Vektoroperationen: Beispiel (MIPS) Beispiel: Multiplikation der 16-Bit-Zahlen in $t0, $t1 mit 0x13 mul $t3, $t2, $t4

51 Vektoroperationen: Beispiel (MIPS) Beispiel: Multiplikation der 16-Bit-Zahlen in $t0, $t1 mit 0x13 li $t4, 0x13 $t4= mul $t3, $t2, $t4

52 Vektoroperationen: Beispiel (MIPS) Beispiel: Multiplikation der 16-Bit-Zahlen in $t0, $t1 mit 0x13 Kodierung li $t4, 0x13 sll $t2, $t0, 16 $t4= or $t2, $t2, $t1 mul $t3, $t2, $t4 $t2= $t0[15:0] $t1[15:0]

53 Vektoroperationen: Beispiel (MIPS) Beispiel: Multiplikation der 16-Bit-Zahlen in $t0, $t1 mit 0x13 Dekodierung Kodierung li or $t4, 0x13 $t2, $t2, $t1 sll mul $t2, $t0, 16 $t3, $t2, $t4 $t4= 0000 $t2= $t0[15:0] 0013 $t1[15:0] srl $t0, $t3, 16 andi $t1, $t3, 0xffff

54 Vektoroperationen: Beispiel (MIPS) Beispiel: Multiplikation der 16-Bit-Zahlen in $t0, $t1 mit 0x13 Dekodierung Kodierung li $t4, 0x13 sll $t2, $t0, 16 or $t2, $t2, $t1 mul $t3, $t2, $t4 srl $t0, $t3, 16 andi $t1, $t3, 0xffff $t4= $t2= $t0[15:0] Beispiel: $t1[15:0] $t0 = 0003 $t1 = 0002 $t2 =

55 Vektoroperationen: Beispiel (MIPS) Beispiel: Multiplikation der 16-Bit-Zahlen in $t0, $t1 mit 0x13 Dekodierung Kodierung li $t4, 0x13 sll $t2, $t0, 16 or $t2, $t2, $t1 mul $t3, $t2, $t4 srl $t0, $t3, 16 andi $t1, $t3, 0xffff $t4= $t2= $t0[15:0] Beispiel: $t1[15:0] $t0 = 0003 $t1 = 0002 $t2 = $t3 =

56 Vektoroperationen: Beispiel (MIPS) Beispiel: Multiplikation der 16-Bit-Zahlen in $t0, $t1 mit 0x13 Dekodierung Kodierung li $t4, 0x13 sll $t2, $t0, 16 or $t2, $t2, $t1 mul $t3, $t2, $t4 srl $t0, $t3, 16 andi $t1, $t3, 0xffff $t4= $t2= $t0[15:0] Beispiel: $t1[15:0] $t0 = 0003 $t1 = 0002 $t2 = $t3 = (De)kodierungsoperationen, um eine Multiplikation zu sparen

57 Vektoroperationen: Ökonomie Vektorberechnung: Kodierung Vektor-Operation Dekodierung

58 Vektoroperationen: Ökonomie Vektorberechnung: Kodierung Vektor-Operation Dekodierung (De)kodierung kann in Sonderfällen übersprungen werden: C-Beispiel (Bit- ): av etc. dauerhaft kodiert Preis: Zugriff auf Einzelbits benötigt Bitoperationen (billig, aber nicht kostenlos)

59 Vektoroperationen: Ökonomie Vektorberechnung: Kodierung Vektor-Operation Dekodierung (De)kodierung kann in Sonderfällen übersprungen werden: C-Beispiel (Bit- ): av etc. dauerhaft kodiert Preis: Zugriff auf Einzelbits benötigt Bitoperationen (billig, aber nicht kostenlos) Herausforderung: Überlauf =

60 Vektoroperationen: Beispiel (MIPS MDMX) MDMX: Teil von MIPS64 (64-Bit-Register) Arithmetik auf: 4 16 Bit-Vektoren 8 8 Bit-Vektoren z.b. add.ob $t0, $t1, 1 # 8 Ein-Byte-Inkrementierungen Fängt Überläufe ab, klammert auf Maximum/Minimum ( kein Überlauf) Shuffle -Befehl zur Umsortierung von Bytes Operationstypen: für alle i: v1 [i] v 2 [i] für alle i: v1 [i] v 2 [k] (k konstant) für alle i: v1 [i] k (k konstant) (wobei {+,,,...})

61 Vektoroperationen und Schleifenabwicklung unsigned short a[len];... for (int i = 0; i < len; i++) { a[i]++; }

62 Vektoroperationen und Schleifenabwicklung unsigned short a[len];... for (int i = 0; i < len; i++) { a[i]++; } li $s0, len la $t0, a L:bgt $t0, $s0, Z lh $t1, 0($t0) lh $t2, 2($t0) lh $t3, 4($t0) lh $t4, 6($t0) addi $t1, $t1, 1 addi $t2, $t2, 1 addi $t3, $t3, 1 addi $t4, $t4, 1 sh $t1, 0($t0) sh $t2, 2($t0) sh $t3, 4($t0) sh $t4, 6($t0) addi $t0, $t0, 8 b L Z:...

63 Vektoroperationen und Schleifenabwicklung unsigned short a[len];... for (int i = 0; i < len; i++) { a[i]++; } li $s0, len la $t0, a L:bgt $t0, $s0, Z lh $t1, 0($t0) lh $t2, 2($t0) lh $t3, 4($t0) lh $t4, 6($t0) addi $t1, $t1, 1 addi $t2, $t2, 1 addi $t3, $t3, 1 addi $t4, $t4, 1 sh $t1, 0($t0) sh $t2, 2($t0) sh $t3, 4($t0) sh $t4, 6($t0) addi $t0, $t0, 8 b L Z:... li $s0, len la $t0, a L:bgt $t0, $s0, Z ld $t1, 0($t0) # ld: 64-Bit-Ladebefehl add.qh $t1, $t1, 1 # 4 Halbwort- # Inkrementierungen sd $t1, 0($t0) # sd: 64 Bits zurückschreiben addi $t0, $t0, 8 b L Z:... Partielle Schleifenabwicklung ermöglicht Vektorbefehle

64 Vektoroperationen auf x86_64 Entwicklung von Vektoroperationen auf der x86-architektur: Zwei-Operanden-Befehle (a := a + b): MMX: 8 64-Bit-Register, Integer-Operationen (ähnlich MDMX) Später auf 16 Register erweitert (AMD) SSE: Bit-Register, Integer und Fließkomma Später auf 16 Register erweitert (AMD) Drei-Operanden-Befehle (a := b + c): AVX: Bit-Register Speicherbandbreite auf zwei 256-Bit-Ladeoperationen pro Zyklus erweitert

65 Zusammenfassung: Vektoroperationen SIMD: Eine Instruktion löst Berechnungen auf mehreren Datensätzen aus Einige Formen von Vektoroperationen (bitweise-und, bitweise-oder) weit verbreitet Andere Formen benötigen spezielle Hardware-Vektoroperationen: MDMX MMX SSE AVX Übersetzer verwendet (unter Anderem) Schleifenabwicklung, um automatisch zu vektorisieren

66 Nebenläufigkeit vs. Parallelität Vorgänge sind nebenläufig gdw sie unabhängig voneinander bearbeitet werden können. Vorgänge sind parallel gdw 1. Die Vorgange nebenläufig sind 2. Die Vorgänge gleichzeitig ablaufen können.

67 Nebenläufigkeit vs. Parallelität Vorgänge sind nebenläufig gdw sie unabhängig voneinander bearbeitet werden können. Vorgänge sind parallel gdw 1. Die Vorgange nebenläufig sind 2. Die Vorgänge gleichzeitig ablaufen können. Nebenläufige Ausführung: Wir erlauben dem System, Vorgänge in beliebiger Reihenfolge auszuführen (insbesondere auch gleichzeitig). Parallele Ausführung: Wir führen parallele Vorgänge gleichzeitig aus.

68 Nebenläufigkeit in C Threads: Nebenläufige Ausführung mit gleicher Seitentabelle (Adreßraum) Parallele Ausführung erlaubt, aber nicht garantiert Thread-Schnittstellen: C11-Threads POSIX threads (pthreads) (UNIX) Windows Threads

69 Nebenläufigkeit in C Threads: Nebenläufige Ausführung mit gleicher Seitentabelle (Adreßraum) Parallele Ausführung erlaubt, aber nicht garantiert Thread-Schnittstellen: C11-Threads POSIX threads (pthreads) (UNIX) Windows Threads

70 POSIX threads pthread_t t; int d =...; Haupt-Thread pthread_create(&t, NULL, f, &d); Kind-Thread void * f(void * arg){ int a = *((int *)arg); void *ergebnis pthread_join(t, &ergebnis) } return (void *) ergebnis;

71 POSIX threads pthread_t t; int d =...; Haupt-Thread pthread_create(&t, NULL, f, &d); Kind-Thread void * f(void * arg){ int a = *((int *)arg); void *ergebnis pthread_join(t, &ergebnis) } return (void *) ergebnis;

72 POSIX threads pthread_t t; int d =...; Haupt-Thread pthread_create(&t, NULL, f, &d); Kind-Thread void * f(void * arg){ int a = *((int *)arg); void *ergebnis pthread_join(t, &ergebnis) } return (void *) ergebnis;

73 Thread-Konfiguration pthread_create(&t, NULL, f, konf); Funktionszeiger (f) Daten (konf) Konfiguration mit mehreren Threads: pthread_create(&t, NULL, f, konf[0]); pthread_create(&t, NULL, f, konf[1]); pthread_create(&t, NULL, f, konf[2]); pthread_create(&t, NULL, f, konf[3]);

74 Thread-Konfiguration pthread_create(&t, NULL, f, konf); Funktionszeiger (f) Daten (konf) Konfiguration mit mehreren Threads: pthread_create(&t, NULL, f, konf[0]); pthread_create(&t, NULL, f, konf[1]); pthread_create(&t, NULL, f, konf[2]); pthread_create(&t, NULL, f, konf[3]); Gleiche Funktion mit unterschiedlichen Konfigurationen

75 Thread-Implementierung Stapel Threads teilen sich: statischen Speicher Ablagespeicher Programmspeicher Jeder Thread hat eigenen Stapelspeicher Im Voraus mit fester Größe alloziert Virtueller Adreßraum Datei Ablage.data.bss.text

76 Thread-Implementierung Stapel Threads teilen sich: statischen Speicher Ablagespeicher Programmspeicher Jeder Thread hat eigenen Stapelspeicher Im Voraus mit fester Größe alloziert Virtueller Adreßraum Stapel 1 Stapel 2 Datei Ablage.data.bss.text

77 Threads vs. Prozesse Threads P0 Prozesse fork()

78 Threads vs. Prozesse Threads Prozesse P0 fork() Elternprozeß P1 Kindprozeß

79 Threads vs. Prozesse Threads P0 Prozesse fork() P1 Stapel Datei Ablage.data.bss.text

80 Threads vs. Prozesse Threads P0 Prozesse fork() P1 Stapel Stapel Datei Kopie Datei Ablage.data.bss.text Ablage.data.bss.text

81 Threads vs. Prozesse Threads T0 T1 T2 P0 Prozesse fork() P1 Stapel Stapel Datei Datei Ablage.data.bss.text Ablage.data.bss.text

82 Threads vs. Prozesse Threads T0 T1 T2 P0 Prozesse fork() P1 Stapel Stapel 1 Stapel 2 Datei Stapel Datei Stapel Datei Ablage.data.bss.text Ablage.data.bss.text Ablage.data.bss.text

83 Threads vs. Prozesse Threads T0 T1 T2 P0 Prozesse fork() P1 Stapel Stapel 1 Stapel 2 Datei Stapel Datei Stapel Datei Ablage.data.bss.text Ablage.data.bss.text Ablage.data.bss.text

84 Zusammenfassung Nebenläufige Ausführung: Mehrere Vorgänge können in beliebiger Reihenfolge (oder auch gleichzeitig) ausgeführt werden Parallele Ausführung: Mehrere Vorgänge werden gleichzeitig ausgeführt Nebenläufigkeit im Betriebssystem: Prozesse Kindprozesse (per fork()) mit eigener Seitentabelle Threads (z.b. C11-Threads, POSIX Threads, Win32-Threads) Mehrete Threads teilen sich Seitentabelle Unabhängige Stapel im geteilten Adreßbereich

85 Trivial-Parallele Bearbeitung Trivial-parallele (embarrassingly parallel) Probleme: Zu bearbeitende Daten haben keine Daten- oder Kontrollflußabhängigkeiten Daten können einfach partitioniert werden Thread 0 Thread 1

86 Trivial-Parallele Bearbeitung Trivial-parallele (embarrassingly parallel) Probleme: Zu bearbeitende Daten haben keine Daten- oder Kontrollflußabhängigkeiten Daten können einfach partitioniert werden Thread 0 Thread 1

87 Trivial-Parallele Bearbeitung Trivial-parallele (embarrassingly parallel) Probleme: Zu bearbeitende Daten haben keine Daten- oder Kontrollflußabhängigkeiten Daten können einfach partitioniert werden Thread 0 Thread 1

88 Trivial-Parallele Bearbeitung Trivial-parallele (embarrassingly parallel) Probleme: Zu bearbeitende Daten haben keine Daten- oder Kontrollflußabhängigkeiten Daten können einfach partitioniert werden Thread 0 Thread 1

89 Trivial-Parallele Bearbeitung Trivial-parallele (embarrassingly parallel) Probleme: Zu bearbeitende Daten haben keine Daten- oder Kontrollflußabhängigkeiten Daten können einfach partitioniert werden Thread 0 Thread 1

90 Trivial-parallele Programme: Beispiel typedef struct { int start, stop; } konf_t; int proc(void *arg) { konf_t k = *((konf_t *)arg); for (int i = k.start; i < k.stop; i++) daten[i] += 1; return 0; }

91 Trivial-parallele Programme: Beispiel konf_t konf[4]; pthread_t t[4]; int pos = 0; int schritt = GROESSE / 4; for (int i = 0; i < 4; i++){ konf[i].start = pos; pos += schritt; konf[i].stop = pos; if (i == 3) konf[i].stop = GROESSE; pthread_create(t + i, NULL, proc, konf + i); } for (int i = 0; i < 4; i++) pthread_join(t[i], NULL); typedef struct { int start, stop; } konf_t; int proc(void *arg) { konf_t k = *((konf_t *)arg); for (int i = k.start; i < k.stop; i++) daten[i] += 1; return 0; }

92 Zusammenfassung Trivial-Parallele Abarbeitung: Anwendbar wenn: Daten leicht partitionierbar (Array, Hash-Abbildung,... ) Keine Abhängigkeit zwischen Daten-Partitionen Vorgehen: Bestimme Anzahl der Arbeiter-Threads Teile Daten in Partitionen Gib jedem Arbeiter-Thread eine Partition Warte, bis alle Threads fertig sind

93 Fork-Join Bearbeitung Algorithmen der Klasse Teile-und-Herrsche (divide-and-conquer) sind oft nicht trivial-parallel Algorithmus teilt Problem in kleinere Unterprobleme: Rekursion löst Unterprobleme Beispiel: Quicksort Idee: Rekursion in Threads (fork) Warten, bis alle Rekursions-Threads fertig sind (join)

94 Fork-Join Bearbeitung: Beispiel Quicksort 4 Threads

95 Fork-Join Bearbeitung: Beispiel Quicksort 4 Threads

96 Fork-Join Bearbeitung: Beispiel Quicksort 4 Threads

97 Fork-Join Bearbeitung: Beispiel Quicksort 4 Threads

98 Fork-Join Bearbeitung: Beispiel Quicksort qsort() qsort() qsort() qsort() 4 Threads

99 Zusammenfassung Fork-Join-Abarbeitung: Anwendbar wenn: Algorithmus verwendet Teile-und-Herrsche -Strategie Vorgehen: Ersetze Rekursion durch Thread-Erzeugung und Thread-join Beschränke ggf. Thread-Erzeugung auf feste Tiefe

100 Unregelmäßige Daten Nicht alle parallelen Probleme sind einfach strukturiert Alternative Strategie: Arbeitsqueue Strategie: Thread ist fertig: Thread nimmt nächstes Stück Arbeit von Queue Neues Stück Arbeit fällt an: Neue Arbeit auf Queue

101 Unregelmäßige Daten typedef struct aufgabe aufgabe_t; void berechne(aufgabe_t *a);

102 Unregelmäßige Daten typedef struct aufgabe aufgabe_t; void berechne(aufgabe_t *a); struct knoten { aufgabe_t *aufgabe; struct knoten *naechste; } *arbeitsqueue, **arbeitsqueue_ende;

103 Unregelmäßige Daten typedef struct aufgabe aufgabe_t; void berechne(aufgabe_t *a); struct knoten { aufgabe_t *aufgabe; struct knoten *naechste; } *arbeitsqueue, **arbeitsqueue_ende; aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

104 Wettlaufsituationen (1) NULL arbeitsqueue a0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

105 Wettlaufsituationen (1) NULL arbeitsqueue a0 T0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

106 Wettlaufsituationen (1) NULL arbeitsqueue a0 T0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

107 Wettlaufsituationen (1) NULL Kontextwechsel: T0 T1 arbeitsqueue a0 T0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

108 Wettlaufsituationen (1) NULL arbeitsqueue a0 T1 T0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

109 Wettlaufsituationen (1) NULL arbeitsqueue a0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; T1 T0 struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

110 Wettlaufsituationen (1) NULL arbeitsqueue a0 T1:a T1 T0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

111 Wettlaufsituationen (1) NULL arbeitsqueue a0 T1:a T1 T0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

112 Wettlaufsituationen (1) NULL Kontextwechsel: T1 T0 arbeitsqueue a0 T1:a T0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

113 Wettlaufsituationen (1) NULL arbeitsqueue T1:a a0 T0:a T0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

114 Wettlaufsituationen (1) NULL Dereferenzierung eines NULL-Zeigers arbeitsqueue T1:a a0 T0:a T0 aufgabe_t *naechste_aufgabe() { if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; return a->aufgabe; }

115 Wettlaufsituationen (2) aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

116 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T0:a T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

117 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T0:a T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

118 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T0:a T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

119 Wettlaufsituationen (2) NULL Kontextwechsel: T0 T1 arbeitsqueue a0 a1 T0:a T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

120 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T1:a T0:a T1 T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

121 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T1:a T0:a T1 T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

122 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T1:a T0:a aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; T1 T0 arbeitsqueue = a->naechste; return a->aufgabe; }

123 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T1:a T0:a T1 T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

124 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T1:a T0:a T1 T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

125 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T1:a T0:a T1 T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

126 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T1:a T0:a aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; T1 T0 arbeitsqueue = a->naechste; return a->aufgabe; }

127 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T1:a T0:a T1 T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

128 Wettlaufsituationen (2) NULL Kontextwechsel: T1 T0 arbeitsqueue a0 a1 T1:a T0:a T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

129 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 T1:a T0:a T0 aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

130 Wettlaufsituationen (2) NULL arbeitsqueue a0 a1 Gleiche Aufgabe mehrfach zurückgeliefert T1:a T0:a aufgabe_t *naechste_aufgabe() { struct knoten *a = arbeitsqueue; if (a == NULL) return NULL; arbeitsqueue = a->naechste; return a->aufgabe; }

131 Wettlaufsituationen (Bzw. kritischer Wettlauf, race condition) Ausführungsgeschwindigkeit/-Reihenfolge zweier Threads beeinflußt Programmergebnis

132 Wettlaufsituationen (Bzw. kritischer Wettlauf, race condition) Ausführungsgeschwindigkeit/-Reihenfolge zweier Threads beeinflußt Programmergebnis Möglich bei Threads (geteilter Adreßraum) Möglich bei externer Kommunikation (zwei Programme und eine Datei) Kann auch ohne parallele Ausführung auftreten, Nebenläufigkeit ist ausreichend Die bisherigen Probleme können alle schon auf single-core-prozessoren auftreten

133 Wettlaufsituationen (Bzw. kritischer Wettlauf, race condition) Ausführungsgeschwindigkeit/-Reihenfolge zweier Threads beeinflußt Programmergebnis Möglich bei Threads (geteilter Adreßraum) Möglich bei externer Kommunikation (zwei Programme und eine Datei) Kann auch ohne parallele Ausführung auftreten, Nebenläufigkeit ist ausreichend Die bisherigen Probleme können alle schon auf single-core-prozessoren auftreten Wettlaufsituation zwischen Threads T1, T2 gdw: T1 und T2 verwenden beide die Ressource v (lesend/schreibend/ausführend) T1 oder T2 modifiziert v

134 Kritische Sektionen Kritische Sektion: Code, der nur von einem Ausführungspfad gleichzeitig ausgeführt werden darf

135 Kritische Sektionen Kritische Sektion: Code, der nur von einem Ausführungspfad gleichzeitig ausgeführt werden darf Nicht-nebenläufige Ausführung muß erzwungen werden Typischerweise durch Lock-Mechanismus: lock: Wartet, bis Lock-Variable frei ist Belegt Lock-Variable unlock: Gibt Lock-Variable wieder frei... lock(); // kritische Sektion unlock();...

136 Arbeitsqueue mit Locks Locks verhindern die Probleme unserer Queue: aufgabe_t *naechste_aufgabe() { lock(); // Kritische Sektion beginnt if (arbeitsqueue == NULL) return NULL; struct knoten *a = arbeitsqueue; arbeitsqueue = a->naechste; unlock(); // Kritische Sektion endet return a->aufgabe; }

137 Zusammenfassung: Locks Zugriff auf Daten bei nebenläufiger Bearbeitung führt oft zu Wettlaufsituationen: Programmergebnis hängt von Ausführungsreihenfolge ab Subtile, schwer zu findende Bugs Vermeidung durch: Identifizierung der kritischen Sektionen Kritische Sektionen von Locks umgeben

138 POSIX-Spinlocks #include<pthread.h> Spinlock: Wartet in Schleife, bis Lock verfügbar int pthread_spin_init(pthread_spinlock_t *lock, int); Initialisiert Lock vor Verwendung (kann Speicher allozieren) int pthread_spin_destroy(pthread_spinlock_t *lock); Deinitialisiert Lock nach allen Verwendungen int pthread_spin_lock(pthread_spinlock_t *lock); Belegt Lock int pthread_spin_unlock(pthread_spinlock_t *lock); Gibt Lock frei int pthread_spin_trylock(pthread_spinlock_t *lock); Versucht, Lock zu nehmen, gibt durch Rückgabewert an ob erfolgreich

139 POSIX-Mutexes #include<pthread.h> Mutex: Wenn Lock nicht verfügbar, ruft Scheduler auf und blockiert Analoge Befehle zu spinlocks: int pthread_mutex_init(pthread_mutex_t *lock, NULL); int pthread_mutex_destroy(pthread_mutex_t *lock); int pthread_mutex_lock(pthread_mutex_t *lock); int pthread_mutex_unlock(pthread_mutex_t *lock); int pthread_mutex_trylock(pthread_mutex_t *lock);

140 Spinlock vs. Mutex Vergleich der beiden Lock-Mechanismen: Spinlock Mutex Verwendet syscall nein ja Lock schon belegt? Versuche erneut (Schleife) Scheduler: blockiert bis Mutex frei Zeit bis zum nächsten Versuch minimal beliebig lange Latenz minimal beliebig hoch Rechenzeit mit Warten verbraucht beliebig hoch minimal

141 Zusammenfassung Wettlaufsituationen: Zwei Threads verwenden gleiche Variable/Ressource v Mindestens ein Thread schreibt auf v Schutz: Kritische Sektionen von Locks umgeben(spinlocks, mutexes) spinlocks verbrauchen Rechenzeit; besser für parallele Threads mutexes rufen Betriebssystem auf; besser für große kritische Sektionen / single-core Locks nichttrivial zu implementieren: Benötigen Spezialbefehle

142 Die Speisenden Philosophen (1) Dining Philosophers Problem 5 Philosophen, 5 Reisschüsseln, 5 Eßstäbchen Philosophen wechseln ab zwischen Philosophieren und Essen

143 Die Speisenden Philosophen (1) Dining Philosophers Problem 5 Philosophen, 5 Reisschüsseln, 5 Eßstäbchen Philosophen wechseln ab zwischen Philosophieren und Essen Zum Essen braucht ein Philosoph beide Eßstäbchen

144 Die Speisenden Philosophen (1) Dining Philosophers Problem 5 Philosophen, 5 Reisschüsseln, 5 Eßstäbchen Philosophen wechseln ab zwischen Philosophieren und Essen Zum Essen braucht ein Philosoph beide Eßstäbchen Eßstäbchen verhalten sich wie Locks

145 Die Speisenden Philosophen (1) Dining Philosophers Problem 5 Philosophen, 5 Reisschüsseln, 5 Eßstäbchen Philosophen wechseln ab zwischen Philosophieren und Essen Zum Essen braucht ein Philosoph beide Eßstäbchen Eßstäbchen verhalten sich wie Locks

146 Die Speisenden Philosophen (2) Beispielalgorithmus: nimm links nimm rechts iss lege rechts ab lege links ab philosophiere

147 Die Speisenden Philosophen (2) Beispielalgorithmus: nimm links nimm rechts iss lege rechts ab lege links ab philosophiere

148 Die Speisenden Philosophen (2) Beispielalgorithmus: nimm links nimm rechts iss lege rechts ab lege links ab philosophiere

149 Die Speisenden Philosophen (2) Beispielalgorithmus: nimm links nimm rechts iss lege rechts ab lege links ab philosophiere nimm rechts blockiert: Kein Philosoph kann weitermachen Deadlock

150 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

151 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

152 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

153 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

154 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

155 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

156 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

157 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

158 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

159 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

160 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere

161 Die Speisenden Philosophen (3) Beispielalgorithmus 2: solange ich rechts nicht habe: nimm links ist rechts frei? nimm rechts sonst lege links ab iss lege rechts ab lege links ab philosophiere Muster wiederholt sich: Kein Philosoph kann weitermachen Livelock

162 Die Speisenden Philosophen (4) Oder zwei Philosophen setzen sich über die anderen hinweg: nimm links nimm rechts wiederhole: iss philosophiere

163 Die Speisenden Philosophen (4) Oder zwei Philosophen setzen sich über die anderen hinweg: nimm links nimm rechts wiederhole: iss philosophiere Unfaire Ressourcenverwendung: Verhungern (starvation)

164 Zusammenfassung Wettlaufsituationen Schutz: Kritische Sektionen von Locks umgeben(spinlocks, mutexes) Risiken bei mehreren Locks: Deadlock: Zwei (oder mehr) Threads warten auf Locks in zirkulärer Abhängigkeit Livelock: Zwei (oder mehr) Threads bewegen sich, um Deadlock zu vermeiden, machen aber keinen echten Fortschritt Starvation: Eine echte Teilmenge der Threads beansprucht alle Ressourcen, andere Threads verhungern