Demand Paging

• Virtual memory = indirect addressing + demand paging

– Without demand paging, indirect addressing by itself is valuable because it reduces external fragmentation

• Demand paging attributes:– Process may run with less than all pages in memory– Unused portion of process’ address space resides

on backing store (on disk)– Pages are loaded into memory from backing store,

and visa versa upon page eviction– Pages loaded into memory as they are referenced

(or demanded); less useful pages are evicted to make room

Demand Paging Solves …

• Insufficient memory for single process• Insufficient memory for several processes during

multiprogramming• Relocation during execution via paging• Efficient use of memory: only active subset of process’ pages

are in memory (unavoidable waste is internal to pages)• Ease of programming – no need to be concerned with partition

starting address and limits• Protection – separate address spaces enforced by translation

of hardware• Sharing: map same physical page into more than 1 address

space• Less disk activity than with swapping alone• Fast process start-up: process can run with as little as 1 page• Higher CPU utilization since many partially loaded processes

can be in memory simultaneously

Data Structures for Demand Paging

• Page tables – location of pages that are in memory

• Backing store map – location of pages that are not in memory

• Physical memory map (frame map)– Fast physical to virtual mapping (to invalidate translations for

page that is no longer in memory)– Allocation/use of page frames – in use or free– Number of page frames are allotted to each process

• Cache of page tables – Translation Lookaside Buffer (TLB)

Hardware Influence on Demand Paging

• TLB is special hardware

• Base/limit registers describe kernel’s and current process’ page table area

• Size of PTE and meaning of certain bits in PTE (present/absent, protection, referenced, modified bits)

Virtual Memory Policies

• Fetch policy – which pages to load and when?

• Page replacement policy – which pages to remove/overwrite and when in order to free up memory space?

Fetch Policy

• Demand paging – pages are loaded on demand, not in advance

– Process starts up with none of its pages loaded in memory; page faults load pages into memory

– Initially many page faults– Context switching may clear pages and will

cause faults when process runs again

Fetch Policy

• Pre-paging – load pages before process runs– Need a working set of pages to load on context

switches

• Few systems use pure demand paging, but instead, does pre-paging

• Thrashing – occurs when program causes page fault every few instructions

– What can be done to alleviate problem?

Page Replacement Policy

• Question of which page to evict when memory is full and a new page is demanded

• Goal: reduce the number of page faults– Why? Page fault is very expensive – 10

msec. to fetch from disk; on a 100 MIPS machine, 10 msec. is equal to 1 Million instructions

Page Replacement Policy

• Demand paging is likely to cause a large number of page faults, especially when a process starts up

• Locality of reference saves demand paging– Locality of reference – next reference more likely to be near

last one– Reasons:

• Next instruction in stream is close to the last• Small loops• Common subroutines• Locality in data layout (arrays, matrices of data, fields of

structure are contiguous)• Sequential processing of files and data

• With locality of reference, a page that is brought in by one instruction is likely to contain the data required by the next instruction

Page Replacement Policy

• Policy can be global (inter-process) or local (per-process)

• Policies:– Optimal – replace page that will be used farthest in

the future (or never used again)– FIFO & variants – might throw out important pages

• Second chance, clock– LRU & variants – difficult to implement exactly

• NFU – crude approximation to LRU• Aging – efficient and good approximation to LRU

– NRU – crude, simplistic version of LRU– Working set – expensive to implement

• Working set clock – efficient and most widely used in practice

Page Replacement Policy: NRU

• Not recently used – a poor man’s LRU• Uses 2 bits (can be implemented in HW):

– R – page has been referenced– M – page has been modified– OS clears R-bit periodically

• R=0 means pages are “cold”• R=1 means pages are “hot” or recently referenced

• When free pages are needed, sweep through all of memory and reclaim pages based on R and M classes:

– 00 = not referenced, not modified– 01 = not referenced, modified– 10 = referenced, not modified– 11 = referenced and modified– Pages should be removed in what order?– How can class 01 exist – if it was modified, shouldn’t the page

