Algorithme de remplacement de page d'horloge - Pages déjà existantes

Lors de la simulation de l'algorithme de remplacement de la page d'horloge, lorsqu'une référence est déjà en mémoire, l'aiguille de l'horloge incrémente-t-elle toujours?

Voici un exemple:

Avec 4 emplacements, en utilisant l'algorithme de remplacement de la page d'horloge

Liste de référence: 1 2 3 4 1 2 5 1 3 2 4 5

La liste initiale ressemblerait à ceci:

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

La prochaine référence à insérer serait 1, puis 2. La main pointe-t-elle toujours à 1 après 1 et après 2? En d'autres termes, après avoir inséré le 5, l'horloge ressemblerait-elle à ceci:

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

?

Je pense que cet exemple peut clarifier tous vos doutes.

Par exemple:
Suppose que la mémoire principale est vide à la séquence de référence de la page de démarrage:
3 2 3 0 8 4 2 5 0 9 8 3 2un bit de référence par trame (appelé bit "utilisé")

  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 |
+ --- + --- + + --- + --- + + --- + --- + + --- + --- + + --- + --- + + --- + ----  


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

* = indique le pointeur qui identifie le prochain emplacement à numériser 
P = page # stockée dans ce cadre 
U = drapeau utilisé, 
0 = non utilisé récemment 
1 = référencé récemment

Ceci est appelé algorithme de balayage linéaire ou algorithme de deuxième chance, utilisé dans BSD Linux. 
Il est généralement implémenté comme une file d'attente circulaire.

Si une référence arrive pour une page déjà en mémoire, l'algorithme de remplacement n'est pas du tout appelé.

L' algorithme de remplacement d'horloge essaie d'obtenir certains des avantages du remplacement LRU, mais sans l'énorme surcharge de manipulation des bits LRU à chaque page visitée.

Une page peut être dans l'un des trois états suivants:

1. Présent dans la mémoire et le recently-usedbit est true. Dans ce cas, il n'y aura aucun défaut de page lorsqu'un accès se produit à la page, donc aucun bit ne changera.
2. Présent en mémoire mais le recently-usedbit l'est false. Dans ce cas, la page est également marquée dans le tableau des pages de telle sorte que si la page est consultée, une erreur de page se produira. (Et si l'erreur de page se produit dans ce cas, la seule chose que le gestionnaire d'erreur de page fait est de changer l'état en recently-used.)
3. La page n'est pas présente en mémoire. Dans ce cas, nous regardons le clock-hand. Pendant que le clock-handpointe vers une page avec le recently-usedbit défini, truenous inversons le recently-usedbit false, puis l'incrémentons clock-handpour pointer vers la page suivante. Lorsque nous trouvons une page recently-useddéjà effacée, c'est la page que nous remplaçons. Ensuite , nous marquons la nouvelle page recently-usedet incrémenter le clock-handà la prochaine page.

L'horloge est, au fond, un algorithme probabiliste pour approximer LRU. Si le taux auquel la page est consultée est beaucoup plus élevé que le taux auquel la page clock-handrevient sur la même page, alors la page a une forte probabilité d'être marquée recently-used. Si le taux auquel la page est consultée est faible par rapport au taux auquel la page clock-handrevient, alors la page est plus susceptible d'être en état de ne pas l'être recently-used . La page la plus récemment utilisée ne sera jamais remplacée. (Pourquoi?)