Intel x86 Assembly Language & Microarchitecture
Paging - Virtuelle Adressierung und Speicher

Einführung

Geschichte

Die ersten Computer

Frühe Computer verfügten über einen Speicherblock, in den der Programmierer Code und Daten eingegeben und die CPU in dieser Umgebung ausgeführt hat. Angesichts der Tatsache, dass die Computer damals sehr teuer waren, war es bedauerlich, dass sie einen Job erledigten, anhalten und auf den nächsten Job warten mussten, um ihn zu laden, und diesen dann verarbeiten.

Multi-User, Multi-Verarbeitung

So wurden Computer rasch raffinierter und unterstützten mehrere Benutzer und / oder Programme gleichzeitig - doch dann begannen Probleme mit der einfachen Idee eines "Speicherblocks". Wenn auf einem Computer zwei Programme gleichzeitig ausgeführt wurden oder dasselbe Programm für mehrere Benutzer ausgeführt wurde - was natürlich für jeden Benutzer separate Daten erfordert hätte -, wurde die Verwaltung dieses Speichers kritisch.

Beispiel

Zum Beispiel: Wenn ein Programm geschrieben wurde, um an der Speicheradresse 1000 zu arbeiten, dort aber bereits ein anderes Programm geladen wurde, konnte das neue Programm nicht geladen werden. Eine Möglichkeit, dies zu lösen, wäre, Programme mit "relativer Adressierung" zum Laufen zu bringen - es spielt keine Rolle, wo das Programm geladen wurde, es hat lediglich alles relativ zu der Speicheradresse getan, in die es geladen wurde. Aber dies erforderte Hardware-Unterstützung.

Raffinesse

Als die Computerhardware immer raffinierter wurde, konnte sie größere Speicherblöcke unterstützen, wodurch mehr Programme gleichzeitig verwendet werden konnten, und es wurde schwieriger, Programme zu schreiben, die das bereits Geladene nicht beeinträchtigten. Eine Streu-Speicherreferenz könnte nicht nur das aktuelle Programm, sondern auch jedes andere Programm im Speicher - einschließlich des Betriebssystems selbst - beeinträchtigen.

Lösungen

Was benötigt wurde, war ein Mechanismus, der es Speicherblöcken erlaubte, dynamische Adressen zu haben. Auf diese Weise könnte ein Programm so geschrieben werden, dass es mit seinen Speicherblöcken an Adressen arbeitet, die es erkannt hat, und nicht auf andere Blöcke für andere Programme zugreifen kann (es sei denn, eine Zusammenarbeit erlaubte es).

Segmentierung

Ein Mechanismus, der dies implementierte, war die Segmentierung. Dadurch konnten Speicherblöcke unterschiedlicher Größe definiert werden, und das Programm musste definieren, auf welches Segment es ständig zugreifen wollte.

Probleme

Diese Technik war mächtig - aber ihre Flexibilität war ein Problem. Da Segmente den verfügbaren Speicher im Wesentlichen in Blöcke unterschiedlicher Größe unterteilt haben, war die Speicherverwaltung für diese Segmente ein Problem: Zuweisung, Freigabe, Verkleinerung, Zerkleinerung, Fragmentierung - alles erfordert ausgeklügelte Routinen und manchmal Massenkopieren.

Paging

Eine andere Technik teilte den gesamten Speicher in Blöcke gleicher Größe ("Pages"), wodurch die Zuweisungs- und Aufhebungsroutinen sehr einfach wurden und das Wachstum, das Verkleinern und die Fragmentierung aufgehoben wurden (mit Ausnahme der internen Fragmentierung, die lediglich ein Problem darstellt Verschwendung).

Virtuelle Adressierung

Durch Aufteilen des Speichers in diese Blöcke können sie nach Bedarf mit verschiedenen Programmen mit der Adresse versehen werden, unter der das Programm es benötigt. Diese "Zuordnung" zwischen der physischen Adresse des Speichers und der gewünschten Adresse des Programms ist sehr leistungsfähig und bildet die Grundlage für die Speicherverwaltung aller gängigen Prozessoren (Intel, ARM, MIPS, Power ua).

