Algoritme penggantian halaman jam - Sudah ada halaman

Saat mensimulasikan algoritma penggantian halaman jam, ketika referensi masuk yang sudah ada dalam memori, apakah jarum jam masih bertambah?

Berikut ini sebuah contoh:

Dengan 4 slot, gunakan algoritma penggantian halaman jam

Daftar referensi: 1 2 3 4 1 2 5 1 3 2 4 5

Daftar awal akan terlihat seperti ini:

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

Referensi berikutnya untuk memasukkan adalah 1, lalu 2. Apakah tangan masih menunjuk 1 setelah 1, dan setelah 2? Dengan kata lain, setelah memasukkan angka 5, apakah jam akan terlihat seperti ini:

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

?

Saya pikir contoh ini dapat mengklarifikasi semua keraguan Anda.

Sebagai contoh:
Mengasumsikan memori utama kosong pada urutan referensi halaman awal adalah:
3 2 3 0 8 4 2 5 0 9 8 3 2satu bit referensi per bingkai (disebut bit "bekas")

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

* = menunjukkan penunjuk yang mengidentifikasi lokasi berikutnya untuk memindai 
P = halaman # disimpan dalam bingkai itu 
U = bendera yang digunakan, 
0 = tidak digunakan baru-baru ini 
1 = direferensikan baru-baru ini

Ini disebut algoritma pemindaian linier atau algoritme kesempatan kedua, yang digunakan dalam BSD Linux. 
Umumnya ini diterapkan sebagai antrian melingkar.

Jika referensi tiba untuk halaman yang sudah ada dalam memori, maka algoritma penggantian tidak dipanggil sama sekali.

The algoritma penggantian jam mencoba untuk mencapai beberapa manfaat penggantian LRU, tetapi tanpa overhead besar memanipulasi LRU bit pada setiap halaman hit.

Satu halaman bisa dalam satu dari tiga negara:

1. Hadir dalam memori dan recently-usedbit true. Dalam hal ini tidak akan ada kesalahan halaman ketika akses terjadi ke halaman, jadi tidak ada bit yang akan berubah.
2. Hadir dalam memori tetapi recently-usedsedikit false. Dalam hal ini halaman juga ditandai dalam tabel halaman sedemikian rupa sehingga jika halaman diakses kesalahan halaman akan terjadi. (Dan jika kesalahan halaman terjadi dalam kasus ini, satu-satunya hal yang dilakukan penangan kesalahan halaman adalah mengubah status ke recently-used.)
3. Halaman tidak ada dalam memori. Dalam hal ini kita melihat clock-hand. Sementara clock-handmenunjuk ke halaman dengan recently-usedbit yang diatur truekita membalikkan recently-usedbit ke false, dan kemudian clock-handnaik untuk menunjuk ke halaman berikutnya. Ketika kami menemukan halaman dengan yang recently-usedsudah dihapus, itu adalah halaman yang kami ganti. Lalu kami menandai halaman baru sebagai recently-useddan menambah clock-handke halaman berikutnya .

Clock, pada dasarnya, adalah algoritma probabilistik untuk mendekati LRU. Jika tingkat di mana halaman sedang diakses jauh lebih tinggi daripada tingkat di mana clock-handkembali ke halaman yang sama maka halaman tersebut memiliki kemungkinan tinggi untuk ditandai recently-used. Jika tingkat di mana halaman sedang diakses rendah dibandingkan dengan tingkat di mana clock-handkembali sekitar, maka halaman lebih mungkin dalam keadaan tidak recently-used . Halaman yang paling terakhir digunakan tidak akan pernah diganti. (Mengapa?)