1. 1 Virtual Memory (b)

2. 2 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. Read the desired page into the (newly) free frame. Update the page and frame tables. 4. Restart the process.

3. 3 Page Replacement

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

5. 5 Graph of Page Faults Versus The Number of Frames

6. 6 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 1 2 3 1 2 3 4 1 2 5 3 4 9 page faults 1 2 3 1 2 3 5 1 2 4 5 10 page faults 4 43

7. 7 FIFO Page Replacement

8. 8 FIFO page replacement  Assign time stamp with each page  time created  Replace oldest page  Advantages  easy  Disadvantages  could replace frequently used page  Can we improve the performance by adding more frames?  FIFO Replacement – Belady’s Anomaly  more frames  less page faults? Replacement Algorithms

9. 9 FIFO Illustrating Belady’s Anomaly What is going on here? Belady’s Anomaly

10. 10 Optimal Algorithm  Replace page that will not be used for longest period of time.  4 frames example 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5  How do you know this?  Used for measuring how well your algorithm performs. 1 2 3 4 6 page faults 4 5

11. 11 Optimal Page Replacement

12. 12 Least Recently Used (LRU) Algorithm  Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5  Counter implementation  Every page entry has a counter; every time page is referenced through this entry, copy the clock into the counter.  When a page needs to be changed, look at the counters to determine which are to change. 1 2 3 5 4 4 3 5

13. 13 LRU Page Replacement

14. 14 LRU Algorithm (Cont.)  Stack implementation – 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

15. 15 Use Of A Stack to Record The Most Recent Page References

16. 16 LRU Approximation Algorithms  Reference bit  With each page associate a bit, initially = 0  When page is referenced bit set to 1.  Replace the one which is 0 (if one exists). We do not know the order, however.  Second chance  Need reference bit.  Clock replacement.  If page to be replaced (in clock order) has reference bit = 1. then:  set reference bit 0.  leave page in memory.  replace next page (in clock order), subject to same rules.

17. 17 Second-Chance (clock) Page-Replacement Algorithm

18. 18 Clock Algorithm Enhancements  Consider reference bit and dirty bit  4 possible cases  (0,0) neither modified or referenced  (0,1) not recently used but modified  (1,0) recently used but clean  (1,1) recently used and modified  Still use “ clock algorithm ”  clear only reference bit upon consideration  Macintosh uses this scheme Clock Algorithm

19. 19 Clock Algorithm Enhancements  Add additional reference bits  At regular intervals  record the reference bits  clear the reference bits  Record the reference bits in a shift register  8 bits  shift in the new reference bit value  Replace page with lowest reference value Clock Algorithm

20. 20 Counting Algorithms  Keep a counter of the number of references that have been made 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.

21. 21 Allocation of Frames  Each process needs minimum number of pages.  Example: IBM 370 – 6 pages to handle SS MOVE instruction:  instruction is 6 bytes, might span 2 pages.  2 pages to handle from.  2 pages to handle to.  Two major allocation schemes.  fixed allocation  priority allocation

22. 22 Fixed Allocation  Equal allocation – e.g., if 100 frames and 5 processes, give each 20 pages.  Proportional allocation – Allocate according to the size of process.

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

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

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

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

27. 27 Locality In A Memory-Reference Pattern

28. 28 Working Set of a Process  W(t, x): The set of pages accessed over the last x instructions at time t.  Principle of locality ensures that the working set changes slowly.

29. 29 Working-Set Model    working-set window  a fixed number of page references Example: 10,000 instruction  WSS i (working set of Process P i ) = 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 =  WSS i  total demand frames  if D > m  Thrashing  Policy if D > m, then suspend one of the processes.

30. 30 Working-set model

31. 31 Working Sets  Processes go through phases  Stable  stays within stable working set  Transient  working set is rapidly changing  A study in 1971 revealed  Stable phases account for ~ 98% of time  Half of the page faults occur during other 2%  Fault rates during transitions were 100 to 1000 times higher than during stable phases  Stable phases were relatively insensitive to the time delta chosen.

32. 32 Working Set Policy  Working set Policy  Compute working set size for all processes  Only admit a process if total working set size leaves free frames  Don ’ t allow a working set page to be replaced  When a process is blocked (I/O, etc.)  Prepage in its working set upon return.  How do we keep track of working set?

33. 33 Keeping Track of the Working Set  Approximate with interval timer + a reference bit  Example:  = 10,000  Timer interrupts after every 5000 time units.  Keep in memory 2 bits for each page.  Whenever a timer interrupts copy and sets the values of all reference bits to 0.  If one of the bits in memory = 1  page in working set.  Why is this not completely accurate?  Improvement = 10 bits and interrupt every 1000 time units.

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

35. 35 Other Considerations  Prepaging  Page size selection  fragmentation  table size  I/O overhead  locality

36. 36 Other Considerations (Cont.)  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. Otherwise there is a high degree of page faults.

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

