Chapter 8: Virtual Memory

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 discuss the principle of the working-set model
• To examine the relationship between shared memory and memory-mapped files
• To explore how kernel memory is managed

2
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

3
Background (Cont.)

• 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

4
Background (Cont.)

• 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

5
Virtual Memory That is Larger Than Physical Memory

6
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

7
Shared Library Using Virtual Memory

8
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

9
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

10
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:

• During MMU address translation, if valid–invalid bit in page table entry is i  page fault

11
Page Table When Some Pages Are Not in Main Memory

12
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

13
Steps in Handling a Page Fault

14
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
• Pure demand paging
• Actually, a given instruction could access multiple pages -> multiple page faults
• Consider fetch and decode of instruction which adds 2 numbers from memory and stores result back to memory
• Pain decreased because of locality of reference
• Hardware support needed for demand paging
• Page table with valid / invalid bit
• Secondary memory (swap device with swap space)
• Instruction restart

15
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

24
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

25
Need For Page Replacement

26
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

27
Page Replacement

28
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

29
Graph of Page Faults Versus The Number of Frames

30
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

31
FIFO Illustrating Belady’s Anomaly

32
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

33
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?

34
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
• LRU and OPT are cases of stack algorithms that don’t have Belady’s Anomaly

35
Use Of A Stack to Record Most Recent Page References

36
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
• 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

37
Second-Chance (clock) Page-Replacement Algorithm

38
Enhanced Second-Chance Algorithm

• Improve algorithm by using reference bit and modify bit (if available) in concert
• Take ordered pair (reference, modify)
1.(0, 0) neither recently used not modified – best page to replace
2.(0, 1) not recently used but modified – not quite as good, must write out before replacement
3.(1, 0) recently used but clean – probably will be used again soon
4.(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

39
Counting Algorithms

• Keep a counter of the number of references that have been made to each page
• Not common

• Lease Frequently Used (LFU) Algorithm: replaces page with smallest count

• Most Frequently Used (MFU) Algorithm: based on the argument that the page with the smallest count was
probably just brought in and has yet to be used

40
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

• Thrashing  a process is busy swapping pages in and out

48
Thrashing (Cont.)

49
Demand Paging and Thrashing

• Why does demand paging work?

Locality model
• Process migrates from one locality to another
• Localities may overlap

• Why does thrashing occur?

 size of locality > total memory size
• Limit effects by using local or priority page replacement

50
Working-Set Model
•   working-set window  a fixed number of page references
Example: 10,000 instructions
• WSSi (working set of Process Pi) =
total number of pages referenced in the most recent  (varies in time)
• if  too small will not encompass entire locality
• if  too large will encompass several localities
• if  =   will encompass entire program
• D =  WSSi  total demand frames
• Approximation of locality
• if D > m  Thrashing
• Policy if D > m, then suspend or swap out one of the processes

52
Keeping Track of the Working Set

• Approximate with interval timer + a reference bit

• Example:  = 10,000
• Timer interrupts after every 5000 time units
• Keep in memory 2 bits for each page
• Whenever a timer interrupts copy and sets the values of all reference bits to 0
• If one of the bits in memory = 1  page in working set
• Why is this not completely accurate?
• Improvement = 10 bits and interrupt every 1000 time units

53
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

54
Working Sets and Page Fault Rates

• Direct relationship between working set of a process and its page-fault rate
• Working set changes over time
• Peaks and valleys over time

55