Chapter 9: Virtual Memory

1. Chapter 9: Virtual Memory

2. Chapter 9: Virtual Memory • Background • Demand Paging • Process Creation • Page Replacement • Allocation of Frames • Thrashing • Demand Segmentation • Operating System Examples

3. 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

4. Virtual Memory That is Larger Than Physical Memory 

5. Virtual-address Space

6. Shared Library Using Virtual Memory

7. Paging • A paging policy defines how the page frames will be loaded and unloaded by the virtual memory system.

8. Paging • paging policies: • Fetch policy. Decides when a page should be loaded into memory • Replacement policy. Determines which page should be removed from primary memory if all page frames are full. • Placement policy. Determines where the fetched page should be loaded in primary memory.

9. The Fetch Policy • The fetch policy determines when a page should be brought into primary memory. • Prefetch paging. Pages are fetched into memory before they are needed. • difficult; how do we know which pages are going to be used? • Demand paging. Pages are fetched into memory only when process addresses it (demands it)

10. Demand Paging Algorithm • Page fault occurs • Process with missing page is interrupted • Memory manager locates the missing page • Page frame is unloaded (replacement policy) • Page is loaded in the vacated page frame • Page table is updated • Process is restarted

11. 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

12. Transfer of a Paged Memory to Contiguous Disk Space

13. Valid-Invalid Bit • With each page table entry a valid–invalid bit is associated(1  in-memory, 0 not-in-memory) • Initially valid–invalid but is set to 0 on all entries • Example of a page table snapshot: • During address translation, if valid–invalid bit in page table entry is 0  page fault Frame # valid-invalid bit 1 1 1 1 0  0 0 page table

14. Page Table When Some Pages Are Not in Main Memory

15. Page Fault • If there is ever a reference to a page, first reference will trap to OS  page fault • OS looks at another table to decide: • Invalid reference  abort. • Just not in memory. • Get empty frame. • Swap page into frame. • Reset tables, validation bit = 1. • Restart instruction: Least Recently Used • block move • auto increment/decrement location

16. Steps in Handling a Page Fault

17. 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

18. Performance of Demand Paging • Page Fault Rate 0  p  1.0 • if p = 0 no page faults • if p = 1, every reference is a fault • Effective Access Time (EAT) EAT = (1 – p) x memory access + p (page fault overhead + [swap page out ] + swap page in + restart overhead)

19. Demand Paging Example • Memory access time = 1 microsecond • 50% of the time the page that is being replaced has been modified and therefore needs to be swapped out • Swap Page Time = 10 msec = 10,000 msec EAT = (1 – p) x 1 + p (15000) 1 + 15000P (in msec)

20. Process Creation • Virtual memory allows other benefits during process creation: - Copy-on-Write - Memory-Mapped Files (later)

21. Copy-on-Write • Copy-on-Write (COW) allows both parent and child processes to initially share the same pages in memoryIf either process modifies a shared page, only then is the page copied • COW allows more efficient process creation as only modified pages are copied • Free pages are allocated from a pool of zeroed-out pages

22. Page Replacement • Prevent over-allocation of memory by modifying page-fault service routine to include 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

23. Need For Page Replacement

24. 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

25. Page Replacement

26. 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 all our examples, the reference string is 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5

27. Graph of Page Faults Versus The Number of Frames

28. First-In-First-Out (FIFO) Algorithm • Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5 • 3 frames (3 pages can be in memory at a time per process) • 4 frames • FIFO Replacement – Belady’s Anomaly • more frames  more page faults 1 1 4 5 2 2 1 3 9 page faults 3 3 2 4 1 1 5 4 2 2 1 10 page faults 5 3 3 2 4 4 3

29. FIFO Page Replacement

30. Belady’s Anomaly Let page reference stream,R = 012301401234 Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 3 3 3 4 4 4 4 4 4 1 1 1 1 0 0 0 0 0 2 2 2 2 2 2 2 1 1 1 1 1 3 3 Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 0 0 0 4 4 4 4 3 3 1 1 1 1 1 1 1 0 0 0 0 4 2 2 2 2 2 2 2 1 1 1 1 3 3 3 3 3 3 3 2 2 2 • FIFO with m = 3 has 9 faults • FIFO with m = 4 has 10 faults

31. FIFO Illustrating Belady’s Anomaly

32. Stack Algorithms • Problem: in some algorithms the set of pages loaded with 3 frames is not necessarily also loaded with 4 frames. • In FIFO, m=3, S7(3) = {4, 0, 1} but S7(4) = {4, 1, 2, 3} • Once page set differs, the set of pages loaded diverges quickly.

33. Stack Algorithms • Some algorithms are well-behaved • Inclusion Property: Pages loaded at time t with m is also loaded at time t with m+1 Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 3 1 1 1 1 2 2 2 LRU Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 0 1 1 1 1 2 2 2 3 3

34. Stack Algorithms • Some algorithms are well-behaved • Inclusion Property: Pages loaded at time t with m is also loaded at time t with m+1 Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 3 3 1 1 1 1 1 2 2 2 0 LRU Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 0 0 1 1 1 1 1 2 2 2 2 3 3 3

35. Stack Algorithms • Some algorithms are well-behaved • Inclusion Property: Pages loaded at time t with m is also loaded at time t with m+1 Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 3 3 3 1 1 1 1 0 0 2 2 2 2 1 LRU Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 3 3 3 3