38. 38 Other Considerations (Cont.)  Program structure  int A[][] = new int[1024][1024];  Each row is stored in one page  Program 1 for (j = 0; j < A.length; j++) for (i = 0; i < A.length; i++) A[i,j] = 0; 1024 x 1024 page faults  Program 2 for (i = 0; i < A.length; i++) for (j = 0; j < A.length; j++) A[i,j] = 0; 1024 page faults

39. 39 Other Considerations (Cont.)  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.

40. 40 Reason Why Frames Used For I/O Must Be In Memory

41. 41 Operating System Examples  Unix SVR4  Solaris 2  Linux  Win 2K  Windows NT

42. 42 Memory Management  Two separate memory management schemes in Unix SVR4 and Solaris  Paging System – Allocate page frames  Kernel Memory Allocator – Allocate memory for the kernel  Paging System Data Structures  Page Table – One entry for each page of virtual memory for that process  Page Frame Number – physical frame #  Age – how long in memory w/o reference  Copy on Write – 2 processes sharing page: after fork(), waiting for exec()  Modify – page modified?  Reference – set when page accessed  Valid – page is in main memory  Protect – are we allowed to write to this page?

43. 43 Paging Data Structures  Disk Block Descriptor  Swap Device Number – Logical device  Device Block Number – Block location  Type of storage – Swap or executable  Page Frame Data Table  Page State – Available, in use, in executable, in transfer  Reference Count – # processes using page  Logical Device – Device holding copy  Block Number – Location on device  Pfdata pointer – For linked list of pages  Swap-use Table  Reference Count – # references to page on a storage device  Page/storage unit number – Page ID

44. 44 SVR4 Page Replacement  Clock algorithm variant (Fig 8.23)  Fronthand – Clear Use bits  Backhand – Check Use bits, if use=0 prepare to swap page out  Scanrate – How fast hands move  Faster rate frees pages faster  Handspread – Gap between hands  Smaller gap frees pages faster  System adjusts values based on free memory

45. 45 SVR4 Kernel Allocation  Used for structures < size of a page  Lazy buddy system  Don ’ t split/coalesce blocks as often  Frequently allocate/release memory, but the amount of blocks is use tends to remain steady  Locally free – Not coalesced  Globally free – Coalesce if possible  Want: # locally free  # in use

46. 46 Solaris 2  Maintains a list of free pages to assign faulting processes.  Lotsfree – threshold parameter to begin paging.  Paging is peformed by pageout process.  Pageout scans pages using modified clock algorithm.  Scanrate is the rate at which pages are scanned. This ranged from slowscan to fastscan.  Pageout is called more frequently depending upon the amount of free memory available.

47. 47 Solar Page Scanner

48. 48 Linux Memory Management  Virtual Memory Addressing  Supports 3-level page tables  Page Directory - One page in size (must be in memory)  Page Middle Directory - Can span multiple pages, Will have size=1 on Pentium  Page Table - Points to individual pages  Page Allocation  Uses a buddy system with 1-32 page block sizes

49. 49 Linux Memory Management  Page Replacement  Based on clock algorithm  Uses age variable  Incremented when page is accessed  Decremented as it scans memory  When age=0, page may be replaced  Has effect of least frequently used method  Kernel Memory Allocation  Uses scheme called slab allocation  Blocks of size 32 through 4080 bytes

50. 50 Win 2K Memory Management  Virtual Address Map  00000000 to 00000FFF – Reserved (Catch NULL pointers)  00001000 to 7FFFEFFF – User space  7FFFEFFF to 7FFFFFFF – Reserved (Catch wild pointers)  80000000 to FFFFFFFF – System  Page States  Available – Not currently used  Reserved – Set aside, but not counted against memory quota (not in use)  No disk swap space allocated yet  Process can declare memory that can be quickly allocated when it is needed  Committed: space set aside in paging file (in use)

51. 51 W2k Resident Set Management  Uses variable allocation, local scope  When a page fault occurs, a page is selected from the local set of pages  If main memory is plentiful, allow the resident set to grow as pages are brought into memory  If main memory is scarce, remove less recently accessed pages from the resident set

52. 52 W2k Paging  Page Faults  Page marked as not present  CPU (H/W) determines page isn ’ t in memory  Interrupts the program, starts O.S. page fault handler  O.S. verifies the reference is valid but not in memory (Otherwise reports illegal address)  Swap out a page if needed  Read referenced page from disk  Update page table entry  Resume interrupted process (or switch to another process)  Page Size  Smaller has more frames, less internal fragmentation, but larger tables  Common sizes: Table 8.2, page 348

53. 53 Windows NT  Uses demand paging with clustering. Clustering brings in pages surrounding the faulting page.  Processes are assigned working set minimum and working set maximum.  Working set minimum is the minimum number of pages the process is guaranteed to have in memory.  A process may be assigned as many pages up to its working set maximum.  When the amount of free memory in the system falls below a threshold, automatic working set trimming is performed to restore the amount of free memory.  Working set trimming removes pages from processes that have pages in excess of their working set minimum.