Chapter 8a: Virtual Memory I Silberschatz, Galvin and Gagne ©2013

Chapter 8a: Virtual Memory I

Operating System Concepts Essentials – 2 nd Edition

Silberschatz, Galvin and Gagne ©2013

Chapter 8a: Virtual Memory I

 Background

 Demand Paging

 Copy-on-Write

 Page Replacement

Operating System Concepts Essentials – 2 nd Edition 8.2


Objectives

 Describe benefits of virtual memory

 Explain concepts of:

 Demand paging

 Page-replacement algorithms

 Allocation of page frames

 Discuss principle of working-set model

 Explore how kernel memory is managed



Background

 Code must 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



Background

 Execute partially-loaded program

 No longer constrained by physical memory limits

 Program uses less memory while running

 More programs can run at same time

 Increased CPU utilization

 Increased throughput

 No increase in response or turnaround time

 Less I/O needed to load or swap programs into memory

 Each user program runs faster



Background (Cont.)

 Virtual memory – separates logical (virtual) memory from physical memory

 Only part of must be in memory for execution

 Logical address space can be much larger than physical address space

 Allows shared address spaces

 More efficient process creation

 More programs can run concurrently

 Less I/O needed to load or swap processes




 Virtual address space – logical view of process stored in memory

 Usually starts at address 0x0

 Contains contiguous addresses

 Physical memory organized into page frames

 MMU maps logical to physical memory

 MMU = Memory Management Unit




 Virtual memory implemented via:

 Demand paging

 Demand segmentation



Virtual Memory That is Larger Than Physical Memory



Virtual-address Space

 Logical address space:

 Stack starts at highest logical address, grows “down”

 Heap grows “up”

 Maximizes address space usage

 Holeunused address space between stack and heap

 No physical memory needed until stack or heap grows



Virtual-address Space

 Enables sparse address space

 Holes filled as needed

 System libraries shared via mapping into virtual address space

 Shared memory by mapping pages read-write into virtual address space

 Pages shared during fork() , speeding process creation



Shared Library Using Virtual Memory



Demand Paging

 Bring page into memory only when it ’s needed

 Less I/O needed

 No unnecessary I/O

 Less memory needed

 Faster response

 More users

 Similar to paging system with swapping



Demand Paging

 Page is needed

 reference to it





Invalid reference

 abort

Not-in-memory

 bring to memory

 Lazy swapper – never swap page into memory unless page will be needed

 Swapper that deals with pages is called pager



Basic Concepts

 With swapping , pager guesses which pages will be used before swapping out again

 Instead, pager brings in only needed pages into memory

 How to determine set of pages?

 Need new MMU functionality to implement demand paging



Basic Concepts

 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 page into memory from storage

 Without changing program behavior

 Without programmer needing to change code



Valid-Invalid Bit

 Valid –invalid bit associated with each entry in page table

 v => memory resident

 i => not-in-memory

 Initially set to i for all entries

 E.g.,



Page Table When Some Pages Are Not in Main Memory



Page Fault

 First reference to a page will trap to OS: page fault

1.

OS checks another table to decide:





Invalid reference => abort

Not in memory

2.

Find free frame in physical memory

3.

Swap page into frame via scheduled disk operation

4.

Reset tables to indicate page now in memory

 validation bit = v

5.

Restart instruction that caused page fault



Steps in Handling a Page Fault



Aspects of Demand Paging

 Hardware support needed for demand paging

 Page table with valid / invalid bit

 Secondary memory (device with swap space )

 Instruction restart




 Extreme case – start process with no pages in memory

 Pure demand paging

 OS sets instruction pointer to first instruction of process

 Non-memory-resident causes page fault




 A given instruction could access multiple pages

 Cause multiple page faults

 E.g., instruction C = A + B

 A, B, and C on different pages

 Overhead decreased because of locality of reference

 Data often close together in memory



Stages of Demand Paging

1.

Trap to OS

2.

Save user registers and process state

3.

Determine if interrupt was page fault

4.

Check if page reference was legal, determine location of page on disk




5.

Issue a read from disk to a free frame:

 Wait in queue for device until read request serviced

 Wait for device seek and/or latency time

 Begin transfer of page to free frame

6.

While waiting, allocate CPU to some other user

7.

Receive interrupt from disk I/O subsystem (done)

8.

Save registers and process state for other user




9.

Determine that interrupt was from disk

10.

