Introduction to

Operating Systems
C-CS316 Spring 2024

LECTURE 11:
Virtual Memory
Dr. Basma Hassan Dr. Ahmed Salama
[email protected] [email protected]

Faculty of Computing and Information Sciences

 Chapter10: Virtual Memory
Demand Paging

Copy-on-Write

Page Replacement

Allocation of Frames

Thrashing

Memory-Mapped Files

Allocating Kernel Memory

Faculty of Computing and Information Sciences

2
Virtual memory

Virtual memory is a memory management technique that provides an illusion to the process
that it has contiguous working memory, which is larger than the actual physical memory (RAM)
installed on the system.

Virtual memory can be implemented via:

Demand paging

Demand segmentation

Faculty of Computing and Information Sciences

3
Virtual memory (Cont.)
• Virtual memory
• allows each process to have its own separate address space, which can be much larger than
the physical memory available on the system. This enables programs to address more
memory than physically exists, which is particularly useful for running large applications or
multiple processes simultaneously.

• provides isolation between processes. Each process operates within its own virtual address
space, preventing one process from accessing with the memory of another process.

• Only part of the program needs to be in memory for execution

Faculty of Computing and Information Sciences

4
Virtual Memory That is Larger Than Physical Memory

Faculty of Computing and Information Sciences

5
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 processes
• Similar to paging system with swapping (diagram on right)
• Page is needed  reference to it
• invalid reference  abort
• not-in-memory (page fault) bring to memory
• Lazy swapper – never swaps a page into memory unless page will be needed
• Swapper that deals with pages is a pager

Faculty of Computing and Information Sciences

6
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)

Faculty of Computing and Information Sciences

7
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

Faculty of Computing and Information Sciences

8
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

Faculty of Computing and Information Sciences

9
Page Table When Some Pages Are Not in Main Memory

Faculty of Computing and Information Sciences

10
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 typically allocate free frames using a technique known as zero-fill-on-
demand -- the content of the frames zeroed-out before being allocated.
• When a system starts up, all available memory is placed on the free-frame list.

Faculty of Computing and Information Sciences

11
Performance of Demand Paging

• The Effective Access Time (EAT) represents the average time it takes to perform a
memory access, taking into account both the time required for accessing data stored in
memory and the additional overhead incurred in case of a page fault.

• Page Fault Rate 0  p  1 •When 𝑝=0, it means there are no page faults. This implies
• if p = 0 no page faults all pages that the program needs are already in memory
• if p = 1, every reference is a fault
•When 𝑝=1, it means every memory reference results in a
• Effective Access Time (EAT) page fault.

EAT = (1 – p) x memory access + p (page fault overhead + swap page out + swap page in )

Average page-fault service time

Faculty of Computing and Information Sciences

12
Demand Paging Example

• Memory access time = 200 nanoseconds

• Average page-fault service time = 8 milliseconds
• EAT = (1 – p) x 200 + p (8 milliseconds) 1 millisecond (ms)=1,000,000 nanoseconds (ns)
= (1 – p ) x 200 + p x 8,000,000
= 200 + p x 7,999,800
• If one access out of 1,000 causes a page fault (p=0.001) , then
EAT =8,200 nanoseconds = 8.2 microseconds.

Faculty of Computing and Information Sciences

13
Copy-on-Write
• Copy-on-Write (COW) allows both parent and child processes to initially share the same
pages in memory

• If either process modifies a shared page, only then is the page copied

• COW allows more efficient process creation as only modified pages are copied

• In general, free pages are allocated from a pool of zero-fill-on-demand pages

• Pool should always have free frames for fast demand page execution

• Don’t want to have to free a frame as well as other processing on page fault

Faculty of Computing and Information Sciences

14
What Happens if There is no Free Frame?

• 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
MM
• Same page may be brought into memory several times P1 p5
P2
P3
p4

Faculty of Computing and Information Sciences

15
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

Faculty of Computing and Information Sciences

16
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

