Übung zu Betriebssysteme

Transkript

1 Übung zu Betriebssysteme Interruptsynchronisation 22. & 24. November 2017 Andreas Ziegler Bernhard Heinloth Lehrstuhl für Informatik 4 Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl für Verteilte Systeme und Betriebssysteme

2 Motivation Interrupts verändern (potenziell) den Zustand des Systems

3 Motivation Interrupts verändern (potenziell) den Zustand des Systems main(){ } consume(); IRQ_handler(){ } produce();

4 Keine Synchronisation main() E 0 (Anwendung) (IRQ)

5 Keine Synchronisation main() consume() E 0 (Anwendung) (IRQ)

6 Keine Synchronisation main() consume() E 0 (Anwendung) (IRQ)

7 Keine Synchronisation main() consume() E 0 (Anwendung) produce() (IRQ)

8 Keine Synchronisation main() consume() E 0 (Anwendung) produce() (IRQ)

9 Keine Synchronisation Was ist mit int buf[size]; int pos = 0; void produce(int data) { if (pos < SIZE) buf[pos++] = data; } int consume() { return pos > 0? buf[--pos] : -1; }?

10 Keine Synchronisation Was ist mit int buf[size]; int pos = 0; void produce(int data) { if (pos < SIZE) buf[pos++] = data; } int consume() { return pos > 0? buf[--pos] : -1; }? Hier ist ein Lost Update möglich!

11 bewährtes Hausmittel: Mutex void produce(int data) { mutex.lock(); if (pos < SIZE) buf[pos++] = data; mutex.unlock(); } int consume() { mutex.lock(); int r = pos > 0? buf[--pos] : -1; mutex.unlock(); return r; }

12 bewährtes Hausmittel: Mutex Verklemmt sich!

13 weiche Synchronisation void produce(int data) { if (pos < SIZE) buf[pos++] = data; } int consume() { int x, r = -1; if (pos > 0) do { x = pos; r = buf[x]; } while(!cas(&pos, x, x-1)); return r; }

14 weiche Synchronisation Optimistischer Ansatz + keine Interruptsperre + kann sehr effizient sein kein generischer Ansatz kann sehr kompliziert werden fehleranfällig

15 weiche Synchronisation Optimistischer Ansatz + keine Interruptsperre + kann sehr effizient sein kein generischer Ansatz kann sehr kompliziert werden fehleranfällig Betriebssystemarchitekt sollte Treiber- und Anwendungsentwicklern entgegenkommen für Erfolg des Betriebsystems entscheidend

16 harte Synchronisation main() E 0 (Anwendung) (IRQ)

17 harte Synchronisation main() cli E 0 (Anwendung) (IRQ)

18 harte Synchronisation main() cli E 0 (Anwendung) consume() (IRQ)

19 harte Synchronisation main() cli E 0 (Anwendung) consume() (IRQ)

20 harte Synchronisation main() cli sti E 0 (Anwendung) consume() (IRQ)

21 harte Synchronisation main() cli sti E 0 (Anwendung) consume() produce() (IRQ)

24 harte Synchronisation ignoriert main() cli sti E 0 (Anwendung) consume() produce() (IRQ)

25 harte Synchronisation ignoriert* main() cli sti E 0 (Anwendung) consume() produce() (IRQ) * vereinfachte Darstellung und nicht ganz korrekt: genaugenommen kann der LAPIC maximal zwei Unterbrechungen des selben Vektors speichern.

26 harte Synchronisation Pessimistischer Ansatz + einfach + funktioniert immer Verzögerung von IRQs hohe Latenz, ggf. Verlust von Interrupts blockiert pauschal alle IRQs

27 Prolog/Epilog-Modell

28 Idee Aufspalten der IRQ-Behandlung in Prolog erledigt das Nötigste auf Epilog läuft auf neuer Ebene 1 2 und übernimmt Synchronisation / IRQs wieder frei