Hardware- und Betriebssystemunterstützung

Die Hardware führte die Neuzuordnung automatisch und kontinuierlich durch, erforderte jedoch Speicher, um die Tabellen zu definieren, was zu tun ist. Natürlich musste der mit dieser Remapping verbundene Haushalt von etwas gesteuert werden. Das Betriebssystem müsste den Speicher nach Bedarf auslagern und die Datentabellen verwalten, die von der Hardware benötigt werden, um die benötigten Programme zu unterstützen.

Paging-Funktionen

Wenn die Hardware dieses Remapping durchführen konnte, was erlaubte es dann? Der Haupttreiber war Multiprocessing - die Fähigkeit, mehrere Programme auszuführen, die jeweils über einen eigenen "eigenen" Speicher verfügen, der voneinander geschützt ist. Zwei weitere Optionen waren "spärliche Daten" und "virtueller Speicher".

Multiprocessing

Jedes Programm erhielt seinen eigenen, virtuellen "Adressraum" - eine Reihe von Adressen, denen der physische Speicher zugeordnet werden konnte, und zwar an den gewünschten Adressen. Solange genügend physischer Arbeitsspeicher zur Verfügung stand (siehe "Virtueller Arbeitsspeicher" weiter unten), könnten zahlreiche Programme gleichzeitig unterstützt werden.

Darüber hinaus konnten diese Programme nicht auf Speicher zugreifen, der nicht ihrem virtuellen Adressraum zugeordnet war. Der Schutz zwischen den Programmen erfolgte automatisch. Wenn Programme zur Kommunikation benötigt werden, könnten sie das Betriebssystem bitten, einen gemeinsam genutzten Speicherblock einzurichten - einen physischen Speicherblock, der gleichzeitig in zwei Adressbereiche verschiedener Programme abgebildet wurde.

Kleinere Daten

Wenn Sie einen großen virtuellen Adressraum zulassen (4 GB ist typisch, um den 32-Bit-Registern zu entsprechen, die diese Prozessoren normalerweise hatten), verschwendet er keinen Speicher, wenn große Bereiche dieses Adressraums nicht zugeordnet werden. Dies ermöglicht die Erstellung riesiger Datenstrukturen, bei denen jeweils nur bestimmte Teile abgebildet werden. Stellen Sie sich ein dreidimensionales Array mit 1.000 Bytes in jede Richtung vor: Das würde normalerweise eine Milliarde Bytes dauern! Ein Programm könnte jedoch einen Block seines virtuellen Adressraums reservieren, um diese Daten zu "halten", aber nur kleine Abschnitte zuzuordnen, wenn sie gefüllt sind. Dies führt zu einer effizienten Programmierung und verschwendet keinen Speicher für Daten, die noch nicht benötigt werden.

Virtueller Speicher

Oben habe ich den Begriff "virtuelle Adressierung" verwendet, um die von der Hardware ausgeführte virtuell-physische Adressierung zu beschreiben. Dies wird häufig als "virtueller Speicher" bezeichnet. Dieser Begriff entspricht jedoch eher der Technik der Verwendung von virtueller Adressierung, um die Illusion von mehr Speicherplatz zu unterstützen, als tatsächlich verfügbar ist.

Es funktioniert so:

• Wenn Programme geladen werden und mehr Speicherplatz anfordern, stellt das Betriebssystem den verfügbaren Speicherplatz zur Verfügung. Das Betriebssystem verfolgt nicht nur, welcher Speicher zugeordnet wurde, sondern auch, wann der Speicher tatsächlich verwendet wird - die Hardware unterstützt das Markieren der verwendeten Seiten.
• Wenn das Betriebssystem nicht mehr über genügend physischen Speicher verfügt, wird der gesamte Speicher angezeigt, den das Betriebssystem an die Seite weitergegeben hat, die am wenigsten verwendet wurde oder die am längsten nicht verwendet wurde. Es speichert den Inhalt dieser bestimmten Seite auf der Festplatte, merkt sich, wo sich das befunden hat, markiert es als "Nicht vorhanden" für die Hardware des ursprünglichen Besitzers, setzt dann die Seite auf Null und gibt sie an den neuen Eigentümer weiter.
• Wenn der ursprüngliche Besitzer erneut versucht, auf diese Seite zuzugreifen, benachrichtigt die Hardware das Betriebssystem. Das Betriebssystem weist dann eine neue Seite zu (möglicherweise muss der vorherige Schritt erneut ausgeführt werden!), Der Inhalt der alten Seite wird geladen und die neue Seite wird dann an das ursprüngliche Programm übergeben.

  Es ist wichtig zu beachten, dass jede Seite einer beliebigen Adresse zugeordnet werden kann und jede Seite dieselbe Größe hat, dass eine Seite so gut wie jede andere ist - solange der Inhalt gleich bleibt!

