This algorithm requires that each page contained in the page table, besides the common attributes, must also contains two further bits:

• reference bit (R): this bit will be 1 when the system accesses the page, both for read and write operations;
• dirty bit (D): this bit will be 1 only when the page will be written: when a page must be removed from main memory, this bit will remember the operative system to make a copy into secondary storage, before wiping it out.

Searching for a virtual page to be removed will take in account of four possible combinations:

1. R=0, D=0: this page has never been used nor modified -> remove this page
2. R=0, D=1: this page has not been recently used, but has been modified -> write it back to secondary storage and set D=0;
3. R=1, D=0: this page has been recently used only for read access -> set R=0
4. R=1, D=1: this page has been recently used and modified -> set R=0, do a write back and set D=0.

Searching for the best page to replace won’t only be equivalent to select the less used page, but also those pages that weren’t modified; in this way, the more the system uses a page, the less is the probability for that page to be removed.

When a page present into the main memory is dirty, the system must issue two I/O requests: the former to access the secondary memory for paging it out, the latter to bring the requested page into memory (page in). In this scenario, by analyzing the dirty pages periodically and writing them back to the storage, the algorithm improves the overall performances as well as average access time to memory.

This algorithm suffers the disadvantage of partitioning the main memory in two classes: pages which are frequently accessed and pages less frequently accessed; when searching for target page ends, it’s not assured that the victim page is the oldest, but only one of the less accessed pages.

The best instance happens when the first frame has both R & D bits equal to zero: searching stops immediately and it’s not necessary to page it out.

The worst case happens when all pages are both referenced and modified: in this scenario the MMU must completely scan all the entries, just like a FIFO.

The simulator, written in C, is made up of different entities, which are:

• process: it simulates a user process which can access to an random memory location or issue a I/O read
• i/o device: a dedicated thread is spawn to simulate an i/o device (it comes with a FIFO queue to serve processes requests)
• mmu: the MMU simulates the Memory Management Unit, i.e. the responsible to translate virtual addresses (generated by a user process) into physical address; it’s also implements the second chance algorithm.

It let the user specify how many processes run, how much physical memory is installed, the page size and so on; it requires only a C compiler (like gcc) and the utility Makefile.

Its output is in italian language, even if very simple terms have been used.

Download vmbo.tar.gz