Chapter 10: Virtual Memory

Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne ©2018
 Objectives

 To describe the benefits of a virtual memory system

 To explain the concepts of demand paging, page-replacement

algorithms, and allocation of page frames

 To discuss the principle of the working-set model

 To examine the relationship between shared memory and memory-

mapped files

Operating System Concepts – 10th Edition 10.2 Silberschatz, Galvin and Gagne ©2018
 Background

Operating System Concepts – 10th Edition 10.3 Silberschatz, Galvin and Gagne ©2018
 Background
 Code needs to be in memory to execute, but entire program rarely used
 Error code, unusual routines, large data structures

 Consider ability to execute partially-loaded program

 Program no longer constrained by limits of physical memory
 Each program takes less memory while running  more programs
run at the same time
 Less I/O needed to load or swap programs into memory  each
user program runs faster

Operating System Concepts – 10th Edition 10.4 Silberschatz, Galvin and Gagne ©2018
 Background (Cont.)
 Virtual memory – separation of user logical memory from physical
memory
 Only part of the program needs to be in memory for execution
 Logical address space can therefore be much larger than physical address
space
 Allows address spaces to be shared by several processes
 Allows for more efficient process creation
 More programs running concurrently
 Less I/O needed to load or swap processes

Operating System Concepts – 10th Edition 10.5 Silberschatz, Galvin and Gagne ©2018
 Background (Cont.)
 Virtual address space – logical view of how process is stored in
memory
 Usually start at address 0, contiguous addresses until end of space
 Meanwhile, physical memory organized in page frames
 MMU must map logical to physical

 Virtual memory can be implemented via:

 Demand paging
 Demand segmentation

Operating System Concepts – 10th Edition 10.6 Silberschatz, Galvin and Gagne ©2018
 Virtual Memory That is Larger Than Physical Memory

Operating System Concepts – 10th Edition 10.7 Silberschatz, Galvin and Gagne ©2018
 Virtual-address Space
 Usually design logical address space for
stack to start at Max logical address and
grow “down” while heap grows “up”
 Maximizes address space use
 Unused address space between
the two is a hole
 No physical memory needed
until heap or stack grows to a
given new page
 Enables sparse address spaces with
holes left for growth, dynamically linked
libraries, etc.
 System libraries shared via mapping into
virtual address space
 Shared memory by mapping pages read-
write into virtual address space
 Pages can be shared during fork(),
speeding process creation

Operating System Concepts – 10th Edition 10.8 Silberschatz, Galvin and Gagne ©2018
 Shared Library Using Virtual Memory

Operating System Concepts – 10th Edition 10.9 Silberschatz, Galvin and Gagne ©2018
 Demand Paging

Operating System Concepts – 10th Edition 10.10 Silberschatz, Galvin and Gagne ©2018
 Demand Paging
 Could bring entire process into memory
at load time
 Or bring a page into memory only when
it is needed
 Less I/O needed, no unnecessary
I/O
 Less memory needed
 Faster response
 More users
 Similar to paging system with swapping
(diagram on right)
 Page is needed  reference to it
 invalid reference  abort
 not-in-memory  bring to memory
 Lazy swapper – never swaps a page
into memory unless page will be needed
 Swapper that deals with pages is a
pager

Operating System Concepts – 10th Edition 10.11 Silberschatz, Galvin and Gagne ©2018
 Basic Concepts
 With swapping, pager guesses which pages will be used before
swapping out again

 Instead, pager brings in only those pages into memory

 How to determine that set of pages?

 Need new MMU functionality to implement demand paging

 If pages needed are already memory resident

 No difference from non demand-paging

 If page needed and not memory resident

 Need to detect and load the page into memory from storage
 Without changing program behavior
 Without programmer needing to change code
Operating System Concepts – 10th Edition 10.12 Silberschatz, Galvin and Gagne ©2018
 Valid-Invalid Bit
 With each page table entry a valid–invalid bit is associated
(v  in-memory – memory resident, i  not-in-memory)
 Initially valid–invalid bit is set to i on all entries
 Example of a page table snapshot:

 During MMU address translation, if valid–invalid bit in page table entry

is i  page fault

Operating System Concepts – 10th Edition 10.13 Silberschatz, Galvin and Gagne ©2018
 Page Table When Some Pages Are Not in Main Memory

Operating System Concepts – 10th Edition 10.14 Silberschatz, Galvin and Gagne ©2018
 Page Fault
 If there is a reference to a page, first reference to that page will trap to
operating system:
page fault

1. Operating system looks at another table to decide:

 Invalid reference  abort
 Just not in memory

2. Find free frame

3. Swap page into frame via scheduled disk operation

