clock-page-replacement 0.1.1

Simple clock page replacement algorithm implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# Clock Page Replacement

A simple clock page replacement algorithm implementation.

## Usage

First, you should have your type representing a page table entry on a memory implement `Page` trait which requires basic access to some flag bits:

```rust
pub trait Page {
    /// Check if the page is valid.
    fn is_valid(&self) -> bool;

    /// Check if the page is accessed.
    fn is_accessed(&self) -> bool;

    /// Check if the page is dirty.
    fn is_dirty(&self) -> bool;

    /// Set the 'A' bit.
    fn set_accessed(&mut self);

    /// Set the 'D' bit.
    fn set_dirty(&mut self);

    /// Clear the 'A' bit.
    fn clear_accessed(&mut self);

    /// Clear the 'D' bit.
    fn clear_dirty(&mut self);
}
```

Then create a `ClockPageReplacer` instance. Every time you allocate a physical memory page, you should call `ClockPageReplacer::register` to register it to the replacer.

You don't need to unregister a page when it's evicted from the physical memory, because the replacer will automatically remove it when it becomes invalid.

When you need to replace a page, call the `replace` method to get the page to replace. The page is automatically removed from the replacer.