Next: File Management Up: Memory Management Previous: Virtual Memory Contents

Page Replacement Algorithms [174]

FIFO:

``replace the oldest page'' (or use a free frame)
usually implemented with a linked (FIFO) list

int fifo_alg() {
int save_reg,page,frame,earliest_time;
  save_reg = FTVR;
  earliest_time = INFINITY;
  do {
    FTVR++;
    if (FTVR >= FTLR) FTVR = 0;
    page = FTBR->entries[FTVR].page;
    if (page == NIL) return(FTVR);
    if (PTBR->entries[page].first_time < earliest_time) {
      earliest_time = PTBR->entries[page].first_time;
      frame = FTVR;
    }
  } while (FTVR != save_reg);
  FTVR = frame; 
  return(FTVR);
}

VM: MEM - A Simulator [175]

mem> h
i(nit    pages frames [pages in 1..20, frames in 1..20]
r(ead    page         [page  in 0..19]
w(rite   page         [page  in 0..19]
d(elete  page         [page  in 0..19]
l(ogical addr         [page:22bits offset:10bits]
a(lgorithm 0:FIFO|1:OPT|2:LRU_TIME|3:LRU_REF|4:CLOCK|5:LFU|6:MFU|
           7:ENHANCED|8:LRU_STACK
m(ode      0:DETAILED|1:FRAMES|2:SUMMARY
v(irtual   0:OFF|1:ON
n(ogo                 [save all reads for go]
g(o                   [do all reads; for SUMMARY try all frames]
q(uit
mem> quit

VM: Page and Frame Tables in MEM [176]

mem> alg 0
mem> mode 0
mem> init 8 3
mem> logical 1026
     Page Tbl   Frame Tbl   (Alg:0)
     frame bit       page
   0     0   0          1 < Fault 1
>  1     0   1         -1
   2     0   0         -1
   3     0   0 
   4     0   0 
   5     0   0 
   6     0   0 
   7     0   0 
Logical  Address page :  1   offset:    2
Physical Address frame:  0   offset:    2

[V.B] VM: FIFO using MEM [177]

mem> alg 0 
mem> mode 1
mem> init 8 3
mem> r 7 r 0 r 1 r 2 r 0 r 3 r 0 r 4 r 2 r 3 r 0 r 3 r 2 r 1 r 2 r 0 r 1 r 7 
     r 0 r 1
     page: 7  faults: 1  frames:  7 -1 -1  time:  1 
           0          2           7  0 -1         1  2 
           1          3           7  0  1         1  2  3 
           2          4           2  0  1         4  2  3 
           0          4           2  0  1         4  2  3 
           3          5           2  3  1         4  6  3 
           0          6           2  3  0         4  6  7 
           4          7           4  3  0         8  6  7 
           2          8           4  2  0         8  9  7 
           3          9           4  2  3         8  9 10 
           0         10           0  2  3        11  9 10 
           3         10           0  2  3        11  9 10 
           2         10           0  2  3        11  9 10 
           1         11           0  1  3        11 14 10 
           2         12           0  1  2        11 14 15 
           0         12           0  1  2        11 14 15 
           1         12           0  1  2        11 14 15 
           7         13           7  1  2        18 14 15 
           0         14           7  0  2        18 19 15 
           1         15           7  0  1        18 19 20

VM: Optimal Algorithm [178]

``replace the page that will not be used for the longest time''
lowest page-fault rate of all algorithms
requires advanced knowledge of page reference string
useful for comparison studies

[V.B] VM: OPT using MEM [179]

mem> nogo
mem> r 7 r 0 r 1 r 2 r 0 r 3 r 0 r 4 r 2 r 3 r 0 r 3 r 2 r 1 r 2 r 0 r 1 r 7
     r 0 r 1
mem> go
     page: 7  faults: 1  frames:  7 -1 -1
           0          2           7  0 -1
           1          3           7  0  1 
           2          4           2  0  1 
           0          4           2  0  1 
           3          5           2  0  3 
           0          5           2  0  3 
           4          6           2  4  3 
           2          6           2  4  3 
           3          6           2  4  3 
           0          7           2  0  3 
           3          7           2  0  3 
           2          7           2  0  3 
           1          8           2  0  1 
           2          8           2  0  1 
           0          8           2  0  1 
           1          8           2  0  1 
           7          9           7  0  1 
           0          9           7  0  1 
           1          9           7  0  1

VM: Least Recently Used (LRU) [180]

FIFO: when a page was brought into memory in the past
OPT: when a page is used in the future
LRU: when a page was used in the past
``replace the page that has not been used for the longest time''
requires a logical clock time for each page (LRU_TIME)
or a stack of recent page references (LRU_STACK)
or a list of all references (LRU_REF)
same as OPT but on reverse of page reference string
optimal algorithm looking backward in time

VM: LRU_TIME using MEM [181]

better than FIFO (15) but worst than OPT (9)

     page: 7  faults: 1  frames:  7 -1 -1  time:  1 
           0          2           7  0 -1         1  2 
           1          3           7  0  1         1  2  3 
           2          4           2  0  1         4  2  3 
           0          4           2  0  1         4  5  3 
           3          5           2  0  3         4  5  6 
           0          5           2  0  3         4  7  6 
           4          6           4  0  3         8  7  6 
           2          7           4  0  2         8  7  9 
           3          8           4  3  2         8 10  9 
           0          9           0  3  2        11 10  9 
           3          9           0  3  2        11 12  9 
           2          9           0  3  2        11 12 13 
           1         10           1  3  2        14 12 13 
           2         10           1  3  2        14 12 15 
           0         11           1  0  2        14 16 15 
           1         11           1  0  2        17 16 15 
           7         12           1  0  7        17 16 18 
           0         12           1  0  7        17 19 18 
           1         12           1  0  7        20 19 18

VM: LRU_STACK [182]

keep a stack of every page which owns a frame
on each reference
find the page within the stack and remove it
push the page onto the top of the stack
on page fault:
if FREE frame, take it
otherwise, LRU page is at the bottom of the stack
return its frame

VM: LRU_STACK using MEM [183]

     page: 7  faults: 1  frames:  7 -1 -1  stack:  7 
           0          2           7  0 -1          7  0 
           1          3           7  0  1          7  0  1 
           2          4           2  0  1          0  1  2 
           0          4           2  0  1          1  2  0 
           3          5           2  0  3          2  0  3 
           0          5           2  0  3          2  3  0 
           4          6           4  0  3          3  0  4 
           2          7           4  0  2          0  4  2 
           3          8           4  3  2          4  2  3 
           0          9           0  3  2          2  3  0 
           3          9           0  3  2          2  0  3 
           2          9           0  3  2          0  3  2 
           1         10           1  3  2          3  2  1 
           2         10           1  3  2          3  1  2 
           0         11           1  0  2          1  2  0 
           1         11           1  0  2          2  0  1 
           7         12           1  0  7          0  1  7 
           0         12           1  0  7          1  7  0 
           1         12           1  0  7          7  0  1

VM: LRU_REF [184]

new page reference : 4
current frame pages: 2 0 3
current ref string : 7 0 1 2 0 3 0 4
reverse ref string : 4 0 3 0 2 1 0 7
apply OPT algorithm: 2 0 3 yields 4 0 3

VM: LRU Approximations [185]

hardware usually does not support LRU
but does support REF bit
interrupt every 100 msec
move REF bit to 8-bit shift register (and clear)
00000000 IMPLIES no refs in last 8 periods
11111111 IMPLIES at least one ref in each period
01111111 IMPLIES no ref in the recent period
smallest integer IMPLIES approximately LRU
``additional-reference-bits algorithm''
ONE bit of history
just use the REF bit itself
``second-chance'' page-replacement algorithm

Second-Chance (CLOCK) Algorithm [186]

$\begin{picture}(560,354)(20,480) \thicklines\put(120,735){\framebox (30,20){}} \... ... 20,715){\makebox(0,0)[lb]{\raisebox{0pt}[0pt][0pt]{next victim}}} \end{picture}$

if REF then clear bit (NOREF) and move on
next victim is a NOREF
if all pages have been referenced then CLOCK = FIFO

VM: CLOCK Circular Queue [187]

$\begin{picture}(340,339)(40,480) \thicklines\put( 40,500){\framebox (140,300){}}... ...310,580){\makebox(0,0)[lb]{\raisebox{0pt}[0pt][0pt]{frame table}}} \end{picture}$

frame table is circular queue of pages

VM: CLOCK using MEM [188]

better than FIFO (15) but worse than LRU (12)

     page: 7  faults: 1  frames:  7 -1 -1   ref:  1 
           0          2           7  0 -1         1  1 
           1          3           7  0  1         1  1  1 
           2          4           2  0  1         1  0  0 
           0          4           2  0  1         1  1  0 
           3          5           2  0  3         1  0  1 
           0          5           2  0  3         1  1  1 
           4          6           4  0  3         1  0  0 
           2          7           4  2  3         1  1  0 
           3          7           4  2  3         1  1  1 
           0          8           4  2  0         0  0  1 
           3          9           3  2  0         1  0  1 
           2          9           3  2  0         1  1  1 
           1         10           3  1  0         0  1  0 
           2         11           3  1  2         0  1  1 
           0         12           0  1  2         1  1  1 
           1         12           0  1  2         1  1  1 
           7         13           0  7  2         0  1  0 
           0         13           0  7  2         1  1  0 
           1         14           0  7  1         1  1  1

VM: ENHANCED Second Chance [189]

if victim is dirty then it costs time to write it out
better to choose a non-dirty victim (Macintosh VM)

   class1: (ref=0,dirty=0) => good page to replace
   class2: (0,1) => not as good because old page needs to be written
   class3: (1,0) => not good because its recently referenced
   class4: (1,1) => definitely not good because it also has to be written

   PASS:    do
               a. if empty frame, take it
               b. if class1, take it
               c. if class2, then record first instance
               d. clear ref bit if class 2 has not been found yet
            until complete pass
            if class2 was found, take first instance
            invariant1: there are no free frames
            invariant2: there are only class1 and class2 because
                        all bits were cleared.

   if the first PASS does not succeed, try one more PASS

VM: ENHANCED using MEM [190]

if no writing, ENHANCED = CLOCK
in the case below, WRITES alter the sequence of events

    rpage: 7  faults: 1  frames:  7 -1 -1  ref,dirty:  1,0
           0          2           7  0 -1              1,0 1,0
    wpage: 1          3           7  0  1              1,0 1,0 1,1
           2          4           2  0  1              1,0 0,0 0,1
           0          4           2  0  1              1,0 1,0 0,1
           3          5           2  0  3              1,0 0,0 1,0
    wpage: 0          5           2  0  3              1,0 1,1 1,0
           4          6           4  0  3              1,0 0,1 0,0
           2          7           4  0  2              1,0 0,1 1,0
           3          8           4  3  2              0,0 1,0 1,0
           0          9           0  3  2              1,0 1,0 0,0
           3          9           0  3  2              1,0 1,0 0,0
           2          9           0  3  2              1,0 1,0 1,0
           1         10           0  1  2              0,0 1,0 0,0
           2         10           0  1  2              0,0 1,0 1,0
           0         10           0  1  2              1,0 1,0 1,0
           1         10           0  1  2              1,0 1,0 1,0
           7         11           0  1  7              0,0 0,0 1,0
           0         11           0  1  7              1,0 0,0 1,0
           1         11           0  1  7              1,0 1,0 1,0

VM: Counting Algorithms [191]

maintain a count of the number of references to a page
Least Frequently Used (LFU): ``replace page with smallest count''
active pages will have large counts
but initialization pages will have large counts
Most Frequently Used (MFU): ``replace page with largest count''
recent pages are active pages but will have small counts
neither are common
do not approximate OPT well

VM: LFU using MEM [192]

    page: 7  faults: 1  frames:  7 -1 -1  count: 1 
          0          2           7  0 -1         1  1 
          1          3           7  0  1         1  1  1 
          2          4           2  0  1         1  1  1 
          0          4           2  0  1         1  2  1 
          3          5           2  0  3         1  2  1 
          0          5           2  0  3         1  3  1 
          4          6           4  0  3         1  3  1 
          2          7           4  0  2         1  3  1 
          3          8           3  0  2         1  3  1 
          0          8           3  0  2         1  4  1 
          3          8           3  0  2         2  4  1 
          2          8           3  0  2         2  4  2 
          1          9           3  0  1         2  4  1 
          2         10           3  0  2         2  4  1 
          0         10           3  0  2         2  5  1 
          1         11           3  0  1         2  5  1 
          7         12           3  0  7         2  5  1 
          0         12           3  0  7         2  6  1 
          1         13           3  0  1         2  6  1

VM: MFU using MEM [193]

     page: 7  faults: 1  frames:  7 -1 -1  count: 1 
           0          2           7  0 -1         1  1 
           1          3           7  0  1         1  1  1 
           2          4           2  0  1         1  1  1 
           0          4           2  0  1         1  2  1 
           3          5           2  3  1         1  1  1 
           0          6           2  3  0         1  1  1 
           4          7           4  3  0         1  1  1 
           2          8           4  2  0         1  1  1 
           3          9           4  2  3         1  1  1 
           0         10           0  2  3         1  1  1 
           3         10           0  2  3         1  1  2 
           2         10           0  2  3         1  2  2 
           1         11           0  1  3         1  1  2 
           2         12           0  1  2         1  1  1 
           0         12           0  1  2         2  1  1 
           1         12           0  1  2         2  2  1 
           7         13           7  1  2         1  2  1 
           0         14           7  0  2         1  1  1 
           1         15           7  0  1         1  1  1

Replacement Algorithm Performance [194]

$\begin{picture}(520,264)(0,560) \thicklines\put(180,800){\circle*{14}} \put(180,... ...} \put(400,700){\makebox(0,0)[lb]{\raisebox{0pt}[0pt][0pt]{FIFO}}} \end{picture}$

more frames IMPLIES less faults
if [frames allocated] = 1?
if [frames allocated] = [logical pages]?

mem> mode 2
mem> init 8 8

VM: Belady's Anomaly [195]

$\begin{picture}(520,264)(0,560) \thicklines\put(160,700){\circle*{14}} \put(200,... ...} \put(420,660){\makebox(0,0)[lb]{\raisebox{0pt}[0pt][0pt]{FIFO}}} \end{picture}$

more frames IMPLIES more faults
FIFO may replace pages that are just about to be used again

VM: Belady's Anomaly using MEM [196]

     page: 1  faults: 1  frames:  1 -1 -1  time:  1 
           2          2           1  2 -1         1  2 
           3          3           1  2  3         1  2  3 
           4          4           4  2  3         4  2  3 
           1          5           4  1  3         4  5  3 
           2          6           4  1  2         4  5  6 
           5          7           5  1  2         7  5  6 
           1          7           5  1  2         7  5  6 
           2          7           5  1  2         7  5  6 
           3          8           5  3  2         7 10  6 
           4          9           5  3  4         7 10 11 
           5          9           5  3  4         7 10 11 
     page: 1  faults: 1  frames:  1 -1 -1 -1  time:  1 
           2          2           1  2 -1 -1         1  2 
           3          3           1  2  3 -1         1  2  3 
           4          4           1  2  3  4         1  2  3  4 
           1          4           1  2  3  4         1  2  3  4 
           2          4           1  2  3  4         1  2  3  4 
           5          5           5  2  3  4         7  2  3  4 
           1          6           5  1  3  4         7  8  3  4 
           2          7           5  1  2  4         7  8  9  4 
           3          8           5  1  2  3         7  8  9 10 
           4          9           4  1  2  3        11  8  9 10 
           5         10           4  5  2  3        11 12  9 10

VM: Allocation of Frames [197]

up to now: just one process in memory and all frames are available
m frames available for n processes
equal allocation: m/n frames per process
but small processes may get too many frames
proportional allocation based on size of process: s_i/S times m
S=sum s_i
may want to increase allocation for high-priority processes
what happens if a fault occurs and no free frames?
local replacement: reuse a frame from the faulting process
can not make use of under-utilized frames
global replacement: take a frame from any process
high-priority takes from low-priority (``stealing'')
``fate'' of a process depends on the behavior of others
tends to increase system throughput
but may cause thrashing

VM: Thrashing [198]

Scenario 1:

process has a small number of frames (allocation or stealing)
process has a large number of active pages
process spends more time paging than executing

Scenario 2:

OS monitors CPU utilization
if low utilization then increase degree of multiprogramming
new process takes frames from other processes
- they start thrashing
utilization decreases and OS adds more processes
more thrashing

VM: Thrashing [199]

$\begin{picture}(515,264)(5,560) \thicklines\put(100,800){\line( 0,-1){240}} \put... ...t(370,790){\makebox(0,0)[lb]{\raisebox{0pt}[0pt][0pt]{thrashing}}} \end{picture}$

VM: Thrashing Solutions [200]

use a local replacement algorithm
thrashing process cannot steal frames
but queue time (paging device) will increase for ALL processes
provide a process as many frames as it ``needs''
may suspend other processes (and free up their frames)
``need'' based on locality model
set of pages that are actively used together
subroutines or data structures
if full set in memory then no more faults (until new locality)

VM: Working-Set Model [201]

approximation to the program's locality
let Delta be the working-set window
keep list of all pages used during the last Delta page references

$\begin{picture}(695,94)(0,720) \thicklines\put(210,740){\vector( 0, 1){ 55}} \pu... ...}} \put(695,800){\makebox(0,0)[lb]{\raisebox{0pt}[0pt][0pt]{...}}} \end{picture}$

small Delta IMPLIES does not encompass locality
large Delta IMPLIES given too many frames
let WSS_i be the size of the working set for process i
demand D = sum WSS_i
if not enough frames, then suspend processes (and free frames)
prevents thrashing and keeps multiprogramming high as possible
optimizes CPU utilization

VM: Page-Fault Frequency Strategy [202]

PFF Strategy
direct approach to solve thrashing
may need to suspend other processes to get more frames

$\begin{picture}(520,264)(0,560) \thicklines\put(100,800){\line( 0,-1){240}} \put... ...box(0,0)[lb]{\raisebox{0pt}[0pt][0pt]{decrease number of frames}}} \end{picture}$

VM: Program Structure [203]

assume OS allocates less than 128 frames for this process:
each row contains one page

     int A[128][128];    /* ROW MAJOR: A[0][0], A[0][1], A[0][2] ...*/
     for (i=0; i<= 127; i++)
       for (j=0; j<= 127; j++)
          A[i][j] = 0;

if page is 128 words, then above has 128 page faults

     for (j=0; j<= 127; j++)
       for (i=0; i<= 127; i++)
          A[i][j] = 0;

now there will be 128 times 128 = 16,384 faults

Next: File Management Up: Memory Management Previous: Virtual Memory Contents

Ted Billard 2001-11-17