4. Reset tables to indicate page now in memory

Set validation bit = v

5. Restart the instruction that caused the page fault

Operating System Concepts – 10th Edition 10.15 Silberschatz, Galvin and Gagne ©2018
 Steps in Handling a Page Fault

Operating System Concepts – 10th Edition 10.16 Silberschatz, Galvin and Gagne ©2018
 Aspects of Demand Paging
 Extreme case – start process with no pages in memory
 OS sets instruction pointer to first instruction of process, non-
memory-resident -> page fault
 And for every other process pages on first access
 Pure demand paging
 Actually, a given instruction could access multiple pages -> multiple
page faults
 Consider fetch and decode of instruction which adds 2 numbers
from memory and stores result back to memory
 Pain decreased because of locality of reference
 Hardware support needed for demand paging
 Page table with valid / invalid bit
 Secondary memory (swap device with swap space)
 Instruction restart

Operating System Concepts – 10th Edition 10.17 Silberschatz, Galvin and Gagne ©2018
 Instruction Restart
 Consider an instruction that could access several different locations

 block move

 auto increment/decrement location

 Restart the whole operation?

 What if source and destination overlap?

Operating System Concepts – 10th Edition 10.18 Silberschatz, Galvin and Gagne ©2018
 What Happens if There is no Free Frame?

 Used up by process pages

 Also in demand from the kernel, I/O buffers, etc.

 How much to allocate to each?

 Page replacement – find some page in memory, but not really in

use, page it out
 Algorithm – terminate? swap out? replace the page?
 Performance – want an algorithm which will result in minimum
number of page faults

 Same page may be brought into memory several times

Operating System Concepts – 10th Edition 10.19 Silberschatz, Galvin and Gagne ©2018
 Page Replacement

Operating System Concepts – 10th Edition 10.20 Silberschatz, Galvin and Gagne ©2018
 Page Replacement

 Prevent over-allocation of memory by modifying page-fault service

routine to include page replacement

 Use modify (dirty) bit to reduce overhead of page transfers – only

modified pages are written to disk

 Page replacement completes separation between logical memory and

physical memory – large virtual memory can be provided on a smaller
physical memory

Operating System Concepts – 10th Edition 10.21 Silberschatz, Galvin and Gagne ©2018
 Need For Page Replacement

Operating System Concepts – 10th Edition 10.22 Silberschatz, Galvin and Gagne ©2018
 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
- Write victim frame to disk if dirty

3. Bring the desired page into the (newly) free frame; update the page
and frame tables

4. Continue the process by restarting the instruction that caused the trap

Note now potentially 2 page transfers for page fault – increasing EAT

Operating System Concepts – 10th Edition 10.23 Silberschatz, Galvin and Gagne ©2018
 Page Replacement

Operating System Concepts – 10th Edition 10.24 Silberschatz, Galvin and Gagne ©2018
 Page and Frame Replacement Algorithms

 Frame-allocation algorithm determines

 How many frames to give each process
 Which frames to replace
 Page-replacement algorithm
 Want lowest page-fault rate on both first access and re-access
 Evaluate algorithm by running it on a particular string of memory
references (reference string) and computing the number of page
faults on that string
 String is just page numbers, not full addresses
 Repeated access to the same page does not cause a page fault
 Results depend on number of frames available
 In all our examples, the reference string of referenced page
numbers is
7,0,1,2,0,3,0,4,2,3,0,3,0,3,2,1,2,0,1,7,0,1

Operating System Concepts – 10th Edition 10.25 Silberschatz, Galvin and Gagne ©2018
 Graph of Page Faults Versus The Number of Frames

Operating System Concepts – 10th Edition 10.26 Silberschatz, Galvin and Gagne ©2018
 First-In-First-Out (FIFO) Algorithm
 Reference string: 7,0,1,2,0,3,0,4,2,3,0,3,0,3,2,1,2,0,1,7,0,1
 3 frames (3 pages can be in memory at a time per process)

15 page faults
 Can vary by reference string: consider 1,2,3,4,1,2,5,1,2,3,4,5
 Adding more frames can cause more page faults!
 Belady’s Anomaly
 How to track ages of pages?
 Just use a FIFO queue

Operating System Concepts – 10th Edition 10.27 Silberschatz, Galvin and Gagne ©2018
 FIFO Illustrating Belady’s Anomaly

Operating System Concepts – 10th Edition 10.28 Silberschatz, Galvin and Gagne ©2018
 Optimal Algorithm
 Replace page that will not be used for longest period of time
 9 is optimal for the example
 How do you know this?
 Can’t read the future
 Used for measuring how well your algorithm performs

