Operating Systems:

Internals and Design Principles, 6/E

William Stallings

Chapter 8
Virtual Memory

7/18/10
 Roadmap
• Hardware and Control Structures
• Operating System Software
• UNIX and Solaris Memory Management
• Linux Memory Management
• Windows Memory Management
Terminology
 Key points in
Memory Management
1) Memory references are logical addresses
dynamically translated into physical addresses at
run time
– A process may be swapped in and out of main
memory occupying different regions at different
times during execution
2) A process may be broken up into pieces that
do not need to located contiguously in main
memory
 Breakthrough in
Memory Management
• If both of those two characteristics are
present,
– then it is not necessary that all of the pages or all
of the segments of a process be in main memory
during execution.
• If the next instruction, and the next data
location are in memory then execution can
proceed
– at least for a time
 Execution of a Process
• Operating system brings into main memory a
few pieces of the program
• Resident set - portion of process that is in
main memory
• An interrupt is generated when an address is
needed that is not in main memory
• Operating system places the process in a
blocking state
 Execution of a Process
• Piece of process that contains the logical
address is brought into main memory
– Operating system issues a disk I/O Read request
– Another process is dispatched to run while the
disk I/O takes place
– An interrupt is issued when disk I/O complete
which causes the operating system to place the
affected process in the Ready state
 Implications of
this new strategy
• More processes may be maintained in main
memory
– Only load in some of the pieces of each process
– With so many processes in main memory, it is very
likely a process will be in the Ready state at any
particular time
• A process may be larger than all of main
memory
 Real and
Virtual Memory
• Real memory
– Main memory, the actual RAM
• Virtual memory
– Memory on disk
– Allows for effective multiprogramming and
relieves the user of tight constraints of main
memory
 Locality and Virtual Memory
• Benefits (1 & 2) are attractive, but is the scheme
practical
– Q: won't interrupting to page in in the
middle of program cause noticeable delays?
 Locality and Virtual Memory
• Over any short period of time, execution may be
confined to a small section of the program (e.g. a
subroutine or a loop).
– Only access a few local variables, or an array.
• Wasteful to load all of the other stuff, not being used
– Often the case in simple paging or partitioning
with swapping, we swap out a process after being
swapped in, and it only used a very small part of
its data and code during that time.
 Thrashing
• A state in which the system spends most of its
time swapping pieces rather than executing
instructions.
• To avoid this, the operating system tries to guess
which pieces are least likely to be used in the near
future.
• The guess is based on recent history
 Principle of Locality
• Program and data references within a process
tend to cluster
• Only a few pieces of a process will be needed
over a short period of time
• Therefore it is possible to make intelligent
guesses about which pieces will be needed in
the future
• This suggests that virtual memory may work
efficiently
A Processes Performance
in VM Environment
• Note that during
the lifetime of the
process, references
are confined to a
subset of pages.
 Support Needed for
Virtual Memory
• Hardware must support paging and
segmentation
• Operating system must be able to manage the
movement of pages and/or segments
between secondary memory and main
memory
 Paging
• Each process has its own page table
• Each page table entry contains the frame
number of the corresponding page in main
memory
• Two extra bits are needed to indicate:
– whether the page is in main memory or not
– Whether the contents of the page has been
altered since it was last loaded
(see next slide)
Paging Table
Address Translation
 Page Tables
• Page tables are also stored in virtual memory
• When a process is running, part of its page
table is in main memory
 Two-Level
Hierarchical Page Table
Address Translation for Hierarchical
page table
 Page Size
• Smaller page size, less amount of internal
fragmentation
• But Smaller page size, more pages required
per process
– More pages per process means larger page tables
• Larger page tables means large portion of
page tables in virtual memory
 Page Size
• Secondary memory is designed to efficiently
transfer large blocks of data so a large page
size is better
 Further complications
to Page Size
• Small page size, large number of pages will be
found in main memory
• As time goes on during execution, the pages in
memory will all contain portions of the
process near recent references. Page faults
low.
• Increased page size causes pages to contain
locations further from any recent reference.
Page faults rise.
Page Size
 Roadmap
• Hardware and Control Structures
• Operating System Software
• UNIX and Solaris Memory Management
• Linux Memory Management
• Windows Memory Management
 Memory Management
Decisions
• Whether or not to use virtual memory
techniques
• The use of paging or segmentation or both
• The algorithms employed for various aspects
of memory management
 Key Design Elements

• Key aim: Minimise page faults

– No definitive best policy
 Fetch Policy
• Determines when a page should be brought
into memory
• Two main types:
– Demand Paging
– Prepaging
 Demand Paging
and Prepaging
• Demand paging
– only brings pages into main memory when a
reference is made to a location on the page
– Many page faults when process first started
• Prepaging
– brings in more pages than needed
– More efficient to bring in pages that reside
contiguously on the disk
– Don’t confuse with “swapping”
 Placement Policy
