Download
1 / 53
530 likes | 533 Views
Learn about virtual memory and demand paging, which allow for efficient memory management and execution of programs, with fewer I/O and memory requirements. Explore page replacement algorithms like Optimal, FIFO, LRU, and NFU, as well as the concept of simulating LRU in software.
E N D
Background • 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. • Virtual memory can be implemented via: • Demand paging • Demand segmentation
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
Page Fault • If there is ever a reference to a page, first reference will trap to OS page fault • OS decides: • Invalid reference abort. • Just not in memory. • Get empty frame.
Page Fault • Get empty frame. • Swap page into frame. • Reset tables, validation bit = 1. • Restart instruction
What happens if there is no free frame? • Page replacement – find some page in memory, but not really in use, swap it out. • algorithm • performance – want an algorithm which will result in minimum number of page faults. • Same page may be brought into memory several times.
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.
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. • Read the desired page into the (newly) free frame. Update the page and frame tables. • Restart the process.
Page Replacement Algorithms • Want lowest page-fault rate. • Evaluate algorithm by running it on a particular string of memory references (reference string) and computing the number of page faults on that string. • In examples, the reference string is: 7,0,1,2,0, 3,0,4,2,3, 0,3,2,1,2,0,1,7,0,1
Optimal Algorithm • Replace page that will not be used for longest period of time. • Used for measuring how well your algorithm performs.
First-In-First-Out • Throw out the page that has been in memory the longest. • Good when talking about a set of pages for initialization. • Bad when talking about heavily used variable.
Problem with FIFO • Considers only time when loaded into system. Not whether it has been used. • Set of “second chance” algorithms that use the reference bit in page table entry to determine if it has been recently used. • Example: Clock Page Replacement Algorithm.
Least Recently Used (LRU) Algorithm • Based on principal of “Locality of Reference”. • A page that has been used in the near past is likely to be used in the near future. • LRU: Determine the least recently used page in memory and evict it. • Can be done but very expensive.
Software Approximations to LRU • Not Frequently Used (NFU). • Associate a software counter with each page. • On timer interrupt, OS scans all pages in memory. • For each page, the R bit (Referenced bit)is added to the counter. • Page with lowest count is evicted.
Problem with NFU • It never forgets. • A page referenced often in earlier phases of the program may not be evicted long after it has been used. • Would like to have an algorithm that “ages” the count. That is, the latest references should be the most important.
Aging Algorithm for Simulating LRU • On each timer interrupt scan the pages to get the R bit. • Shift right one bit of the counter. • Place the R bit in the leftmost bit of the counter. • Choose the page to evict that has the lowest count.
Example Assume all counters are currently 0. Consider the case when pages 0,2,4, and 5 are referenced between last interrupt.
Simulating LRU in Software • The aging algorithm simulates LRU in software
Simulating LRU in Software • The aging algorithm simulates LRU in software Assume references 0,1, and 4 next window.
Simulating LRU in Software • The aging algorithm simulates LRU in software
Simulating LRU in Software Assume 0,1,3,5 • The aging algorithm simulates LRU in software
Simulating LRU in Software • The aging algorithm simulates LRU in software
Allocation of Frames • Each process needs minimum number of pages. • Two major allocation schemes. • fixed allocation • Variable allocation. • Replacement Scope can be: • Local. • Global.
Fixed Allocation, Local Scope • Number of pages per process is fixed based on some criteria. • Can use equal allocation or proportional allocation. • Equal allocation – e.g., if 100 frames and 5 processes, give each 20 pages. • What are the drawbacks of equal allocation?
Fixed Allocation, Local Scope • Proportional Allocation • Allocate page size based on the size of the process. • Problem?
Fixed Allocation, Local Scope • Equal allocation – e.g., if 100 frames and 5 processes, give each 20 pages. • What are the drawbacks of this approach? • Allocation may be too small causing significant paging. • Allocation may too large reducing number of processes in memory and wasting memory that could be used by other processes.
Fixed Allocation, Local Scope • Proportional Allocation • Allocate page size based on the size of the process. • Problem? • Process needs will vary over its execution leading to the same problems as equal-size pages.
Problem with Fixed Allocation Schemes • All processes treated the same. No priorities. • Can use process priority rather than size to allocate frames.
Variable Allocation, Global Replacement • When a page fault occurs, new page frame allocated to the process. • Page replacement based on previous approaches: e.g., LRU, FIFO, etc. • No consideration of which process should (or can best afford) to lose a page. • Can lead to high page-fault rates.
Thrashing • If a process does not have “enough” pages, the page-fault rate is very high. This leads to: • low CPU utilization. • operating system thinks 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.
Working-Set Model: Local Scope, Variable Allocation • working-set window a fixed number of page references Example: 10,000 instruction • 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 • if D > m Thrashing • Policy if D > m, then suspend one of the processes.
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.
Other Considerations • Prepaging: Predicting future page requests. • Page size selection • fragmentation • table size • I/O overhead
Other Considerations • TLB Reach - The amount of memory accessible from the TLB. • TLB Reach = (TLB Size) X (Page Size) • Ideally, the working set of each process is stored in the TLB.
Increasing the Size of the TLB • Increase the Page Size. • This may lead to an increase in fragmentation as not all applications require a large page size. • Provide Multiple Page Sizes. • This allows applications that require larger page sizes the opportunity to use them without an increase in fragmentation.
Other Considerations • 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.
