4.4 Page replacement algorithms

1. 4.4 Page replacement algorithms

2. Page replacement algorithms • Also seen in: • CPU cache • Web server cache of web pages • Buffered I/O (file) caches

3. Optimal page replacement • Page fault occurs • Scan all pages currently in memory • Determine which page won’t be needed (referenced) until furthest in the future • Replace that page • Not really possible. (But useful as a benchmark.) • Depends on code as well as data.

4. Algorithms we will discuss: • Optimal • NRU • FIFO • Second chance • Clock • LRU • NFU • Aging • Working set • WSClock

5. NRU (not recently used) • Bits set by hardware after every memory reference • Cleared only by software (OS) • R bits – set when page is referenced (read or write) • M bits – set when page is modified (written) • Periodically (after k clock interrupts), R bits are cleared

6. NRU page categories • Not referenced, not modified • Not referenced, modified • Occurs when #4’s R bit is cleared during clock interrupt • Referenced, not modified • Referenced, modified NRU algorithm: remove random page from lowest numbered non empty class

7. NRU algorithm evaluation • Simple • Efficient • Not optimal but adequate

8. FIFO page replacement • Queue pages as they are requested. • Remove page at head (front) of queue. • Oldest page is removed first + simple/efficient - might remove a heavily used page

9. Second chance page replacement • Inspect R bit of oldest page • If R==0 then • page is old & unused • Replace it • Else • Clear R bit • Move page to from head to tail of FIFO • Treating it as a newly loaded page • Try another page

10. Second chance page replacement load time page

11. Clock page replacement • Circular list instead of queue • Clock hand points to oldest page • If (R==0) then • Page is unused • Replace it • Else • Clear R • Advance clock hand

12. Clock page replacement

13. LRU (least recently used) page replacement • Page recently used is likely to be used in the near future; page not used in ages is not likely to be used in the near future. • Algorithm: • “age” the pages • Maintain a queue of pages in memory. • Recently used at front; oldest at rear. • Every time a page is referenced, it is removed from the queue and placed at the front of the queue. • This is slow!

14. LRU in hardware • implementation #1: • 64 bit counter, C, incremented after every instruction • Each page also has a 64 bit counter • When a page is referenced, C is copied to its counter. • Page with lowest counter is oldest.

15. LRU in hardware • implementation #2: • Given n page frames, let M be a nxn matrix of bits initially all 0. • Reference to page frame k occurs. • Set all bits in row k of M to 1. • Set all bits in column k of M to 0. • Row with lowest binary value is least recently used.

16. LRU in hardware: implementation #2 example oldest

17. NFU (Not Frequently Used) • Hardware doesn’t often support LRU • Software counter associated w/ each page initially set to 0. • At each clock interrupt: • Add R bit (either 0 or 1) to the counter for each page. • Page with lowest counter is NFU

18. NFU problem • It never forgets! • So pages that were frequently referenced (during initialization for example) but are no longer needed appear to be FU. • Solution (called “aging”): • Shift all counters to right 1 bit before R bit is added in. • Then R bit is added to MSb (leftmost bit) instead of LSb (rightmost bit). • Page w/ lowest value is chosen for removal.

19. NFU w/ aging • Shift to right • MSb = R 00010000

20. Differences between LRU and NFU • LRU updated after every instruction so it’s resolution is very fine. • NFU is coarse (updated after n instructions execute between clock interrupts). • A given page referenced by n-1 instruction is given equal weight to a page referenced by only 1 instruction (between clock interrupts). • n/2 references to a given page at the beginning of the interval are given equal weight with n/2 references to another page at the end of the interval.

21. Working set page replacement algorithm • Demand paging = start up processes with 0 pages and only load what’s needed. • Locality of reference = during any phase of execution, the process references only a relatively small fraction of its pages. • Working set = set of pages that a process is currently using. • Thrashing = causing a page fault every few instructions.

22. Working sets • Working set model = make sure a page is in memory before the process needs it. • a.k.a. prepaging • w.s. = set of pages used in the k most recent memory references.

23. Working set algorithm • Uses current virtual time = amount of CPU time a process has actually used since it started. • T is a threshold on CVT • R and M bits as before; clock interrupt

24. Working set algorithm age = current virtual time – time of last use  (greatest age/least virtual time) and choose that one if no better candidate exists. If no suitable candidate exists, pick one at random.

25. WSClock page replacement • Previous WS algorithm requires entire page table be scanned at each page fault. • WSClock: • Simple, efficient, widely used. • Uses circular list of page frames.

26. WSClock page replacement At each page fault… Loop once through page table: Examine PTE pointed to by clock hand. If r bit == 1 then clear r bit; advance clock hand; goto loop else If age>t If page is clean then use this page! Else write dirty page to disk; advance clock hand; goto loop If write scheduled, wait for completion and used that page. Else pick a victim at random.

27. WSClock page replacement clear r bit and advance clock hand. Replace old and advance.

28. Summary of page replacement algorithms