• Wenn ein Programm auf einen nicht zugeordneten Speicherort zugreift, benachrichtigt die Hardware das Betriebssystem wie zuvor. Dieses Mal weist das Betriebssystem darauf hin, dass es sich nicht um eine Seite handelt, die weggespeichert wurde. Er erkennt sie also als Fehler im Programm und beendet ihn!

  Das passiert eigentlich, wenn Ihre App auf mysteriöse Weise verschwindet - vielleicht mit einer MessageBox vom Betriebssystem. Es ist auch das, was (oft) geschieht, um einen berüchtigten Blue Screen oder Sad Mac zu verursachen - das fehlerhafte Programm war in der Tat ein Betriebssystemtreiber, der auf den Speicher zugreifen konnte, auf den er nicht zugreifen sollte!

Paging-Entscheidungen

Die Hardware-Architekten mussten einige große Entscheidungen bezüglich Paging treffen, da das Design das Design der CPU direkt beeinflussen würde! Ein sehr flexibles System hätte einen hohen Aufwand und würde gerade für die Verwaltung der Paging-Infrastruktur selbst große Mengen an Speicher erfordern.

Wie groß sollte eine Seite sein?

In der Hardware wäre die einfachste Implementierung von Paging die Übernahme einer Adresse in zwei Teile. Der obere Teil ist ein Indikator, auf welche Seite zugegriffen werden soll, während der untere Teil der Index der Seite für das erforderliche Byte ist:

+-----------------+------------+
| Page index      | Byte index |
+-----------------+------------+

Es stellte sich jedoch schnell heraus, dass für kleine Seiten für jedes Programm umfangreiche Indexe erforderlich wären: Selbst nicht zugeordneter Speicher würde einen entsprechenden Eintrag in der Tabelle erfordern.

Stattdessen wird ein mehrstufiger Index verwendet. Die Adresse ist in mehrere Teile aufgeteilt (drei sind im folgenden Beispiel angegeben), und der obere Teil (allgemein als "Verzeichnis" bezeichnet) wird in den nächsten Teil aufgenommen und so weiter, bis der letzte Byteindex auf der letzten Seite decodiert ist:

+-----------+------------+------------+
| Dir index | Page index | Byte index |
+-----------+------------+------------+

Dies bedeutet, dass ein Verzeichnisindex für einen großen Teil des Adressraums "nicht zugeordnet" angeben kann, ohne dass zahlreiche Seitenindizes erforderlich sind.

Wie kann man die Verwendung der Seitentabellen optimieren?

Jeder Adresszugriff, den die CPU vornehmen wird, muss zugeordnet werden. Der virtuell-physische Prozess muss daher so effizient wie möglich sein. Wenn das oben beschriebene dreistufige System implementiert werden würde, würde dies bedeuten, dass jeder Speicherzugriff tatsächlich drei Zugriffe hätte: einen in das Verzeichnis; eine in die Seitentabelle; und dann endlich die gewünschten Daten selbst. Und wenn die CPU auch einen Housekeeping-Vorgang durchführen musste, z. B. um anzuzeigen, dass auf diese Seite jetzt zugegriffen wurde oder in die geschrieben wurde, würde dies weitere Zugriffe erfordern, um die Felder zu aktualisieren.

