Chapter 10: Virtual Memory. Virtual memory. Background Demand Paging Page Replacement Allocation of Frames Thrashing Operating System Example

Transcription

1 Chapter 0: Virtual Memory Background Demand Paging Page Replacement Allocation of Frames Thrashing Operating System Example 0. Virtual memory separation of logical memory from physical memory only part of the program must 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 implemented via: demand paging demand segmentation 0. Virtual Memory That is Larger Than Physical Memory 0.3

2 Demand Paging Bring a page into memory only when it is needed Less I/O needed Less memory needed Faster response More users Page is needed reference to it invalid reference abort not-in-memory bring to memory 0.4 Transfer of a Paged Memory to Contiguous Disk Space 0.5 Valid-Invalid Bit each page table entry has valid invalid bit: in-memory, 0 not-in-memory initially valid invalid but is set to 0 on all entries Example: Frame # valid-invalid bit page table if valid invalid bit is 0 page fault M 0.6

3 Page Table When Some Pages Are Not in Main Memory 0.7 Page Fault Procedure ) first page reference will trap to OS page fault ) OS looks at another table to decide: ) invalid reference abort. ) just not in memory 3) get empty frame 4) swap page into frame 5) reset tables, validation bit = 6) restart instruction ) caution: is it restartable? 0.8 Steps in Handling a Page Fault 0.9 3

4 What happens if there is no free frame? Page replacement find some page in memory, that is not in use Algorithm performance want an algorithm which will result in minimum number of page faults Same pages may be paged in/out repeatedly 0.0 Performance of Demand Paging Page Fault Rate 0 p.0 if p = 0 no page faults if p =, every reference is a fault Effective Access Time (EAT) EAT = ( p) * memory access + p (page fault overhead + [swap page out ] + swap page in + restart overhead) optional 0. Copy-on-Write used when creating a new process (fork) parent and child process initially share the same pages in memory if either process modifies a shared page, only then is the page copied COW allows efficient process creation free pages are allocated from a pool of zeroed-out pages 0. 4

5 Memory-Mapped Files File I/O treated as routine memory access by mapping a disk block to a page in memory file is initially read using demand paging portion of file read from the file system into a physical page Subsequent reads/writes to/from the file are treated as ordinary memory accesses Less overhead than read() write() system calls several processes may map to same file via page sharing 0.3 Memory Mapped Files 0.4 Need For Page Replacement 0.5 5

6 Basic Page Replacement. Find the location of the desired page on disk. 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. Read the desired page into the (newly) free frame. Update the page and frame tables 4. Restart the process 0.6 Page Replacement 0.7 Page Replacement Algorithms Want lowest page-fault rate Evaluate algorithm: Consider series of memory references (reference string) Compute the number of page faults Example: reference string,, 3, 4,,, 3,,, 3, 4, Page number 0.8 6

7 Graph of Page Faults Versus The Number of Frames 0.9 First-In-First-Out (FIFO) Algorithm Reference string:,, 3, 4,,, 5,,, 3, 4, 5 3 frames (3 pages can be in memory at a time per process) 4 frames page faults page faults 0.0 FIFO: Belady s Anamoly 0. 7

8 Optimal Algorithm Replace page that will not be used for longest time 4 frames example:,, 3, 4,,, 5,,, 3, 4, page faults 4 5 How do you know this? (predict future!) Used to measure quality of an algorithm 0. Least Recently Used (LRU) Algorithm Reference string:,, 3, 4,,, 5,,, 3, 4, Counter implementation Every page entry has a counter On page access, copy the clock into the counter When a page needs to be changed, compare counters Replace page with smallest counter 0.3 LRU Algorithm via Stack keep a stack of page numbers in a double link form: Page referenced: move it to the top requires 6 pointers to be changed No search for replacement 0.4 8

9 LRU Approximation Algorithms Reference bit(s) for each page initially = 0 set to when page is used victim page has 0 problems: order no page with 0 bit aging 0.5 Example: Second-Chance Algorithm FIFO via circular queue page use set bit to victim is page with 0 upon bit check, reset to Counting Algorithms Counter frequency of references to each page LFU Algorithm: replaces page with smallest count MFU Algorithm: based on the argument that the page with the smallest count was probably just brought in and has yet to be used 0.7 9

10 Allocation of Frames Each process needs minimum number of pages Example: IBM pages for SS MOVE instruction: instruction is 6 bytes, might span pages pages to handle from address pages to handle to address Two major allocation schemes: fixed allocation priority allocation 0.8 Fixed Allocation Equal allocation e.g., if 00 frames and 5 processes, give each 0 pages Proportional allocation, allocate according to the size of process si = size of process pi S = si m = total number of frames ai = allocation for pi si = m S m = 64 si = 0 s = 7 0 a = a = Priority Allocation Use a proportional allocation scheme using priorities rather than size If process P i generates a page fault, select for replacement one of its frames. select for replacement a frame from a process with lower priority number

11 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 Local replacement - each process selects from only its own set of frames 0.3 Thrashing If a process does not have enough pages, the page-fault rate is very high: process does page i/o low CPU utilization scheduler starts another process less memory per process 0.3 Thrashing Why does paging work? Locality model Process migrates from one locality to another Localities may overlap Why does thrashing occur? Σ size of locality > total memory size 0.33

12 Locality In A Memory-Reference Pattern 0.34 Working-Set Model Working set of Process WS(t) = pages referenced in the most recent working-set window 0.35 Working-Set Model WSS i = number of distinct pages used by process i in the most recent if too small will not encompass entire locality if too large will encompass several localities if = will encompass entire program D = Σ WSS i total demand frames if D > m Thrashing Policy: if D > m, then suspend a process 0.36

13 Keeping Track of the Working Set Approximate with interval timer + a reference bit + memory bits Example: = 0,000 timer interrupts after every 5000 time units then copy all reference bits to memory bits clear all reference bits to 0 if one of the bits in memory = page in working set 0.37 Page-Fault Frequency Scheme Establish acceptable page-fault rate If actual rate too low, process loses frame If actual rate too high, process gains frame 0.38 Other Considerations Prepaging Page size selection fragmentation table size I/O overhead TLB Reach = (TLB Size) X (Page Size) increase the page size provide multiple page sizes Inverted page table Program structure I/O interlock

14 Example: Windows NT Uses demand paging with clustering Clustering brings in pages surrounding the faulting page Process has working set minimum and maximum minimum number of pages guaranteed to process in memory a process is assigned more pages up to maximum When the amount of free memory in system falls to threshold automatic working set trimming removes pages from processes that have more than minimum