29 Idee Aufspalten der IRQ-Behandlung in Operationen Prolog erledigt das Nötigste auf Epilog läuft auf neuer Ebene 1 2 und übernimmt Synchronisation / IRQs wieder frei höhere Ebene betreten: cli höhere Ebene verlassen: sti niedrigere Ebene unterbrechen: IRQ-Leitung bei harter Synchronisation

30 Idee Aufspalten der IRQ-Behandlung in Operationen Prolog erledigt das Nötigste auf Epilog läuft auf neuer Ebene 1 2 und übernimmt Synchronisation / IRQs wieder frei höhere Ebene betreten: cli, enter höhere Ebene verlassen: sti, leave niedrigere Ebene unterbrechen: IRQ-Leitung, relay bei harter Synchronisation und Prolog/Epilog-Modell

31 Prolog/Epilog-Modell main() E 0 (Anwendung) 2 (Epilog) (IRQ/Prolog)

32 Prolog/Epilog-Modell main() enter E 0 (Anwendung) 2 (Epilog) (IRQ/Prolog)

33 Prolog/Epilog-Modell main() enter E 0 (Anwendung) 2 (Epilog) (IRQ/Prolog)

34 Prolog/Epilog-Modell main() enter E 0 (Anwendung) 2 (Epilog) leave (IRQ/Prolog)

37 Prolog/Epilog-Modell main() enter E 0 (Anwendung) 2 (Epilog) leave prolog (IRQ/Prolog)

38 Prolog/Epilog-Modell main() enter E 0 (Anwendung) epilog 2 (Epilog) leave leave prolog (IRQ/Prolog) relay

39 Prolog/Epilog-Modell main() enter E 0 (Anwendung) epilog 2 (Epilog) leave leave prolog (IRQ/Prolog) relay

40 Prolog/Epilog-Modell Kombinierter Ansatz + einfaches Programmiermodell (für Anwendungsentwickler) + geringer Interruptverlust Ebene 1 2 ist zusätzlicher Overhead etwas mehr Arbeit für den Betriebssystemarchitekten

41 Prolog/Epilog-Modell Kombinierter Ansatz + einfaches Programmiermodell (für Anwendungsentwickler) + geringer Interruptverlust Ebene 1 2 ist zusätzlicher Overhead etwas mehr Arbeit für den Betriebssystemarchitekten guter Kompromiss

42 Umsetzung main(){ enter(); consume(); leave(); } epilog(){ } produce();

43 Umsetzung main() E 0 (Anwendung) 2 (Epilog) (IRQ/Prolog)

44 Umsetzung main() enter E 0 (Anwendung) 2 (Epilog) (IRQ/Prolog)

45 Umsetzung main() enter E 0 (Anwendung) consume() 2 (Epilog) (IRQ/Prolog)

46 Umsetzung main() enter E 0 (Anwendung) consume() 2 (Epilog) (IRQ/Prolog)

47 Umsetzung main() enter E 0 (Anwendung) consume() 2 (Epilog) prolog (IRQ/Prolog) relay

48 Umsetzung main() enter E 0 (Anwendung) consume() 2 (Epilog) enqueue prolog (IRQ/Prolog) relay

49 Umsetzung main() enter E 0 (Anwendung) consume() 2 (Epilog) leave enqueue prolog (IRQ/Prolog) relay

50 Umsetzung main() enter E 0 (Anwendung) produce() 2 (Epilog) consume() leave leave enqueue prolog (IRQ/Prolog) relay

51 Umsetzung main() enter E 0 (Anwendung) produce() 2 (Epilog) consume() leave leave enqueue prolog (IRQ/Prolog) relay

52 Aufgabe

53 Wechsel von harter Synchronisation zu Prolog/Epilog-Modell

54 Wechsel von harter Synchronisation zu Prolog/Epilog-Modell Was wird gebraucht?

55 Wechsel von harter Synchronisation zu Prolog/Epilog-Modell Was wird gebraucht? List/Queue zum Einreihen der Epiloge Guard mit enter(), leave() und relay() für Prioritätsebenen

