Moin Moin liebe Leute, willkommen zum nächsten Video zur Vorlesungsreihe Betriebssysteme.

Hier der zweite Teil vom vierten Kapitel.

Es geht weiter mit der Softwareprogrammierung der Unterbrechungsbehandlung.

Jetzt soll es gehen um den Zustand.

Wir haben im letzten Video gesagt, man muss den Zustand vor Beginn der Unterbrechungsbehandlung

irgendwie sichern, damit man ihn hinterher nach der Unterbrechungsbehandlung wieder laden

kann um an der selben Stelle im Hauptprogramm weiterzumachen.

Jetzt ist die Frage Zustandsicherung, was müssen wir dann da eigentlich alles sichern?

Die erste Idee wäre natürlich, wir müssen den Zustand vom Rechner sichern.

Der Zustand des Rechners ist aber vergleichsweise riesig.

Da gehören einmal die Sachen zu, die im Prozessor stehen, Instruction Pointer, Stack Pointer,

Rechenregister und so weiter.

Da gehört dann aber reintrittlich natürlich auch der Hauptspeicherinhalt dazu, das was

in Cashew steht, das was in den IOCarten in den Registern steht und potentiell natürlich

auch noch das was auf der Platte steht.

Und da ahnt ihr schon, bei jedem Interhub alles zu sichern?

Ne.

Also wenn ich eine Taste tippe, dass dann einmal die Festplatte kopiert werden muss,

das kann es ja irgendwie nicht sein, das dauert ja Stunden.

Ok, packen wir das von der anderen Seite an.

Wir wollen ja, dass nach der Interhub Bearbeitung unser Hauptprogramm weiter laufen kann, als

wäre nichts passiert.

Heißt, wir dürfen im Prinzip nichts verändern, was hinterher noch gebraucht wird.

Oder anders ausgedrückt, alles was wir verändern, was hinterher gebraucht wird, müssen wir

zwischen speichern und später wieder herstellen.

Und das sag ich mal, ist so die Idee.

Also wir wissen beispielsweise, wir brauchen den Instruction Pointer, wir rechnen ja an

kompletten anderen Stellen irgendwo, den müssen wir hinterher wieder restaurieren.

Das heißt, den vom Hauptprogramm, den müssen wir uns irgendwie abspeichern und hinterher

müssen wir ihn wieder laden, damit es im Hauptprogramm dann wieder weitergeht.

Stackpointer, den werden wir vermutlich auch brauchen während unseres Unterprogramms,

unserer Unterbrechungsbehandlung.

Sprich, den werden wir zwischenzeitlich zwar ändern dürfen, er muss am Ende unserer Unterbrechungsbearbeitung

aber den gleichen Wert haben.

Die Rechenregister, ja wir werden sie vermutlich ändern.

Wir wollen ja in der Unterbrechungsbearbeitung irgendwie was rechnen.

Dann müssen wir die Register vor Aufruf der eigentlichen Unterbrechungsbearbeitung irgendwie

beispielsweise auf den Stack sichern und bevor wir ins Hauptprogramm zurückkehren, müssen

wir die Register wieder restaurieren.

Das gilt für den Rest hier unten auch.

Gut, jetzt merkt man dann aber schnell, die Unterbrechungsbearbeitung liest und schreibt

vermutlich nichts auf der Platte.

Heißt, die Platte können wir einfach so lassen, wie sie ist, da brauchen wir gar nichts kopieren.

Und auch, ja gut, Caches, die sieht man ja inhaltlich ähnlich, aber Hauptspeicherinhalt,

ja Hauptspeicherinhalt dürfen wir halt nichts ändern, worauf das Hauptprogramm gerade zugreift.

So die Idee.

Gut, hier ist es die Frage, wie sichern wir und bzw. wie restaurieren wir wieder?

Da muss man zunächst einmal dann schon mal unterscheiden, nämlich die CPU sichert schon

bevor sie in die Unterbrechungsbehandlung rein springt ein Teil ihres Zustands.

Das muss sie.