Project Description

In class, we have been discussing various page replacement algorithms that an Operating System implementer may choose to use. In this project, you will compare the results of three different algorithms on traces of memory references. While simulating an algorithm, you will collect statistics about its performance such as the number of page faults that occur and the number of dirty frames that had to be written back to disk. When you are done with your program, you will write up your results and provide a graph that compares the performance of the various algorithms.

The three algorithms for this project are:

NRU – pick a not recently used page using the R and D bits.

LRU – Implement perfect LRU

Aging – Implement the aging algorithm that approximates LRU with an 8-bit counter

For NRU and Aging, do a refresh of the R bits every 5000 memory references.

You may write your program in C/C++, Java, Perl, or Python.

Implement a page table for a 32-bit address space. All pages will be 4KB in size. The number of frames will be a parameter to the execution of your program.

How it Will Work

You will write a program called vmsim that takes the following command line:

./vmsim –n <numframes> -a <nru|lru|aging> <tracefile>

The program will then run through the memory references of the file and display the action taken for each address (hit, page fault – compulsory miss, page fault – evict clean, page fault – evict dirty).

When the trace is over, print out summary statistics in the following format:

Number of frames:       8

Total memory accesses:  1000000

Total page faults:      181856

Total writes to disk:   29401

Implementation

We are providing two sample memory traces. We will grade with two additional ones. The traces are available at /u/OSLab/original/ in the files gcc.trace.gz and swim.trace.gz

Each trace is gzip compressed, so you will have to copy each trace to your directory under /u/OSLab/ and then decompress it like:

gunzip gcc.trace.gz

In the resulting trace file is a sequence of lines, each having a memory address in hexadecimal followed by a R or W character to indicate if that access was a read or a write. For example, gcc.trace trace starts like this:

0041f7a0 R
13f5e2c0 R

If you are writing in C, you may parse each line with the following code:

unsigned int address;
char mode;

fscanf(file, "%x %c", &addr, &mode);

Write Up

For each of your three algorithms, describe in a document the resulting statistics for 8, 32, 64, 128, and 256 frames. Plot them with a line graph with frames on the X-axis and Page Faults on the Y-axis.

Construct a table that indicates the total size of the page table for the various configurations.

Finally, determine which algorithm you think might be most appropriate for use in an actual operating system. Use LRU as the baseline for your comparisons.

File Backups

One of the major contributions the university provides for the AFS filesystem is nightly backups. However, the /u/OSLab/ partition is not part of AFS space. Thus, any files you modify under your personal directory in /u/OSLab/ are not backed up. If there is a catastrophic disk failure, all of your work will be irrecoverably lost. As such, it is my recommendation that you:

Backup all the files you change under /u/OSLab to your ~/private/ directory frequently!

Loss of work not backed up is not grounds for an extension. You have been warned.

Requirements and Submission

You need to submit:

Your well-commented program’s source
A document (.DOC or .PDF) detailing the results of your simulation with a graph plotting the number of page faults versus the number of frames, the table containing the size of the two-level page table, and your conclusions on which algorithm would be best to use in a real OS
Please don’t submit the trace files as they are very large.

Make a tar.gz file as in the first assignment, named USERNAME-project3.tar.gz

Copy it to ~jrmst106/submit/1550 by the deadline for credit.