56 Wechsel von harter Synchronisation zu Prolog/Epilog-Modell Was wird gebraucht? List/Queue zum Einreihen der Epiloge Guard mit enter(), leave() und relay() für Prioritätsebenen Was muss angepasst werden?

57 Wechsel von harter Synchronisation zu Prolog/Epilog-Modell Was wird gebraucht? List/Queue zum Einreihen der Epiloge Guard mit enter(), leave() und relay() für Prioritätsebenen Was muss angepasst werden? Keyboard Application Guardian

58 Wechsel von harter Synchronisation zu Prolog/Epilog-Modell Was wird gebraucht? List/Queue zum Einreihen der Epiloge Guard mit enter(), leave() und relay() für Prioritätsebenen Was muss angepasst werden? Keyboard Application Guardian alles was hart synchronisiert

59 Aufgabenstellung Warteschlange gegeben

60 Aufgabenstellung Warteschlange gegeben, Implementierung ist allerdings nicht unterbrechungstransparent benötigt Schutz vor Unterbrechungen im Guard oder durch Modifikation der Queue selbst

61 Aufgabenstellung Warteschlange gegeben, Implementierung ist allerdings nicht unterbrechungstransparent benötigt Schutz vor Unterbrechungen im Guard oder durch Modifikation der Queue selbst Gate muss geändert werden (trigger() zu prolog() und epilog())

62 Aufgabenstellung Warteschlange gegeben, Implementierung ist allerdings nicht unterbrechungstransparent benötigt Schutz vor Unterbrechungen im Guard oder durch Modifikation der Queue selbst Gate muss geändert werden (trigger() zu prolog() und epilog()) jede Gate-Instanz darf nur einmal in der Epilogwarteschlange vorkommen

63 MPStuBS

64 Prolog/Epilog-Modell auf Mehrkernprozessoren jeder Kern hat eine eigene Epilogwarteschlange (damit die Epiloge auf dem selben Kern wie deren zugehörige Prologe ausgeführt werden)

65 Prolog/Epilog-Modell auf Mehrkernprozessoren jeder Kern hat eine eigene Epilogwarteschlange (damit die Epiloge auf dem selben Kern wie deren zugehörige Prologe ausgeführt werden) Zu jedem Zeitpunkt darf maximal ein Kern Epiloge ausführen

66 Prolog/Epilog-Modell auf Mehrkernprozessoren jeder Kern hat eine eigene Epilogwarteschlange (damit die Epiloge auf dem selben Kern wie deren zugehörige Prologe ausgeführt werden) Zu jedem Zeitpunkt darf maximal ein Kern Epiloge ausführen E E 2 0 E E E 2 1 E 3 1

67 Prolog/Epilog-Modell auf Mehrkernprozessoren jeder Kern hat eine eigene Epilogwarteschlange (damit die Epiloge auf dem selben Kern wie deren zugehörige Prologe ausgeführt werden) Zu jedem Zeitpunkt darf maximal ein Kern Epiloge ausführen E E 2 0 E E E 2 1 E 3 1 Verwendung eines big kernel lock (BKL)

68 Prolog/Epilog-Modell auf Mehrkernprozessoren jeder Kern hat eine eigene Epilogwarteschlange (damit die Epiloge auf dem selben Kern wie deren zugehörige Prologe ausgeführt werden) Zu jedem Zeitpunkt darf maximal ein Kern Epiloge ausführen E E 2 0 E E E 2 1 E 3 1 Verwendung eines big kernel lock (BKL) korrekte Sperrreihenfolge ist extrem wichtig!

69 Beispiel für Mehrkernprozessoren CPU 1 CPU 0 E 0 2

76 Beispiel für Mehrkernprozessoren CPU 1 CPU 0 E 0 CPU 0 2

80 Beispiel für Mehrkernprozessoren CPU 0 CPU 1 CPU 1 CPU 0 E 0 2

88 Fragen? Nächste Woche (29. November & 1. Dezember) Abgabe von Aufgabe 2 im Huber-CIP