Nun wir haben ja gerade so ein Stück eine Idee davon bekommen, dass diese Zugriffsfehler durchaus

aufwendig sind. Also eben auch Prozesse durchaus kräftig verzögern können. Und nun wollen wir uns

mal ein Stück weit um so eine Art Schadensanalyse kümmern. Das heißt, dass ein bisschen genauer

untersuchen, wie häufig denn so eine Zugriffsfehler sein können, wie viele bei der Ausführung von

solchen Maschinenbefehl möglicherweise auftreten können und was es für Konsequenzen für Prozesslaufzeiten

denn letztendlich halt hat. Diese Zugriffsfehler treten für Seitenfehler wie auch Segmentfehler auf.

Ich hatte es ja schon gesagt, weil in beiden Fällen typischerweise haben wir eine Technik,

wo wir sowas wie Präsenzbits halt haben. Wir werden uns aber, wie ich auch schon andeutete,

auf Seitenfehler beschränken, weil PageFault und virtueller Speicher auf Basis von Seiten und

Seitenrahmen eben heute so der Standard ist. Die technische Grundlage dafür ist das PresentBit.

Also der Seitenfehler oder Segmentfehler würde dann auftauchen, wenn praktisch bei der Ausführung

eines Befehls, wo denn die betreffende Adresse, die auf diese Seite sich bezieht, eben ausgelagert ist.

In dem Fall ist das PresentBit in den betreffenden Seiten des Crypto auf Null gesetzt und dann

kommt es zum Trepp. Dann muss das Betriebssystem einen Trepphändler durchlaufen lassen. Der

Behandlungsaufwand, der kann je nach Art der CPU und Adressierungsart, die wir hier haben,

und Befehlssatz sehr aufwendig sein und dazu führen, dass der Leistungsverlust beträchtlich ist.

Ich möchte hier nochmal erwähnen, dass praktisch das eine Seite nicht anwesend ist oder eben

anwesend ist, durch die MMU erkannt wird im Zusammenhang mit der Adressumsetzung. Also wo

man von einer virtuellen zu einer realen Adresse die Adressumsetzung durchführt und da letztendlich

ja den Seitendeskriptor selektiert hat aus einer Seitentabelle und in diesem Deskriptor dann eben

passend zu der virtuellen Adresse um die es hier geht eben das PresentBit überprüft. Das wird also

durch die MMU erkannt, aber dass eine Seite nicht drin ist, dass die also nicht anwesend ist,

dass PresentBit auf Null ist oder dass die Seite anwesend ist, dass PresentBit auf Eins ist, das

wird durchs Betriebssystem definiert. Wenn man also einlagert, dann wird dieses PresentBit Null sein

für die betreffende Seite. Wenn das Betriebssystem entscheidet auszulagern, dann wird dieses PresentBit

eben auf Null sein. Null heißt auslagern oder ist ausgelagert, eins heißt eingelagert. Nun schauen

wir uns mal hier in so einer Fallstudie einfach so ein einfaches Programmchen an. Wir haben hier

ein Hauptprogramm, das ruft eine Prozedur auf, die indirekt über eine Zeigervariable adressiert ist,

passend zu dem Szenario, was wir gerade vorher gesehen haben. Die Zeigervariable heißt 9 und die

wird hier statisch belegt mit der Adresse der Prozedur Hello. Wenn man also jetzt hier die Zeile 8

zur Ausführung bringt, dann würde man normalerweise erwarten, dass eben das Hi rauskommt. Wir wollen

das Programm nicht ausführen selbst, wir wollen nur analysieren, was bei der Ausführung eines

solchen Programms oder insbesondere eines Maschinenbefehls, nämlich genau dieses

Maschinenbefehls in der Zeile 8, der hier relevant ist, eben an Seitenfehlern sozusagen auftreten kann.

Dazu schauen wir uns an, wie es auf der Assemblerebene aussieht. Die relevante

Maschinenanweisung ist hier die in Zeile 16, Call-Stern-9 haben wir gerade gesehen. Wir schauen uns

dann noch ein bisschen genauer an, nämlich wie die denn assembliert werden würde. Jetzt hier bei

einer 32-Bit-Maschine, da sehen wir, dass dieser Maschinenbefehl aus 1, 2, 3, 4, 5, 6 Bits besteht.

Das sind also eigentlich sechs virtuelle Adressen mit diesem Maschinenbefehl, wenn man so will,

dann verbunden. Okay, die CPU der x86 wird diesen Maschinenbefehl dann irgendwann mal ausführen,

wenn dieses Programm zur Ausführung kommt und dann kann man die Frage stellen, okay,

wie viele Seitenfehler würden denn bei der Ausführung eines solchen Maschinenbefehls

möglich sein, einer oder mehrere? Nun, den schlimmsten Fall, in dem Fall hier mit Call-Stern-9,

wollen wir uns mal anschauen. Nehmen wir mal an, dass der Operationscode und das ist genau

dann diese Hexadizimalzahl FF1-5 in dem Fall, dass die bereits gelesen wurde. Wenn also die CPU

der x86 hier in dem Fall praktisch diesen Maschinenbefehl zu Beginn seines fetch execute

cycles für diesen Befehl interpretieren würde, dann zeigt der Program-Counter auf den Anfang

dieses Maschinenbefehls und diese ersten 16-Bit, also die zwei Bytes, die sollen jetzt schon gelesen

sein. Das heißt, die CPU ist in der Lage praktisch diesen Befehl denn zu dekodieren. Das ist die

eine Voraussetzung. Und dann nehmen wir mal an, dass die Seitengrenzen für unseren Prozess hier so