LIFO PRA

This is terrible! Why?
All but the last frame are frozen once loaded so you essentially use only one frame.

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. that has been least recently used.

LRU is definitely

• Implementable: The past is knowable
• Good: Simulation studies
• Difficult
  • Essentially need to either
    1. 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.
    2. Keep the PTEs in a linked list in usage order, which means on each reference moving the PTE to the end of the list

Homework: 19, 20

A hardware cutsie in Tanenbaum (skipped in 202)

• For n pages, keep an nxn bit matrix.
• On a reference to page i, set row i to all 1s and col 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
• Cute, but still impractical.

3.4.7: Simulating LRU in Software

The Not Frequently Used (NFU) PRA

• Include a counter in each PTE (and have R in each PTE)
• Set counter to zero when page is brought into memory
• For each PTE, every k clock ticks
  1. Add R to counter
  2. Clear R
• Choose as victim the PTE with lowest count

The Aging PRA

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

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

R	counter
1	10000000
0	01000000
1	10100000
1	11010000
0	01101000
0	00110100
1	10011010
1	11001101
0	01100110

Homework: 21, 25

3.5: Modeling Paging Algorithms

3.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.

Repeat the above calculations for LRU.