Operating System Concepts – 10th Edition 10.29 Silberschatz, Galvin and Gagne ©2018
 Least Recently Used (LRU) Algorithm
 Use past knowledge rather than future
 Replace page that has not been used in the most amount of time
 Associate time of last use with each page

 12 faults – better than FIFO but worse than OPT

 Generally good algorithm and frequently used
 But how to implement?

Operating System Concepts – 10th Edition 10.30 Silberschatz, Galvin and Gagne ©2018
 Counting Algorithms

 Keep a counter of the number of references that have been made

to each page
 Not common

 Lease Frequently Used (LFU) Algorithm: replaces page with

smallest count

 Most Frequently Used (MFU) Algorithm: based on the argument

that the page with the smallest count was probably just brought in
and has yet to be used

Operating System Concepts – 10th Edition 10.31 Silberschatz, Galvin and Gagne ©2018
 Allocation of Frames

Operating System Concepts – 10th Edition 10.32 Silberschatz, Galvin and Gagne ©2018
 Allocation of Frames
 Each process needs minimum number of frames
 Example: IBM 370 – 6 pages to handle SS MOVE instruction:
 instruction is 6 bytes, might span 2 pages
 2 pages to handle from
 2 pages to handle to
 Maximum of course is total frames in the system
 Two major allocation schemes
 fixed allocation
 priority allocation
 Many variations

Operating System Concepts – 10th Edition 10.33 Silberschatz, Galvin and Gagne ©2018
 Fixed Allocation
 Equal allocation – For example, if there are 100 frames (after
allocating frames for the OS) and 5 processes, give each process
20 frames
 Keep some as free frame buffer pool

 Proportional allocation – Allocate according to the size of process

 Dynamic as degree of multiprogramming, process sizes
change
m 64
si  size of process pi s1  10
S   si s2  127
m  total number of frames a1 
10
 62 » 4
137
si
ai  allocation for pi  m 127
S a2   62 » 57
137

Operating System Concepts – 10th Edition 10.34 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 10.35 Silberschatz, Galvin and Gagne ©2018
 Global vs. Local Allocation
 Global replacement – process selects a replacement frame
from the set of all frames; one process can take a frame from
another
 But then process execution time can vary greatly
 But greater throughput so more common

 Local replacement – each process selects from only its own

set of allocated frames
 More consistent per-process performance
 But possibly underutilized memory

Operating System Concepts – 10th Edition 10.36 Silberschatz, Galvin and Gagne ©2018
 Thrashing

Operating System Concepts – 10th Edition 10.37 Silberschatz, Galvin and Gagne ©2018
 Thrashing
 If a process does not have “enough” pages, the page-fault rate is
very high
 Page fault to get page
 Replace existing frame
 But quickly need replaced frame back
 This leads to:
 Low CPU utilization
 Operating system thinking 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

Operating System Concepts – 10th Edition 10.38 Silberschatz, Galvin and Gagne ©2018
 Thrashing

Operating System Concepts – 10th Edition 10.39 Silberschatz, Galvin and Gagne ©2018
 Thrashing (Cont.)

Operating System Concepts – 10th Edition 10.40 Silberschatz, Galvin and Gagne ©2018
 Demand Paging and Thrashing
 Why does demand paging work?
Locality model
 Process migrates from one locality to another
 Localities may overlap

 Why does thrashing occur?

 size of locality > total memory size
 Limit effects by using local or priority page replacement

Operating System Concepts – 10th Edition 10.41 Silberschatz, Galvin and Gagne ©2018
 Locality In A Memory-Reference Pattern
34

32

30

memory address 28

26

24

22
page num bers

20

18

execution time

Operating System Concepts – 10th Edition 10.42 Silberschatz, Galvin and Gagne ©2018
 Working-Set Model
   working-set window  a fixed number of page references
Example: 10,000 instructions
 WSSi (working set of Process Pi) =
total number of pages referenced in the most recent  (varies in time)
 if  too small will not encompass entire locality
 if  too large will encompass several localities
 if  =   will encompass entire program
 D =  WSSi  total demand frames
 Approximation of locality
 if D > m  Thrashing
 Policy if D > m, then suspend or swap out one of the processes

Operating System Concepts – 10th Edition 10.43 Silberschatz, Galvin and Gagne ©2018
 Keeping Track of the Working Set
 Approximate with interval timer + a reference bit
 Example:  = 10,000
 Timer interrupts after every 5000 time units
 Keep in memory 2 bits for each page
 Whenever a timer interrupts copy and sets 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

Operating System Concepts – 10th Edition 10.44 Silberschatz, Galvin and Gagne ©2018
 End of Chapter 10

Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne ©2018