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 four 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 four algorithms for this project are:

Opt – Simulate what the optimal page replacement algorithm would choose if it had perfect knowledge

Random – Pick a page at random

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

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

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 <opt|aging|nru|rand> [-r <refresh>] <tracefile>

The program will then run through the memory references of the file and display the action taken for each address (hit, page fault – no eviction, 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 bzip.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 bzip.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);

Please Note

Implementing OPT in a naïve fashion will lead to unacceptable performance. It should not take more than 5 minutes to run your program.

Write Up

NRU and Aging both need a time periodic refresh of the R bits. Using a single memory reference as a unit of time, determine experimentally a good number of references to wait between refreshes. Intelligently sample the page faults with different refresh rates. Plot the results on a graph and describe in a paragraph the best choice. You do not need to find the absolute minimum, just approximately how long to wait.

For each of your four algorithms (with NRU and Aging both using the refresh period you determined above), describe in a document the resulting page fault statistics for 8, 32, 64, and 128 frames. Plot them with a line graph with Frames on the X-axis and Page Faults on the Y-axis.

Finally, determine which algorithm you think might be most appropriate for use in an actual operating system. Use OPT 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 and your conclusions on which algorithm would be best to use in a real OS
DO NOT submit the trace files.

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.