Virtual Memory: Silberschatz, Galvin and Gagne ©2009 Operating System Concepts - 8 Edition

Virtual Memory
Operating System Concepts 8th Edition
Silberschatz, Galvin and Gagne 2009
What to Learn?
Chapter 8 in the text book OSCE. Chapter 9 in OSC.
The benefits of a virtual memory system
The concepts of
demand
paging
page-replacement
and
algorithms
allocation of physical page frames
Other related techniques

Copy-on-write.
Memory mapped files
9.2
Background
Virtual memory
Only
part of the program needs to be

in memory for execution
Logical
address space can be much

larger than physical address space
Allows
address spaces to be shared

by several processes
9.3
Virtual Memory That is

Larger Than Physical Memory
9.4
Transfer of a Paged Memory to

Contiguous Disk Space
9.5
Demand Paging for Virtual Memory

Bring a page into memory ONLY when it is
needed
Less
I/O needed
Less
memory needed
Faster
More
response
users supported
Check a page table entry when a page is
needed
not-in-memory
bring to memory
9.6
Valid-Invalid Bit
With each page table entry a validinvalid bit is
associated
(v in-memory, i not-in-memory)
Initially validinvalid bit is set to i on all entries

Not in memory page fault
Frame #
valid-invalid bit
v
v
v
v
i
.
i
i
page table
9.7
Page Table When Some Pages

Are Not in Main Memory
9.8
Handling a Page Fault

1. Get an empty physical frame
2. Swap page from the disk into frame
3. Reset the page table
Set validation bit = v

4. Restart the instruction that caused the
page fault
9.9
Page Fault (Cont.)

Restart instruction
Special handling
block
Auto
move
increment/decrement
9.10
Steps in Handling a Page Fault
9.11
Performance of Demand Paging

Page Fault Rate 0 p 1.0
if
p = 0, no page faults
if
p = 1, every reference is a fault
Effective Access Time (EAT)
EAT = (1 p) x memory access

+ p (page fault overhead
+ swap page out
+ swap page in
+ restart overhead
)
9.12
Demand Paging Performance Example

Memory access time = 200 nanoseconds
Average page-fault service time = 8 milliseconds
EAT = (1 p) x 200 + p (8 milliseconds)
= (1 p x 200 + p x 8,000,000
= 200 + p x 7,999,800
If one access out of 1,000 causes a page fault, then
EAT = 8.2 microseconds.

This is a slowdown by a factor of 40!!
9.13
Other Benefits
Virtual memory allows other benefits
- Shared pages
- Copy-on-Write during process creation
- Memory-Mapped Files
9.14
Shared Pages with Virtual Memory
9.15
Copy-on-Write: Lazy copy during process creation

Copy-on-Write (COW) allows both parent and child
processes to initially share the same pages in

memory
If either process modifies a shared page, this page is

copied
COW allows more efficient process creation as only
modified pages are copied
9.16
Before Process 1 Modifies Page C
9.17
Copy on Write: After Process 1

Modifies Page C
9.18
Memory-Mapped Files
Allow file I/O to be treated as routine memory
access by mapping a disk block to a page in

memory
Simplifies file access by treating file I/O
through direct memory access rather than

read() write() system calls
File access is managed with demand paging.

Several processes may map the same file
into memory as shared data
9.19
Memory Mapped Files
9.20
Example of Linux mmap

#define NUMINTS 1000
#define FILESIZE
NUMINTS * sizeof(int)
fd = open(FILEPATH, O_RDWR | O_CREAT |

O_TRUNC, 0600);
result = lseek(fd, FILESIZE-1, SEEK_SET);
result = write(fd, "", 1);
map = mmap(0, FILESIZE, PROT_READ |
PROT_WRITE, MAP_SHARED, fd, 0);
for (i = 1; i <=NUMINTS; ++i) map[i] = 2 * i;
munmap(map, FILESIZE);
close(fd);
9.21
Demand paging when there is no free frame?
Page replacement find some page in
memory, but not really in use, swap it out

Algorithm
Performance
want an algorithm which will

result in minimum number of page faults
Same page may be brought into memory
several times
9.22
Need For Page Replacement
9.23
Page Replacement
9.24
Basic Page Replacement

1. Find the location of the desired page on disk
2. Find a free frame:
- If there is a free frame, use it

- If there is no free frame, use a page replacement
algorithm to select a victim frame
3. Swap out: Use modify (dirty) bit to reduce overhead
of page transfers only modified pages are written to

disk
4. Bring the desired page into the free frame.
Update the page and frame tables
9.25
Expected behavior: # of Page Faults vs.

# of Physical Frames
9.26
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).
Maintain a queue and select based on FIFO order.
4 frames
9 page faults
10 page faults
Beladys Anomaly: more frames more page faults

9.27
FIFO Page Replacement
9.28
FIFO Illustrating Beladys Anomaly
9.29
Optimal Algorithm
Replace page that will not be used for longest period of time
4 frames example
1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
1
6 page faults
3
4
How do you know this?

Used for measuring how well your algorithm performs
9.30
Optimal Page Replacement
9.31
Least Recently Used (LRU) Algorithm

Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
Counter implementation
Every page entry has a counter; every time 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
9.32
LRU Page Replacement
9.33
LRU Algorithm Implementation