have been referenced?

Page Replacement Policy: FIFO

• First-in, first-out

• Easy to implement, but does not consider page usage – pages that are frequently referenced might be removed

• Keep linked list representing order in which pages have been brought into memory

Page Replacement Policy: Second Chance

• Variant of FIFO

• When free page frames are needed, examine pages in FIFO order starting from the beginning

– If R=0, reclaim page– If R=1, set R=0 and place at the end of FIFO

list (hence, the second chance)– If not enough reclaims on first pass, revert to

pure FIFO on second pass

Page Replacement Policy: Clock

• Variant of FIFO, better implementation of Second Chance

• Pages are arranged in circular list; pages never moved around the list

• When free page frames are needed, examine pages in clock-wise order from current position

– If R=0, reclaim page– If R=1, set R=0 and advance hand

Page Replacement Policy: Clock

• 2-hand clock variant– one hand changes R from 1 to 0– second hand reclaims pages

• How is this different from 1-hand clock?– With 1 hand, time between cycles of the

hand is proportional to memory size– With 2 hands, time between changing R and

reclaiming pages can be varied dynamically depending on the momentary need to reclaim page frames

Page Replacement Policy: LRU

• Keep linked list representing order in which pages have been used

• On potentially every reference, find referenced page in the list and bring it to the front – very expensive!

• Can do LRU faster with special hardware– On reference store time (or counter) in PTE; find

page with oldest time (or lowest counter) to evict– NxN Matrix algorithm:

• Initially set NxN bits to 0• When page frame K is referenced,

– Set all bits of row K to 1– Set all bits of column K to 0

• Row with lowest binary value is LRU– But, hardware is often not available!

Page Replacement Policy: NFU and Aging

• Simulating LRU in software• NFU

– At each clock interrupt, add R bit (0 or 1) to counter associated with page

– Reclaim page with lowest counter– Disadvantage – no aging of pages

• Aging– Shift counter to the right, then add R to the left – recent R bit is

added as most significant bit, thereby dominating the counter value

– Reclaim page with lowest counter– Acceptable disadvantages

• Cannot distinguish between references early in clock interval from latter references since shift and add is done to all counters at once

• With 8-bit counter, have only a memory of 8 clock ticks back

Page Replacement Policy: Working Set

• Working set – set of pages process is currently using

– As a function of k most recent memory references, w(k,t) is working set at any time t

– As a function of past e msec. of execution time, w(e,t) is set of pages process referenced in the last e msec. of process’ execution time

• Replacement policy: find page not in working set and evict it

Page Replacement Policy: Working Set Implementation

• If R=0, page is candidate for removal– Calculate age = current time – time of last use– If age > threshold, page is reclaimed– If age < threshold, still in working set, but may be

removed if it is oldest page in working set

• If R=1, set time of last use = current time– Page was recently referenced, so in working set

• If no page has R=0, choose random page for removal (one that requires no writeback)

Page Replacement Policy: Working Set Clock

• Use circular list of page frames • If R=0, age > threshold, and

– Page is clean (M=0), reclaim– Page is dirty (M=1), schedule write but advance hand

to check other pages

• If R=1, set R=0 and advance hand

• At end of 1st pass, if no page has been reclaimed:– If write has been scheduled, keep moving hand until

write is done and page is clean. Evict 1st clean page– If no writes scheduled, claim any clean page even

though it is in the working set

Page Replacement Policy: Summary

• FIFO easy to implement, but does not account for page usage

• Because of locality of reference, LRU is a good approximation to optimal

– Naïve LRU has high overhead – update some data structure on every reference!

• Practical algorithms– Approximate LRU– Maintain list of free page frames for quick allocation– When number of page frames in free list falls below a low

water mark (threshold), invoke page replacement policy until number of free page frames goes above high water mark

Page Replacement Policy: Evaluation Metrics

• Results: page fault rate over some workload

• Speed: work that must be done on each reference

• Speed: work that must be done when page is reclaimed

• Overhead: storage required by algorithm’s bookkeeping and special hardware required