Thuật toán thay thế trang đồng hồ - Các trang đã có sẵn

Khi mô phỏng thuật toán thay thế trang đồng hồ, khi tham chiếu đã có trong bộ nhớ, kim đồng hồ có còn tăng không?

Đây là một ví dụ:

Với 4 khe cắm, sử dụng thuật toán thay thế trang đồng hồ

Danh sách tham khảo: 1 2 3 4 1 2 5 1 3 2 4 5

Danh sách ban đầu sẽ như thế này:

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

Tham chiếu tiếp theo để chèn sẽ là 1, sau đó 2. Tay có còn chỉ 1 sau 1 và sau 2 không? Nói cách khác, sau khi chèn 5, đồng hồ sẽ trông như thế này:

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

?

Tôi nghĩ ví dụ này có thể làm rõ tất cả những nghi ngờ của bạn.

Ví dụ:
Giả sử bộ nhớ chính trống ở chuỗi tham chiếu trang bắt đầu là:
3 2 3 0 8 4 2 5 0 9 8 3 2một bit tham chiếu trên mỗi khung (được gọi là bit "đã sử dụng")

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

* = cho biết con trỏ xác định vị trí tiếp theo cần quét 
P = trang # được lưu trữ trong khung đó 
U = cờ đã sử dụng, 
0 = không được sử dụng gần đây 
1 = được tham chiếu gần đây

Đây được gọi là thuật toán quét tuyến tính hoặc thuật toán cơ hội thứ hai, được sử dụng trong BSD Linux. 
Nói chung, nó được thực hiện như một hàng đợi tròn.

Nếu một tham chiếu đến một trang đã có trong bộ nhớ, thì thuật toán thay thế hoàn toàn không được gọi.

Các thuật toán thay thế đồng hồ đang cố gắng để đạt được một số lợi ích của LRU thay thế, nhưng không có chi phí khổng lồ điều khiển các bit LRU trên mỗi hit trang.

Một trang có thể ở một trong ba trạng thái:

1. Hiện tại trong bộ nhớ và recently-usedbit là true. Trong trường hợp này, sẽ không có lỗi trang khi truy cập xảy ra với trang, vì vậy không có bit nào thay đổi.
2. Có mặt trong bộ nhớ nhưng recently-usedbit là false. Trong trường hợp này, trang cũng được đánh dấu trong bảng trang theo cách mà nếu trang được truy cập, sẽ xảy ra lỗi trang. (Và nếu lỗi trang xảy ra trong trường hợp này, điều duy nhất mà trình xử lý lỗi trang thực hiện là thay đổi trạng thái thành recently-used.)
3. Trang không có trong bộ nhớ. Trong trường hợp này, chúng tôi nhìn vào clock-hand. Trong khi clock-handtrỏ đến một trang có tập recently-usedbit, truechúng ta lật recently-usedbit sang false, rồi tăng dần clock-handđể trỏ đến trang tiếp theo. Khi chúng tôi tìm thấy một trang recently-usedđã bị xóa, đó là trang chúng tôi thay thế. Sau đó, chúng tôi đánh dấu trang mới recently-usedvà thặng dư clock-handcho tới trang.

Đồng hồ, về cơ bản, là một thuật toán xác suất để xấp xỉ LRU. Nếu tốc độ mà trang đang được truy cập cao hơn nhiều so với tốc độ clock-handquay trở lại cùng một trang thì trang đó có xác suất cao được đánh dấu recently-used. Nếu tốc độ mà trang đang được truy cập thấp so với tốc độ clock-handquay lại xung quanh, thì trang có nhiều khả năng không ở trạng thái không recently-used . Trang được sử dụng gần đây nhất sẽ không bao giờ được thay thế. (Tại sao?)