• Determines where in real memory a process
piece is to reside
• Important in a segmentation system
• Paging or combined paging with segmentation
hardware performs address translation
 Replacement Policy
• When all of the frames in main memory are
occupied and it is necessary to bring in a new
page, the replacement policy determines
which page currently in memory is to be
replaced.
 But…
• Which page is replaced?
• Page removed should be the page least likely
to be referenced in the near future
– How is that determined?
– Principal of locality again
• Most policies predict the future behavior on
the basis of past behavior
 Replacement Policy:
Frame Locking
• Frame Locking
– If frame is locked, it may not be replaced
– Kernel of the operating system
– Key control structures
– I/O buffers
– Associate a lock bit with each frame
 Basic Replacement
Algorithms
• There are certain basic algorithms that are
used for the selection of a page to replace,
they include
– Optimal
– Least recently used (LRU)
– First-in-first-out (FIFO)
– Clock
• Examples (do page replacement animation)
 Examples
• An example of the implementation of these
policies will use a page address stream formed
by executing the program is
– 232152453252
• Which means that the first page referenced is
2,
– the second page referenced is 3,
– And so on.
 Optimal policy
• Selects for replacement that page for which
the time to the next reference is the longest
• But Impossible to have perfect knowledge of
future events
 Optimal Policy
Example

• The optimal policy produces three page faults

after the frame allocation has been filled.
 Least Recently
Used (LRU)
• Replaces the page that has not been
referenced for the longest time
• By the principle of locality, this should be the
page least likely to be referenced in the near
future
• Difficult to implement
– One approach is to tag each page with the time of
last reference.
– This requires a great deal of overhead.
 LRU Example

• The LRU policy does nearly as well as the

optimal policy.
– In this example, there are four page faults
 First-in, first-out (FIFO)
• Treats page frames allocated to a process as a
circular buffer
• Pages are removed in round-robin style
– Simplest replacement policy to implement
• Page that has been in memory the longest is
replaced
– But, these pages may be needed again very soon if
it hasn’t truly fallen out of use
 FIFO Example

• The FIFO policy results in six page faults.

– Note that LRU recognizes that pages 2 and 5 are
referenced more frequently than other pages,
whereas FIFO does not.
 Clock Policy
• Uses an additional bit called a “use bit”
• When a page is first loaded in memory or
referenced, the use bit is set to 1
• When it is time to replace a page, the OS
scans the set flipping all 1’s to 0
• The first frame encountered with the use bit
already set to 0 is replaced.
Clock Policy
Clock Policy
 Clock Policy Example

• Note that the clock policy is adept at

protecting frames 2 and 5 from replacement.
Combined Examples
Comparison
 Resident Set
Management
• The OS must decide how many pages to bring
into main memory
– The smaller the amount of memory allocated to
each process, the more processes that can reside
in memory.
– Small number of pages loaded increases page
faults.
– Beyond a certain size, further allocations of pages
will not affect the page fault rate.
 Resident Set Size
• Fixed-allocation
– Gives a process a fixed number of pages within
which to execute
– When a page fault occurs, one of the pages of that
process must be replaced
• Variable-allocation
– Number of pages allocated to a process varies
over the lifetime of the process
 Replacement Scope
• The scope of a replacement strategy can be
categorized as global or local.
– Both types are activated by a page fault when
there are no free page frames.
– A local replacement policy chooses only among
the resident pages of the process that generated
the page fault
– A global replacement policy considers all unlocked
pages in main memory
 Fixed Allocation,
Local Scope
• Decide ahead of time the amount of allocation
to give a process
• If allocation is too small, there will be a high
page fault rate
• If allocation is too large there will be too few
programs in main memory
– Increased processor idle time or
– Increased swapping.
 Variable Allocation, Global Scope
• Easiest to implement
– Adopted by many operating systems
• Operating system keeps list of free frames
• Free frame is added to resident set of process
when a page fault occurs
• If no free frame, replaces one from another
process
– Therein lies the difficulty … which to replace.
 Variable Allocation,
Local Scope
• When new process added, allocate number of
page frames based on application type,
program request, or other criteria
• When page fault occurs, select page from
among the resident set of the process that
suffers the fault
• Reevaluate allocation from time to time
 Resident Set
Management Summary
 Cleaning Policy
• A cleaning policy is concerned with
determining when a modified page should be
written out to secondary memory.
• Demand cleaning
– A page is written out only when it has been
selected for replacement
• Precleaning
– Pages are written out in batches
 Cleaning Policy
• Best approach uses page buffering
• Replaced pages are placed in two lists
– Modified and unmodified
• Pages in the modified list are periodically
written out in batches
• Pages in the unmodified list are either
reclaimed if referenced again or lost when its
frame is assigned to another page
 Load Control
