Chapter 8

Virtual Memory
 Hardware and Control Structures

◼ Two characteristics fundamental to memory

management:
1) all memory references are logical addresses that are
dynamically translated into physical addresses at run time
2) a process may be broken up into a number of pieces that
don’t need to be contiguously located in main memory
during execution
◼ If these two characteristics are present, it is not
necessary that all of the pages or segments of a
process be in main memory during execution
Terminology
◼ 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 is complete, which causes
the operating system to place the affected process in the Ready
state.
 Implications
◼ 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
Table 8.2
Characteristics of

Paging and

Segmentation
 To avoid this, the
A state in which operating system tries
the system spends to guess, based on
most of its time recent history, which
swapping process pieces are least likely
pieces rather than to be used in the near
executing future
instructions
 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

◼ Avoids thrashing
Paging Behavior

◼ During the lifetime of the

process, references are
confined to a subset of pages
 For virtual memory to be practical and
effective:
• hardware must support paging and
segmentation
• operating system must include software for
managing the movement of pages and/or
segments between secondary memory and
main memory
 Paging
◼ The term virtual memory is usually associated with systems that
employ paging

◼ Use of paging to achieve virtual memory was first reported for

the Atlas computer

◼ Each process has its own page table

◼ each page table entry contains the frame number of the
corresponding page in main memory
 Memory
Management
Formats
Address Translation
 Two-Level
Hierarchical Page Table
Address Translation
◼ Page number portion of a virtual address is mapped into a hash
value
◼ hash value points to inverted page table

◼ Fixed proportion of real memory is required for the tables

regardless of the number of processes or virtual pages supported
◼ Structure is called inverted because it indexes page table entries by
frame number rather than by virtual page number
 Inverted Page Table
Each entry in the page table includes:

Page Process Control Chain

number identifier bits pointer
• the process • includes • the index
that owns flags and value of the
this page protection next entry
and locking in the chain
information
 Translation Lookaside
Buffer (TLB)
◼ Each virtual memory ◼ To overcome the effect of
reference can cause two doubling the memory
physical memory accesses: access time, most virtual
◼ one to fetch the page memory schemes make
table entry use of a special high-speed
cache called a translation
◼ one to fetch the data
lookaside buffer
Use of a T L B
 TL B
o peration
 Page Size
◼ The smaller the page size, the lesser the amount of internal
fragmentation
◼ however, more pages are required per process
◼ more pages per process means larger page tables
◼ for large programs in a heavily multiprogrammed environment
some portion of the page tables of active processes must be in
virtual memory instead of main memory
◼ the physical characteristics of most secondary-memory devices
favor a larger page size for more efficient block transfer of data
Paging Behavior of a Program
 Page Size
The design issue of main memory is
page size is related to getting larger and
the size of physical address space used by
main memory and applications is also
program size growing

◼ Contemporary programming
techniques used in large
programs tend to decrease the most obvious on
personal computers
locality of references within a where applications are
process becoming increasingly
complex
 Segmentation
Advantages:
◼ Segmentation • simplifies handling
allows the of growing data
programmer to structures
view memory as • allows programs to
consisting of be altered and
multiple address recompiled
independently
spaces or
• lends itself to
segments
sharing data
among processes
• lends itself to
protection
 Segment Organization
◼ Each segment table entry contains the starting address of the
corresponding segment in main memory and the length of the
segment

◼ A bit is needed to determine if the segment is already in main

memory

◼ Another bit is needed to determine if the segment has been

modified since it was loaded in main memory
Address Translation
 Combined Paging and
Segmentation

In a combined
paging/segmentation system Segmentation is visible to the
a user’s address space is programmer
broken up into a number of
segments. Each segment is
broken up into a number of
fixed-sized pages which are Paging is transparent to the
equal in length to a main programmer
memory frame
Address Translation
Combined Segmentation
and Paging
Protection
R elationships
Policies for Virtual Memory
◼ Key issue: Performance
▪ minimize page faults
◼ Determines when a
page should be Two main
brought into types:
memory

Demand
Prepaging
Paging
 Demand Paging
◼ Demand Paging
◼ only brings pages into main memory when a reference is made
to a location on the page
◼ many page faults when process is first started
◼ principle of locality suggests that as more and more pages are
brought in, most future references will be to pages that have
recently been brought in, and page faults should drop to a very
low level
 Prepaging
◼ Prepaging
◼ pages other than the one demanded by a page fault are brought
in
◼ exploits the characteristics of most secondary memory devices
◼ if pages of a process are stored contiguously in secondary
memory it is more efficient to bring in a number of pages at
one time
◼ ineffective if extra pages are not referenced
◼ should not be confused with “swapping”
 Placement Policy
◼ Determines where in real memory a process
piece is to reside
◼ Important design issue in a segmentation system
◼ Paging or combined paging with segmentation
placing is irrelevant because hardware performs
functions with equal efficiency
◼ For NUMA systems an automatic placement
strategy is desirable
 Replacement Policy
◼ Deals with the selection of a page in main memory
to be replaced when a new page must be brought in
◼ objective is that the page that is removed be the page
least likely to be referenced in the near future

◼ The more elaborate the replacement policy the