36. Stack Algorithms • Some algorithms are well-behaved • Inclusion Property: Pages loaded at time t with m is also loaded at time t with m+1 Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 3 3 3 4 1 1 1 1 0 0 0 2 2 2 2 1 1 LRU Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 2 2 2 2 2 4 3 3 3 3 3

37. Stack Algorithms • Some algorithms are well-behaved • Inclusion Property: Pages loaded at time t with m is also loaded at time t with m+1 Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 3 3 3 4 4 4 2 2 2 1 1 1 1 0 0 0 0 0 0 3 3 2 2 2 2 1 1 1 1 1 1 4 LRU Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 0 0 0 0 0 0 0 0 4 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 4 4 4 4 3 3 3 3 3 3 3 3 3 2 2 2

38. Stack Algorithms • Some algorithms are not well-behaved • Inclusion Property: Pages loaded at time t with m is also loaded at time t with m+1 Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 3 3 3 4 4 4 4 4 4 1 1 1 1 0 0 0 0 0 2 2 2 2 2 2 2 1 1 1 1 1 3 3 FIFO Frame 0 1 2 3 0 1 4 0 1 2 3 4 0 0 0 0 0 0 0 4 4 4 4 3 3 1 1 1 1 1 1 1 0 0 0 0 4 2 2 2 2 2 2 2 1 1 1 1 3 3 3 3 3 3 3 2 2 2

39. Stack Algorithms • LRU and LFU can be shown to be stack algorithms • FIFO is not. • stack algorithms are useful • know that performance will be better if add memory • can predict performance improvement obtained by adding memory allocation

40. Belady’s Optimal Algorithm • Replace page with maximal forward distance: yt = max xeS t-1(m)FWDt(x) Let page reference stream,R = 2031203120316457 Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7 0 2 2 2 1 0 0 2 3

41. Belady’s Optimal Algorithm • Replace page with maximal forward distance: yt = max xeS t-1(m)FWDt(x) Let page reference stream,R = 2031203120316457 Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7 0 2 2 2 1 0 0 2 3 FWD4(2) = 1 FWD4(0) = 2 FWD4(3) = 3

42. Belady’s Optimal Algorithm • Replace page with maximal forward distance: yt = max xeS t-1(m)FWDt(x) Let page reference stream,R = 2031203120316457 Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7 0 2 2 2 2 1 0 0 0 2 31 FWD4(2) = 1 FWD4(0) = 2 FWD4(3) = 3

43. Belady’s Optimal Algorithm • Replace page with maximal forward distance: yt = max xeS t-1(m)FWDt(x) Let page reference stream,R = 2031203120316457 Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7 0 2 2 2 2 2 2 1 0 0 0 0 0 2 31 1 1

44. Belady’s Optimal Algorithm • Replace page with maximal forward distance: yt = max xeS t-1(m)FWDt(x) Let page reference stream,R = 2031203120316457 Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7 0 2 2 2 2 2 2 2 1 0 0 0 0 0 3 2 31 1 1 1 FWD7(2) = 2 FWD7(0) = 3 FWD7(1) = 1

45. Belady’s Optimal Algorithm • Replace page with maximal forward distance: yt = max xeS t-1(m)FWDt(x) Let page reference stream,R = 2031203120316457 Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7 0 2 2 2 2 2 2 2 2 2 0 1 0 0 0 0 0 3 3 3 3 2 31 1 1 1 1 1 1 FWD10(2) =  FWD10(3) = 2 FWD10(1) = 3

46. Belady’s Optimal Algorithm • Replace page with maximal forward distance: yt = max xeS t-1(m)FWDt(x) Let page reference stream,R = 2031203120316457 Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7 0 2 2 2 2 2 2 2 2 2 0 0 0 1 0 0 0 0 0 3 3 3 3 3 3 2 31 1 1 1 1 1 1 1 1 FWD13(0) =  FWD13(3) =  FWD13(1) = 

47. Belady’s Optimal Algorithm • Replace page with maximal forward distance: yt = max xeS t-1(m)FWDt(x) Let page reference stream,R = 2031203120316457 Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7 0 2 2 2 2 2 2 2 2 2 0 0 0 0 4 4 4 1 0 0 0 0 0 3 3 3 3 3 3 6 6 6 7 2 31 1 1 1 1 1 1 1 1 1 1 5 5 10 page faults • Perfect knowledge of Rperfect performance • Impossible to implement

48. Least Recently Used (LRU) • Replace page with maximalbackward distance: yt = max xeS t-1(m)BKWDt(x) • BKWDt(x) is the distance to the most recent preceding occurrence of x in the reference stream. • It is always greater than 0 and • is infinity if x has not been referenced previously • will have been referenced if it was loaded however • if more than one page has the max BKWD, then choose arbitrarily.

49. Least Recently Used (LRU) • Replace page with maximalbackward distance: yt = max xeS t-1(m)BKWDt(x) Let page reference stream,R = 2031203120316457 Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7 0 2 2 2 1 0 0 2 3 BKWD4(2) = 3 BKWD4(0) = 2 BKWD4(3) = 1

50. Least Recently Used (LRU) • Replace page with maximal backward distance: yt = max xeS t-1(m)BKWDt(x) Let page reference stream,R = 2031203120316457 Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7 0 2 2 2 1 1 0 0 0 2 3 3 BKWD4(2) = 3 BKWD4(0) = 2 BKWD4(3) = 1