A. Frank - P.

Weisberg
Operating Systems
Virtual Memory
Policies
2
A. Frank - P. Weisberg
Virtual Memory Management
Background
Demand Paging
Demand Segmentation
Paging Considerations
Page Replacement Algorithms
Virtual Memory Policies

3
A. Frank - P. Weisberg
Memory Management Software
Memory management software depends on
whether the hardware supports paging or
segmentation or both.
Pure segmentation systems are rare. Segments
are usually paged -- memory management
issues are then those of paging.
We shall thus concentrate on issues associated
with paging.
To achieve good performance we need a low
page fault rate.
4
A. Frank - P. Weisberg
Virtual Memory Policies
Need to decide on:
Fetch policy
Placement policy
Replacement policy
Resident Set Management
Load Control
5
A. Frank - P. Weisberg
Fetch Policy
Determines when a page should be brought into main
memory. Two common policies:
1. Demand Paging only brings pages into main memory
when a reference is made to a location on the page
(i.e., paging on demand only):
many page faults when process first starts but should
decrease as more pages are brought in.
2. Prepaging brings in pages whose use is anticipated:
locality of references suggest that it is more efficient to
bring in pages that reside contiguously on the disk.
efficiency not definitely established: the extra pages
brought in are often not referenced.
6
A. Frank - P. Weisberg
Placement Policy
Determines where in real memory a process
piece resides.
For paging (and paged segmentation):
the hardware decides where to place the page:
the chosen frame location is irrelevant since all
memory frames are equivalent (not an issue).
For pure segmentation systems:
first-fit, next fit... are possible choices (a real issue).
7
A. Frank - P. Weisberg
Replacement Policy
Deals with the selection of a page in main
memory to be replaced when a new page is
brought in.
This occurs whenever main memory is full
(no free frame available).
Occurs often since the OS tries to bring into
main memory as many processes (pages) as it
can to increase the multiprogramming level.
8
A. Frank - P. Weisberg
Replacement Policy
Not all pages in main memory can be selected
for replacement.
Some frames are locked (cannot be paged out):
much of the kernel is held on locked frames as well
as key control structures and I/O buffers.
The OS might decide that the set of pages
considered for replacement should be:
limited to those of the process that has suffered the
page fault.
the set of all pages in unlocked frames.
9
A. Frank - P. Weisberg
Replacement Policy
The decision for the set of pages to be
considered for replacement is related to the
resident set management strategy:
how many page frames are to be allocated to each
process? We will discuss this later.
No matter what is the set of pages considered
for replacement, the replacement policy deals
with algorithms that will choose the page within
that set.
10
A. Frank - P. Weisberg
Resident Set Management
The OS must decide how many page frames to
allocate to a process:
large page fault rate if too few frames are allocated.
low multiprogramming level if too many frames are
allocated.
11
A. Frank - P. Weisberg
Resident Set Size
Fixed-allocation policy:
allocates a fixed number of frames that remains constant
over time:
the number is determined at load time and depends on the
type of the application.
Variable-allocation policy:
the number of frames allocated to a process may vary
over time:
may increase if page fault rate is high.
may decrease if page fault rate is very low.
requires more OS overhead to assess behavior of active
processes.
12
A. Frank - P. Weisberg
Replacement Scope
Replacement scope is the set of frames to be
considered for replacement when a page fault occurs.
Local replacement policy:
each process selects from only its own set of allocated
frames.
Global replacement policy:
process selects a replacement frame from the set of all
frames; one process can take a frame from another.
We will consider the possible combinations of
replacement scope and resident set size policy.
13
A. Frank - P. Weisberg
Local vs. Global Replacement Policies
14
A. Frank - P. Weisberg
Fixed allocation + Local scope
Each process is allocated a fixed number of pages:
determined at load time; depends on application type.
When a page fault occurs, page frames considered for
replacement are local to the page-fault process:
the number of frames allocated is thus constant.
previous replacement algorithms can be used.
Problem: difficult to determine ahead of time a good
number for the allocated frames:
if too low: page fault rate will be high.
if too large: multiprogramming level will be too low.
15
A. Frank - P. Weisberg
Fixed Allocation: Equal/Proportional
Equal allocation for example, if there are 100 frames
and 5 processes, give each process 20 frames.
Proportional allocation allocate according to the size
of process.
59 64
137
127
5 64
137
10
127
10
64
2
1
2
1
~ =
~ =
=
=
=
a
a
s
s
m
m
S
s
p a
m
s S
p s
i
i i
i
i i
= =
=

=
=
for allocation
frames of number total
process of size
16
A. Frank - P. Weisberg
Fixed Allocation: Priority
Use a proportional allocation scheme
using priorities rather than size.
If process P
i
generates a page fault:
select for replacement one of its frames.
select for replacement a frame from a process
with lower priority number.
17
A. Frank - P. Weisberg
Fixed allocation + Global scope
Impossible to achieve:
if all unlocked frames are candidate for
replacement, the number of frames allocated to a
process will necessary vary over time.
18
A. Frank - P. Weisberg
Variable allocation + Global scope
Simple to implement -- adopted by many OSs (like
Unix SVR4).
A list of free frames is maintained:
when a process issues a page fault, a free frame (from
this list) is allocated to it.
Hence the number of frames allocated to a page fault
process increases.
The choice for the process that will loose a frame is
arbitrary; Its far from optimal.
Page buffering can alleviate this problem since a
page may be reclaimed if it is referenced again soon.
19
A. Frank - P. Weisberg
Variable allocation + Local scope
May be the best combination (used by Windows NT).
Allocate at load time a certain number of frames to a
new process based on application type:
use either pre-paging or demand paging to fill up
the allocation.
When a page fault occurs, select the page to replace
from the resident set of the process that suffered the
page fault.
Reevaluate periodically the allocation provided and
increase or decrease it to improve the overall
performance.
20
A. Frank - P. Weisberg
The Working Set Strategy
The working set strategy is a variable-
allocation method with local scope based on the
assumption of locality of references.
The working set for a process at time t, W(D,t),
is the set of pages that have been referenced in
the last D virtual time units:
virtual time = time elapsed while the process
was in execution.
D is a window of time.
W(D,t) is an approximation of the programs
locality.
21
A. Frank - P. Weisberg
The Working Set Strategy
The working set of a process first grows when it
starts executing.
Then stabilizes by the principle of locality.
It grows again when the process enters a new
locality (transition period):
up to a point where the working set contains pages
from two localities.
Then decreases after a sufficient long time
spent in the new locality.

