CSC501 Operating Systems Principles. Memory Management

Transcription

1 CSC501 Operating Systems Principles Memory Management 1

2 Previous Lecture q Memory Management Q Segmentation Q Paging q Today s Lecture Q Lab 3 Q Page replacement algorithms

3 Lab 3 : Demand Paging q Goal: Be familiar with VM & Demand Paging q You are asked to implement the following syscalls Q xmmap, xmunmap, vcreate, vgetmem/vfreemem, srpolicy q Deadlines: Q Part 1: March 26 th 11:45pm v Will not be graded Q Part 2: April 9 th 11:45pm v Will be graded 3

4 Lab 3 : Demand Paging q From the OS perspective: Q Q Q Q Q Pages are evicted to disk when memory is full Pages loaded from disk when referenced again References to evicted pages cause a TLB miss v Page table entry (PTE) was invalid, causes fault OS allocates a page frame, reads page from disk When I/O completes, the OS fills in PTE, marks it valid, and restarts faulting process q Dirty vs. clean pages Here, the disk refers to the backing store! Q Actually, only dirty pages need to be written to disk Q Clean pages do not but you need to know where on disk to read them from again 4

5 Lab 3 : Demand Paging q From the process perspective: Q Demand paging is also used when it first starts up Q When a process is created, it has v A brand new page table with all valid bits off v No pages in memory Q When the process starts executing v Instructions fault on code and data pages v Faulting stops when all necessary code and data pages are in memory v Only code and data needed by a process needs to be loaded, which will change over time Q When the process terminates v All related pages reclaimed back to OS Question: How about context switching? 5

6 Lab 3: Physical Memory Layout Backing store pages (8M) 4096 pages (16M) Free Frames Kernel Heap 1024 frames Free memory Hole Free memory Xinu text, data, bss 0x pages (4M) pages 0-24 pages 6

7 Lab 3: Backing Store Backing Store pages (8M) 4096 pages (16M) Free Frames Kernel Heap 1024 frames Free memory Hole Free memory Xinu text, data, bss 0x pages (4M) pages 0-24 pages 7

8 Lab 3: Virtual Heap Virtual Heap (process-specific) 8M-4G Backing Store pages (8M) 4096 pages (16M) Free Frames Kernel Heap 1024 frames Free memory Hole Free memory Xinu text, data, bss 0x pages (4M) pages 0-24 pages 8

9 Lab 3: Backing Stores q There are 8 backing stores in total: Q APIs: get_bs/release_bs, read_bs/write_bs Q Emulated by physical memory Q Skeleton already given v You may want to add some sanity check! 9

10 Lab 3: Other Issues q The NULL process Q No private heap q Global page table entries Q The entire 16M physical memory Q Identity mapping q Page fault ISR Q Paging/pfintr.S, pfint.c q Support data structures Q Inverted page table Q Help functions To be extended with your own page replacement algorithm v E.g., finding a backing store from a virtual address 10

11 Lab 3 : Other Issues q System initialization, mainly data structures v Protect backing stores and free frames Keep them from kernel heap (maxaddr in i386.c) v Initialize inverted page tables and global page table entries (shared among all processes) v Allocate/initialize a page directory for NULL and set the CR3 (PDBR) to the page directory of NULL write_cs3() in control_reg.c v Install page fault handler set_evec() in evec.c v Enable paging enable_paging() in control_reg.c 11

12 Question: In 32-bit architecture with two-level hierarchical page table and 4k page size, how many frames will be needed to keep all page tables in memory? 12

13 Question: In the handout, there is a constant called NFRAMES in h/paging.h. What is the minimum number to test replacement policies? 13

14 Lab 3: Bonus Points q Additional Features (each 10 points) Q Pageable stack Q COW Q Memory sharing Q q For each feature, you need to provide the test case that demonstrate it works. Q Important: there is no need for TA to verify it by going through your code! 14

15 Page Replacement Algorithms q So, when we have a page fault we have to find an eviction candidate. q Optimally, we would like to evict the page that will not be referenced again for the longest amount of time. Q In reality the OS has no way of knowing when each of the pages will be referenced next.

16 Page Replacement Algorithms A B C D E 1 TLB miss 1 off TLB Logical Memory 0 9 V i 2 V i 5 V 8 Page Table Restart Process Update PTE Page fault 3 8 Find Frame Page fault handler C E A Physical Memory 5 Get page from backing store Question: How to pick up a victim page? Bring in page 6 A D B E C

