4.4.8: The Working Set Page Replacement Problem (Peter Denning)

The working set policy (Peter Denning)

The goal is to specify which pages a given process needs to have memory resident in order for the give process to run without too many page faults.

• But this is impossible since it requires predicting the future.
• So we make the assumption that the immediate future is well approximated by the immediate past.
• 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.
• W(t,&omega) is the set of pages referenced (by the given process) from time t-ω to time t.
• That is, W(t,ω) is the set pages referenced during the window of size ω ending at time t.
• That is, W(t,ω) is the set of pages referenced by the last ω memory references ending at reference t.
• W(t,ω) is called the working set at time t (with window ω).
• Does this Netscape support the ω notation to give the Greek letter?
• w(t,ω) is the size of the set W(t,ω), i.e. is the number of pages referenced in the window.

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

• Allocate w(t,ω) frames to each process. This number differs for each process and changes with time.
• On a fault, one replaces a page not in the working set. But it is not easy to find such a page quickly.
• Indeed determining W(t,ω) is difficult.
• We will see that the working set algorithm is essentially a ``global policy'' (defined below). I would actually prefer covering the working set policy after defining local and global policies but decided to follow Tannenbaum.
• If a process is suspended, it is often swapped out; the working set then can be used to say which pages should be brought back when the process is resumed.

Interesting questions include:

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

... Various approximations to the working set, have been devised. We will study three: using virtual time instead of memory references (immediately below), WSClock (section 4.4.9), and Page Fault Frequency (section 4.6).

Using virtual time

Approximate the working set as those pages referenced during the last m milliseconds. Then clear the reference bit every m milliseconds and set it on every reference. Note that the time is measured only while this process is running. That is why it is called virtual time. So now to choose a victim, we need to find a page with the R bit clear. Similar to NRU.

4.4.9: The WSClock Page Replacement Algorithm

• Use the aging algorithm above to maintain a counter for each PTE and declare a page whose counter is above a certain threshold to be part of the working set.
• Apply the clock algorithm globally (i.e. to all pages) but refuse to page out any page in a working set. The resulting algorithm is called wsclock.
• What if we find there are no pages we can page out?
  Simple answer: Pick some page (almost at random).
  Another answer: Reduce the multiprogramming level (explained in 4.6 below).

4.4.10: Summary of Page Replacement Algorithms

4.5: Modeling Paging Algorithms

4.5.1: Belady's anomaly

Consider a system that has no pages loaded and that uses the FIFO PRU.
Consider the following ``reference string'' (sequences of pages referenced).

 0 1 2 3 0 1 4 0 1 2 3 4

If we have 3 frames this generates 9 page faults (do it).

If we have 4 frames this generates 10 page faults (do it).

Theory has been developed and certain PRA (so called ``stack algorithms'') cannot suffer this anomaly for any reference string. FIFO is clearly not a stack algorithm. LRU is. Tannenbaum has a few details, but we are skipping it.

Repeat the above calculations for LRU.

4.6: Design issues for (demand) Paging Systems

4.6.1: Local vs Global Allocation Policies

A local PRA is one is which a victim page is chosen among the pages of the same process that requires a new page. That is the number of pages for each process is fixed. So LRU means the page least recently used by this process.

• Of course we can't have a purely local policy, why?
  Answer: A new process has no pages and even if we didn't apply this for the first page loaded, the process would remain with only one page.
• Perhaps wait until a process has been running a while or give the process an initial allocation based on the size of the executable.
• A global policy is one in which the choice of victim is made among all pages of all processes.

If we apply global LRU indiscriminately with some sort of RR processor scheduling policy, and memory is somewhat over-committed, then by the time we get around to a process, all the others have run and have probably paged out this process.

If this happens each process will need to page fault at a high rate; this is called thrashing.

It is therefore important to get a good idea of how many pages a process needs, so that we can balance the local and global desires. The working set W(t,ω) is good for this.

An approximation to the working set policy that is useful for determining how many frames a process needs (but not which pages) is the Page Fault Frequency (PFF) algorithm.

• For each process keep track of the page fault frequency, which is the number of faults divided by the number of references.
• Actually, must use a window or a weighted calculation since you are really interested in the recent page fault frequency.
• If the PFF is too high, allocate more frames to this process. Either
  1. Raise its number of frames and use a local policy; or
  2. Bar its frames from eviction (for a while) and use a global policy.
• What if there are not enough frames?
  Answer: Reduce the MPL (see next section).

As mentioned above a question arises what to do if the sum of the working set sizes exceeds the amount of physical memory available. This question is similar to the final point about PFF and brings us to consider controlling the load (or memory pressure).

4.6.2: Load Control

To reduce the overall memory pressure, we must reduce the multiprogramming level (or install more memory while the system is running, which is hardly practical). That is, we have a connection between memory management and process management. This is the suspend/resume arcs we saw way back when.