22
A. Frank - P. Weisberg
The Working Set Strategy
The working set concept suggests the following
strategy to determine the resident set size:
Monitor the working set for each process.
Periodically remove from the resident set of a process
those pages that are not in the working set.
When the resident set of a process is smaller than its
working set, allocate more frames to it:
If not enough free frames are available, suspend the
process (until more frames are available), i.e., a process
may execute only if its working set is in main memory.
23
A. Frank - P. Weisberg
Working-Set Model
A = working-set window = a fixed number of page references
Example: 10,000 instructions
WSS
i
(working set of Process P
i
) =
total number of pages referenced in the most recent A
(varies in time):
if A too small it will not encompass entire locality.
if A too large it will encompass several localities.
if A = will encompass entire program.
D = E WSS
i
total demand frames
if D > m Thrashing
Policy if D > m, then suspend one of the processes
24
A. Frank - P. Weisberg
Working-set model
25
A. Frank - P. Weisberg
Keeping Track of the Working Set
Approximate with interval timer + a reference bit.
Example: A = 10,000
Timer interrupts after every 5000 time units.
Keep in memory 2 bits for each page.
Whenever a timer interrupts, copy and set the values of all
reference bits to 0.
If one of the bits in memory = 1 page in working set.
Why is this not completely accurate?
Improvement = 10 bits and interrupt every 1000 time
units.
26
A. Frank - P. Weisberg
The Working Set Strategy
Practical problems with this working set strategy:
measurement of the working set for each process is
impractical:
necessary to time stamp the referenced page at every
memory reference.
necessary to maintain a time-ordered queue of referenced
pages for each process.
the optimal value for D is unknown and time varying.
Solution: rather than monitor the working set, monitor
the page fault rate!
27
A. Frank - P. Weisberg
Page-Fault Frequency Scheme
Establish acceptable page-fault rate:
If actual rate too low, process loses frame.
If actual rate too high, process gains frame.
28
A. Frank - P. Weisberg
Page-Fault Frequency (PFF) Strategy
Define an upper bound U
and lower bound L for page
fault rates.
Allocate more frames to a
process if fault rate is
higher than U.
Allocate less frames if fault
rate is less than L.
The resident set size should
be close to the working set
size W.
We suspend the process if
the PFF > U and no more
free frames are available.
29
A. Frank - P. Weisberg
Working Sets and Page-Fault rates
30
A. Frank - P. Weisberg
Load Control
Determines the number of
processes that will be
resident in main memory
(i.e., the multiprogramming
level):
Too few processes: often
all processes will be
blocked and the
processor will be idle.
Too many processes: the
resident size of each
process will be too small
and flurries of page faults
will result: thrashing.
31
A. Frank - P. Weisberg
Load Control
A working set or page fault frequency algorithm
implicitly incorporates load control:
only those processes whose resident set is
sufficiently large are allowed to execute.
Another approach is to adjust explicitly the
multiprogramming level so that the mean time
between page faults equals the time to process a
page fault:
performance studies indicate that this is the point
where processor usage is at maximum.
32
A. Frank - P. Weisberg
Process Suspension
Explicit load control requires that we sometimes swap
out (suspend) processes.
Possible victim selection criteria:
Faulting process
this process may not have its working set in main memory so
it will be blocked anyway.
Last process activated
this process is least likely to have its working set resident.
Process with smallest resident set
this process requires the least future effort to reload.
Largest process
will yield the most free frames.
33
A. Frank - P. Weisberg
Windows XP (1)
Uses demand paging with clustering.
Clustering brings in pages surrounding the faulting
page.
Processes are assigned working set minimum and
working set maximum
Working set minimum is the minimum number of
pages the process is guaranteed to have in memory.
A process may be assigned as many pages up to its
working set maximum.
34
A. Frank - P. Weisberg
Windows XP (2)
When the amount of free memory in the system
falls below a threshold, automatic working set
trimming is performed to restore the amount of
free memory.
Working set trimming removes pages from
processes that have pages in excess of their
working set minimum.
35
A. Frank - P. Weisberg
Solaris
Maintains a list of free pages to assign faulting processes.
Lotsfree threshold parameter (amount of free memory) to
begin paging.
Desfree threshold parameter to increasing paging.
Minfree threshold parameter to being swapping.
Paging is performed by pageout process.
Pageout scans pages using modified clock algorithm.
Scanrate is the rate at which pages are scanned. This ranges
from slowscan to fastscan.
Pageout is called more frequently depending upon the amount
of free memory available.
36
A. Frank - P. Weisberg
Solaris 2 Page Scanner