The document discusses virtual memory management, including the concepts of logical and physical addresses, page faults, and the importance of resident sets in a multi-process environment. It describes various page replacement strategies such as optimal, LRU, and FIFO, as well as the impact of page size and frame allocation on performance and thrashing issues. Additionally, it introduces the working set model to minimize page faults by maintaining recently accessed pages in memory, highlighting its applications and limitations.

1. Copyright ©: Lawrence Angrave, Vikram Adve, Caccamo 1
Virtual Memory

2. Virtual Memory
 All memory addresses within a process are logical addresses and they
are translated into physical addresses at run-time
 Process image is divided in several small pieces (pages) that don’t need
to be continuously allocated
 A process image can be swapped in and out of memory occupying
different regions of main memory during its lifetime
 When OS supports virtual memory, it is not required for a process to
have all its pages loaded in main memory at the time it executes

3. Virtual Memory
 At any time, the portion of process image that is loaded in main memory
is called the resident set of the process
 If the CPU try to access an address belonging to a page that currently is
not loaded in main memory, it generates a page fault interrupt and:
 The interrupted process changes to blocked state
 The OS issues a disk I/O read request
 The OS tries to dispatch another process while the I/O request is served
 Once the disk completes the page transfer, an I/O interrupt is issued
 The OS handles the I/O interrupt and moves the process with page fault
back to ready state

4. Virtual Memory
 Since the OS only loads some pages of each process, more processes
can be resident in main memory and be ready for execution
 Virtual memory gives the programmer the impression that he/she is
dealing with a huge main memory (relying on available disk space). The
OS loads automatically and on-demand pages of the running process.
 A process image may be larger than the entire main memory

5. Virtual Memory &
Multiprogramming
 Eviction of Virtual Pages
 On page fault: Choose VM page to page out
 How to choose which data to page out?
 Allocation of Physical Page Frames
 How to distribute page frames to processes?

6. Page eviction
 Hopefully, kick out a less-useful page
 Modified (dirty) pages require writing, clean pages don’t
 Goal: kick out the page that’s least useful
 Problem: how do you determine utility?
 Heuristic: temporal and spatial locality exist
 Kick out pages that aren’t likely to be used again

7. Temporal & spatial locality
 temporal locality:
 if a particular memory location is referenced, then the same
location will likely be referenced again in the near future.
 spatial locality:
 if a particular memory location is referenced at a particular time,
then nearby memory locations will likely be referenced in the near
future.

8. Page Replacement Strategies
 The Principle of Optimality
 Replace page that will be used farthest in the future.
 Random page replacement
 Choose a page randomly
 FIFO - First in First Out
 Replace the page that has been in primary memory the longest
 It is simple to implement but it performs quite poorly
 LRU - Least Recently Used
 Replace the page that has not been used for the longest time
 Clock policy
 It uses an additional control bit (U-bit) to choose page to be replaced
 Working Set
 Keep in memory those pages that the process is actively using.

9. Principle of Optimality
 Description:
 Assume each page can be labeled with number of references that
will be executed before that page is first referenced.
 Then the optimal page algorithm would choose the page with the
highest label to be removed from the memory.
 Impractical! Why?
 Provides a basis for comparison with other schemes.
 If future references are known
 should not use demand paging
 should use “pre-paging” to overlap paging with computation.

10. LRU (Least Recently Used)
 Description:
 It replaces the page in memory that has not been
referenced for the longest time
 It works almost as well as optimal policy since it
leverages on principle of locality
 It is difficult to implement

11. Clock policy
 Description:
 It tries to approximate LRU policy but it imposes less overhead
 It requires an additional U-bit (use bit) for each page
 When a page is first loaded in main memory, its U-bit is set to 1.
each time a page is referenced, its U-bit is set to 1.
 If a page needs to be replaced, the replacement algorithm first
searches for a page that has both U and M bits set to zero. While
scanning is performed, the U-bit of scanned pages is reset to zero

12. Page size
 Page size is a crucial parameter for performance of virtual
memory
 Quiz: What is the effect of resizing memory pages?

13. Page size
Page
fault
rate
Page size
P
size of
entire
process
Note that page fault rate
is also affected by the number
of frames allocated to a process

14. Page size
 Page size is a crucial parameter for performance of virtual memory
 Quiz: What is the effect of resizing memory pages?
 If page size is too small, the page table becomes very large; on the
