Operating Systems

Start Lecture #20

LIFO PRA

This is terrible! Why?
Ans: All but the last frame are frozen once loaded so you can replace only one frame. This is especially bad after a phase shift in the program as now the program is references mostly new pages but only one frame is available to hold them.

3.4.6 Least Recently Used (LRU) PRA

When a page fault occurs, choose as victim that page that has been unused for the longest time, i.e. the one that has been least recently used.

LRU is definitely

1. Implementable: The past is knowable.
2. Good: Simulation studies have shown this.
3. Difficult. Essentially the system needs to either:
   • Keep a time stamp in each PTE, updated on each reference and scan all the PTEs when choosing a victim to find the PTE with the oldest timestamp.
   • Keep the PTEs in a linked list in usage order, which means on each reference moving the corresponding PTE to the end of the list.

Homework: 28, 22.

A hardware cutsie in Tanenbaum

A clever hardware method to determine the LRU page.

• For n pages, keep an nxn bit matrix.
• On a reference to page i, set row i to all 1s and column i to all 0s.
• At any time the 1 bits in the rows are ordered by inclusion. I.e. one row's 1s are a subset of another row's 1s, which is a subset of a third. (Tanenbaum forgets to mention this.)
• So the row with the fewest 1s is a subset of all the others and is hence least recently used.
• This row also has the smallest value, when treated as an unsigned binary number. So the hardware can do a comparison of the rows rather than counting the number of 1 bits.
• Cute, but still impractical.

3.4.7 Simulating (Approximating) LRU in Software

The Not Frequently Used (NFU) PRA

Keep a count of how frequently each page is used and evict the one that has been the lowest score. Specifically:

• Include a counter (and reference bit R) in each PTE.
• Set the counter to zero when the page is brought into memory.
• Every k clocks, perform the following for each PTE.
  1. Add R to the counter.
  2. Clear R.
• Choose as victim the PTE with lowest count.

The Aging PRA

NFU doesn't distinguish between old references and recent ones. The following modification does distinguish.

• Include a counter (and reference bit, R) in each PTE.
• Set the counter to zero when the page is brought into memory.
• Every k clock ticks, perform the following for each PTE.
  1. Shift the counter right one bit.
  2. Insert R as the new high order bit of the counter.
  3. Clear R.
• Choose as victim the PTE with lowest count.

Aging does indeed give more weight to later references, but an n bit counter maintains data for only n time intervals; whereas NFU maintains data for at least 2ⁿ intervals.

Homework: 24, 33.

3.4.8 The Working Set Page Replacement Algorithm (Peter Denning)

The working set policy

The goals are first to specify which pages a given process needs to have memory resident in order for the process to run without too many page faults and second to ensure that these pages are indeed resident.

But this is impossible since it requires predicting the future. So we again make the assumption that the near future is well approximated by the immediate past.

We measure time in units of memory references, so t=1045 means the time when the 1045th memory reference is issued. In fact we measure time separately for each process, so t=1045 really means the time when this process made its 1045th memory reference.

Definition: w(k,t), the working set at time t (with window k) is the set of pages referenced by the last k memory references ending at reference t.

The idea of the working set policy is to ensure that each process keeps its working set in memory.

• Allocate |w(t,k)| frames to each process. This number differs for each process and changes with time.
• On a fault, evict a page not in the working set. But it is not easy to find such a page quickly. Indeed determining w(t,k) precisely is quite time consuming and difficult. It is never done in real systems.
• If a process is suspended and swapped out; the working set then can be used to say which pages should be brought back when the process is resumed.

Homework: Describe a process (i.e., a program) that runs for a long time (say hours) and always has a working set size less than 10. Assume k=100,000 and the page size is 4KB. The program need not be practical or useful.

Homework: Describe a process that runs for a long time and (except for the very beginning of execution) always has a working set size greater than 1000. Again assume k=100,000 and the page size is 4KB. The program need not be practical or useful.

