Algoritmo de substituição de página de relógio - páginas já existentes

Ao simular o algoritmo de substituição da página de relógio, quando chega uma referência que já está na memória, o ponteiro do relógio ainda aumenta?

Aqui está um exemplo:

Com 4 slots, usando o algoritmo de substituição da página de relógio

Lista de referência: 1 2 3 4 1 2 5 1 3 2 4 5

A lista inicial ficaria assim:

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

A próxima referência a inserir seria 1, depois 2. O ponteiro ainda apontaria para 1 após 1 e após 2? Em outras palavras, depois de inserir o 5, o relógio ficaria assim:

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

?

Eu acho que este exemplo pode esclarecer todas as suas dúvidas.

Por exemplo:
Supõe que a memória principal esteja vazia na sequência de referência da página inicial:
3 2 3 0 8 4 2 5 0 9 8 3 21 bit de referência por quadro (chamado de bit "usado")

  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 o ponteiro que identifica o próximo local a ser digitalizado 
P = número da página armazenado nesse quadro 
U = bandeira usada, 
0 = não usado recentemente 
1 = referenciado recentemente

Isso é chamado de algoritmo de varredura linear ou algoritmo de segunda chance, usado no BSD Linux. 
Geralmente é implementado como uma fila circular.

Se chegar uma referência para uma página que já está na memória, o algoritmo de substituição não será chamado.

O algoritmo de substituição de clock está tentando obter alguns dos benefícios da substituição de LRU, mas sem a sobrecarga maciça de manipular os bits de LRU em cada página acessada.

Uma página pode estar em um dos três estados:

1. Presente na memória e o recently-usedbit é true. Nesse caso, não haverá falha na página quando um acesso ocorrer, portanto nenhum bit será alterado.
2. Presente na memória, mas a parte recently-usedé false. Nesse caso, a página também é marcada na tabela de páginas de forma que, se a página for acessada, ocorrerá uma falha na página. (E se a falha da página ocorrer neste caso, a única coisa que o manipulador de falhas da página faz é alterar o estado para recently-used.)
3. A página não está presente na memória. Neste caso, olhamos para o clock-hand. Enquanto o clock-handestá apontando para uma página com o recently-usedbit definido true, alternamos o recently-usedbit para falsee, em seguida, aumentamos clock-handpara apontar para a próxima página. Quando encontramos uma página recently-usedjá limpa, é a página que substituímos. Em seguida, marcamos a nova página como recently-usede aumentamos clock-handpara a próxima página.

O relógio é, no fundo, um algoritmo probabilístico para aproximar a LRU. Se a taxa na qual a página está sendo acessada for muito maior que a taxa na qual a página clock-handvoltará para a mesma página, a página terá uma alta probabilidade de ser marcada recently-used. Se a taxa na qual a página está sendo acessada for baixa em comparação com a taxa em que ela clock-handvoltará, é mais provável que a página esteja no estado não recently-used . A página usada mais recentemente nunca será substituída. (Por quê?)