Professional Documents
Culture Documents
ch9 Virtual Memory
ch9 Virtual Memory
Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne ©2018
Chapter 9: Virtual Memory
▪ Background
▪ Demand Paging
▪ Page Replacement
▪ Allocation of Frames
▪ Thrashing
Operating System Concepts – 10th Edition 10.2 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
▪ 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
Operating System Concepts – 10th Edition 10.3 Silberschatz, Galvin and Gagne ©2018
Virtual memory
Operating System Concepts – 10th Edition 10.4 Silberschatz, Galvin and Gagne ©2018
Virtual memory (Cont.)
Operating System Concepts – 10th Edition 10.5 Silberschatz, Galvin and Gagne ©2018
Virtual Memory That is Larger Than Physical Memory
Operating System Concepts – 10th Edition 10.6 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 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.7 Silberschatz, Galvin and Gagne ©2018
Shared Library Using Virtual Memory
Operating System Concepts – 10th Edition 10.8 Silberschatz, Galvin and Gagne ©2018
Demand Paging
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
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.11 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:
Operating System Concepts – 10th Edition 10.12 Silberschatz, Galvin and Gagne ©2018
Page Table When Some Pages Are Not
in Main Memory
Operating System Concepts – 10th Edition 10.13 Silberschatz, Galvin and Gagne ©2018
Steps in Handling Page Fault
Operating System Concepts – 10th Edition 10.14 Silberschatz, Galvin and Gagne ©2018
Steps in Handling a Page Fault (Cont.)
Operating System Concepts – 10th Edition 10.15 Silberschatz, Galvin and Gagne ©2018
Aspects of Demand Paging
Operating System Concepts – 10th Edition 10.16 Silberschatz, Galvin and Gagne ©2018
Instruction Restart
Operating System Concepts – 10th Edition 10.17 Silberschatz, Galvin and Gagne ©2018
Free-Frame List
▪ When a page fault occurs, the operating system must bring the
desired page from secondary storage into main memory.
▪ Most operating systems maintain a free-frame list -- a pool of free
frames for satisfying such requests.
Operating System Concepts – 10th Edition 10.18 Silberschatz, Galvin and Gagne ©2018
Stages in Demand Paging – Worse Case
Operating System Concepts – 10th Edition 10.19 Silberschatz, Galvin and Gagne ©2018
Stages in Demand Paging (Cont.)
Operating System Concepts – 10th Edition 10.20 Silberschatz, Galvin and Gagne ©2018
Demand Paging Optimizations
▪ Swap space I/O faster than file system I/O even if on the same device
• Swap allocated in larger chunks, less management needed than file
system
▪ Copy entire process image to swap space at process load time
• Then page in and out of swap space
• Used in older BSD Unix
▪ Demand page in from program binary on disk, but discard rather than paging
out when freeing frame
• Used in Solaris and current BSD
• Still need to write to swap space
Pages not associated with a file (like stack and heap) – anonymous
memory
Pages modified in memory but not yet written back to the file system
▪ Mobile systems
• Typically don’t support swapping
• Instead, demand page from file system and reclaim read-only pages
(such as code)
Operating System Concepts – 10th Edition 10.21 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.22 Silberschatz, Galvin and Gagne ©2018
Need For Page Replacement
Operating System Concepts – 10th Edition 10.23 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.24 Silberschatz, Galvin and Gagne ©2018
Page Replacement
Operating System Concepts – 10th Edition 10.25 Silberschatz, Galvin and Gagne ©2018
Page and Frame Replacement Algorithms
Operating System Concepts – 10th Edition 10.26 Silberschatz, Galvin and Gagne ©2018
Graph of Page Faults Versus the Number of Frames
Operating System Concepts – 10th Edition 10.27 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.28 Silberschatz, Galvin and Gagne ©2018
FIFO Illustrating Belady’s Anomaly
Operating System Concepts – 10th Edition 10.29 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.30 Silberschatz, Galvin and Gagne ©2018
Least Recently Used (LRU) Algorithm
Operating System Concepts – 10th Edition 10.31 Silberschatz, Galvin and Gagne ©2018
LRU Algorithm (Cont.)
▪ 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 find
smallest value
Search through table needed
▪ Stack implementation
• Keep a stack of page numbers in a double link form:
• Page referenced:
move it to the top
requires 6 pointers to be changed
• But each update more expensive
• No search for replacement
Operating System Concepts – 10th Edition 10.32 Silberschatz, Galvin and Gagne ©2018
LRU Algorithm (Cont.)
▪ LRU and OPT are cases of stack algorithms that don’t have
Belady’s Anomaly
▪ Use Of A Stack to Record Most Recent Page References
Operating System Concepts – 10th Edition 10.33 Silberschatz, Galvin and Gagne ©2018
LRU Approximation Algorithms
▪ LRU needs special hardware and still slow
▪ Reference bit
• With each page associate a bit, initially = 0
• When page is referenced bit set to 1
• Replace any with reference bit = 0 (if one exists)
We do not know the order, however
Operating System Concepts – 10th Edition 10.34 Silberschatz, Galvin and Gagne ©2018
LRU Approximation Algorithms (cont.)
▪ Second-chance algorithm
• Generally FIFO, plus hardware-provided reference bit
• Clock replacement
• If page to be replaced has
Reference bit = 0 -> replace it
reference bit = 1 then:
– set reference bit 0, leave page in memory
– replace next page, subject to same rules
Operating System Concepts – 10th Edition 10.35 Silberschatz, Galvin and Gagne ©2018
Second-chance Algorithm
Operating System Concepts – 10th Edition 10.36 Silberschatz, Galvin and Gagne ©2018
Enhanced Second-Chance Algorithm
▪ Improve algorithm by using reference bit and modify bit (if available)
in concert
▪ Take ordered pair (reference, modify):
• (0, 0) neither recently used not modified – best page to replace
• (0, 1) not recently used but modified – not quite as good, must
write out before replacement
• (1, 0) recently used but clean – probably will be used again soon
• (1, 1) recently used and modified – probably will be used again
soon and need to write out before replacement
▪ When page replacement called for, use the clock scheme but use the
four classes replace page in lowest non-empty class
• Might need to search circular queue several times
Operating System Concepts – 10th Edition 10.37 Silberschatz, Galvin and Gagne ©2018
Counting Algorithms
Operating System Concepts – 10th Edition 10.38 Silberschatz, Galvin and Gagne ©2018
Page-Buffering Algorithms
▪ Keep a pool of free frames, always
• Then frame available when needed, not found at fault time
• Read page into free frame and select victim to evict and add to
free pool
• When convenient, evict victim
▪ Possibly, keep list of modified pages
• When backing store otherwise idle, write pages there and set to
non-dirty
▪ Possibly, keep free frame contents intact and note what is in them
• If referenced again before reused, no need to load contents again
from disk
• Generally useful to reduce penalty if wrong victim frame selected
Operating System Concepts – 10th Edition 10.39 Silberschatz, Galvin and Gagne ©2018
Applications and Page Replacement
▪ All of these algorithms have OS guessing about future page access
▪ Some applications have better knowledge – i.e. databases
▪ Memory intensive applications can cause double buffering
• OS keeps copy of page in memory as I/O buffer
• Application keeps page in memory for its own work
▪ Operating system can given direct access to the disk, getting out of
the way of the applications
• Raw disk mode
▪ Bypasses buffering, locking, etc.
Operating System Concepts – 10th Edition 10.40 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.41 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
Operating System Concepts – 10th Edition 10.42 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
Operating System Concepts – 10th Edition 10.43 Silberschatz, Galvin and Gagne ©2018
Thrashing (Cont.)
▪ Thrashing. A process is busy swapping pages in and out
Operating System Concepts – 10th Edition 10.44 Silberschatz, Galvin and Gagne ©2018
Demand Paging and Thrashing
Operating System Concepts – 10th Edition 10.45 Silberschatz, Galvin and Gagne ©2018
Page-Fault Frequency
▪ More direct approach than WSS
▪ Establish “acceptable” page-fault frequency (PFF) rate and use
local replacement policy
• If actual rate too low, process loses frame
• If actual rate too high, process gains frame
Operating System Concepts – 10th Edition 10.46 Silberschatz, Galvin and Gagne ©2018
End of Chapter 9
Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne ©2018