Once your system is working correctly, you will evaluate the performance of several page replacement algorithms on a selection of simple programs across a range of memory sizes. You will write a short lab report that explains the experiments, describes your results, and draws conclusions about the behavior of each algorithm.
This project is split into two parts. Part 1 is to write the virtual memory code, and is due on Friday, April 17th. Part 2 is to conduct a performance evaluation of your code and write a lab report, due on Wednesday, April 29th.
git clone https://github.com/dthain/cse30341-spring-2020 cd cse30341-spring-2020 cd project5 make(Note that the page table code does some very Linux specific magic, and so you should be sure to run it on the CSE student machines.)
Look through main.c and notice that the program simply creates a virtual disk and page table, and then attempts to run one of our three "programs" using the virtual memory. Because no mapping has been made between virtual and physical memory, a page fault happens immediately:
% ./virtmem 100 10 rand alpha page fault on page #0The program exits because the page fault handler isn't written yet. That is your job!
Try this as a getting started exercise. If you run the program with an equal number of pages and frames, then the disk is completely unneeded: physical memory is large enough to accommodate every page. In that case, just make page N map directly to frame N, and do nothing else. So, modify the page fault handler to do that:
page_table_set_entry(pt,page,page,PROT_READ|PROT_WRITE);With that trivial page fault handler, all of the example programs will run, cause a number of page faults, but then run to completion. (And will also tell you the "correct" result computed for that program.)
Congratulations, you have written your first page fault handler!
Of course, when there are fewer frames than pages, then this simple scheme will not do. Instead, we must keep recently used pages in the physical memory, other pages on disk, and update the page table appropriately as they move back and forth.
|Let's work through an example, starting with the figure at the right. Suppose that we begin with nothing in physical memory. If the application begins by trying to read page 2, this will result in a page fault. The page fault handler choose a free frame, say frame 3. It then adjusts the page table to map page 2 to frame 3, with read permissions. Then, it loads page 2 from disk into page 3. When the page fault handler completes, the read operation is re-attempted, and succeeds.|
|The application continues to run, reading various pages. Suppose that it reads pages 3, 5, 6, and 7, each of which result in a page fault, and must be loaded into memory as before. Now physical memory is fully in use.|
|Now suppose that the application attempts to write to page 5. Because this page only has the R bit set, a page fault will result. The page fault handler looks at the current page bits, and upon seeing that it already has the PROT_READ bit set, adds the PROT_WRITE bit. The page fault handler returns, and the application can continue. Page 5, frame 1 is modified.|
|Now suppose that the application reads page 1. Page 1 is not currently paged into physical memory. The page fault handler must decide which frame to remove. Suppose that it picks page 5, frame 0 at random. Because page 5 has the PROT_WRITE bit set, we know that it is dirty. So, the page fault handler writes page 5 back to the disk, and reads page 1 in its place. Two entries in the page table are updated to reflect the new situation.|
./virtmem npages nframes rand|fifo|custom alpha|beta|gamma|deltanpages is the number of pages and nframes is the number of frames to create in the system. The third argument is the page replacement algorithm. You must implement rand (random replacement), fifo (first-in-first-out), and custom, an algorithm of your own invention. The final argument specifies which built-in program to run: alpha, beta, gamma, or delta. Each manipulates the virtual memory with a different pattern of access.
You may only modify the file main.c. Your job is to implement three page replacement algorithms. rand and fifo should be implemented as discussed in class. You should invent a third algorithm, custom that performs better than rand or fifo for at least some of the four programs. "Better" in this case means that it results in fewer disk reads and writes.
A complete and correct program will run each of the sample programs to completion with only the following output:
Part 1 is due at 11:59PM EST on Friday, April 17th. If you have unusual circumstances that would prevent you from meeting that deadline, please contact Prof. Thain.
Your dropbox directory is /escnfs/courses/sp20-cse-30341.01/dropbox/YOURNAME. Make a directory called project5 there and copy your source files and Makefile into that directory. (Please don't turn in any executables, virtual disks, or other large files.)
Write up a lab report document that has the following elements:
Please submit a file called report.pdf into the same dropbox directory for the Project 5 code.