17 Page Replacement Algorithms q NRU q FIFO q FIFO w/ Second Chance q Clock (GCM) q LRU q NFU q Aging q Working set q WSClock 17

18 Not Recently Used (NRU) q Examine Modified (M) and Referenced (R) bits associated with each page q Page fault occurs, OS places all pages in 1 or 4 classifications Q Class 0: R=0, M=0 Q Class 1: R=0, M=1 Q Class 2: R=1, M=0 Q Class 3: R=1, M=1 q NRU Algorithm says to remove a page at random from the lowest nonempty class.

19 FIFO q Simple design of having a queue maintained for pages in memory. Q The head of the queue contains oldest page in memory. Q The tail of the queue contains the newest page in memory. q Is there a potential problem with evicting the head of the queue each time?

20 FIFO with second chance q Performs like FIFO, but inspects the Referenced (R) bit. Q If R bit of the head page is 1, it is cleared and placed at the tail. Question: What happens if all pages in memory have the R bit set to one?

21 Clock Page Replacement (GCM) q Behaves liked FIFO with second chance except that it is a circular linked list.

22 Least Recently Used (LRU) q Idea: pages used recently will likely be used again soon Q throw out page that has been unused for longest time q Must keep a linked list of pages Q most recently used at front, least at rear Q update this list every memory reference!! q Keep counter in each page table entry Q choose page with lowest value counter Q periodically zero the counter

23 LRU using Matrix q Alternatively used a n by n matrix. n is the number of page frames. Q All values in matrix initially set to 0 Q When a page frame, k, is referenced, the hardware first sets all the bits in row k to 1. Q Then sets all the bits in column k to 0. Q The row whose binary value is lowest is the LRU at any instant.

24 Example of LRU using Matrix Pages referenced in order 0,1,2,3,2,1,0,3,2,3

25 Simulated LRU Not Frequently Used q Most machines do not have the hardware to perform true LRU, but it may be simulated. q We can use a counter to keep track of each R bit for each page upon a timer tick. q Page with the lowest R-bit is evicted. Q What is the problem with this type of history keeping?

26 Modified NFU q Counters are each shifted right 1 bit before the R bit is added. q R bit is added to the leftmost, rather than the rightmost bit. q This modified algorithm is known as aging.

27 Modified NFU (Aging)

28 Working Set Page Replacement q Locality of Reference a process references only a small fraction of its pages during any particular phase of its execution. q The set of pages that a process is currently using is called the working set.

29 Thrashing q If a process does not have enough frames, the page-fault rate is very high. This leads to: Q low CPU utilization Q operating system thinks that it needs to increase the degree of multiprogramming Q another process added to the system q Thrashing a process is busy swapping pages in and out

30 Thrashing q Why does paging work? Q Locality model v Process migrates from one locality to another v Localities may overlap q Why does thrashing occur? Σ size of locality > total memory size

31 Working-Set Model q working-set window a fixed number of page references Example: 10,000 instruction q WS i (working set of Process P i ) = total number of pages referenced in the most recent Q if too small will not encompass entire locality Q if too large will encompass several localities Q if = will encompass entire program q D = Σ WS i total demand frames Q if D > m Thrashing Q Policy if D > m, then suspend one of the processes

32 Working Set Page Replacement (cont.) q The working set algorithm is based on determining a working set and evicting any page that is not in the current working set upon a page fault.

33 Working Set Page Replacement (cont.)

34 Working Set Page Replacement (cont.) q So, what happens in a multiprogramming environment as processes are switched in and out of memory? Q Do we have to take a lot of page fault when the process is first started? Q It would be nice to have a particular processes working set loaded into memory before it even begins execution. This is called prepaging.

35 Working Set Page Replacement (cont.) q What happens when there is more than one page with R=0? q What happens when all pages have R=1? q This algorithm requires the entire page table be scanned at each page fault until a suitable candidate is located. Q All entries must have their Time of last use updated even after a suitable entry is found.

36 WSClock Page Replacement (Cont.) q What happens when R=0? Q Is age > τ, and page is clean then it is evicted v If it is dirty then we can proceed to find a page that may be clean and avoid a process switch. We will still need to write to disk and this write is scheduled. q What happens if we go all the way around? (Two Scenarios) Q At least one write has been scheduled. Keep Looking someone eventually write to disk. Q No writes have been scheduled all pages are in the working set, so evict a clean page or the current page if a clean page does not exist.

37 Page Replacement Algorithm Summary

38 Next Lecture q IPC 38