Mein, mein liebe Leute, willkommen zur nächsten Video zur Erfolgsung Betriebssysteme.

In diesem Video soll es gehen weiterhin um das Kapitel Synchronisation und zwar in diesem Fall jetzt um die Prioritätsebenen.

Das soll heißen, wir gucken uns das ein bisschen formaler mal an, wie Interamts abgearbeitet werden und wie da die Konsistenzsicherung passieren kann.

Also der sogenannte Prioritätsebenenmodell, was ist das? Folgende Idee.

Wir haben hier, jetzt mal grafisch dargestellt, zwei verschiedene Ebenen, nämlich die Anwendungsebene, hier so ein bisschen bläulich und die Unterbrechungsebene, in diesem Fall ein bisschen rötlich.

Was sind so die Eigenschaften? Ja die Eigenschaften von der Ebene E0 der Anwendungsebene ist, dass diese Anwendungsebene praktisch jederzeit unterbrochen werden kann durch die drunter liegende Schicht der Interamts.

Umgekehrt die E1-Ebene, da sagen wir jetzt, die ist nicht unterbrechbar, wenn ein Interapt läuft, wissen wir, dann hat die CPU ja vorher die Interapt-Annahme, die weiteren Interaps, verunterbunden.

Das heißt, der Interapt-Händler läuft von Anfang bis Ende durch, der ist nicht unterbrechbar. Haben wir im letzten Video gesagt, das ist die RANTO-Completion-Semantik.

RANTO-Completion-Semantik, noch mal vielleicht ein bisschen genauer, hier grafisch mal dargestellt, wenn ein Interapt läuft, der hat die Anwendungsebene unterbrochen.

Er selber wird aber nicht unterbrochen, selbst wenn jetzt kurz, also während er läuft, kurz danach ein weiterer Interapt signalisiert wird von der Hardware.

Der Interapt hier, der wird verzögert, der wird erst angenommen, wenn die erste Interapt-Abarbeitung erledigt ist.

Also, wenn die Interapt-Abarbeitung mal gestartet ist, RANTO-Completion-Semantik, die läuft bis zum Ende ab, gegebenenfalls sequenziell danach kommt dann halt der nächste Interapt dran.

Jetzt kann man sich fragen, wenn jetzt zwei Interaps exakt gleichzeitig signalisiert werden, wer kommt denn dann dran? Was ist denn da die Strategie?

Denkt euch irgendeine aus, da sind verschiedene möglich.

FIFO im Sinne First In, First Out, da haben wir aber nicht genau weiß, welches ist jetzt der erste.

Da kann man den Prioritäten zuweisen, hatten wir uns schon mal überlegt, man kann sie auch zufällig abarbeiten, ist im Prinzip für das Modell jetzt erst einmal egal.

In der Praxis wird es immer so sein, dass man natürlich irgendwie einen Interapt-Controller hat und der Interapt-Controller muss letztendlich dann hardwaremäßig entscheiden, welcher Interapt als nächstes dran kommt.

Gut, das sind die Ebenen, das ist die RANTO-Completion-Semantik.

Jetzt können Fäden, Kontrollflüsse, Ebenen auch wechseln. Wir haben gesagt, auf der unteren Ebene sind wir nicht unterbrechbar, haben wir eine RANTO-Completion-Semantik.

Das heißt, wenn jetzt das Anwendungsprogramm ein CLEAR aufruft, CLEAR INTERAPT ENABELBIT, dann ist das Anwendungsprogramm ja nicht mehr unterbrechbar, heißt der Kontrollfluss wechselt sozusagen auf die Interapt-Ebene.

Da haben wir jetzt nämlich die gleiche Semantik, wir sind nicht mehr unterbrechbar, wie das hier in dieser Ebene halt so ist, und wir haben die RANTO-Completion-Semantik.

RANTO-Completion, also bis zum STI, werden wir nicht mehr unterbrochen.

Wechselt jetzt der Anwendungsfaden mit STI wieder zurück auf seine Anwendungsebene, dann schlagen natürlich jetzt wiederum die dann anhängigen Interaps durch.

