Virtual Memory Operating System Concepts 8 th Edition

Virtual Memory n Chapter 8 in the text book OSCE. Chapter 9 in OSC.

Objectives n To describe the benefits of a virtual memory system n To explain

Background n Virtual memory – separation of user logical memory from physical memory. l

Virtual Memory That is Larger Than Physical Memory Operating System Concepts – 8 th

Virtual-address Space Operating System Concepts – 8 th Edition 9. 6 Silberschatz, Galvin and

Shared Library Using Virtual Memory Operating System Concepts – 8 th Edition 9. 7

Demand Paging n Bring a page into memory only when it is needed Less

Transfer of a Paged Memory to Contiguous Disk Space Operating System Concepts – 8

Valid-Invalid Bit n With each page table entry a valid–invalid bit is associated (v

Page Table When Some Pages Are Not in Main Memory Operating System Concepts –

Page Fault n If there is a reference to a page, first reference to

Page Fault (Cont. ) n Restart instruction l block move l auto increment/decrement location

Steps in Handling a Page Fault Operating System Concepts – 8 th Edition 9.

Performance of Demand Paging n Page Fault Rate 0 p 1. 0 l if

Demand Paging Example n Memory access time = 200 nanoseconds n Average page-fault service

Process Creation n Virtual memory allows other benefits during process creation: - Copy-on-Write -

Before Process 1 Modifies Page C Operating System Concepts – 8 th Edition 9.

Copy on Write: After Process 1 Modifies Page C Operating System Concepts – 8

Copy-on-Write: Lazy copy n Copy-on-Write (COW) allows both parent and child processes to initially

What happens if there is no free frame? n Page replacement – find some

Need For Page Replacement Operating System Concepts – 8 th Edition 9. 22 Silberschatz,

Page Replacement Operating System Concepts – 8 th Edition 9. 23 Silberschatz, Galvin and

Basic Page Replacement 1. Find the location of the desired page on disk 2.

Expected behavior: # of Page Faults vs. # of Physical Frames Operating System Concepts

First-In-First-Out (FIFO) Algorithm n Reference string: 1, 2, 3, 4, 1, 2, 5, 1,

FIFO Page Replacement Operating System Concepts – 8 th Edition 9. 27 Silberschatz, Galvin

FIFO Illustrating Belady’s Anomaly Operating System Concepts – 8 th Edition 9. 28 Silberschatz,

Optimal Algorithm n Replace page that will not be used for longest period of

Optimal Page Replacement Operating System Concepts – 8 th Edition 9. 30 Silberschatz, Galvin

Least Recently Used (LRU) Algorithm n Reference string: 1, 2, 3, 4, 1, 2,

LRU Page Replacement Operating System Concepts – 8 th Edition 9. 32 Silberschatz, Galvin

LRU Algorithm (Cont. ) n Stack implementation – keep a stack of page numbers

Use Of A Stack to Record The Most Recent Page References Operating System Concepts

LRU Approximation Algorithms n Reference bit l With each page associate a bit, initially

Second-Chance (clock) Page-Replacement Algorithm Operating System Concepts – 8 th Edition 9. 36 Silberschatz,

Issues with Page Allocation and Replacement n Initial Allocation. Each process needs minimum number

Fixed Allocation n Equal allocation – For example, if there are 100 frames and

Priority Allocation n Use a proportional allocation scheme using priorities rather than size n

Thrashing n If a process does not have “enough” pages, the page-fault rate is

Thrashing (Cont. ) Operating System Concepts – 8 th Edition 9. 41 Silberschatz, Galvin

Relationship of Demand Paging and Thrashing n Why does demand paging work? Locality model

Locality In A Memory-Reference Pattern Operating System Concepts – 8 th Edition 9. 43

Working Sets and Page Fault Rates Operating System Concepts – 8 th Edition 9.

Memory-Mapped Files n Memory-mapped file I/O allows file I/O to be treated as routine

Memory Mapped Files Operating System Concepts – 8 th Edition 9. 46 Silberschatz, Galvin

Other Issues -- Prepaging n To reduce page faults (e. g. during process startup)

Tradeoffs: Page Size n. Impact of Page size selection: l. Internal l. Page l.

Other Issues – TLB Reach n TLB Reach - The amount of memory accessible

Other Issues – Impact of Program Structure n Program structure l Int[128, 128] data;

Other Issues – I/O interlock n I/O Interlock – Pages must sometimes be locked

Reason Why Frames Used For I/O Must Be In Memory Operating System Concepts –

Slides: 52

Download presentation

Virtual Memory n Chapter 8 in the text book OSCE. Chapter 9 in OSC. n Demand Paging n Copy-on-Write n Page Replacement n Allocation of Frames n Thrashing n Memory-Mapped Files Operating System Concepts – 8 th Edition 9. 2 Silberschatz, Galvin and Gagne © 2009

Objectives n To describe the benefits of a virtual memory system n To explain the concepts of demand paging, page-replacement algorithms, and allocation of page frames n To discuss the principle of the working-set model Operating System Concepts – 8 th Edition 9. 3 Silberschatz, Galvin and Gagne © 2009

Background n Virtual memory – separation of user logical memory from physical memory. l Only part of the program needs to be in memory for execution l Logical address space can therefore be much larger than physical address space l Allows address spaces to be shared by several processes l Allows for more efficient process creation n Virtual memory can be implemented via: l Demand paging l Demand segmentation Operating System Concepts – 8 th Edition 9. 4 Silberschatz, Galvin and Gagne © 2009

Demand Paging n Bring a page into memory only when it is needed Less I/O needed l Less memory needed l Faster response l More users l n Page is needed reference to it invalid reference abort l not-in-memory bring to memory l n Lazy swapper – never swaps a page into memory unless page will be needed l Swapper that deals with pages is a pager Operating System Concepts – 8 th Edition 9. 8 Silberschatz, Galvin and Gagne © 2009

Valid-Invalid Bit n With each page table entry a valid–invalid bit is associated (v in-memory, i not-in-memory) n Initially valid–invalid bit is set to i on all entries n Example of a page table snapshot: Frame # valid-invalid bit v v i …. i i page table n During address translation, if valid–invalid bit in page table entry is I page fault Operating System Concepts – 8 th Edition 9. 10 Silberschatz, Galvin and Gagne © 2009

Page Fault n If there is a reference to a page, first reference to that page will trap to 1. 2. 3. 4. 5. operating system: page fault Operating system looks at another table to decide: l Invalid reference abort l Just not in memory Get empty frame Swap page into frame Reset tables Set validation bit = v 6. Restart the instruction that caused the page fault Operating System Concepts – 8 th Edition 9. 12 Silberschatz, Galvin and Gagne © 2009

Performance of Demand Paging n Page Fault Rate 0 p 1. 0 l if p = 0 no page faults l if p = 1, every reference is a fault n Effective Access Time (EAT) EAT = (1 – p) x memory access + p (page fault overhead + swap page out + swap page in + restart overhead ) Operating System Concepts – 8 th Edition 9. 15 Silberschatz, Galvin and Gagne © 2009

Demand Paging Example n Memory access time = 200 nanoseconds n Average page-fault service time = 8 milliseconds n EAT = (1 – p) x 200 + p (8 milliseconds) = (1 – p x 200 + p x 8, 000 = 200 + p x 7, 999, 800 n If one access out of 1, 000 causes a page fault, then EAT = 8. 2 microseconds. This is a slowdown by a factor of 40!! Operating System Concepts – 8 th Edition 9. 16 Silberschatz, Galvin and Gagne © 2009

Process Creation n Virtual memory allows other benefits during process creation: - Copy-on-Write - Memory-Mapped Files (later) Operating System Concepts – 8 th Edition 9. 17 Silberschatz, Galvin and Gagne © 2009

Copy-on-Write: Lazy copy n 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, this page is copied n COW allows more efficient process creation as only modified pages are copied Operating System Concepts – 8 th Edition 9. 20 Silberschatz, Galvin and Gagne © 2009

What happens if there is no free frame? n Page replacement – find some page in memory, but not really in use, swap it out l Algorithm l Performance – want an algorithm which will result in minimum number of page faults n Same page may be brought into memory several times Operating System Concepts – 8 th Edition 9. 21 Silberschatz, Galvin and Gagne © 2009

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 3. Swap out: Use modify (dirty) bit to reduce overhead of page transfers – only modified pages are written to disk 4. Bring the desired page into the free frame. Update the page and frame tables Operating System Concepts – 8 th Edition 9. 24 Silberschatz, Galvin and Gagne © 2009

First-In-First-Out (FIFO) Algorithm n Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5 n 3 frames (3 pages can be in memory at a time per process). Maintain a queue and select based on FIFO order. n 4 frames 1 1 4 5 2 2 1 3 3 3 2 4 1 1 5 4 2 2 1 5 3 3 2 4 4 3 9 page faults 10 page faults n Belady’s Anomaly: more frames more page faults Operating System Concepts – 8 th Edition 9. 26 Silberschatz, Galvin and Gagne © 2009

Optimal Algorithm n Replace page that will not be used for longest period of time n 4 frames example 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5 1 4 2 6 page faults 3 4 5 n How do you know this? n Used for measuring how well your algorithm performs Operating System Concepts – 8 th Edition 9. 29 Silberschatz, Galvin and Gagne © 2009

Least Recently Used (LRU) Algorithm n Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5 1 1 5 2 2 2 3 5 5 4 4 3 3 3 n Counter implementation l Every page entry has a counter; every time page is referenced through this entry, copy the clock into the counter l When a page needs to be changed, look at the counters to determine which are to change Operating System Concepts – 8 th Edition 9. 31 Silberschatz, Galvin and Gagne © 2009

LRU Algorithm (Cont. ) n Stack implementation – keep a stack of page numbers in a double link form: l Page referenced: 4 move it to the top 4 requires l 6 pointers to be changed No search for replacement Operating System Concepts – 8 th Edition 9. 33 Silberschatz, Galvin and Gagne © 2009

LRU Approximation Algorithms n Reference bit l With each page associate a bit, initially = 0 l When page is referenced bit set to 1 l Replace the one which is 0 (if one exists) 4 We do not know the order, however n Second chance l Need reference bit l Clock replacement l If page to be replaced (in clock order) has reference bit = 1 then: 4 set reference bit 0 4 leave page in memory 4 replace Operating System Concepts – 8 th Edition next page (in clock order), subject to same rules 9. 35 Silberschatz, Galvin and Gagne © 2009

Issues with Page Allocation and Replacement n Initial Allocation. Each process needs minimum number of pages l Two schemes: Fixed allocation vs. priority allocation n Where to find frames • Global replacement – find a frame from all processes. • Local replacement – find only from its own allocated frames Operating System Concepts – 8 th Edition 9. 37 Silberschatz, Galvin and Gagne © 2009

Fixed Allocation n Equal allocation – For example, if there are 100 frames and 5 processes, give each process 20 frames. n Proportional allocation – Allocate according to the size of process Operating System Concepts – 8 th Edition 9. 38 Silberschatz, Galvin and Gagne © 2009

Priority Allocation n Use a proportional allocation scheme using priorities rather than size n If process Pi generates a page fault, l select for replacement one of its frames l select for replacement a frame from a process with lower priority number Operating System Concepts – 8 th Edition 9. 39 Silberschatz, Galvin and Gagne © 2009

Thrashing n If a process does not have “enough” pages, the page-fault rate is very high. This leads to: l low CPU utilization l operating system thinks that it needs to increase the degree of multiprogramming l another process added to the system n Thrashing a process is busy swapping pages in and out Operating System Concepts – 8 th Edition 9. 40 Silberschatz, Galvin and Gagne © 2009

Relationship of Demand Paging and Thrashing n Why does demand paging work? Locality model l Process migrates from one locality to another l Localities l Need may overlap a minimum working set to be effective n Why does thrashing occur? working-sets > total memory size Operating System Concepts – 8 th Edition 9. 42 Silberschatz, Galvin and Gagne © 2009

Memory-Mapped Files n Memory-mapped file I/O allows file I/O to be treated as routine memory access by mapping a disk block to a page in memory n A file is initially read using demand paging. A page-sized portion of the file is read from the file system into a physical page. Subsequent reads/writes to/from the file are treated as ordinary memory accesses. n Simplifies file access by treating file I/O through direct memory access rather than read() write() system calls n Also allows several processes to map the same file allowing the pages in memory to be shared Operating System Concepts – 8 th Edition 9. 45 Silberschatz, Galvin and Gagne © 2009

Other Issues -- Prepaging n To reduce page faults (e. g. during process startup) n Preload some pages before they are referenced n But if prepaged pages are unused, I/O and memory wasted n Assume s pages are prepaged and α of the pages is used l Page fault cost of s * α > cost of prepaging s * (1 - α) unnecessary pages? Operating System Concepts – 8 th Edition 9. 47 Silberschatz, Galvin and Gagne © 2009

Tradeoffs: Page Size n. Impact of Page size selection: l. Internal l. Page l. I/O fragmentation table size overhead llocality Operating System Concepts – 8 th Edition 9. 48 Silberschatz, Galvin and Gagne © 2009

Other Issues – TLB Reach n TLB Reach - The amount of memory accessible from the TLB n TLB Reach = (TLB Size) X (Page Size) n Ideally, the working set of each process is stored in the TLB l Otherwise there is a high degree of page faults n Increase the Page Size l Increase TLB reach l But may increase internal fragmentation as not all applications require a large page size Operating System Concepts – 8 th Edition 9. 49 Silberschatz, Galvin and Gagne © 2009

Other Issues – Impact of Program Structure n Program structure l Int[128, 128] data; Each row is stored in one page l Program 1 for (j = 0; j <128; j++) for (i = 0; i < 128; i++) data[i, j] = 0; l 128 x 128 = 16, 384 page faults l Program 2 for (i = 0; i < 128; i++) for (j = 0; j < 128; j++) data[i, j] = 0; 128 page faults Operating System Concepts – 8 th Edition 9. 50 Silberschatz, Galvin and Gagne © 2009

Other Issues – I/O interlock n I/O Interlock – Pages must sometimes be locked into memory n 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 Operating System Concepts – 8 th Edition 9. 51 Silberschatz, Galvin and Gagne © 2009