Faculty of Computing and Information Sciences

17
Basic Page Replacement

Faculty of Computing and Information Sciences

18
Page Replacement Algorithms

• Page-replacement Technique

• 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,2,1,2,0,1,7,0,1

Faculty of Computing and Information Sciences

19
First-In-First-Out (FIFO) Algorithm

• Reference string: 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1

• 3 frames (3 pages can be in memory at a time per process)

14 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

Faculty of Computing and Information Sciences

20
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

9 page faults

• Since this algorithm requires knowledge of future memory accesses, it is often used as a theoretical
benchmark rather than a practical algorithm.

Faculty of Computing and Information Sciences

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

Faculty of Computing and Information Sciences

22
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

Faculty of Computing and Information Sciences

23
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

Faculty of Computing and Information Sciences

24
LRU Approximation Algorithms

• LRU needs special hardware and still slow

• 1) Reference bit algorithm

• 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

Faculty of Computing and Information Sciences

25
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

Faculty of Computing and Information Sciences

26
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 ( disk imaging, partition editing, and data recovery.)
• Bypasses buffering, locking, etc.

Faculty of Computing and Information Sciences

27
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

Faculty of Computing and Information Sciences

28
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

• Proportional allocation – Allocate according to the size of process

• Dynamic as degree of multiprogramming, process sizes change

m = 64
si = size of process pi
s1 = 10
S =  si
s2 = 127
m = total number of frames 10
a1 = ´ 62 » 4
s 137
ai = allocation for pi = i  m
S 127
a2 = ´ 62 » 57
137

Faculty of Computing and Information Sciences

29
Global vs. Local Allocation

• Global replacement – process selects a replacement frame from the set of all
frames; one process can take a frame from another

• But then process execution time can vary greatly

• But greater throughput so more common

• Local replacement – each process selects from only its own set of allocated frames

• More consistent per-process performance

• But possibly underutilized memory

Faculty of Computing and Information Sciences

30
Non-Uniform Memory Access

• So far, we assumed that all memory accessed equally

• Many systems are NUMA – speed of access to memory varies
• Consider system boards containing CPUs and memory, interconnected over a system bus
• NUMA multiprocessing architecture

Faculty of Computing and Information Sciences

31
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

Faculty of Computing and Information Sciences

32
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 page replacement

Faculty of Computing and Information Sciences

33
Allocating Kernel Memory

• Treated differently from user memory

• Often allocated from a free-memory pool

• Kernel requests memory for structures of varying sizes

• Some kernel memory needs to be contiguous

• i.e., for device I/O

Faculty of Computing and Information Sciences

34
Slab Allocator
• Alternate strategy
• Slab is one or more physically contiguous pages
• Cache consists of one or more slabs
• Single cache for each unique kernel data structure
• Each cache filled with objects – instantiations of the data structure
• When cache created, filled with objects marked as free
• When structures stored, objects marked as used
• If slab is full of used objects, next object allocated from empty slab
• If no empty slabs, new slab allocated
• Benefits include no fragmentation, fast memory request satisfaction

Faculty of Computing and Information Sciences

35
Slab Allocation

Faculty of Computing and Information Sciences

36
Prepaging
• To reduce the large number of page faults that occurs at process startup

• Prepage all or some of the pages a process will need, before they are referenced

• But if prepaged pages are unused, I/O and memory was wasted

• Assume s pages are prepaged and α of the pages is used

• Is cost of s * α save pages faults > or < than the cost of prepaging
s * (1- α) unnecessary pages?
• IF α near zero  prepaging loses

Faculty of Computing and Information Sciences

37
I/O interlock

• I/O Interlock – Pages must sometimes be locked into

memory

• Consider I/O - Pages that are used for copying a file from
a device must be locked from being selected for eviction
by a page replacement algorithm

• Pinning of pages to lock into memory

Faculty of Computing and Information Sciences

38
 End of Lecture!
Thanks for your Attention!

Faculty of Computing and Information Sciences

39