Nun, ich möchte jetzt erstmal kurz einen Teil des Stoffes aus der Systemprogrammierung 1 hier zu den

Adressräumen rekapitulieren und da beginnen wir mal mit dem Begriff der Referenzfolge,

der Reference String, wie man dazu aussagt. Nun, ein laufender Prozess, der generiert im Folgen von

Adressen auf den Haupt- oder auf den Arbeitsspeicher. Und diese Adressfolge ist dann letztendlich immer

durch das Programm definiert, vorgeschrieben, das eben genau diesen Prozess dann eben spezifiziert.

Das ist der eine Punkt, das ist die statische Sicht, die man da praktisch hat. Und da gibt es

natürlich noch eine dynamische Komponente und die hängt dann im Wesentlichen auch von den Eingabedaten

für diesen Programmablauf. Denn jeweils ab je nach Eingabedaten werden unterschiedliche Programm

Pfade mit dem Prozess durchlaufen. Und das bedeutet dann halt eben auch, dass sich denn

unterschiedliche Folgen von solchen Adressen für wiederholte Programmabläufe geben können,

wenn die Eingabedaten sich letztendlich unterscheiden. Dieser Wertevorrat dieser

Adressen ist durchs Programm letztendlich definiert, aber sozusagen die Größe dieses

Vorrats ist dann nach oben begrenzt. Wir können sagen, initial ist er irgendwie statisch. Also

wenn man sich jetzt vorstellt, das Programm wird zur Ausführung gebracht, dann gibt es sozusagen

die statisch spezifizierte Folge von diesen Anweisungen, von den Befehlen, die in diesem

Programm denn drin stehen, letztendlich so eine initiale Adressfolge vor, wenn es denn dazu kommt,

dass das Programm zur Ausführung kommt, weil man ja durchs Betriebssystem dafür Sorge getragen

hat, dass dieses Programm Text und Daten im Speicher, im Hauptspeicher platziert worden ist

und demzufolge jedes einzelne Maschinenbefehl und jeder Operand, jede Variable, die wir halt haben,

also jedes Objekt dieses Programms eben eine Adresse zugewiesen bekommen hat. Das ist sozusagen

die initiale Sicht. Diese kann sich denn zur Laufzeit dynamisch verändern. Wir wissen ja,

dass man dynamischen Speicher anfordern kann, dann muss auch dieser dynamische Speicher

irgendwelche Adressen zugewiesen bekommen. Das heißt, das erweitert sich sozusagen dieser

Wertevorrat, den wir halt haben. Es hängt auch von den Eingabedaten ab, wie ich gerade schon sagte,

dass man dann halt bestimmte Programm-Fade halt durchläuft, die vielleicht wiederholt letztendlich

durchläuft. Und dieser Adressvorrat, der sich dann halt ergibt, der wird normalerweise dann von

dem Prozess einfach nicht überschritten werden können. Da haben wir dann zwei verschiedene

Sicht. Wir könnten denn, wenn wir vor einer sogenannten typ-sicheren Programmiersprecher

ausgehen, dann könnte man tatsächlich sagen, dass der Compiler in der Lage ist, praktisch diesen

Wertevorrat von Adressen, die einem Prozess zugebilligt werden, also das sind die gültigen

Adressen für diesen Prozess, die er dann irgendwann mal benutzen kann, dass die eigentlich zugesichert

werden können. Oder, wenn wir so eine typ-sichere Programmiersprache etwa nicht hätten, also C zum

Beispiel ist eine nicht typ-sichere Programmiersprache, dann würde man dem Betriebssystem diese

Funktion halt übertragen. Und hier verwendet das Betriebssystem typischerweise Hardware-Unterstützung,

das ist die Memory Management Unit, die dann von dem Betriebssystem in entsprechender Art und

Weise programmiert ist, sodass ein Prozess dann praktisch immer nur mit seinen gültigen Adressen

arbeiten kann. Aber eben auch in der Hardware dann feststellbar ist, wenn ein Prozess mal ungültige

Adressen generiert und versucht, mit diesen Adressen zu arbeiten, dass es dann halt eben

zu einem Ausführungszeit, zu einem Laufzeitfehler kommen wird, was dann vom Betriebssystem

entsprechend behandelt wird. Dieser zugebilligte Wertevorrat definiert dann letztendlich diesen

Adressraum. Und man kann sagen, dass ein Prozess dann praktisch logisch oder physisch genau eben in

diesem Adressraum eingeschlossen ist. Normalerweise wird er aus diesem Adressraum dann halt nicht

ausbrechen und in fremde Adressräume eindringen. Man kann sich aber nicht sicher sein, ob das ein

Prozess oder ein Programm so geschrieben ist, dass es nicht doch für einen Prozess denn möglich

wäre. Und deshalb eben genau diese Absicherung. Bei einer typischeren Programmiersprache würden

wir gar nicht in der Lage sein, so eine Krabbe schreiben zu können, dass dann die Prozesse

fehlerhafte Adressen generieren. Im Falle von C sehr wohl. Und deshalb haben wir als Betriebssystem,

was dann halt mit einer Memory Management Unit den Prozess dann eigentlich in seinen Adressraum

einkapselt. Und wenn er den Adressen generiert, die nicht mehr zu seinem Wertevorrat gehören,

kommt es dann halt zu dem sogenannten Trap. Das sehen wir dann später noch. Wir wissen halt auch,