Mein, mein liebe Leute, nächstes Video zum Kapitel Unterbrechung, Synchronisation in Sachen

Betriebssysteme. Diesmal wollen wir uns angucken, das sogenannte Prolog-Epilog-Modell. Ja, das ist so

eine weitere Methode, wie man es interruptsynchronisieren kann, nach den harten und weichen Synchronisierereien,

die wir uns im letzten Video angeguckt haben. Ja, was ist jetzt das Prolog-Epilog-Modell?

Gucken wir uns den Ansatz an, implementieren wir den und gucken, wie gut der dann wohl

funktioniert. Ja, ganz kurz zurück, wie war das mit der harten Synchronisation? Wir haben

den gemeinsamen Zustand von Anwendungen und Interapt-Händler auf die jeweils untere Ebene

gelegt und haben dann mit Kli uns die synchronisiert. Hauptproblem war die Hohe Latenz. Was heißt

Hohe Latenz? Hohe Latenz heißt, ja hier wird der Interapt signalisiert zu diesem Zeitpunkt,

aber er wird nicht angenommen, nicht ausgeführt, weil beispielsweise hier das Anwendungsprogramm

vorher ein Kli aufgerufen hat und ja wird verzögert, bis das Hauptprogramm ein Stie aufruft,

also die Zeit vergeht und dann natürlich zusätzlich noch die Zeit, die das in diesem

Falle Produce dann selber noch braucht. Also das sind die zwei Verzögerungsteile. Der erste Teil

bedingt durch das Kli-Stie und der zweite Teil bedingt durch die eigentliche Interapt-Aberbeitung

selbst. Ja und die Latenz, also die Zeit, die vergeht vom Signalisieren des Interapts bis zum

Ende der Bearbeitung, die soll diese Latenz, die soll klein sein. Wie kriegen wir das hin? Ja,

folgende Idee. Ihr erinnert euch an die Videos zum Software-Q Teil. Hier machen wir es so ähnlich.

Wir führen eine weitere Ebene jetzt ein und wir haben jetzt einen hardwareabhängigen Teil unserer

Interapt-Bearbeitung. Das ist dann der sogenannte Prolog und dahin anhängig haben wir noch den

Epilog. Ihr erinnert euch an diese Zweiteilung bei den Software-Qs. Also wir machen erstmal das,

was die Hardware unbedingt erfordert. Im Beispiel war es immer, wir holen das Zeichen von Tastaturcontroller

ab und schmeißen es schnell in irgendeinen kleinen Buffer. Dann schalten wir die Interaps wieder ein.

Wir gehen eine Ebene hoch und dann verarbeiten wir das Zeichen. Wir holen es aus dem Minibuffer

wieder raus, rechnen das ASCII-Zeichen daraus, malen es auf dem Bildschirm und so weiter.

Ja, also ihr seht hier auch da malen wir eigentlich schon so diese zwei Ebenen. Interapts aus,

Interapts an. Die Idee ist dann, dann haben wir unseren Buffer auf sozusagen der Ebene zwischen

Ebene 0 und Ebene 1. Wir sind jetzt ja nicht im Anwendungskontext, wir sind aber auch nicht

mehr im Interapt-Kontext. Der Interapt-Kontext ist ja vorbei, wenn wir das Zeichen vom Tastaturcontroller

abgeholt haben. Danach schalten wir die Interaps wieder an. Das heißt wir sind raus aus der Interapt-Ebene.

Das ist das neue. Wir haben hier eine zusätzliche Ebene zwischen Interapt- und Anwendungsebene gelegt.

Die Ebene, die wird jetzt in Folge Epiloguebene genannt. Das ist die, in der dann das Allermeiste

abgehandelt wird. Also die Produce-Funktion wird in diese Ebene was in den Buffer reinlegen. Ja und

die Consume-Methode, die dann aus E0 heraus aufgerufen wird, die wird aber auch erst aufgerufen,

nachdem das E0 in die Ebene E1 ½ gewechselt ist. Gut, also die Unterbrechungsbehandlung,

die wird immer zweigeteilt. Haben wir schon bei den Software-Qs gesehen. Hier heißen die

Dinger jetzt Prolog und Epilogue, die zwei Teile. Also wir haben einen Prolog, da handelt es mit der

Hardware aus und wir haben einen Epilogue, der macht den Teil, naja was die Software halt noch so alles

tun muss. Prolog, so die Idee, läuft auf Hardware-Unterbrechungsebene, hat Priorität

über die Anwendungsebene und auch, ihr habt ja gesehen, liegt unterhalb der Epiloguebene, hat

also auch Priorität gegenüber der Epiloguebene. Also Prolog können jederzeit laufen, egal ob der

Faden in der Anwendungs- oder Epiloguebene ist. Die Idee der Prolog soll kurz sein, also der soll,

wenn es irgendwie geht, ganz zeitlich gesehen kurz laufen. Er holt sich nur aus der Hardware

irgendwie Kleinigkeiten, schreibt die irgendwo hin und bestätigt, dass das Zeichen abgeholt worden

ist und fertig. Das heißt dann im Umkehrschluss, dass die Unterbrechungen nur sehr kurz gesperrt

bleiben, damit auch die Latenz letztendlich minimiert wird. Die Verarbeitung geht damit nicht

schneller, aber bis die Verarbeitung anfängt, die Zeit diminieren wir. Und der Prolog, mal gesehen,

also wenn es dann was zu verarbeiten gibt, wird ein Epilogue angefordert. Ihr erinnert euch an

das SoftIRQ Prinzip, dann können wir einen Epilogue oder einen SoftIRQ triggern und der macht dann den

Rest. Der Epilogue, der läuft jetzt auf der Epiloguebene und die liegt jetzt zwischen

Anwendungsebene und Interruptebene. Ausführung logisch jetzt verzögert zum Prolog. Erstmal läuft