greater the hardware and software overhead to
implement it
▪ When a frame is locked the page currently stored in that frame
may not be replaced
▪ kernel of the OS as well as key control structures are held
in locked frames
▪ I/O buffers and time-critical areas may be locked into
main memory frames
▪ locking is achieved by associating a lock bit with each
frame
Algorithms used for
the selection of a
page to replace:
• Optimal
• Least recently used (LRU)
• First-in-first-out (FIFO)
• Clock
▪ Selects the page for which the time to the
next reference is the longest
▪ Produces three page faults after the frame
allocation has been filled
 Least Recently Used
( LR U)
◼ 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
L R U Example
 First-in-First-out ( F IF O )
◼ Treats page frames allocated to a process as a circular buffer

◼ Pages are removed in round-robin style

▪ simple replacement policy to implement

◼ Page that has been in memory the longest is replaced

 Clock Policy
◼ Requires the association of an additional bit with each frame
◼ referred to as the use bit

◼ When a page is first loaded in memory or referenced, the use bit

is set to 1

◼ The set of frames is considered to be a circular buffer

◼ Any frame with a use bit of 1 is passed over by the algorithm

◼ Page frames visualized as laid out in a circle

C lock
Policy
C lock
Policy
Combined Examples
◼ Improves paging A replaced page is
not lost, but
performance and rather assigned to
allows the use of one of two lists:

a simpler page
replacement
policy
Free page list Modified page list

list of page frames

pages are written
available for
out in clusters
reading in pages
 Replacement Policy and Cache Size
◼ With large caches, replacement of pages can have a performance
impact
◼ if the page frame selected for replacement is in the cache, that
cache block is lost as well as the page that it holds
◼ in systems using page buffering, cache performance can be
improved with a policy for page placement in the page buffer
◼ most operating systems place pages by selecting an arbitrary
page frame from the page buffer
◼ 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 can reside in memory
◼ small number of pages loaded increases page faults
◼ beyond a certain size, further allocations of pages will not
effect the page fault rate
 Resident Set Size
Fixed-allocation Variable-allocation
◼ gives a process a fixed ◼ allows the number of page
number of frames in main frames allocated to a
memory within which to process to be varied over
execute the lifetime of the process
◼ when a page fault occurs,
one of the pages of that
process mustbe replaced
◼ 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

Local
• chooses only among the resident pages of the process that generated
the page fault

Global
• considers all unlocked pages in main memory
Fixed Allocation, Local Scope
◼ Necessary to 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 • increased processor idle time

large, there will be
too few programs • increased time spent in
in main memory swapping
 Variable Allocation
Global Scope
◼ Easiest to implement
◼ adopted in a number of operating systems

◼ OS maintains a list of free frames

◼ Free frame is added to resident set of process when a page fault

occurs

◼ If no frames are available the OS must choose a page currently in

memory

◼ One way to counter potential problems is to use page buffering

 Variable Allocation
Local Scope
◼ Decision to increase or decrease a resident set size is based
on the assessment of the likely future demands of active
processes

Key elements:

• criteria used to determine

resident set size
• the timing of changes
 Cleaning Policy
◼ Concerned with determining when a modified page should be
written out to secondary memory

Demand Cleaning
a page is written out to secondary memory only when it has been selected for
replacement

Precleaning
allows the writing of pages in batches
Multiprogramming
◼ If the degree of multiprogramming is to be reduced, one or more
of the currently resident processes must be swapped out

Six possibilities exist:

• Lowest-priority process
• Faulting process
• Last process activated
• Process with the smallest resident set
• Largest process
• Process with the largest remaining execution window
 Unix
◼ Intended to be machine independent so its memory
management schemes will vary
◼ early Unix: variable partitioning with no virtual memory
scheme
◼ current implementations of UNIX and Solaris make use of

S
paV virtual memoryschemes:
gedR

• paging system
• kernel memory allocator
 Paging system Kernel Memory
Allocator

provides a virtual memory

capability that allocates page frames allocates memory for the kernel
in main memory to processes

allocates page frames to disk block

buffers
UNIX SVR4
Memory
Management
Formats
Table 8.6

UNIX SVR4
Memory
Management
Parameters
Table 8.6

UNIX SVR4
Memory
Management
Parameters
◼ The page frame data table is used for page replacement

◼ Pointers are used to create lists within the table

◼ all available frames are linked together in a list of free frames
available for bringing in pages
◼ when the number of available frames drops below a certain
threshold, the kernel will steal a number of frames to
compensate
“Two Handed”
Clock
Page

Replacement
 Linux
Memory Management
◼ Shares many characteristics with Unix
◼ Is quite complex

• process virtual
memory
Two main • kernel memory
aspects allocation
◼ Three level page table structure:

Page directory Page middle directory Page table

process has a single page may span multiple pages may also span multiple pages
directory

each entry points to one page each entry points to one page each entry refers to one
of the page middle directory in the page table virtual page of the process

must be in main memory for

an active process
◼ Based on the clock algorithm

◼ The use bit is replaced with an 8-bit age variable

◼ incremented each time the page is accessed

◼ Periodically decrements the age bits

◼ a page with an age of 0 is an “old” page that has not been
referenced is some time and is the best candidate for
replacement

◼ A form of least frequently used policy

 Windows
Memory Management
◼ 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 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 64 Kbyte boundaries

◼ Regions may be in one of three states:

available reserved committed

 Summary
◼ Desirable to:
◼ maintain as many processes in main memory as possible
◼ free programmers from size restrictions in program
development

◼ With virtual memory:

◼ all address references are logical references that are translated
at run time to real addresses
◼ a process can be broken up into pieces
◼ two approaches are paging and segmentation
◼ management scheme requires both hardware and software
support