Stack implementation keep a stack
of page numbers in a double link

form:
Page
referenced:
move
it to the top
requires
No
6 pointers to be changed
search for replacement
9.34
Use Of A Stack to Record The

Most Recent Page References
9.35
LRU Approximation Algorithms

Reference bit
With each page associate a bit, initially = 0
When page is referenced bit set to 1
Replace the one which is 0 (if one exists)

We
do not know the order, however
Second chance
If page has reference bit = 1 then:

Leave
bit 0.
this page in memory, but set reference
Visit next page (in clock order)
If reference bit is 0, replace it.
9.36
Second-Chance
Page-Replacement Algorithm
9.37
Issues with Page Allocation and

Replacement
Initial Allocation. Each process needs
minimum number of pages

Two
schemes: Fixed allocation vs.

priority allocation
Where to find frames

Global replacement find a frame from all
processes.
Local replacement find only from its
own allocated frames
9.38
Fixed Allocation
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
si size of process pi
S si
m total number of frames
s
ai allocation for pi i m
S
m 64
si 10
s2 127
10
64 5
137
127
a2
64 59
137
a1
9.39
Priority Allocation
Use a proportional allocation scheme using
priorities rather than size
If process Pi generates a page fault,

select
for replacement one of its frames
select
for replacement a frame from a

process with lower priority number
9.40
Thrashing
If a process does not have enough pages,
the page-fault rate is very high. This leads to:

low
CPU utilization
operating
system thinks that it needs to

increase the degree of multiprogramming
another
process added to the system
Thrashing a process is busy swapping
pages in and out
9.41
Thrashing (Cont.)
9.42
Relationship of Demand Paging and

Thrashing
Why does demand paging work?
Locality model
Process
another
migrates from one locality to
Localities
Need
may overlap
a minimum working set to be effective
Why does thrashing occur?
working-sets > total memory size
9.43
Locality In A Memory-Reference Pattern
9.44
Working Sets and Page Fault Rates
9.45
Prefetching Pages (Prepaging)

Optimization to reduce page faults (e.g. during
process startup)
Preload some pages before they are referenced

But if prefetched pages are unused, I/O and
memory was wasted
Assume s pages are prepaged and % of the
pages is used
Page fault cost of s *
>
cost of prepaging s * (1- ) unnecessary pages
9.46
Tradeoffs: Page Size
Impact of page size selection:

Internal
Page
I/O
fragmentation
table size
overhead
locality
9.47
Other Issues TLB Reach

TLB Reach - The amount of memory accessible from the TLB
TLB Reach = (TLB Size) X (Page Size)
Ideally, the working set of each process is stored in the TLB
Increase the Page Size
Increase TLB reach
But may increase internal fragmentation as not all applications

require a large page size
9.48
Other Issues Impact of Program

Structure on Page Faults
<128 physical memory pages for each process. Each page is of
128x4 bytes
Program structure
Int[128,128] data;
Each row is stored in one page
Page faults of Program 1?

for (j = 0; j <128; j++)
for (i = 0; i < 128; i++)
data[i,j] = 0;
Page faults of Program 2 ?

for (i = 0; i < 128; i++)
for (j = 0; j < 128; j++)
data[i,j] = 0;
9.49
Other Issues Impact of Program

Structure
<128 physical pages for each process. Each page is of 128x4 bytes
Program structure
Int[128,128] data;
Each row is stored in one page
Program 1
for (j = 0; j <128; j++)
for (i = 0; i < 128; i++)
data[i,j] = 0;
128 x 128 = 16,384 page faults
Program 2
for (i = 0; i < 128; i++)
for (j = 0; j < 128; j++)
data[i,j] = 0;
128 page faults
9.50
Other Issues I/O interlock

I/O Interlock Pages must sometimes be locked into memory
Consider I/O - Pages that are used for copying a file from a device
must be locked from being selected for eviction by a page replacement

algorithm
9.51

Virtual Memory: Silberschatz, Galvin and Gagne ©2009 Operating System Concepts - 8 Edition

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Virtual Memory: Silberschatz, Galvin and Gagne ©2009 Operating System Concepts - 8 Edition

Uploaded by

Copyright:

Available Formats

Virtual Memory

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

allocation of physical page frames

Other related techniques

Operating System Concepts 8th Edition

Memory mapped files

Silberschatz, Galvin and Gagne 2009

part of the program needs to be

address space can be much

address spaces to be shared

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Virtual Memory That is

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Transfer of a Paged Memory to

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Demand Paging for Virtual Memory

Check a page table entry when a page is

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Initially validinvalid bit is set to i on all entries

Silberschatz, Galvin and Gagne 2009

Page Table When Some Pages

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Handling a Page Fault

Set validation bit = v

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Page Fault (Cont.)

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Steps in Handling a Page Fault

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Performance of Demand Paging

p = 1, every reference is a fault

Effective Access Time (EAT)

EAT = (1 p) x memory access

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Demand Paging Performance Example

EAT = 8.2 microseconds.

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Shared Pages with Virtual Memory

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Copy-on-Write: Lazy copy during process creation

processes to initially share the same pages in

If either process modifies a shared page, this page is

modified pages are copied

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Before Process 1 Modifies Page C

Operating System Concepts 8th Edition

Silberschatz, Galvin and Gagne 2009

Copy on Write: After Process 1