• Determines the number of processes that will
be resident in main memory
– The multiprogramming level
• Too few processes, many occasions when all
processes will be blocked and much time will
be spent in swapping
• Too many processes will lead to thrashing
Multiprogramming
 Process Suspension
• If the degree of multiprogramming is to be
reduced, one or more of the currently resident
processes must be suspended (swapped out).
• Six possibilities exist…
 Suspension policies
• Lowest priority process
• Faulting process
– This process does 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
 Suspension policies cont.
• Process with smallest resident set
– This process requires the least future effort to
reload
• Largest process
– Obtains the most free frames
• Process with the largest remaining execution
window
 Roadmap
• Hardware and Control Structures
• Operating System Software
• UNIX and Solaris Memory Management
• Linux Memory Management
• Windows Memory Management
 Unix
• Intended to be machine independent so
implementations vary
– Early Unix: variable partitioning with no virtual
memory to paged
– Recent Unix (SVR4 & Solaris) using paged virtual
memory
• SVR4 uses two separate schemes:
– Paging system and a kernel memory allocator.
 Paging System and
Kernel Memory Allocator
• Paging system provides a virtual memory
capability that allocates page frames in main
memory to processes
– Also allocates page frames to disk block buffers.
• Kernel Memory Allocator allocates memory
for the kernel
– The paging system is less suited for this task
 Paged VM
Data Structures
Page Table Entry Fields
 Disk Block
Descriptor Fields
Page Frame and
Swap Use fields
 Page Replacement
• The page frame data table is used for page
replacement
• Pointers used to create several lists within the
table
– Free frame list
– When the number of free frames drops below a
threshold, the kernel will steal a number of frames
to compensate.
“Two Handed” Clock
Page Replacement
 Parameters for
Two Handed Clock
• Scanrate:
– The rate at which the two hands scan through the
page list, in pages per second

• Handspread:
– The gap between fronthand and backhand
• Both have defaults set at boot time based on
physical memory
 Kernel Memory
Allocator
• The kernel generates and destroys small tables
and buffers frequently during the course of
execution, each of which requires dynamic
memory allocation.
• Most of these blocks significantly smaller than
typical pages,
– Therefore normal paging would be inefficient
• Variation of “buddy system” is used
 Lazy Buddy
• UNIX often exhibits steady-state behavior in
kernel memory demand;
– i.e. the amount of demand for blocks of a
particular size varies slowly in time.
• To avoid unnecessary joining and splitting of
blocks,
– the lazy buddy system defers coalescing until it
seems likely that it is needed, and then coalesces
as many blocks as possible.
 Lazy Buddy
System Parameters
• Ni = current number of blocks of size 2i
• Ai = current number of blocks of size 2i that
are allocated (occupied).
• Gi = current number of blocks of size 2i that
are globally free.
• Li = current number of blocks of size 2i that
are locally free
 Lazy Buddy
System Allocator
 Linux
Memory Management
• Shares many characteristics with Unix
– But is quite complex
• Two main aspects
– Process virtual memory, and
– Kernel memory allocation.
 Linux
Memory Management
• Page directory
• Page middle directory
• Page table
 Linux Virtual Memory
• Three level page table structure
– Each table is the size of one page
• Page directory
– Each process has one page directory
– 1 page in size, must be in main memory
• Page middle directory:
– May be multiple pages, each entry points to one
page in the page table
 Linux Memory cont
• Page table
– May also span multiple pages.
– Each page table entry refers to one virtual page of
the process.
Address Translation
 Page Replacement
• Based on the clock algorithm
• The “use bit” is replace with an 8-bit age
variable
– Incremented with each page access
• Periodically decrements the age bits
– Any page with an age of 0 is “old” and is a
candidate for replacement
• A form of Least Frequently Used policy
 Windows
Memory Management
• The Windows virtual memory manager
controls how memory is allocated and how
paging is performed.
• Designed to operate over a variety of
platforms
– uses page sizes ranging from 4 Kbytes to 64
Kbytes.
 Windows Virtual
Address Map
• On 32 bit platforms each user process sees a
separate 32 bit address space
– Allowing 4G per process
• Some reserved for the OS,
– Typically each user process has 32G of available
virtual address space
– With all processes sharing the same 2G system
space
32 bit Windows
Address Space
 Windows Paging
• On creation, a process can make use of the
entire user space of almost 2 Gbytes.
• This space is divided into fixed-size pages
managed in contiguous regions allocated on
64Kbyte boundaries
• Regions may be in one of three states
– Available
– Reserved
– Committed
 Resident Set
Management System
• Windows uses “variable allocation, local
scope”
• When activated a process is assigned data
structures to manage its working set
• Working sets of active processes are adjusted
depending on the availability of main memory