Correct the page table and other tables to show page is now in memory

11.

Wait for CPU to be allocated to this process

12.

Restore user registers, process state, and new page table, resume interrupted instruction



Performance of Demand Paging

 Three major activities:

1.

2.

3.

Service interrupt – careful coding req’d

Read page from disk

– lots of time

Restart process – small amount of time



Performance of Demand Paging

 Page Fault Rate 0

 p



1

 if p = 0, no page faults

 if p = 1, every reference causes fault

 Effective Access Time (EAT)

EAT = (1 – p ) x memory access

+ p (page fault overhead

+ swap page out

+ swap page in )



Demand Paging Example

 Memory access time = 200 nanoseconds

 Average page-fault service time = 8 milliseconds

 EAT = (1 – p) x 200 + p (8 milliseconds)

= (1 – p) x 200 + p x 8,000,000

= 200 + p x 7,999,800



Demand Paging Example

 If p = 0.001, then EAT = 8199.8 nanoseconds

 40.9X slowdown

 If want performance degradation < 10%

 220 > 200 + 7,999,800 x p

 20 > 7,999,800 x p

 => p < .0000025

 less than one page fault in every 400,000 memory accesses



Demand Paging Optimizations

 Swap space I/O faster than file system I/O (even if on same device)

 Swap allocated in larger chunks

 Less management needed than file system

 Copy entire process image to swap space at process load time

 Page in and out of swap space

 Used in older BSD Unix




 When free frame, discard rather than page out

 Used in Solaris and current BSD

 Still need to write to swap space

 Pages not associated with a file (like stack and heap) – anonymous memory

 Pages modified in memory but not yet written back to file system




 Mobile systems

 Typically don ’t support swapping

 Instead, demand page from file system and reclaim read-only pages (such as code)



Copy-on-Write

 Copy-on-Write (COW) allows parent and child processes to initially share same pages in memory

 If either modifies shared page, then page copied

 COW allows more efficient process creation

 Only modified pages copied



Copy-on-Write

 In general, free pages allocated from pool of zero-fill-on-demand pages

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

 Freeing frames on page faults inefficient



Copy-on-Write

 vfork() variation on fork() system call has parent suspend and child using copy-on-write address space of parent

 Designed to have child call exec()

 Very efficient



Before Process 1 Modifies Page C



After Process 1 Modifies Page C



What Happens if There is no Free Frame?

 Used up by process pages

 Pages used by kernel, I/O buffers, etc.

 How many pages to allocate each?

 How to deal with frequently used pages?



What Happens if There is no Free Frame?

 Page replacement – find some page in memory to page out

 Algorithm – terminate? swap out? replace the page?

 Performance – want algorithm with minimum number of page faults



Page Replacement

 Prevent over-allocation of memory

 Include page replacement in page fault service

 Use modify bit to reduce overhead of transfers

 Only modified pages are written to disk

 Page replacement completes separation between logical memory and physical memory

 Large virtual memory can be provided by smaller physical memory



Need For Page Replacement



Basic Page Replacement

1.

Find location of desired page on disk

2.

Find a free frame:

 If free frame exists, use it

 If no free frames, use page replacement algorithm to select a victim frame

 If victim frame modified (dirty), write to disk



Basic Page Replacement

3.



Bring desired page into (newly) free frame

Update page and frame tables

4.

Continue process by restarting instruction that caused page fault trap



Page Replacement



Page and Frame Replacement Algorithms

 Frame-allocation algorithm determines

 How many frames per process

 Which frames to replace

 Page-replacement algorithm

 Want lowest page-fault rates



Page and Frame Replacement Algorithms

 Evaluate algorithm against string of memory references, compute number of page faults

 String represents page numbers, not full addresses

 Repeated access to page does not cause page fault

 Results depend on number of frames available

 E.g., reference string of referenced page numbers:

7,0,1,2,0,3,0,4,2,3,0,3,0,3,2,1,2,0,1,7,0,1



Graph of Page Faults Versus The Number of Frames



First-In-First-Out (FIFO) Algorithm

 When a page must be replaced, use the oldest page

 Can be implemented with FIFO queue

 New page put on tail

 Replace page at head of queue


15 page faults


FIFO Illustrating Belady ’ s Anomaly

more frames != fewer page faults



Optimal Algorithm

 Replace page that will not be used for longest period of time

 How do you know this? Can ’t read future

 Used as benchmark test

 Theoretical best