Der Speicher ist zwar schnell, aber dies führt beim Paging zu einer dreifachen Verlangsamung aller Speicherzugriffe! Glücklicherweise haben die meisten Programme einen "Ort des Umfangs" - das heißt, wenn sie auf einen Speicherplatz im Speicher zugreifen, sind zukünftige Zugriffe wahrscheinlich in der Nähe. Und da Pages nicht zu klein ist, muss diese Mapping-Konvertierung nur durchgeführt werden, wenn auf eine neue Seite zugegriffen wird: nicht für jeden Zugriff.

Aber noch besser wäre es, einen Cache mit Seiten, auf die kürzlich zugegriffen wurde, zu implementieren, nicht nur die aktuellsten. Das Problem wäre, auf dem Laufenden zu bleiben, worauf Seiten zugegriffen haben und was nicht - die Hardware müsste bei jedem Zugriff den Cache durchsuchen, um den zwischengespeicherten Wert zu finden. Der Cache ist also als inhaltsadressierbarer Cache implementiert: Statt auf die Adresse zuzugreifen, wird auf den Inhalt zugegriffen - wenn die angeforderten Daten vorhanden sind, werden sie angeboten, andernfalls wird stattdessen ein leerer Speicherort zum Ausfüllen gekennzeichnet. Der Cache verwaltet all das.

Dieser inhaltsadressierbare Cache wird häufig als Translation Lookaside Buffer (TLB) bezeichnet und muss vom Betriebssystem als Teil des virtuellen Adressierungssubsystems verwaltet werden. Wenn die Verzeichnisse oder Seitentabellen vom Betriebssystem geändert werden, muss der TLB benachrichtigt werden, um seine Einträge zu aktualisieren - oder sie einfach zu löschen.

80386 Paging

High Level Design

Der 80386 ist ein 32-Bit-Prozessor mit einem adressierbaren 32-Bit-Speicherplatz. Die Entwickler des Paging-Subsystems stellten fest, dass ein 4K-Seitendesign auf recht ordentliche Weise in diese 32 Bit abgebildet wurde - 10 Bit, 10 Bit und 12 Bit:

+-----------+------------+------------+
| Dir index | Page index | Byte index |
+-----------+------------+------------+
 3         2 2          1 1          0  Bit
 1         2 1          2 1          0  number

Das bedeutete, dass der Byte-Index 12 Bit breit war, was zu einer 4K-Seite führen würde. Die Verzeichnis- und Seitenindizes bestanden aus 10 Bits, die jeweils einer Tabelle mit 1.024 Einträgen entsprechen würden. Wenn diese Tabelleneinträge jeweils 4 Bytes wären, wären das 4K pro Tabelle: ebenfalls eine Seite!

Also haben sie es getan:

• Jedes Programm hätte ein eigenes Verzeichnis, eine Seite mit 1.024 Seiteneinträgen, die jeweils definiert wurden, wo sich die Seitentabelle der nächsten Ebene befand - falls vorhanden.
• Wenn ja, würde diese Seitentabelle 1.024 Seiteneinträge haben, die jeweils definieren, wo sich die letzte Seitenebene befand - falls vorhanden.
• Wenn ja, dann könnte das Byte dieser Seite direkt ausgelesen werden.

Seiteneintrag

Sowohl das oberste Verzeichnis als auch die Seitentabelle der nächsten Ebene umfassen 1.024 Seiteneinträge. Der wichtigste Teil dieser Einträge ist die Adresse dessen, was indiziert wird: eine Seitentabelle oder eine tatsächliche Seite. Beachten Sie, dass diese Adresse nicht die vollen 32 Bits benötigt - da alles eine Seite ist, sind nur die oberen 20 Bits von Bedeutung. Somit können die anderen 12 Bits in dem Page Entry für andere Dinge verwendet werden: ob die nächste Ebene überhaupt vorhanden ist; Housekeeping, ob auf die Seite zugegriffen wurde oder auf die geschrieben wurde; und auch, ob Schreiben überhaupt erlaubt sein sollte!

+--------------+----+------+-----+---+---+
| Page Address | OS | Used | Sup | W | P |
+--------------+----+------+-----+---+---+
Page Address = Top 20 bits of Page Table or Page address
OS           = Available for OS use
Used         = Whether this page has been accessed or written to
Sup          = Whether this page is Supervisory - only accessible by the OS
W            = Whether this page is allowed to be Written
P            = Whether this page is even Present

