4.4. Page Replacement Algorithms
When a page fault occurs, the operating system has to choose a page to remove from memory to make room for the page that has to be brought in. If the page to be removed has been modified while in memory, it must be rewritten to the disk to bring the disk copy up to date. If, however, the page has not been changed (e.g., it contains program text), the disk copy is already up to date, so no rewrite is needed. The page to be read in just overwrites the page being evicted.
While it would be possible to pick a random page to evict at each page fault, system performance is much better if a page that is not heavily used is
. If a heavily used page is removed, it will probably have to be brought back in quickly, resulting in extra overhead. Much work has been done on the subject of page replacement algorithms, both theoretical and experimental. Below we will describe some of the most important algorithms.
It is worth noting that the problem of "page replacement" occurs in other areas of computer design as well. For example, most computers have one or more memory caches consisting of recently used 32-byte or 64-byte memory blocks. When the cache is full, some block has to be chosen for removal. This problem is precisely the same as page replacement except on a shorter time scale (it has to be done in a few nanoseconds, not
as with page replacement). The reason for the shorter time scale is that cache block misses are satisfied from main memory, which has no seek time and no rotational latency.
A second example is in a web browser. The browser keeps copies of previously accessed web pages in its cache on the disk. Usually, the maximum cache
is fixed in advance, so the cache is likely to be full if the browser is used a lot. Whenever a web page is referenced, a check is made to see if a copy is in the cache and if so, if the page on the web is newer. If the cached copy is up to date, it is used;
, a fresh copy is
from the Web. If the page is not in the cache at all or a newer version is available, it is downloaded. If it is a
copy of a cached page it
the one in the cache. When the cache is full a decision has to be made to evict some other page in the case of a new page or a page that is larger than an older version. The considerations are similar to pages of virtual memory, except for the fact that the Web pages are never modified in the cache and thus are never written back to the web server. In a virtual memory system, pages in main memory may be either clean or dirty.
4.4.1. The Optimal Page Replacement Algorithm
The best possible page replacement algorithm is easy to describe but
to implement. It goes like this. At the moment that a page fault occurs, some set of pages is in memory. One of these pages will be referenced on the very
instruction (the page containing that instruction). Other pages may not be referenced until 10, 100, or perhaps 1000 instructions later. Each page can be labeled with the number of instructions that will be executed before that page is first referenced.
The optimal page algorithm simply says that the page with the highest label should be removed. If one page will not be used for 8 million instructions and another page will not be used for 6 million instructions, removing the former pushes the page fault that will fetch it back as far into the future as possible. Computers, like people, try to put off unpleasant events for as long as they can.
The only problem with this algorithm is that it is unrealizable. At the time of the page fault, the operating system has no way of knowing when each of the pages will be referenced next. (We saw a similar situation earlier with the shortest-job-first scheduling algorithmhow can the system tell which job is shortest?) Still, by running a program on a simulator and keeping track of all page references, it is possible to implement optimal page replacement on the
run by using the page reference information collected during the
In this way it is possible to compare the performance of realizable algorithms with the best possible one. If an operating system achieves a performance of, say, only 1 percent
than the optimal algorithm, effort spent in looking for a better algorithm will yield at most a 1 percent improvement.
To avoid any possible confusion, it should be made clear that this log of page references refers only to the one program just measured and then with only one specific input. The page replacement algorithm derived from it is thus specific to that one program and input data. Although this method is useful for evaluating page replacement algorithms, it is of no use in practical systems. Below we will study algorithms that
useful on real systems.
4.4.2. The Not Recently Used Page Replacement Algorithm
In order to allow the operating system to collect useful statistics about which pages are being used and which ones are not, most computers with virtual memory have two status bits associated with each page.
is set whenever the page is referenced (read or written).
is set when the page is written to (i.e., modified). The bits are contained in each page table entry, as shown in Fig. 4-11. It is important to realize that these bits must be updated on every memory reference, so it is essential that they be set by the hardware. Once a bit has been set to 1, it stays 1 until the operating system resets it to 0 in software.
If the hardware does not have these bits, they can be simulated as
. When a process is started up, all of its page table entries are
as not in memory. As soon as any page is referenced, a page fault will occur. The operating system then sets the
bit (in its internal tables), changes the page table entry to point to the correct page, with mode READ ONLY, and restarts the instruction. If the page is subsequently written on, another page fault will occur, allowing the operating system to set the
bit as well and change the page's mode to READ/WRITE.
bits can be used to build a simple paging algorithm as follows. When a process is started up, both page bits for all its pages are set to 0 by the operating system. Periodically (e.g., on each clock interrupt), the
bit is cleared, to distinguish pages that have not been referenced recently from those that have been.
When a page fault occurs, the operating system inspects all the pages and divides them into four categories based on the current values of their
Class 0: not referenced, not modified.
Class 1: not referenced, modified.
Class 2: referenced, not modified.
Class 3: referenced, modified.
Although class 1 pages seem, at first glance, impossible, they occur when a class 3 page has its
bit cleared by a clock interrupt. Clock interrupts do not clear the
bit because this information is needed to know whether the page has to be rewritten to disk or not. Clearing
leads to a class 1 page.
Not Recently Used
a page at random from the
class. Implicit in this algorithm is that it is better to remove a modified page that has not been referenced in at least one clock tick (typically 20 msec) than a clean page that is in heavy use. The main attraction of NRU is that it is easy to understand, moderately efficient to implement, and gives a performance that, while
not optimal, may be adequate.
4.4.3. The First-In, First-Out (FIFO) Page Replacement Algorithm
Another low-overhead paging algorithm is the
how this works, consider a
that has enough
to display exactly
different products. One day, some company introduces a new convenience foodinstant, freeze-
, organic yogurt that can be reconstituted in a microwave oven. It is an immediate success, so our finite supermarket has to get rid of one old product in order to stock it.
One possibility is to find the product that the supermarket has been stocking the longest (i.e., something it
ago) and get rid of it on the grounds that no one is interested any more. In effect, the supermarket maintains a linked list of all the products it currently sells in the order they were introduced. The new one goes on the back of the list; the one at the front of the list is dropped.
As a page replacement algorithm, the same idea is
. The operating system maintains a list of all pages currently in memory, with the page at the head of the list the oldest one and the page at the tail the most recent arrival. On a page fault, the page at the head is removed and the new page added to the tail of the list. When applied to stores, FIFO might remove
wax, but it might also remove flour, salt, or butter. When applied to computers the same problem arises. For this reason, FIFO in its pure form is rarely used.
4.4.4. The Second Chance Page Replacement Algorithm
A simple modification to FIFO that avoids the problem of throwing out a heavily used page is to inspect the
bit of the oldest page. If it is 0, the page is both old and unused, so it is
immediately. If the
bit is 1, the bit is cleared, the page is put onto the end of the list of pages, and its load time is updated as though it had just arrived in memory. Then the search continues.
The operation of this algorithm, called
, is shown in Fig. 4-14. In Fig. 4-14(a) we see pages
kept on a linked list and sorted by the time they arrived in memory.
Figure 4-14. Operation of second chance. (a) Pages sorted in FIFO order. (b) Page list if a page fault occurs at time 20 and
bit set. The
above the pages are their loading times.
(This item is displayed on page 400 in the print version)
Suppose that a page fault occurs at time 20. The oldest page is
, which arrived at time 0, when the process started. If
bit cleared, it is evicted from memory, either by being written to the disk (if it is dirty), or just
(if it is clean). On the other hand, if the
bit is set,
is put onto the end of the list and its "load time" is reset to the current time (20). The
bit is also cleared. The search for a suitable page continues with
What second chance is doing is looking for an old page that has not been referenced in the previous clock interval. If all the pages have been referenced, second chance degenerates into pure FIFO. Specifically, imagine that all the pages in Fig. 4-14(a) have their
bits set. One by one, the operating system moves the pages to the end of the list, clearing the
bit each time it appends a page to the end of the list. Eventually, it comes back to page
, which now has its
bit cleared. At this point
is evicted. Thus the algorithm always terminates.
4.4.5. The Clock Page Replacement Algorithm
Although second chance is a reasonable algorithm, it is unnecessarily inefficient because it is constantly moving pages around on its list. A better approach is to keep all the page
on a circular list in the form of a clock, as shown in Fig. 4-15. A hand points to the oldest page.
Figure 4-15. The clock page replacement algorithm.
When a page fault occurs, the page being pointed to by the hand is inspected. If its
bit is 0, the page is evicted, the new page is inserted into the clock in its place, and the hand is advanced one position. If
is 1, it is cleared and the hand is advanced to the next page. This process is repeated until a page is found with
= 0. Not surprisingly, this algorithm is called
from second chance only in the implementation, not in the page selected.
4.4.6. The Least Recently Used (LRU) Page Replacement Algorithm
to the optimal algorithm is based on the observation that pages that have been heavily used in the last few instructions will probably be heavily used again in the next few. Conversely, pages that have not been used for ages will probably
unused for a long time. This idea suggests a realizable algorithm: when a page fault occurs, throw out the page that has been unused for the longest time. This strategy is called
Least Recently Used
Although LRU is theoretically realizable, it is not cheap. To fully implement LRU, it is necessary to maintain a linked list of all pages in memory, with the most recently used page at the front and the least recently used page at the rear. The difficulty is that the list must be updated on every memory reference. Finding a page in the list, deleting it, and then moving it to the front is a very
operation, even in hardware (
that such hardware could be built).
However, there are other ways to implement LRU with special hardware. Let us consider the simplest way first. This method requires
the hardware with a 64-bit counter,
, that is automatically incremented after each instruction. Furthermore, each page table entry must also have a field large enough to contain the counter. After each memory reference, the current value of
is stored in the page table entry for the page just referenced. When a page fault occurs, the operating system examines all the counters in the page table to find the lowest one. That page is the least recently used.
Now let us look at a second hardware LRU algorithm. For a machine with
page frames, the LRU hardware can maintain a matrix of
bits, initially all zero. Whenever page frame
is referenced, the hardware first sets all the bits of row
to 1, then sets all the bits of column
to 0. At any instant, the row whose binary value is lowest is the least recently used, the row whose value is next lowest is next least recently used, and so forth. The workings of this algorithm are given in Fig. 4-16 for four page frames and page references in the order
Figure 4-16. LRU using a matrix when pages are referenced in the order 0, 1, 2, 3, 2, 1, 0, 3, 2, 3.
(This item is displayed on page 402 in the print version)
0 1 2 3 2 1 0 3 2 3
After page 0 is referenced, we have the situation of Fig. 4-16(a). After page 1 is referenced, we have the situation of Fig. 4-16(b), and so forth.
4.4.7. Simulating LRU in Software
Although both of the previous LRU algorithms are realizable in principle, few, if any, machines have this hardware, so they are of little use to the operating system designer who is making a system for a machine that does not have this hardware. Instead, a solution that can be implemented in software is needed. One possible software solution is called the
Not Frequently Used
) algorithm. It requires a software counter associated with each page, initially zero. At each clock interrupt, the operating system
all the pages in memory. For each page, the
bit, which is 0 or 1, is added to the counter. In effect, the counters are an attempt to keep track of how often each page has been referenced. When a page fault occurs, the page with the lowest counter is chosen for replacement.
The main problem with NFU is that it never forgets anything. For example, in a multipass compiler, pages that were heavily used during pass 1 may still have a high count well into later passes. In fact, if pass 1 happens to have the longest execution time of all the
, the pages containing the code for
passes may always have lower counts than the pass 1 pages. Thus the operating system will remove useful pages instead of pages no longer in use.
Fortunately, a small modification to NFU makes it able to simulate LRU quite well. The modification has two
. First, the counters are each shifted right 1 bit before the
bit is added in. Second, the
bit is added to the leftmost, rather than the rightmost bit.
Figure 4-17 illustrates how the modified algorithm, known as
, works. Suppose that after the first clock tick the
bits for pages 0 to 5 have the values 1, 0, 1, 0, 1, and 1, respectively (page 0 is 1, page 1 is 0, page 2 is 1, etc.). In other words, between tick 0 and tick 1, pages 0, 2, 4, and 5 were referenced, setting their
bits to 1, while the other ones remain 0. After the six corresponding counters have been shifted and the
bit inserted at the left, they have the values shown in Fig. 4-17(a). The four remaining
show the values of the six counters after the next four clock
Figure 4-17. The aging algorithm simulates LRU in software. Shown are six pages for five clock ticks. The five clock ticks are represented by (a) to (e).
When a page fault occurs, the page whose counter is the lowest is removed. It is clear that a page that has not been referenced for, say, four clock ticks will have four leading zeros in its counter and thus will have a lower value than a counter that has not been referenced for three clock ticks.
This algorithm differs from LRU in two ways. Consider pages 3 and 5 in Fig. 4-17(e). Neither has been referenced for two clock ticks; both were referenced in the tick prior to that. According to LRU, if a page must be replaced, we should choose one of these two. The trouble is, we do not know which of these two was referenced last in the interval between tick 1 and tick 2. By recording only one bit per time interval, we have lost the ability to distinguish references early in the clock interval from those occurring later. All we can do is remove page 3, because page 5 was also referenced two ticks earlier and page 3 was not referenced then.
The second difference between LRU and aging is that in aging the counters have a finite number of bits, 8 bits in this example. Suppose that two pages each have a counter value of 0. All we can do is pick one of them at random. In reality, it may well be that one of the pages was last referenced 9 ticks ago and the other was last referenced 1000 ticks ago. We have no way of seeing that. In practice, however, 8 bits is
enough if a clock tick is around 20 msec. If a page has not been referenced in 160 msec, it probably is not that important.