Guten Morgen. Willkommen zur heutigen Systemprogrammierungsvorlesung. Nachdem

wir uns in den letzten zwei Wochen ja mit dem Thema Prozesse und Scan crunch

beschäftigt hatten eigentlich stoolte es in diesem Zyklus.

Ich habe es jetzt aber nicht mitgebracht die entsprechenden Folien, wir werden es

jetzt noch auf die Webseite stellen und ich bringe sie dann nächste Woche auch

noch als Ausdruck mit. Es ist noch ein Kapitel drin, vorgesehen gewesen zu

ursprünglich, wo es um die Umschaltung zwischen Prozessen geht. Das Problem mit

dem Prozessumschaltungskapitel ist allerdings, also erstens mal von der

gesamten Zeitplanung, seit wir die Systemprogrammierung in die zwei Teile

unterteilt haben, passt es uns nicht mehr so richtig gut rein.

Und das andere war dann auch immer, also wenn ich dieses Prozessumschaltungskapitel

jetzt hier im Rahmen dieser Grundstudiums- oder Drittsemesterveranstaltung gelesen habe,

habe ich immer so zwischen uns so das Gefühl gehabt, naja, ich meine, das ist alles interessant

und aus Betriebssystemsicht natürlich, aber mein Gott, warum erzähle ich das jetzt den Leuten

hier in dieser Grundstudiumsveranstaltung oder in der dritten Semesterveranstaltung?

Es ist von der Komplexität her einfach doch ein ganzes Ende tiefgehend und ich denke,

diese Fragestellung, wie baut man wirklich so eine Umschaltung zwischen Prozessen oder

Zwets ist in unserer Betriebssystemevorlesung, die Sie ja ab dem 5. Semester, wenn Sie sich

da vertiefen wollen, hören können, deutlich besser aufgehoben und deswegen haben wir es

jetzt hier ausgeklammert.

Den Foliensatz gibt es nach wie vor, wenn es dann interessiert, wir stellen ihn jetzt

noch zur Verfügung, können Sie da mal reingucken.

Und unabhängig davon denke ich, können wir jetzt momentan mal davon ausgehen, das Betriebssystem

enthält Mechanismen, wie man von einem Prozess auf den anderen umschaltet und das soll jetzt

im Rahmen dieser Veranstaltung noch so ein kleines Geheimnis bleiben, wie man das wirklich

macht.

Soviel kann ich zumindest sagen, also in C können Sie das nicht mehr programmieren,

also da hört es dann wirklich auf, das ist dann halt so Registergefummelt, wo man eben

irgendwelche Rücksprungadressen und Stackpointer und solche Sachen eben geeignet verdreht

und sichert und restauriert und auf die Weise bekommt man sowas dann eben hin.

Ja, wenn wir jetzt mal davon ausgehen, wir haben also, also wir wissen jetzt, wie man

Prozesse erzeugt zumindest, das kennen wir ja aus Systemprogrammierung 1 schon, wir wissen

auch, wie man es jetzt erzeugt, zumindest an der Betriebssystemschnittstelle und auf

die Weise bekommen wir also mehrere potenzielle Abläufe in eine Anwendung hinein und wir

wissen, dass es eben sowas wie Scheduler gibt im Betriebssystem, die dann auch darüber

entscheiden, welchen dieser potenziellen Abläufe oder Aktivitätsträger, die also die Aktivitäten

innerhalb eines Programms eben vorantreiben, welchen solchen Ablauf man zu welchem Zeitpunkt

aktiviert und heute und auch in den nächsten Vorlesungen wollen wir uns jetzt mal mit einem

sehr wichtigen Thema beschäftigen, in diesem Zusammenhang nämlich, ja wie, was muss ich

denn beachten, wenn ich jetzt mehrere solche Abläufe habe, die, wenn ich mehrere Prozessoren

oder Prozessorkerne habe, eventuell ja wirklich gleichzeitig ablaufen, für den Fall, dass

ich nur einen Prozessorkern habe, dann habe ich zumindest, wie wir jetzt gelernt haben

im Rahmen von den Scheduling-Kapiteln, gibt es ja die Möglichkeit bei verdrängendem

Scheduling, dass das Betriebssystem zu irgendwelchen Zeiten den einen Prozess verdrängt und einen

anderen dran nimmt.

Diese Zeiten sind für die Prozesse selbst eventuell überhaupt nicht vorhersagbar, sodass

ich auch da eben die Situation habe, einer läuft ein Stückchen, dann kommt ein anderer

dran, dann kommt wieder der eine dran und wann diese Umschaltung zwischen beiden passiert,

weiß ich nicht.

Und das ist natürlich schon ein Problem, wenn die Umschaltung zu einem Zeitpunkt, das