Algoritmo di sostituzione della pagina dell'orologio - Pagine già esistenti

Quando si simula l'algoritmo di sostituzione della pagina dell'orologio, quando arriva un riferimento che è già in memoria, la lancetta dell'orologio aumenta ancora?

Ecco un esempio:

Con 4 slot, usando l'algoritmo di sostituzione della pagina dell'orologio

Elenco di riferimento: 1 2 3 4 1 2 5 1 3 2 4 5

L'elenco iniziale sarebbe simile al seguente:

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

Il prossimo riferimento da inserire sarebbe 1, quindi 2. La lancetta punterebbe comunque a 1 dopo 1 e dopo 2? In altre parole, dopo aver inserito il 5, l'orologio sarebbe simile al seguente:

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

?

Penso che questo esempio possa chiarire tutti i tuoi dubbi.

Ad esempio:
supponiamo che la memoria principale sia vuota nella sequenza di riferimento della pagina iniziale sia:
3 2 3 0 8 4 2 5 0 9 8 3 2un bit di riferimento per frame (chiamato bit "usato")

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

* = indica il puntatore che identifica la posizione successiva da scansionare 
P = pagina # memorizzata in quel frame 
U = flag usato, 
0 = non usato di recente 
1 = referenziato di recente

Questo si chiama algoritmo di scansione lineare o algoritmo di seconda possibilità, usato in BSD Linux. 
Generalmente è implementato come una coda circolare.

Se arriva un riferimento per una pagina già in memoria, l'algoritmo sostitutivo non viene affatto invocato.

L' algoritmo di sostituzione dell'orologio sta cercando di ottenere alcuni dei vantaggi della sostituzione di LRU, ma senza l'enorme sovraccarico di manipolazione dei bit LRU su ogni hit della pagina.

Una pagina può essere in uno dei tre stati:

1. Presente in memoria e il recently-usedbit è true. In questo caso non si verificherà alcun errore di pagina quando si verifica un accesso alla pagina, quindi nessun bit cambierà.
2. Presente in memoria ma il recently-usedbit lo è false. In questo caso la pagina è anche contrassegnata nella tabella delle pagine in modo tale che se si accede alla pagina si verificherà un errore di pagina. (E se l'errore di pagina si verifica in questo caso, l'unica cosa che fa il gestore di errori di pagina è cambiare lo stato recently-used.)
3. La pagina non è presente in memoria. In questo caso guardiamo al clock-hand. Mentre clock-handsta puntando a una pagina con il recently-usedbit impostato true, capovolgiamo il recently-usedbit falsee quindi incrementiamo clock-handper puntare alla pagina successiva. Quando troviamo una pagina con recently-usedgià cancellata, quella è la pagina che sostituiamo. Poi vi segnalo la nuova pagina come recently-usede incrementare il clock-handalla prossima pagina.

L'orologio è, in sostanza, un algoritmo probabilistico per l'approssimazione di LRU. Se la velocità con cui si accede alla pagina è molto più elevata della frequenza con cui si clock-handsta ritornando alla stessa pagina, la pagina ha un'alta probabilità di essere contrassegnata recently-used. Se la velocità con cui si accede alla pagina è bassa rispetto alla velocità con cui clock-handsta tornando, è più probabile che la pagina non sia nello stato recently-used. La pagina utilizzata più di recente non verrà mai sostituita. (Perché?)