Algorithmus zum Ersetzen von Uhrenseiten - Bereits vorhandene Seiten

Wenn bei der Simulation des Algorithmus zum Ersetzen der Uhrenseite eine Referenz eingeht, die sich bereits im Speicher befindet, erhöht sich der Uhrzeiger dann noch?

Hier ist ein Beispiel:

Mit 4 Steckplätzen unter Verwendung des Algorithmus zum Ersetzen der Uhrenseite

Referenzliste: 1 2 3 4 1 2 5 1 3 2 4 5

Die anfängliche Liste würde folgendermaßen aussehen:

-> [1][1]
   [2][1]
   [3][1]
   [4][1]

Die nächste Referenz zum Einfügen wäre 1, dann 2. Würde die Hand nach 1 und nach 2 immer noch auf 1 zeigen? Mit anderen Worten, nach dem Einfügen der 5 würde die Uhr folgendermaßen aussehen:

-> [5][1]
   [2][0]
   [3][0]
   [4][0]

?

Ich denke, dieses Beispiel kann alle Ihre Zweifel klären.

Beispiel:
Angenommen, der Hauptspeicher ist in der Startseitenreferenzsequenz leer:
3 2 3 0 8 4 2 5 0 9 8 3 2Ein Referenzbit pro Frame (als "verwendetes" Bit bezeichnet)

  PU 3 PU 2 PU 3 PU 0 PU 8 PU 4
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- --- +
| | 0 | * | 3 | 1 | | 3 | 1 | | 3 | 1 | | 3 | 1 | | 3 | 1 |
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- --- +
| | 0 | | | 0 | * | 2 | 1 | | 2 | 1 | | 2 | 1 | | 2 | 1 |
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- --- +
| | 0 | | | 0 | | | 0 | * | | 0 | * | 0 | 1 | | 0 | 1 |
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- --- +
| | 0 | | | 0 | | | 0 | | | 0 | | | 0 | * | 8 | 1 |
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- --- +
| | 0 | | | 0 | | | 0 | | | 0 | | | 0 | | | 0 | *
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- ----  


  PU 2 PU 5 PU 0 PU 9 PU 8 PU 3
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- --- +
| 3 | 1 | * | 3 | 1 | * | 5 | 1 | | 5 | 1 | | 5 | 1 | | 5 | 1 |
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- --- +
| 2 | 1 | | 2 | 1 | | 2 | 0 | * | 2 | 0 | * | 9 | 1 | | 9 | 1 |
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- --- +
| 0 | 1 | | 0 | 1 | | 0 | 0 | | 0 | 1 | | 0 | 1 | * | 0 | 1 | *
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- --- +
| 8 | 1 | | 8 | 1 | | 8 | 0 | | 8 | 0 | | 8 | 0 | | 8 | 1 |
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- --- +
| 4 | 1 | | 4 | 1 | | 4 | 0 | | 4 | 0 | | 4 | 0 | | 4 | 0 |
+ --- + --- + + --- + --- + + --- + --- + --- + --- + --- + --- + --- + --- + --- --- ----  


  VE 2 VE   
+ --- + --- + + --- + --- + 
| 5 | 1 | * | 5 | 0 |
+ --- + --- + + --- + --- + 
| 9 | 1 | | 9 | 0 |
+ --- + --- + + --- + --- +
| 0 | 0 | | 2 | 1 |   
+ --- + --- + + --- + --- +  
| 8 | 0 | | 8 | 0 | *
+ --- + --- + + --- + --- + 
| 3 | 1 | | 3 | 1 |  
+ --- + --- + + --- + --- +  

* = gibt den Zeiger an, der den nächsten zu scannenden Ort angibt 
P = in diesem Frame gespeicherte Seitennummer 
U = gebrauchtes Flag, 
0 = wurde in letzter Zeit nicht verwendet 
1 = kürzlich referenziert

Dies wird als linearer Scan-Algorithmus oder Algorithmus der zweiten Chance bezeichnet, der in BSD Linux verwendet wird. 
Im Allgemeinen wird es als kreisförmige Warteschlange implementiert.

Wenn eine Referenz für eine bereits im Speicher befindliche Seite eintrifft, wird der Ersetzungsalgorithmus überhaupt nicht aufgerufen.

Der Taktersetzungsalgorithmus versucht, einige der Vorteile des LRU-Austauschs zu erzielen, jedoch ohne den massiven Aufwand, die LRU-Bits bei jedem Seitentreffer zu manipulieren.

Eine Seite kann sich in einem von drei Zuständen befinden:

1. Im Speicher vorhanden und das recently-usedBit ist true. In diesem Fall liegt kein Seitenfehler vor, wenn auf die Seite zugegriffen wird, sodass sich keine Bits ändern.
2. Im Speicher vorhanden, aber das recently-usedBit ist false. In diesem Fall wird die Seite auch in der Seitentabelle so markiert, dass beim Zugriff auf die Seite ein Seitenfehler auftritt. (Und wenn der Seitenfehler in diesem Fall auftritt, ändert der Seitenfehler-Handler nur den Status in recently-used.)
3. Die Seite ist nicht im Speicher vorhanden. In diesem Fall schauen wir uns die an clock-hand. Während das clock-handauf eine Seite mit recently-usedgesetztem Bit zeigt, truedrehen wir das recently-usedBit auf falseund erhöhen clock-handes dann , um auf die nächste Seite zu zeigen. Wenn wir eine Seite finden, die recently-usedbereits gelöscht wurde, ersetzen wir diese Seite. Dann markieren wir die neue Seite als recently-usedund erhöhen sie clock-handauf die nächste Seite.

Die Uhr ist im Kern ein probabilistischer Algorithmus zur Approximation der LRU. Wenn die Rate, mit der auf die Seite zugegriffen wird, viel höher ist als die Rate, mit der die clock-handSeite wieder auf dieselbe Seite zurückkehrt, besteht eine hohe Wahrscheinlichkeit, dass die Seite markiert wird recently-used. Wenn die Rate , mit der die Seite zugegriffen wird niedrig , um die Rate verglichen wird , bei dem das clock-handkommt wieder um, dann ist die Seite eher im Zustand sein , nicht recently-used . Die zuletzt verwendete Seite wird niemals ersetzt. (Warum?)