Wenn das P Bit 0 ist, darf der Rest des Eintrags alles enthalten, was das Betriebssystem dort einfügen möchte - beispielsweise wo sich der Inhalt der Seite auf der Festplatte befinden muss!

PDBR ( PDBR )

Wenn jedes Programm ein eigenes Verzeichnis hat, woher weiß die Hardware, wo sie mit dem Mapping beginnen soll? Da die CPU jeweils nur ein Programm ausführt, verfügt sie über ein einziges Steuerregister, das die Adresse des Verzeichnisses des aktuellen Programms enthält. Dies ist das CR3 ( CR3 ). Während das Betriebssystem zwischen verschiedenen Programmen wechselt, aktualisiert es die PDBR mit dem entsprechenden PDBR für das Programm.

Seitenfehler

Jedes Mal, wenn die CPU auf den Speicher zugreift, muss sie die angegebene virtuelle Adresse in die entsprechende physische Adresse abbilden. Dies ist ein dreistufiger Prozess:

1. Indizieren Sie die oberen 10 Bits der Adresse in die von der PDBR angegebene PDBR , um die Adresse der entsprechenden PDBR zu erhalten.
2. Indizieren Sie die nächsten 10 Bits der Adresse in die vom Verzeichnis angegebene Seite, um die Adresse der entsprechenden Seite zu erhalten.
3. Indizieren Sie die letzten 12 Bits der Adresse, um die Daten von dieser Seite zu erhalten.

Da beide Schritte 1. und 2. Seiteneinträge verwenden, könnte jeder Eintrag auf ein Problem hinweisen:

• Die nächste Ebene kann mit "Nicht vorhanden" gekennzeichnet sein.
• Die nächste Ebene kann als "Nur Lesen" markiert werden - und die Operation ist ein Schreibvorgang.
• Die nächste Ebene kann als "Supervisor" gekennzeichnet sein - und es ist das Programm, das auf den Speicher zugreift, nicht das Betriebssystem.

Wenn ein solches Problem von der Hardware bemerkt wird, löst der Zugriff nicht den Zugriff aus, sondern ein Fehler: Interrupt Nr. 14, der Seitenfehler. Außerdem werden einige spezifische Steuerregister mit der Information, warum der Fehler aufgetreten ist, ausgefüllt: die Adresse, auf die verwiesen wird; ob es ein Supervisor-Zugriff war; und ob es ein Schreibversuch war.

Es wird erwartet, dass das Betriebssystem diesen Fehler auffängt, die Steuerregister dekodiert und entscheidet, was zu tun ist. Bei einem ungültigen Zugriff kann das fehlerhafte Programm abgebrochen werden. Wenn es sich um einen Zugriff auf den virtuellen Speicher handelt, sollte das Betriebssystem eine neue Seite zuweisen (die möglicherweise eine bereits verwendete Seite räumen muss!), Und den erforderlichen Inhalt (entweder alle Nullen oder den vorherigen Inhalt, der von der Festplatte geladen wird) auffüllen ), ordnen Sie die neue Seite in die entsprechende Seitentabelle ein, markieren Sie sie als vorhanden und setzen Sie dann die fehlerhafte Anweisung fort. Diesmal verläuft der Zugriff erfolgreich, und das Programm wird ohne Kenntnis darüber, dass etwas Besonderes passiert ist (es sei denn, es wird auf die Uhr geschaut!)

80486 Paging

Das 80486-Paging-Subsystem war dem 80386-System sehr ähnlich. Es war abwärtskompatibel, und die einzigen neuen Funktionen waren die Steuerung des Speichercaches auf Seite-für-Seite-Basis - die Entwickler des Betriebssystems konnten bestimmte Seiten als nicht zwischengespeichert markieren oder ein anderes Durchschreiben oder Zurückschreiben verwenden Caching-Techniken.

Ansonsten ist das Beispiel "80386 Paging" anwendbar.

Pentium Paging

