Page replacement alg

PAGE REPLACEMENT
ALGORITHMS
P. Raveena Lakshmi, M.Sc.,
M.Phil.,
Assistant Professor

Page Replacement Algorithms
 Want lowest page-fault rate.
 Evaluate algorithm by running it on a
particular string of memory
references (reference string) and
computing the number of page faults
and page replacements on that
string.
 In all our examples, we use a few
recurring reference strings.

Graph of Page Faults vs. the Number of
Frames

The FIFO Policy
 Treats page frames allocated to a
process as a circular buffer:
When the buffer is full, the oldest page is
replaced. Hence first-in, first-out:
A frequently used page is often the oldest, so
it will be repeatedly paged out by FIFO.
Simple to implement:
requires only a pointer that circles through the
page frames of the process.

First-In-First-Out (FIFO) Algorithm
 Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
 3 frames (3 pages can be in memory
at a time per process):
 4 frames:
 FIFO Replacement manifests Belady’s Anomaly:
 more frames  more page faults
1
2
3
1
2
3
4
1
2
5
3
4
9 page faults
1
2
3
1
2
3
5
1
2
4
5 10 page faults
44 3

FIFO Illustrating Belady’s Anomaly
A. Frank - P. Weisberg

Optimal Page Replacement
 The Optimal policy selects for
replacement the page that will not be used
for longest period of time.
 Impossible to implement (need to
know the future) but serves as a
standard to compare with the other
algorithms we shall study.

Optimal Page Replacement

Optimal Algorithm
 Reference string : 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
 4 frames example
 How do you know future use? You don’t!
 Used for measuring how well your algorithm
performs.
1
2
3
4
6 page faults
4 5

The LRU Policy
 Replaces the page that has not been
referenced for the longest time:
By the principle of locality, this should be
the page least likely to be referenced in
the near future.
performs nearly as well as the optimal
policy.

Least Recently Used (LRU) Algorithm
 Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
8 page faults
5
2
4
3
1
2
3
4
1
2
5
4
1
2
5
3
1
2
4
3

Implementation of the LRU Policy
 Each page could be tagged (in the page table
entry) with the time at each memory
reference.
 The LRU page is the one with the smallest
time value (needs to be searched at each
page fault).
 This would require expensive hardware and a
great deal of overhead.
 Consequently very few computer systems
provide sufficient hardware support for true
LRU replacement policy.

LRU Implementations
 Counter implementation:
 Every page entry has a counter; every time a page is
referenced through this entry, copy the clock into the
counter.
 When a page needs to be changed, look at the
counters to determine which are to change.
 Stack implementation – keep a stack of page
numbers in a double link form:
 Page referenced:
 move it to the top
 requires 6 pointers to be changed
 No search for replacement.

Use of a stack to implement LRU
• Stack implementation – keep a stack of page numbers in
a double link form:
– Page referenced:
• move it to the top
• requires 6 pointers to be changed
– No search for replacement – always take the bottom
one.

The Clock (Second Chance) Policy
 The set of frames candidate for replacement is
considered as a circular buffer.
 When a page is replaced, a pointer is set to point
to the next frame in buffer.
 A reference bit for each frame is set to 1
whenever:
 a page is first loaded into the frame.
 the corresponding page is referenced.
 When it is time to replace a page, the first frame
encountered with the reference bit set to 0 is
replaced:
 During the search for replacement, each reference bit

Clock Page-Replacement Algorithm

Page replacement alg

More Related Content

What's hot (20)

Similar to Page replacement alg (20)

Recently uploaded (20)

Page replacement alg