So, ja, hallo, willkommen zur heutigen Systemprogrammierung. Wir hatten letzte Woche uns ja beschäftigt mit der

Fragestellung, wie kommt man nun von so einem C-Programm zum laufenden Prozess. Und da bin ich

nicht ganz fertig geworden am Ende. Das heißt, da muss ich noch mal aufsetzen. Und ich schaue

gerade mal, was ein guter Punkt ist, dran aufzusetzen. Wir hatten uns über Prozesszustände,

denke ich, ist ein ganz guter Punkt. Ich hatte ja erklärt, wie man eben zu einem fertigen

Programm kommt und wie ein Programm dann in Speicher geladen wird. Für die Programmausführung

wird ein virtueller Adressraum zur Verfügung gestellt. Das heißt also, jede Programmausführung

bekommt im Endeffekt einen Speicher zur Verfügung, der auf einer 32-Bit Architektur irgendwo

von 0 bis 4 GB adressiert ist. Und jede Programmausführung hat den für sich alleine. So, so eine Programmausführung

nennt man dann eben Prozess. Und wenn so ein Prozess erzeugt wird, dann wird eben auch

dieser entsprechende Speicherbereich für ihn erzeugt. Und ja, wenn man einen Prozess

erzeugt, ist das Erzeugen des Speichers eine Sache, die notwendig ist. Es müssen noch

ein paar andere Ressourcen für den Prozess bereitgestellt werden. Also irgendwelche Verwaltungsdatenstrukturen,

solche Geschichten. Aber die wesentlichen Ressourcen, die eigentlich ein Prozess braucht,

um laufen zu können, ist erstmal der Speicher. Es müssen also diese Speicher-Abbildungstabellen

hergestellt werden, die also diese virtuellen oder logischen Adressen, für diese virtuellen

oder logischen Adressen die Abbildung auf die physikalischen Hauptspeicheradressen ermöglichen.

Wenn das alles gemacht ist, dann ist der Prozess erstmal im Zustand bereit. Das heißt also,

er könnte laufen, wenn er denn eine CPU hätte. Und die Fragestellung, welcher der bereiten

Prozesse wann die CPU bekommt, wird vom Betriebssystem entschieden. Da gibt es eine spezielle Komponente

im Betriebssystem, die dann nach irgendwelchen Prioritäten oder sonstigen Kriterien arbeitet.

Und irgendwann entscheidet diese Komponente, die man eben auch Scheduler nennt, eben, dass

dieser Prozess nun den Prozessor bekommen soll. Und dann geht der Prozess in den Zustand

laufend über. Jetzt gibt es zwei Möglichkeiten. Das eine ist, der Prozess führt eine Operation

aus, bei der er länger warten müsste. Ein typischer Fall ist, er führt eine Ein-Ausgabe-Operation

aus, also eine Eingabe zum Beispiel, er liest ein Zeichen von der Tastatur. Und bis dann

dieses Zeichen tatsächlich vorliegt, dauert, also wenn man das mal mit der Taktgeschwindigkeit

von so einem Prozessor vergleicht, natürlich sehr, sehr lange. Das heißt, in der Zwischenzeit

kann die CPU was anderes tun und der Prozess geht in den Zustand blockiert über, erwartet,

also darauf, dass dieses Zeichen kommt. Irgendwann ist das Zeichen dann tatsächlich da. Es wird

vom Betriebssystem entgegengenommen und in irgendeinen Puffer gestellt, also in den Speicher

gestellt, in dem der Prozess dieses Zeichen erwartet hat. Also wenn ich Get Care aufrufe,

dann liegt das Zeichen dann halt anschließend eben in diesem Datenspeicher, auf den diese

Get Care-Funktion zugreift. Das heißt, der Grund für die Blockade ist jetzt weggefallen

und der Prozess geht zurück in den Zustand bereit. Wie lange er dort warten muss, hängt

davon ab, was gerade sonst noch zu tun ist. Typischerweise gerade solche interaktiv arbeitenden

oder auf interaktiven Betrieb optimierten Betriebssysteme arbeiten typischerweise so,

dass sie solche Prozesse, die sehr häufig blockiert sind und primär eigentlich auf

eine Ausgabe warten, dann mit einer relativ hohen Priorität wieder in diese Warteschlange

der bereiten Prozesse reinstellen, damit die relativ schnell wieder dran kommen. Dahinter

steckt so die Überlegung, wenn ein Prozess sehr viel eine Ausgabe macht, also sehr viel

wartet und wenig rechnet, dann kann man ihn auch schnell dran nehmen, weil er ja sowieso

relativ schnell wieder die CPU freigeben wird. Demgegenüber ein Prozess, der sehr viel rechnet,

das ist mein Standardbeispiel, ist immer der berechnet Pi, da kann man beliebig lange

dran rumrechnen und wenn ein Prozess dafür die CPU bekommt, dann wird es eher lange

dauern, bis er sie wieder abgibt. Also sollte man sie ihm auch nicht so schnell wieder geben

und vor allem, weil das natürlich dann die interaktiven Prozesse ausbremst und bei einem

interaktiven Prozess merkt man natürlich auch sehr schnell, wenn der die CPU nicht

sehr schnell wieder bekommt, weil dann muss man auf Antworten warten. Wenn sie so typisch

als Anwendungsszenario, sie arbeiten zum Beispiel mit einem Editor, dann ist es ja so, dieser