Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 31 Annotated
31 -
Outline
Announcements
Reading:
Defining the Problem
Algorithms
Optimal
FIFO
Not Recently Used
Second Chance
1)
a)
b)
c)
d)
2)
MOS 3.3 - 3.7
None Today. Questions?
Page Replacement
Page Replacement
process
OS
disk
...
...
free frame
...
...
page table
main memory
i
(1)
(6)
(2)
(3)
(4)
(5)
What happens when there is no free frame?
Need some algorithm for determining which page to
replace with the one from disk.
Page Replacement Algorithms
Goal:
Evaluation format:
Algorithms
Demand Paging & Prepaging
Later:
Assume the kernel knows the future.
Example:
Pros:
Cons:
Optimal solution will be our baseline of comparison.
Replace a page that has not been recently used.
The algorithm:
How do we determine if this is so?
Page Table Entry bits:
Referenced bit (R) set by MMU on read/write
Modified bit (M) set by MMU on write
bits can only be reset to 0 by kernel.
class 0:
class 1:
class 2:
class 3:
Replace the page in memory that will be used
furthest in the future.
Working Set Model
Page Allocation
Thrashing
Optimal
Not Recently Used
2nd Chance
Not Frequently Used
Clock
Aging
First In, First Out
Least Recently Used
Example:
reference string:
In:
Out:
select a victim page that will minimize
future page faults
a string of memory references.
(i.e. list of accessed pages)
number of page faults the algorithm causes
for that string.
replacing a page that will be needed again soon will cause
more page faults
str r0, 0x0123
str r1, 0x1234
str r2, 0x2345
str r3, 0x3456
ld r0, 0x0100
ld r1, 0x1200
str r4, 0x4567
page 0
page 1
page 2
page 3
page 4
...
0x0000
0x1000
0x2000
0x3000
0x4000
...
0, 1, 2, 3, 0, 1, 4
virtual memory
-
-
-
-
-
-
-
-
-
-
-
-
Optimal Algorithm
minimizes the overall number of page faults
8 pages (0 - 7)
3 physical frames
How many page faults?
9 page faults
-
-
-
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 7 7 2 2 2 2 2 7
x 0 0 0 0 4 0 0 0
x x 1 1 3 3 3 1 1
reference string
page frames
optimal
impossible
running program twice works in theory but not practice.
-
-
Not Recently Used
frame number
valid (present/absent)
protection bits
modified
referenced
-
1)
2)
3)
4)
initially, R and M bits are set to 0
periodically (on clock interrupt), R bit is
cleared by kernel (M remains same)
when replacement needed, pages are classified
into 4 categories (R and M bits)
replace a random page from the set of pages
with the lowest available class
-
-
so we know which pages have been used recently
not referenced, not modified
referenced, not modified
referenced, modified
not referenced, modified
Pros:
Cons:
easy to understand
performance is adequate at best
decision based on limited history
decision based on limited information
kernel must look at every page in page table
(since last clock interrupt)
(only 2 bits of data)
can only remove pages from process that triggered fault.
even more expensive to look at other processes' page tables.
moderately efficient to implement
-
-
-
-
-
-
First In, First Out (FIFO)
Instead of looking at page table entries, kernel
maintains a FIFO queue of loaded pages.
replace the page at the front of the list and
add the new page to the end
replaces page that has been in RAM the longest
-
-
Example:
15 page faults
Consider the reference string:
Increasing the number of frames should generally
always reduce faults.
Similar to FIFO, but considers referenced bit
While the FIFO is full:
What happens if all were used?
If it doesn't, the algorithm is exceptionally bad.
Belady's Anomaly
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 7 7 2 2 2 4 4 4 0 0 0 7 7 7
x 0 0 0 3 3 3 2 2 2 1 1 1 0 0
x x 1 1 1 0 0 0 3 3 3 2 2 2 1
reference string
page frames
Pros:
Cons:
trivial to implement
not limited to current process's pages
age has nothing to do with frequency of use
FIFO suffers from Belady's Anomaly
counterintuitively, page faults can increase with more frames
performance is quite bad in practice
-
-
-
-
1 2 3 4 1 2 5 1 2 3 4 5
2
1
2
3
4
5
6
7
4
6
8
10
12
14
faults vs. frames
frames
faults
Belady's Anomaly
more frames
than pages,
replacement
unnecessary
always
replace
Second Chance
if R = 1, set R = 0 and rotate to end of
FIFO (hence, "Second Chance")
if R = 0, evict it and add the new page
consider the first page:
-
-
-
-
Simply evicts the oldest, as with original FIFO.
A
R=1
A
R=0
A
R=0
G
R=1
B
R=0
B
R=0
C
R=1
C
R=1
C
R=1
D
R=1
D
R=1
D
R=1
E
R=0
E
R=0
E
R=0
F
R=1
F
R=1
F
R=1
Example:
oldest
newest
t=0
t=14
t=14
t=14
t=3
t=3
t=7
t=7
t=7
t=8
t=8
t=8
t=10
t=10
t=10
t=12
t=12
t=12
page fault at t=14 requires replacement:
second chance
evict
add new page
We can improve efficiency with a better data
structure.
Use a circular list.
only need to keep reference to next page
A
R=1
B
R=0
C
R=1
D
R=1
E
R=0
F
R=1
G
R=0
H
R=1
I
R=0
...
...
...
A
R=1
B
R=0
C
R=0
D
R=0
J
R=1
F
R=1
G
R=0
H
R=1
I
R=0
...
...
...
Pros:
Cons:
significant improvement over FIFO
not limited to current process's pages
inefficiency due to moving pages
if many pages have R=1, lots of pointer updates
-
-
-
Clock Implementation
1ki
1Mi
1Gi
1Ti
1Pi
1Ei
= 2^10
= 2^20
= 2^30
= 2^40
= 2^50
= 2^60
assume base 2 if i forgot the "i"