Wenn in der Zwischenzeit ein Interapt signalisiert wurde, dann wird der ABDAN abgearbeitet. Also auch hier haben wir wieder diese Sequenzialisierung in der Interapt-Ebene.

Das Ganze kann man noch ein bisschen verallgemeinern, muss gegebenenfalls nicht nur zwei Ebenen geben.

Jetzt hier im Beispiel, es könnten auch drei sein, oder wir haben neulich das Beispiel Motorola angeguckt, da kann der Interapt-Controller sieben verschiedene Ebenen plus keinen Interapt melden, also da wird es dann acht Ebenen geben.

Hier im Beispiel drei Ebenen, wie sind die gedacht? Ja, jeweils eine tiefere Ebene kann eine höhere unterbrechen.

Ihr seht hier das Beispiel, die unterste Ebene kann alles andere unterbrechen. Die Ebene eins kann die Anwendung unterbrechen, kann aber selber wiederum unterbrochen werden von der Ebene zwei.

Das ist jetzt so ein bisschen die Verallgemeinerung. Wenn wir sagen, wir sind auf Ebene L, dann können wir jederzeit unterbrochen werden durch Kontrollflüsse in unteren Ebenen.

Wir können von unten jederzeit unterbrochen werden. Wir können wiederum nie unterbrochen werden durch Kontrollflüsse höherer Ebenen und auch nicht durch die eigene Ebene.

Also wenn unser Interapt läuft, dann wird er nicht unterbrochen von der gleichen Ebene. Und innerhalb der Ebene, haben wir gesagt, wird alles sequenzialisiert.

Und auch hier natürlich wieder, wir müssen die Ebenen wechseln können. Die Anwendung kann zum Beispiel auf Ebene eins wechseln, in dem Moment, wo sie einfach in ihrem Statusregister diesen Interapt Level auf einsetzt.

Dann werden alle gedisabled ab dieser Ebene.

Gut, was hat das jetzt mit der Konsistenzsicherung zu tun? Das ist doch eigentlich das, was wir machen wollen.

Ja, stellt euch vor, und das machen wir jetzt im folgenden immer. Wir weisen jeder Zustandsvariable, oder jedem Zustand allgemein, eine Ebene zu.

Das steht jetzt im Programm in dem Sinne nicht drin. Gedanklich erst einmal.

Dann sollte klar sein, wenn wir das der Ebene L zuordnen und wir sind vom Kontrollfluss aus in der Ebene L, dann haben wir kein Problem.

Weil in der Ebene L werden wir ja nicht unterbrochen. Die Ebene L unterbricht sich selber nicht.

Das heißt, wenn wir aus der Ebene L heraus auf unseren Zustand zugreifen, ist alles paletti. Kann nichts passieren.

Das sieht ein bisschen anders aus, wenn wir aus höheren, bzw. tieferen Ebenen kommen.

Gut, da gibt es jetzt zwei Varianten. Kommen wir aus einer höheren Ebene.

Dann haben wir gesehen, können wir mit harter Synchronisation was erreichen.

Wir schalten einfach die Interrupts aus. Dadurch wechseln wir dann implizit auf die Ebene L.

Dann sind wir in der Ebene L, dann haben wir das so ähnlich wie hier oben. Dann haben wir die Rante Completion Semantik in der Ebene.

Dann können wir dann wieder auf den Zustand einwandfrei zugreifen. Dann kein Problem mehr. Ist ja alles sequentialisiert.

Oder, das wäre jetzt die letzte Möglichkeit, wir sind jetzt nicht auf der gleichen Ebene. Wir kommen nicht von der höheren Ebene.

Sondern wir kommen von unten. Und das, sag ich mal, ist das Problem.

Das werden wir uns im folgenden Video noch mal genauer angucken.

Das ist das, was man dann als sogenannte weiche Synchronisation bezeichnet.

Was muss man da machen? Da muss man letztendlich Algorithmen finden, die, wenn sie parallel ablaufen, trotzdem nicht den Zustand kaputt machen.