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

Heute soll es gehen in diesem Video um die Fadenverwaltung, in diesem Fall um

Betriebssystem Fäden. Wenn wir unseren Burger hier angucken, ihr wisst es noch, es geht jetzt

hier um die letztendlich Prozessverwaltung. Das soll unser Agenda sein. Gucken wir uns

im ersten Schritt mal an die Betriebssystem Fäden. Was war das noch? Ja, ihr erinnert euch an die

letzten Videos, da haben wir gesagt, oder wir haben uns definiert, erst einmal Coroutine und die Idee

war jetzt für jede Anwendung im Betriebssystem eine Coroutine zu starten. Also wenn jetzt am

Beispiel Unix oder so ein Fork Aufruf kommt, dann kreieren wir einfach im Betriebssystem so einen

neuen Stack mit so einem Fortsetzungsobjekt drauf, sprich wir haben eine neue Coroutine.

Coroutinenwechsel passiert dann letztendlich immer durch einen Systemaufruf, entweder durch

einen expliziten. Also die meisten Betriebssysteme kennen irgendwie so einen Aufruf namens Resume oder

Heald oder so ähnlich oder werden wir auch noch sehen durch einen impliziten Systemaufruf,

nämlich Time-Matics. Der Vorteil davon ist klar, also dann kann man seine Anwendung einfach voneinander

unabhängig entwickeln. Das Betriebssystem kümmert sich darum, dass jede Anwendung dann

eine Coroutine zugeteilt kriegt. Unabhängig insofern schön, also ich muss nicht wissen,

wenn ich mein Programm entwickle, welche Anwendungen parallel laufen werden. Hat man bei den

Coroutinen gesehen, wenn ich einen Resume aufrufe, muss ich an sich als Parameter angeben, welche

andere Coroutine gestartet werden soll. Wenn ich nicht weiß, welche anderen Coroutinen parallel

laufen, kann ich diesen Parameter nicht angeben. Deshalb werden wir jetzt die Ablaufplanung

letztendlich auch zentral implementieren. Wenn das Betriebssystem alle Coroutinen selber anlegt,

kann sich da irgendwie Listen anlegen dazu, welche Coroutinen es gibt und kann sich dann

überlegen bei einem Resume, ja, welche Coroutine soll denn als nächstes mal laufen. Netter

Nebeneffekt, ihr kennt eine Ausgaben, ihr wisst bei einer Ausgabe muss man häufiger mal die Anwendung

irgendwie blockieren. Beispielsweise Anwendung möchte von Tastatur ein Zeichen haben, Taste wurde

aber noch nicht gedrückt, dann muss man die Coroutine, den Faden, den Prozess irgendwie mal

blockieren, bis eine Taste gedrückt wurde. Ja, was heißt das jetzt im Rahmen von Coroutinen?

Wenn das laufende Programm merkt, es will von Tastatur ein Zeichen lesen, da ist kein Zeichen,

dann ruft es einfach ein Resume auf. Dann wird das Resume sich einen anderen Prozess schnappen und

den weiter rechnen. Ja, und die Funktion, die Anwendung, die jetzt von Tastatur was lesen wollte,

die sieht dann sozusagen blockiert aus. Die rechnet dann einfach nicht wieder. Und später

können wir logischerweise entsprechend wieder zurück switchen. Wenn ein Tastendruck da war,

ja dann können wir mit einem Resume entsprechend wieder unsere vorher blockierte Coroutine weiter

laufen lassen. Was wir immer gerne hätten, habe ich schon angedeutet, ist so ein Preemption

Mechanismus. Den gucken wir uns noch genauer an. Wie schaffen wir das einfach? Also wir haben hier

oben gesagt, bei einem Systemaufruf kann man natürlich von einer Anwendung zunächst wechseln.

Es könnte ein Systemaufruf, Resume oder Heal oder so geben. Das müsste aber natürlich kooperativ

passieren. Wenn die Anwendungen irgendwie nicht kooperativ sind, dann wollen wir sie zwangsweise

kooperativ machen. Also wir machen so eine Art Preemption. Gucken wir uns auch gleich noch an.

Jo, wie schaut das aus? Also ihr kennt diese Diagramme. Gehen wir es mal eine Reihe nach

durch. Also wir brauchen eine elementare Operation, irgendwie so ein Schedule. Heißt, wir wollen die

allererste Anwendung starten. Da werdet ihr merken, wenn ihr sowas implementiert, das ist irgendwie

so ein bisschen komisches Gefummel. Das ist irgendwie sowas einmalig besonderes. Ihr müsst

einmal irgendwie schaffen, den allerersten Faden zu starten, die allererste Koroutine. Jo und wenn

ihr einmal das allererste Mal geschafft habt, eine zu starten, dann ist es typischerweise nicht mehr

so schwer, bei einem Resume von einer Anwendung zunächst zu wechseln. Diesen Kontextwechsel von

einer Koroutine zur nächsten haben wir uns letztes Mal hier angeguckt. In diesem Fall jetzt ist das

Resume jetzt allerdings parameterlos typischerweise. Die Anwendung hier, die sagt einfach nur,

ein anderer Prozess soll mal dran, andere Koroutine, welche ist im Prinzip egal. Beim nächsten Resume

irgendeiner. Die Frage ist dann, welche Koroutine stattdessen laufen soll. Das ist die sogenannte

Scheduling-Entscheidung. Wir müssen uns aus der Liste der Koroutine halt eine Koroutine rauspicken.