The definition of Working Set is local to a process. That is, each process has a working set; there is no system wide working set other than the union of all the working sets of each process.

However, the working set of a single process has effects on the demand paging behavior and victim selection of other processes. If a process's working set is growing in size, i.e., w(t,k) is increasing as t increases, then we need to obtain new frames from other processes. A process with a working set decreasing in size is a source of free frames. We will see below that this is an interesting amalgam of local and global replacement policies.

Interesting questions concerning the working set include:

1. What value should be used for k?
   Experiments have been done and k is surprisingly robust (i.e., for a given system, a fixed value works reasonably for a wide variety of job mixes).
2. How should we calculate w(t,k)?
   Hard to do exactly so ...

... Various approximations to the working set, have been devised. We will study two: Using virtual time instead of memory references (immediately below), and Page Fault Frequency (part of section 3.5.1). In 3.4.9 we will see the popular WSClock algorithm that includes an approximation of the working set as well as several other ideas.

Using Virtual Time

Instead of counting memory referenced and declaring a page in the working set if it was used within k references, we keep track of time, which the system does anyway, and declare a page in the working set if it was used in the past τ seconds. Note that the time is measured only while this process is running, i.e., we are using virtual time.

1. Add a field time of last use to the PTE. The procedure for setting this field is in item 3 below.
2. Clear the reference R bit every m milliseconds and set it on every reference, the latter is done by the hardware.
3. To choose a victim when a page fault occurs, we proceed as follows (also setting the time of last use field). Scan the page table one PTE at a time (actually we are only interested in resident pages so we would rather look at a page frame table).
   • If the R bit is 1, the page is in the working set so set the time of last use to the current (virtual) time. (We are assuming τ seconds is bigger than m milliseconds.)
   • If the R bit is 0 and the last use was more than τ seconds ago, the page is not in the working set and is evicted (but we keep scanning).
   • If the R bit is 0 but the last use is less than τ seconds ago, the page is in the working set so is not evicted.
   • If no page was chosen for eviction, evict the LRU page.

3.4.9 The WSClock Page Replacement Algorithm

This is too good and important to skip, but too detailed to remember. Thus it is not grayed out, but I won't ask detailed questions about it on the final.

The WSClock algorithm combines aspects of the working set algorithm and the clock implementation of second chance.

Like clock we create a circular list of nodes with a hand pointing to the next node to examine. There is one such node for every resident page of this process; thus the nodes can be thought of as a list of frames or a kind of inverted page table.

Like working set we store in each node the referenced and modified bits R and M and the time of last use. R and M are cleared when the page is read in. R is set by the hardware on a reference and cleared periodically by the OS (perhaps at the end of each page fault or perhaps every m milliseconds). M is set by the hardware on a write. We indicate below the setting of the time of last use and the clearing of M.

As with working set, we use virtual time and declare a page old if its last reference is more than τ seconds in the past. Other pages are declared young (i.e., in the working set).

As with clock, on every page fault a victim is found by scanning the list starting with the node indicated by the clock hand.

• If R=1, the page has been recently referenced. R is set to 0, the time of last use is set to now, and the hand advances.
• If R=0 and M=1, clear M, (schedule an I/O to) write the dirty page, and advance the hand.
• If R=M=0 and the page is young, advance the hand.
• If R=M=0 and the page is old, this is our victim; done.

It is possible to go all around the clock without finding a victim. In that case

• If writes were scheduled on old pages, one of these will become the victim once it becomes clean.
• If no writes were scheduled, we will never find a victim (since nothing will change) so pick a page at random (or perhaps the oldest of the young pages).
• If only young pages are scheduled for writing, no old victim will be chosen so we will need to again pick a page at random (if every page is dirty, we must wait for one to become clean).

An alternative treatment of WSClock, including more details of its interaction with the I/O subsystem, can be found here.

3.4.10 Summary of Page Replacement Algorithms