9 page faults


Least Recently Used (LRU) Algorithm

 Replace page that has not been used in the most amount of time

 Use past knowledge rather than future

 Associate time of last use with each page


12 page faults


LRU Algorithm (Cont.)

 Counter implementation

 Every page entry has counter

 Every time page referenced, copy clock into counter

 When page needs to be changed, look at counters, find smallest value

 Search through table needed



LRU Algorithm (Cont.)

 Stack implementation

 Keep stack of page numbers in double link form:

 Page referenced:

 Move page to top

 Requires 6 pointers to be changed

 Each update more expensive

 On replacement- no search required

 Bottom of stack..



Stack Algorithms

 LRU and OPT are stack algorithms

 Do NOT exhibit Belady’s Anomaly



Use Of A Stack to Record Most Recent Page References



LRU Approximation Algorithms

 LRU needs special hardware and still slow

 Reference bit

 Associate a bit with each page (initially 0)

 When page referenced, set bit to 1

 Replace any page with reference bit = 0 (if exists)

 Order unknown, however



LRU Approximation Algorithms

 Second-chance algorithm

 Generally FIFO, plus HW reference bit

 Clock replacement

 If page to be replaced has

 Reference bit = 0, then replace it

 Reference bit = 1 then:

– Set reference bit 0, leave page in memory

– Replace next page, subject to same rules



Second-Chance (clock) Page-Replacement Algorithm



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

2.

(0, 1) not recently used but modified

3.

(1, 0) recently used but clean

4.

(1, 1) recently used and modified



Enhanced Second-Chance Algorithm

 When page replacement needed, use clock scheme

 Replace page in lowest non-empty <ref, mod> class

 Might need to search circular queue several times



Counting Algorithms

 Keep counter to track number of references for each page

 Not common

 Lease Frequently Used ( LFU ) Algorithm : replace page with smallest count

 Most Frequently Used ( MFU ) Algorithm : replace page with largest count

 Idea: page with smallest count most recently brought into memory...



Page-Buffering Algorithms

 Always keep pool of free frames

 Frame available when needed, not found at page fault

 Read page into free frame

 Select victim to evict and add to free pool

 Only when convenient



Page-Buffering Algorithms

 If possible, keep list of modified pages

 Write dirty pages to backing store when it ’s idle

 Set page to non-dirty

 If possible, keep free frame contents intact

 If referenced before reused, no need to load contents again from disk

 Reduces penalty if wrong victim frame selected



Applications and Page Replacement

 All PR algorithms have OS guessing about future page access

 Some applications have better knowledge

 E.g., 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



Applications and Page Replacement

 Operating system can given direct access to the disk, getting out of the way of the applications

 Raw disk mode

 Bypasses buffering, locking, etc



Chapter 8a: Virtual Memory I Silberschatz, Galvin and Gagne ©2013

Chapter 8a: Virtual Memory I

Chapter 8a: Virtual Memory I

Objectives

Background

Background

Background (Cont.)

Background (Cont.)

Background (Cont.)

Virtual-address Space

Virtual-address Space

Shared Library Using Virtual Memory

Demand Paging

Demand Paging

Basic Concepts

Basic Concepts

Valid-Invalid Bit

Page Fault

Steps in Handling a Page Fault

Aspects of Demand Paging

Aspects of Demand Paging

Aspects of Demand Paging

Stages of Demand Paging

Stages of Demand Paging

Stages of Demand Paging

Performance of Demand Paging

Performance of Demand Paging

Demand Paging Example

Demand Paging Example

Demand Paging Optimizations

Demand Paging Optimizations

Demand Paging Optimizations

Copy-on-Write

Copy-on-Write

Copy-on-Write

Before Process 1 Modifies Page C

After Process 1 Modifies Page C

Page Replacement

Need For Page Replacement

Basic Page Replacement

Basic Page Replacement

Page Replacement

First-In-First-Out (FIFO) Algorithm

FIFO Illustrating Belady ’ s Anomaly

Optimal Algorithm

Least Recently Used (LRU) Algorithm

LRU Algorithm (Cont.)

LRU Algorithm (Cont.)

Stack Algorithms

LRU Approximation Algorithms

LRU Approximation Algorithms

Counting Algorithms

Page-Buffering Algorithms

Page-Buffering Algorithms

Related documents

Add this document to collection(s)

Add this document to saved

Suggest us how to improve StudyLib