contrary, large pages cause internal fragmentation of memory
 In general small pages allow to exploit principle of locality; in fact, several
small pages can be loaded for a process, and they will include portions of
process image near recent references
 As size of pages is increased, principle of locality is not well exploited
anymore and page fault rate increases
 When size of pages becomes very big, page fault rate starts to decrease
again since a single page approaches the size of entire process image.

15. Frame Allocation for Multiple
Processes
 How are the page frames allocated to individual virtual memories of the
various jobs running in a multi-programmed environment?
 Solution 1: allocate an equal number of frames per job
 but jobs use memory unequally
 high priority jobs have same number of page frames as low priority jobs
 degree of multiprogramming might vary
 Solution 2: allocate a number of frames per job proportional to job size
 how do you define the concept of job size?

16. Frame Allocation for Multiple
Processes
 Why is multi-programming frame allocation so
important?
 If not solved appropriately, it will result in a severe
problem--- Thrashing

17. Trashing
 Thrashing: as number of page frames per VM space
decreases, the page fault rate increases.
 Each time one page is brought in, another page, whose contents
will soon be referenced, is thrown out.
 Processes will spend all of their time blocked, waiting for pages to
be fetched from disk
 I/O utilization at 100% but the system is not getting much useful
work done
 CPU is mostly idle
Real mem
P1 P2 P3

18. Why Trashing
 Computations have locality
 As number of page frames allocated to a process decreases,
the page frames available are not enough to contain the
locality of the process.
 The processes start faulting heavily
 Pages that are read in, are used and immediately paged out.

19. Level of multiprogramming
 Load control has the important function of deciding how many processes will be
resident in main memory
 Quiz: What are the trade-offs involved?

20. Level of multiprogramming
 What are the trade-offs involved?
 If too few processes are resident in memory, it can happen that all processes resident in memory are
blocked so swapping is necessary and CPU is left idle
 If too many processes are resident, then the average size of the resident set of each process will be
insufficient triggering frequent page faults

21. Page Fault Rate vs. Allocated Frames
N
Total number
of pages in process
W
Working Set size
Trashing

22. Working set (1968, Denning)
 Main idea
 figure out how much memory a process needs to keep most of its recent
computation in memory with very few page faults
 How?
 The working set model assumes temporal locality
 Recently accessed pages are more likely to be accessed again
 Thus, as the number of page frames increases above some threshold,
the page fault rate will drop dramatically

23. Working set (1968, Denning)
 What we want to know: collection of pages process must have in order
to avoid thrashing
 This requires knowing the future. And our trick is?
 Intuition of Working Set:
 Pages referenced by process in last  seconds of execution are considered
to comprise its working set
 : the working set parameter
 Usages of working set?
 Cache partitioning: give each application enough space for WS
 Page replacement: preferably discard non-WS pages
 Scheduling: a process is not executed unless its WS is in memory

24. Working set in details
 At virtual time vt, the working set of a process W(vt, T) is the set of pages
that the process has referenced during the past T units of virtual time.
 Virtual time vt is measured in terms of sequence of memory references
 It is easy to notice that size of working set grows as window size is
increased
 Limitations of Working Set
 High overhead to maintain a moving window over memory references
 Past does not always predict the future correctly
 It is hard to identify best value for window size T
  )
,
min(
,
1 N
T
T
vt
W 

Process total number
of pages

25. Calculating Working Set
12 references,
8 faults
Window size
is 

26. Working set in details
 Strategy for sizing the resident set of a process based
on Working set
 Keep track of working set of each process
 Periodically remove from the resident set the pages that
don’t belong to working set anymore
 A process is scheduled for execution only if its working set is
in main memory

27. Working set of real programs
 Typical programs have phases
Working
set
size
transition stable
Sum of both

28. Page Fault Frequency (PFF)
algorithm
 Approximation of pure Working Set
 Assume that working set strategy is valid; hence, properly
sizing the resident set will reduce page fault rate.
 Let’s focus on process fault rate rather than its exact page
references
 If process page fault rate increases beyond a maximum
threshold, then increase its resident set size.
 If page fault rate decreases below a minimum threshold,
then decrease its resident set size
 Without harming the process, OS can free some frames
and allocate them to other processes suffering higher PFF