OS Fall’02

Virtual Memory: Page Replacement

Operating Systems Fall 2002

OS Fall’02

Realizing Virtual Memory Hardware support

Memory Management Unit (MMU): address translation, bits, interrupts

Operating system supportPage replacement policyResident set managementLoad control degree of multiprogramming

OS Fall’02

Page Replacement Policy Resident set maintenance

Fixed or variable allocation Per-process or global replacement

Page replacement problemA fixed number of frames, M, is used to map the process virtual memory pagesWhich page should be replaced when a page fault occurs and all M frames are occupied?

OS Fall’02

Requirements and Metrics Workload: a sequence of virtual

memory references (page numbers) Page fault rate =

#page faults/#memory references Minimize the page fault rate for

workloads obeying the principle of locality

Keep hardware/software overhead as small as possible

OS Fall’02

Algorithms Optimal (OPT) Least Recently Used (LRU) First-In-First-Out (FIFO) Clock

OS Fall’02

Optimal Policy (OPT) Replace the page which will be

referenced again in the most remote future

Impossible to implementWhy?

Serves as a baseline for other algorithms

OS Fall’02

Least Recently Used (LRU) Replace the page that has not been

referenced for the longest time The best approximation of OPT for

the locality constrained workloads Possible to implement Infeasible as the overhead is high

Why?

OS Fall’02

First-In-First-Out (FIFO) Page frames are organized in a

circular buffer with a roving pointer Pages are replaced in round-robin

styleWhen page fault occur, replace the page to which the pointer points to

Simple to implement, low overhead High page fault rate, prone to

anomalous behavior

OS Fall’02

Clock (second chance) Similar to FIFO but takes page usage

into accountCircular buffer + page use bitWhen a page is referenced: set use_bit=1When a page fault occur: For each page:

if use_bit==1: give page a second chance: use_bit=0; continue scan;

if use_bit==0: replace the page

OS Fall’02

Example: Page 727 is needed

0

1

2

3

4

56

7

8

n

.

.

.

Page 9use = 1

Page 19use = 1

Page 1use = 0

Page 45use = 1

Page 191use = 1

Page 556use = 0

Page 13use = 0

Page 67use = 1

Page 33use = 1

Page 222use = 0

next frame pointer

OS Fall’02

After replacement0

1

2

3

4

56

7

8

n

.

.

.

Page 9use = 1

Page 19use = 1

Page 1use = 0

Page 45use = 0

Page 191use = 0

Page 727use = 0

Page 13use = 0

Page 67use = 1

Page 33use = 1

Page 222use = 0

next frame pointer

OS Fall’02

Example of all algorithms

OS Fall’02

LRU and non-local workloads Workload: 1 2 3 4 5 1 2 3 4 5…

Typical for array based applications

What is the page fault rate for M=1,…,5?

A possible alternative is to use a Most Recently Use (MRU) replacement policy

OS Fall’02

Belady’s Anomaly It is reasonable to expect that

regardless of a workload, the number of page faults should not increase if we add more frames: not true for the FIFO policy:

1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

1

2

3

1

2

3

4

1

2

5

3

4

1

2

3

1

2

3

5

1

2

4

5

44 3

OS Fall’02

Algorithm comparison

OS Fall’02

Clock algorithm with 2 bits Use “modified” bit to evict

unmodified (clean) pages in preference over modified (dirty) pages

Four classes:u=0; m=0: not recently used, cleanu=0; m=1: not recently used, dirtyu=1; m=0: recently used, cleanu=1; m=1: recently used, dirty

OS Fall’02

First scan: look for (0,0) frame, do not change the use bit

If (0,0) frame is found, replace it

Second scan: look for (0,1) frame, set use bit to 0 in each frame bypassed

If (0,1) frame is found, replace it

If all failed, repeat the above procedure

this time we will certainly find something

Clock algorithm with 2 bits

OS Fall’02

Page buffering Evicted pages are kept on two lists:

free and modified page lists

Pages are read into the frames on the free page list

Pages are written to disk in large chunks from the modified page list

If an evicted page is referenced, and it is still on one of the lists, it is made valid at a very low cost

OS Fall’02

Resident set management With multiprogramming, a fixed

number of memory frames are shared among multiple processes

How should the frames be partitioned among the active processes?

Resident set is the set of process pages currently allocated to the memory frames

OS Fall’02

The working set model [Denning’68]

Working set is the set of pages in the most recent page references

Working set is an approximation of the program locality

OS Fall’02

The working set strategy Monitor the working set for each

currently active process Adjust the number of pages

assigned to each process according to its working set size

Monitoring working set is impractical The optimal value of is unknown

and would vary

OS Fall’02

Approximating the WS Global page replacement

All memory frames are candidates for page eviction a faulting process may evict a page of other

process

Processes with larger WS are expanding whereas those with smaller WS are shrinking

Problem: may unjustly reduce the WS of some processes

Combine with page buffering

OS Fall’02

Approximating the WS Local page replacement

Only the memory frames of a faulting process are candidates for replacement

Dynamically adjust the process allocation

Page-Fault Frequency (PFF) algorithm

OS Fall’02

Page-Fault Frequency (PFF) Approximate the page-fault frequency:

Count all memory references for each active processWhen a page fault occurs, compare the current counter value with the previous page fault counter value for the faulting processIf < F, expand the WS; Otherwise, shrink the WS by discarding pages with use_bit==0

OS Fall’02

Multiprogramming level Too many processes in memory

Thrashing, inability to run new processes

The solution is swapping: save all the resident set of a process to the disk (swapping out)load the pages of another process instead (swapping in)

Long-term and medium term scheduling decides which processes to swap in/out

OS Fall’02

Long (medium) term scheduling

Decision of which processes to swap out/in is based on

The CPU usageCreating a balanced job mix with respect to I/O vs. CPU bound processes

Two new process states: Ready swappedBlocked swapped

OS Fall’02

UNIX process statesrunning

user

runningkernel

readyuser

readykernel

blocked

zombie

sys. callinterrupt

schedule

created

return

terminated

wait for event

event done

schedule

preempt

interrupt

readyswapped

blockedswapped

Swap out

event done

Swap outSwap in

OS Fall’02

Segmentation with paging Segmentation

simplifies protection and sharing, enforce modularity, but prone to external fragmentation

Paging transparent, eliminates ext. fragmentation, allows for sophisticated memory management

Segmentation and paging can be combined

OS Fall’02

Address translation

Main Memory

PageFrame

Offset

Paging

Page Table

P#

+

Frame # Offset

Seg Table Ptr

+S #

SegmentationProgram

SegmentTable

Seg # Page # Offset

OS Fall’02

Page size considerations Small page size

better approximates localitylarge page tablesinefficient disk transfer

Large page sizeinternal fragmentation

Most modern architectures support a number of different page sizes

a configurable system parameter

OS Fall’02

Next: File system, disks, etc