Danke.
So.
Wir wollen jetzt zwei Aufgaben zum Thema virtuelle Speicherverwaltung
hier behandeln.
In der ersten Aufgabe sei ein Segment S gegeben.
Der Hauptspeicher sei bereits beginnend auf der Adresse 0 mit 64
Blöcken zu je 256 Bytes belegt.
Im Anschluss an diesen Bereich, das heißt im Anschluss an diese 64
Blöcken mit je 256 Bytes, soll ein Segment S mit der virtuellen
Anfangsadresse 2 und so viele Nullen und 2 und 2 Nullen 1811 geladen
werden.
Das ist ja kein Problem.
Danke.
So, dann tun wir mal das hier, das hier.
Ja, was bedeutet das?
Wenn wir uns an die Vorlesung von gestern erinnern, aha, man hat
Blöcke und jeder Block ist so viel und so viel groß und man soll ein
Segment irgendwie mit einer Anfangsadresse und Endadresse in den
Hauptspeicher laden und was hat man an Informationen schon bereits?
Ja, man hat natürlich die folgenden Informationen, dass man zunächst
mal einen virtuellen Adressraum gibt, einen physikalischen Adressraum
und der physikalische Adressraum, also der Hauptspeicher, ist auf der
Adresse 0 belegt mit 64 Blöcken, jeder Block ist 256 Bytes also.
Das heißt, der ist belegt von 0 bis zu einer bestimmten Adresse.
Im Anschluss an diesem Bereich hier soll jetzt ein Segment S geladen
werden unter der Annahme, dass jetzt der Hauptspeicher lückenlos
gefüllt werden soll.
Und von diesem Segment S weiß man, dass das Segment S im virtuellen
Adressraum die Anfangs- und die Endadressen, ich sage mal dazu, 0 und
1811 besitzt.
So viel weiß man, oder?
Das sind eigentlich die Angaben.
Segment S mit der Anfangsadresse und Endadresse, und zwar im
virtuellen Adressraum, Hauptspeicher von 0 an mit 64 Blöcken, jeder
256 Bytes belegt.
Und dann soll ja Segment S geladen werden.
Ja, die erste Aufgabe ist, geben Sie die Ladeadresse des Segments S
unter der Bedienung, dass der Hauptspeicher lückenlos gefüllt werden
soll.
Das heißt eigentlich, an welcher Adresse im Hauptspeicher wird das
Segment S geladen.
So, das ist ja die Situation, das ist ja, was wir wissen.
Der Hauptspeicher ist an der Adresse 0 mit 64 Blöcken, also das ist 2
hoch 6.
Jeder Block ist 256 Bytes, also mal 2 hoch 8, das sind insgesamt 2
hoch 14.
Also von 0 bis 2 hoch 14 ist der Hauptspeicher voll.
2 hoch 14, was ist das für eine Adresse?
1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 1, 1, 1, 1, das ist ja dann 11, 12, 13,
14, 0 und dann der Rest 0, 0, 0, 0 bis 32.
Das heißt, eigentlich diese 64 Blöcke belegen den Hauptspeicher von
der Adresse 0 bis zur Adresse 3FFF.
Okay, was ist die nächste Adresse, was ja die Ladeadresse von dem
Segment S ist?
Die nächste Adresse ist hier natürlich FFF4.
So, das heißt, die 64 Blöcke hier belegen den Hauptspeicher bis zur
Adresse 3FFFF und die nächste Adresse wäre die Ladeadresse von dem
Segment S unter der Bedienung, dass der Hauptspeicher lückenlos
gefüllt werden soll.
Entschuldigung, mein Fehler.
Natürlich, die nächste Adresse hier ist nicht 4FFF, sondern 4, 0, 0, 0
und das wäre ja die Ladeadresse von dem Segment S.
Haben wir alles verstanden?
Einfach, oder?
Zwei Punkte.
So, an welcher Position im Registerspeicher der MMU muss die
physikalische Blocknummer als Abbildungsinformation abgelegt werden
und welchen Wert hat sie?
Also, das heißt, man hat hier jetzt eine segmentorientierte
Speicherverwaltung.
Die virtuelle Adresse, die wird in Segmentnummern unterteilt, wie man
sieht.
Das sind hier 256 Segmente.
Und ausgewählt wird ein Segment über einen Index hier, also über diese
8 Bits.
Dann wird ein Segment hier in dieser Segmenttabelle ausgewählt.
Das heißt, zwei Einträge, einmal ein Segmentbasisadresse und einmal
eine 16-Bit-Segmentlängenangabe in Bytes, die dazu dient, dass keine
segmentüberschreitenden Zugriffe erfolgen.
Das heißt, durch diese Zahl, die man hier einträgt, kann man jetzt
diese Segmentüberschreitungen feststellen.
Aber jetzt, an welcher Position im Registerspeicher der MMU muss die
physikalische Blocknummer als Abbildungsinformation abgelegt werden?
Also, die physikalische Blocknummer, das ist ja eigentlich, was wir
hier nachher haben werden.
Und wo müssen wir das ablegen hier?
An der Position 0, 1, 2 oder 255?
Und welchen Wert müssen wir dort eintragen?
Also, die Aufgabenstellung ist komplizierter als das, was man...
Also, normalerweise ist es immer so in TI, dass weniger
dahintersteckt, als was der ganze Text sagt.
Also, man muss das natürlich verstehen.
Das heißt, jetzt, wenn wir hier das Segment S, die physikalische
Adresse von dem Segment S haben, wo müssen wir jetzt in dieser Segment
-Tabelle suchen, nach der Segment-Basis-Adresse?
Das ist klar.
Das heißt, in welcher Zeile müssen wir suchen.
Und die Zeile, die ermittelt man anhalb von diesen acht Bits.
Die sind ja dazu zuständig, einen Eintrag hier zu ermitteln.
Wenn wir mal die virtuelle Adresse von dem Segment S hier betrachten,
das heißt hier, diese acht Bits, die sind ja zuständig für die
Position.
Diese acht Bits hier, das sind ja die virtuelle Anfangsadresse von dem
Segment S, die ist ja 0,2.
0,2 bedeutet, dass das ja nichts anderes als die zweite Position,
zufällig hier, an der zweiten Position diese Abbildungsinformation
abgelegt werden muss.
So, ist das klar?
Ja, welchen Wert muss hier jetzt eingetragen werden?
Segmentlängenangabe, das ist kein Problem, in Blöcken.
Werden wir später aber ermitteln.
Aber jetzt, welchen Wert müssen wir hier eintragen?
Ja, das ist nichts anderes als das, was man hier als Blocknummer hat.
Und wenn man hier die physikalische Ladeadresse von dem Segment
betrachtet, und zwar diese Bits hier nimmt, die nichts anderes als die
Bitnummer, dann ist das eigentlich der Wert, den man dorthin eintragen
muss.
So, alles klar?
Welchen Wert hat die für die Überprüfung von Segmentüberschreitungen
einzutragende Blockanzahl an?
Das heißt, wir wissen, zum Segment S müssen wir die Basisadresse an
der Stelle 2 suchen.
Hier müssen wir eine, was war das, 4000, oder?
Ein 0024-Bit, 4000 hier eintragen als Segmentbasisadresse.
Und jetzt hier für die Segmentüberschreitung müssen wir die Länge,
also eine Angabe über die Länge des Segments S angeben.
Das ist die eine Variante der segmentorientierten Sprecherverwaltung,
die gestern in der Vorlesung behandelt wurde.
Ist klar, wo die Blöcke nicht an Bytegrenzen, sondern an Blockgrenzen
im Hauptsprecher abgelegt werden, wo man maximal hier einen Verschnitt
von 256 Bytes hat, bei einer Blockgröße von 256.
Naja gut, welchen Wert muss man hier eintragen?
Da muss man wissen, wie groß das Segment S in Blöcken ist.
Segment S, wie groß ist Segment S?
Wissen wir das?
Wer ist Fouya?
Ganz wenige.
Wer ist von Markus?
Warum nicht?
Gut, das wissen wir natürlich, weil wir wissen ja die Anfangs- und
Endadresse von Segment S, das heißt, es geht ja von 0 bis 1811, das
heißt insgesamt ist ja das Segment S 1812 Bytes groß, wenn wir die
beiden hier voneinander subtrahiert.
Und man muss das Ganze hier in der Tabelle, wie wir sehen, in
Blockgröße eingeben, das heißt, man muss hier 1812 Bytes, das ist das
Segment S, und eine Blockgröße ist wie viel?
256 Bytes, das ist natürlich Hexadezimal, das Ganze hier, und 256
Hexadezimal ist 100, das heißt, wir dividieren 1812 durch 100, das ist
18,12.
Das heißt eigentlich, das Segment S braucht wie viele Blöcke?
19, wobei die ersten 18 voll belegt sind und im 19.
Hexadezimal, das wäre dann 25, im 25.
Block sind nur 11 Bytes eigentlich vorhanden.
Soweit klar?
Oder 12 Bytes?
Gut, das heißt, man braucht insgesamt 18 Blöcke, Entschuldigung, 19
Blöcke, und der Wert, den man dort eintragen muss, ist entweder 19
Hexadezimal oder Dezimal 25, wobei die ersten 24 Blöcke voll belegt
sind und der letzte Block nur mit 11 Bytes vom Segment S belegt ist.
So, also Segment S benötigt 19 Blöcke, 0 bis 18 oder bis 24 sind voll
und der letzte enthält nur 12 Bytes, das heißt, für die Überprüfung
einer Segmentüberschreitung muss man für Segment S den Wert 25
eintragen.
Aufgabe 2, haben wir das verstanden?
Also, jetzt stellt euch mal diese Aufgabe für die unterschiedlichen
Varianten, die wir in der Vorlesung kennengelernt haben, vor.
Also drei Varianten, zweimal die segmentorientierte
Speicherverwaltung, wo einmal die virtuelle Adresse nur in einer
Segmentnummer und dann ByteOffset unterteilt ist und einmal diese
Variante, die wir heute auch nochmal gesehen haben, die virtuelle
Adresse in Segmentnummer, Blocknummer und dann ByteNummer.
So, Aufgabe 2, gegeben sei eine Speicherverwaltungseinheit mit einer
Seitengröße von 4 Kilobyte, 8 virtuelle Seiten und 4 physikalische
Seiten.
Die Seitentepelle ist wie folgt belegt.
In der Seitentepelle ist immer die Zuordnung von virtuellen Seiten zu
physikalischen Seiten, und zwar durch die entsprechenden Nummern.
Meine Frage ist hier, ich stelle eine blöde Frage,
diese Seitengröße, ist das die Größe von einer Seite im virtuellen
oder physikalischen Adressraum?
Nein, nein, nein, du nicht.
Wer weiß es nicht?
Okay.
Alle anderen wissen es?
Gut, dann hinten mit der Brille.
Okay,
dann nehmen wir zum Beispiel dich.
Dieselbe, das ist dieselbe, natürlich, ja.
Gut.
So, das heißt, diese Tepelle besagt, dass wir hier 8 Seiten haben, 8
virtuelle Seiten, also der virtuelle Adressraum ist ein bisschen
größer, also umgekehrt darf es nicht sein, dass der physikalische
Adressraum 8 Seiten hat und der virtuelle 4, das wäre blöd.
Und wir haben hier einen aktuellen Ausschnitt aus dieser
Seitentepelle, das heißt, welche physikalischen Seiten sind aktuell im
Hauptspeicher?
Das heißt, es sind die Seiten 3, 1, 2 und 4 und 0, Entschuldigung.
Und ja, was wollen wir eigentlich?
Wie groß ist der physikalische und der virtuelle Adressraum?
Also 4K-Byte Seitengröße, 4 physikalische Seiten, 8 virtuelle Seiten,
das heißt, einmal 4 mal 4K und einmal 8 mal 4K, das heißt, der
physikalische Adressraum ist 16 Byte, der virtuelle Adressraum 32 Byte
groß.
Was wollen wir noch?
Ermitteln Sie die physikalischen Adressen zu den folgenden virtuellen
Adressen, die in dezimaler Schreibweise angegeben sind.
Also, wir wollen wissen, welche physikalische Adresse zu der
virtuellen Adresse 0 gehört, welche zu der virtuellen Adresse 123,
124, 4600, Entschuldigung, 1023, 1024, 4096 und so weiter und so fort.
Ja, wie geht man hier vor?
Man muss zunächst mal wissen, das sind ja virtuelle Adressen, man muss
ja wissen, in welcher Seite im virtuellen Adressraum diese Daten und
entsprechende Adressen liegen.
Und dann guckt man in dieser Seitentabelle, auf welcher Seite werden
diese Adressen abgebildet.
Das ist klar hier, das heißt, wir müssen hier zu jeder virtuellen
Adresse die virtuelle Seitennummer ermitteln und anschließend müssen
wir mit Hilfe von unserer Seitentabelle sehen, auf welcher
physikalischen Seite diese virtuelle Seite abgebildet wird und dann
anschließend die physikalische Adresse berechnen.
So, das heißt, wir fangen mal an, dazu brauchen wir ja diese
Seitentabelle, die wir haben.
Und noch eine blöde Frage, warum gibt es hier Don't Cares eigentlich?
Ja?
Wie bitte?
Ja, aber können mehr oder weniger als vier Don't Cares hier stehen?
Oder müssen immer vier Don't Cares sein?
Also, man kann hier nur eigentlich vier gültige Einträge haben im
Hauptspeicher, weil der Hauptspeicher kann nicht mehr als vier Seiten
aufnehmen.
Okay?
So, nun fangen wir mal an mit der Adresse 0.
Adresse 0, dazu gehört die physikalische Adresse 3.
Entschuldigung.
Adresse 0 ist zunächst mal, wenn wir hier den Speicher betrachten, mit
Adressen 0 bis FFF, Adresse 0 ist hier, und die erste Seite im
virtuellen Adressraum, die geht ja von 0 bis wie viel?
Also egal.
Also die Adresse 0 ist in der Seite 0, die virtuelle Seite 0 wird auf
die physikalische Seitennummer 3 abgebildet.
Also 0 wird auf 3 abgebildet.
So, die Adresse 1023, wo liegt das hier, noch in der Seite 0 oder in
der Seite 1?
Seite 1.
Eine Seite ist 4 Kilobyte groß, das heißt von 0 bis 4095, das wäre
hier, und die nächste Adresse ist hier 4096.
So, das heißt, das ist auch noch in der virtuellen Adresse 0, und das
ist in der virtuellen Adresse 0 und das ist in der virtuellen Adresse
1.
Weil die Seite Nummer 1 fängt ja mit der Adresse 4096.
So, und die hier, in welcher Seite?
Das ist klar, das müssen wir dann durch die Seitengröße dividieren,
also 4096, das ist 6 plus 0, also genau 6.
Das heißt, das ist die virtuelle Seite 6, und wenn wir hier gucken,
die 0 wird auf 3 abgebildet, physikalisch, die 1 wird auf 1
abgebildet, und die 6 wird auf 0 abgebildet.
So, das heißt, wir müssen jetzt nur die Adressen hierzu berechnen, und
zwar im physikalischen Adressraum.
Im physikalischen Adressraum haben wir wiederum vier Seiten, oder was
heißt wiederum, haben wir vier Seiten.
0, die Adresse 0 wird auf 3 abgebildet, also 0, 1, 2, das ist 3, die
Startadresse von Seite 3 ist dann wie viel?
4096 mal 3 ist 8, 8, 2, 2, 1, also Adresse 0 auf Seite 3, und zwar
ganz zu Beginn von Seite 3, weil wir hier wirklich 0 haben, das heißt,
die virtuelle Adresse ist 12.288.
Die Adresse hier, die liegt noch auch in der gleichen Seite, auch im
physikalischen, aber mit einem Offset zu Seitenanfang von 1023, das
heißt hierzu müssen wir 1023 addieren, dann bekommen wir 11, 11, 3, 3,
1, die liegt noch in der gleichen Seite, also auch in 3, das heißt,
wir müssen hier dazu nur eine 1 addieren, dann haben wir 2.
Das hier, das ist Seite 1, wird auch auf Seite 1 abgebildet, und Seite
1 fängt sowohl beim physikalischen als auch beim virtuellen bei 4096.
Und das hier, das wird auf Seite 0, also Seite 6 hier, wird auf 0
abgebildet, und zwar plus Rest 0, das bedeutet hier, was kommt hier
als eine physikalische Adresse?
Neben Markus, genau, du, ja, 0, ganz genau.
So, das heißt, das Ganze sieht wie folgt aus, das sind die
entsprechenden physikalischen Adressen zu den hier angegebenen
virtuellen Adressen unter Benutzung der Tabelle, die hier angegeben
ist.
So viel zum Thema virtuelle Speicherverwaltung, wir sehen uns nochmal
am nächsten Mittwoch, ich darf am nächsten Mittwoch auch die Vorlesung
halten, da wollen wir etwas über DMA-Kontrolle und Interrupt-Kontrolle
hier in der Vorlesung behandeln.
Vielen Dank.