Als der Pentium entwickelt wurde, wurden die Speichergrößen und die darin ablaufenden Programme immer größer. Das Betriebssystem musste mehr und mehr Arbeit leisten, um das Paging-Subsystem nur in der schiere Anzahl von Seitenindizes zu erhalten, die aktualisiert werden mussten, wenn große Programme oder Datensätze verwendet wurden.

Die Pentium-Designer fügten also einen einfachen Trick hinzu: Sie fügten ein zusätzliches Bit in die Einträge des Seitenverzeichnisses ein, in dem angegeben wurde, ob die nächste Ebene eine Seitentabelle (wie zuvor) war - oder sie ging direkt zu einer 4 MB-Seite! Mit dem Konzept von 4 MB-Seiten müsste das Betriebssystem keine Seitentabelle erstellen und diese mit 1.024 Einträgen füllen, die im Wesentlichen Adressen um 4K höher als die vorherigen indexierten.

Adresslayout

+-----------+----------------------+
| Dir Index | 4MB Byte Index       |
+-----------+----------------------+
 3         2 2                    0   Bit
 1         2 1                    0   number

Verzeichnis Eintragslayout

+-----------+----+---+------+-----+---+---+
| Page Addr | OS | S | Used | Sup | W | P |
+-----------+----+---+------+-----+---+---+
Page Addr = Top 20 bits of Page Table or Page address
OS        = Available for OS use
S         = Size of Next Level: 0 = Page Table, 1 = 4 MB Page
Used      = Whether this page has been accessed or written to
Sup       = Whether this page is Supervisory - onlly accessible by the OS
W         = Whether this page is allowed to be Written
P         = Whether this page is even Present

Das hatte natürlich einige Auswirkungen:

• Die 4 MB-Seite musste an einer 4 MB-Adressgrenze beginnen, genau wie die 4K-Seiten an einer 4K-Adressgrenze.
• Alle 4 MB mussten zu einem einzigen Programm gehören oder von mehreren gemeinsam genutzt werden.

Dies war perfekt für die Verwendung mit Peripheriegeräten mit großem Speicher, z. B. Grafikadaptern, die große Adressraumfenster hatten, die für das Betriebssystem zugeordnet werden mussten.

Physical Address Extension (PAE)

Einführung

Bei sinkenden Speicherpreisen konnten Intel-basierte PCs mehr und mehr RAM kostengünstiger zur Verfügung stellen, wodurch die Probleme vieler Benutzer beim Ausführen vieler der immer größeren Anwendungen, die gleichzeitig produziert wurden, gemindert wurden. Während virtueller Speicher den Speicher virtuell "erstellt" hat - vorhandene "alte" Seiteninhalte auf die Festplatte austauschen, um "neue" Daten speichern zu können, verlangsamte dies den Ablauf der Programme, da Page "Thrashing" ständig Daten austauschte ein und aus der Festplatte.

Mehr RAM

Was benötigt wurde, war die Möglichkeit, auf mehr physisches RAM zuzugreifen - es war jedoch bereits ein 32-Bit-Adressbus, daher würde jede Erhöhung größere Adressregister erfordern. Oder würde es Bei der Entwicklung des Pentium Pro (und sogar des Pentium M) konnte als Stopplücke bis zu 64-Bit-Prozessoren eine zusätzliche physische Adresse hinzugefügt werden (wodurch mehr physischer Speicher ermöglicht wird), ohne die Anzahl der Registerbits zu ändern. Dies konnte erreicht werden, da virtuelle Adressen ohnehin physischen Adressen zugeordnet wurden - alles, was geändert werden musste, war das Mapping-System.

Design

Das vorhandene System kann auf maximal 32 Bit physische Adressen zugreifen. Um dies zu erhöhen, musste die Struktur der Seiteneinträge von 32 auf 64 Bit geändert werden. Es wurde beschlossen, die minimale Granularität bei 4K-Seiten beizubehalten, so dass der 64-Bit-Eintrag 52 Bit-Adresse und 12 Bit-Steuerelement hatte (wie der vorherige Eintrag 20 Bit-Adress- und 12 Bit-Steuerelement hatte).

