Chapter 9: Virtual Memory: Silberschatz, Galvin and Gagne ©2013 Operating System Concepts Essentials - 9 Edition

Chapter 9: Virtual Memory
Operating System Concepts Essentials – 9th Edition Silberschatz, Galvin and Gagne ©2013
Chapter 9: Virtual Memory
 Background
 Demand Paging
 Copy-on-Write
 Page Replacement
Operating System Concepts Essentials – 9th Edition 9.2 Silberschatz, Galvin and Gagne ©2013
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 examine the relationship between shared memory and memory-mapped

files
Background
 Code needs to be in memory to execute, but entire program rarely used
 Error code, unusual routines, large data structures
 Entire program code not needed at same time
 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
 Increased CPU utilization and throughput with no increase in response
time or turnaround time
 Less I/O needed to load or swap programs into memory -> each user
program runs faster
Background
 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
 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
Virtual Memory That is
Larger Than Physical Memory
Shared Library Using Virtual Memory
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
Basic Concepts
 With swapping, pager guesses which pages will be used before swapping out again
 Instead of swapping in a whole process, 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
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:
Frame # valid-invalid bit
v
v
v
v
i
….
i
i
page table
 During MMU address translation, if valid–invalid bit in page table entry

is i  page fault
Page Table When Some Pages Are Not in Main Memory
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
Steps in Handling a Page Fault
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
 Hardware support needed for demand paging

 Page table with valid / invalid bit
 Secondary memory (swap device with swap space)
 Instruction restart
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
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
Page Replacement
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
Graph of Page Faults Versus
The Number of Frames
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
FIFO Illustrating Belady’s Anomaly
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
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?
End of Chapter 9
Operating System Concepts Essentials – 9th Edition Silberschatz, Galvin and Gagne ©2013

Chapter 9: Virtual Memory: Silberschatz, Galvin and Gagne ©2013 Operating System Concepts Essentials - 9 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

Chapter 9: Virtual Memory: Silberschatz, Galvin and Gagne ©2013 Operating System Concepts Essentials - 9 Edition

Uploaded by

Copyright:

Available Formats

Chapter 9: Virtual Memory

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

 To examine the relationship between shared memory and memory-mapped

 Entire program code not needed at same time

 Consider ability to execute partially-loaded program

 Virtual address space – logical view of how process is stored in memory

 Or bring a page into memory only when it is

 Similar to paging system with swapping (diagram

 Page is needed  reference to it

 Lazy swapper – never swaps a page into

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

 Hardware support needed for demand paging

 Used up by process pages

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

 Same page may be brought into memory several times

1. Find the location of the desired page on disk

2. Find a free frame:

 In all our examples, the reference string of referenced page numbers is

 Can vary by reference string: consider 1,2,3,4,1,2,5,1,2,3,4,5

 How to track ages of pages?

 How do you know this?

 Used for measuring how well your algorithm performs

 Use past knowledge rather than future

 12 faults – better than FIFO but worse than OPT

You might also like