Gibt es Fragen?

Keine Fragen?

Okay, dann geht es weiter, da wo wir letzte Woche aufgehört haben.

Also Frage war, wie kriegen wir das hin, dass letztendlich Prozesse von einer CPU, ich sag

mal quasi gleichzeitig abgearbeitet werden.

Ihr wisst alle, sie werden immer häppchenweise abgearbeitet.

Erst die erste Applikation, eine Millisekunde, dann kommt die nächste dran.

Und damit sie sich nicht gegenseitig stören, dürfen sie an sich in ihrem normalen Ablaufmodus

mehr oder weniger nichts.

Sie dürfen rechnen und das war's.

Wenn sie was wollen, müssen sie halt einen Systemcall machen, dann sind sie im privilegierten

Modus, wir haben gesagt, das ist nichts anderes als ein Unterprogrammaufruf, allerdings mit

dieser Rechtererweiterung.

Dann können sie irgendwas hochdringend Wichtiges machen, MMU umprogrammieren, I.O. machen usw.

und wenn sie damit fertig sind, geht es halt weiter.

Wenn natürlich jetzt über den Systemcall Vector eine Rechtererweiterung gemacht wird,

dann ist klar, dann darf der Exception oder Systemcall Vector nicht irgendwo hin zeigen.

Darf auch nicht vom Benutzerprogramm veränderbar sein.

Wenn ich über den Exceptionhändler meine Rechtererweiterung kann und ich könnte jetzt

sagen, wo ich hinspringen will, dann hätte ich eine Rechtererweiterung und könnte machen,

was ich will.

Also, wie macht man das heutzutage? Im Prinzip so, dass man einfach sagt, die Interrupt

Exception Systemcall Vektoren, die müssen irgendwie geschützt liegen.

Standardmäßiges Verfahren heutzutage, die liegen einfach im Speicher irgendwo und der

Speicher ist letztendlich wie der Speicher von anderen Applikationen auch für meinen

Userprozess nicht zugänglich.

MMU.

Jo, dann haben wir gesagt, jeder Prozess braucht die CPU, braucht sie, aber alle gleichzeitig

geht nicht, also Häppchen für Häppchen, immer der Reihe nach.

Wie machen wir das?

So, von der Idee her, wir haben eine Endlosschleife in unserem normalerweise Betriebssystem.

Das Betriebssystem macht nichts anderes als den Inhalt der Register vom ersten Prozess

zu laden.

Der erste Prozess läuft eine Weile und nach einer Minute Sekunde oder so hört jetzt die

Arbeit auf und dann speichern wir den aktuellen Zustand vom Prozess 1, also den aktuellen

Zustand, der sich letztendlich durch die Register definiert, wieder irgendwo hin.

Was machen wir dann mit dem Prozess 2, mit dem Prozess 3 und so weiter, bis wir am Ende

angekommen sind und wenn irgendwas noch nicht fertig ist, fangen wir halt oben wieder an.

Jo, das erste, das kann man ein bisschen vereinfachen, dass man sagt, das sieht ja für alle Prozesse

im Prinzip gleich aus, dann sagt man halt das ladende Register vom Prozess 1.

Ja, der erste Prozess, also standardmäßig in der Linux-Unix-Welt ist der Innenprozess.

Die Register in dem Sinne werden gar nicht geladen, der Rechner läuft halt los, CPU läuft

los und dann hat sie irgendeinen Registerinhalt.

Jo, und danach wird dann eigentlich immer nur noch der aktuelle Registerinhalt abgespeichert

von dem jetzt gerade laufenden Prozess und die Register vom nächsten Prozess werden

geladen und fertig.

Und das jetzt in einer Endlosschleife.

Jo, und die zwei, also das Abspeichern der aktuellen Register und das Laden vom nächsten,

das kann man dann zusammenfassen, das ist dann standardmäßig im Betriebssystem immer

die Schedule-Funktion.