Ein 64-Bit-Eintrag, aber eine Seitengröße von (immer noch) 4K, bedeutete, dass anstelle der vorherigen 1.024 nur 512 Einträge pro Seitentabelle oder Verzeichnis vorhanden wären. Das bedeutete, dass die virtuelle 32-Bit-Adresse anders als zuvor aufgeteilt wurde:

+-----+-----------+------------+------------+
| DPI | Dir Index | Page Index | Byte Index |
+-----+-----------+------------+------------+
 3   3 2         2 2          1 1          0   Bit
 1   0 9         1 0          2 1          0   number

 DPI        = 2-bit index into Directory Pointer Table
 Dir Index  = 9-bit index into Directory
 Page Index = 9-bit index into Page Table
 Byte Index = 12-bit index into Page (as before)

Wenn Sie ein Bit sowohl aus dem Verzeichnisindex als auch aus dem Seitenindex entfernen, erhalten Sie zwei Bits für eine dritte Mapping-Ebene: Sie nennen dies die Page Directory Pointer Table (PDPT), eine Tabelle mit genau vier 64-Bit-Einträgen, die vier Verzeichnisse anstelle der vorherigen adressierten ein. Die PDBR ( CR3 ) wies nun stattdessen auf die PDPT hin, die, da CR3 nur 32 Bit betrug, in den ersten 4 GB RAM gespeichert werden musste, um zugänglich zu sein. Da die niedrigen Bits von CR3 für die Steuerung verwendet werden, muss der PDPT an einer 32-Byte-Grenze beginnen.

Seitengrößenerweiterung (PSE)

Und da die vorherigen 4 MB-Seiten so eine gute Idee waren, wollten sie große Seiten wieder unterstützen. Das Entfernen der letzten Schicht des Schichtsystems erzeugte diesmal jedoch keine 10 + 12-Bit-4-MB-Seiten, sondern 9 + 12-Bit-2-MB-Seiten.

PSE-32 (und PSE-40)

Da der Physical Address Extension (PAE) -Modus, der in Pentium Pro (und Pentum M) eingeführt wurde, eine solche Änderung des Betriebssystems für die Speicherverwaltung des Betriebssystems darstellt, entschied sich Intel bei der Entwicklung des Pentium II, den "normalen" Page-Modus zu erweitern unterstützt die neuen Physical Address-Bits des Prozessors innerhalb der zuvor definierten 32-Bit-Einträge.

Sie stellten fest, dass bei der Verwendung einer 4-MB-Seite der Verzeichniseintrag folgendermaßen aussah:

+-----------+------------+---------+
| Dir Index |  Unused    | Control |
+-----------+------------+---------+

Der Dir-Index und der Kontrollbereich des Eintrags waren die gleichen, aber der Block nicht verwendeter Bits zwischen ihnen - die vom Seitenindex verwendet werden würden, wenn er vorhanden wäre - wurde verschwendet. Also entschieden sie sich, diesen Bereich zu verwenden, um die oberen physikalischen Adressbits über 31 zu definieren !

+-----------+------+-----+---------+
| Dir Index |Unused|Upper| Control |
+-----------+------+-----+---------+

Dies ermöglichte den Zugriff auf RAM über 4 GB für Betriebssysteme, die den PAE-Modus nicht verwenden. Mit etwas zusätzlicher Logik können sie dem System große Mengen zusätzlichen RAM zur Verfügung stellen, jedoch nicht mehr als die normalen 4 GB für jedes Programm. Anfangs wurden nur 4 Bits hinzugefügt, wodurch die physische 36-Bit-Adressierung möglich wurde. Daher wurde dieser Modus als Seitengrößenerweiterung 36 (PSE-36) bezeichnet. Die Seitengröße wurde nicht geändert, jedoch nur die Adressierung.

Die Einschränkung war jedoch, dass nur 4MB-Seiten über 4GB definiert werden konnten - 4K-Seiten waren nicht zulässig. Die Übernahme dieses Modus war nicht breit - er war angeblich langsamer als die Verwendung von PAE und wurde von Linux nicht verwendet.

In späteren Prozessoren mit noch mehr Physical Address-Bits wurde der PSE-Bereich von AMD und Intel auf 8 Bit erweitert, was einige Leute als "PSE-40" bezeichneten.