1. © Janice Regan, CMPT 300, May 2007 0 CMPT 300 Introduction to Operating Systems Memory: Paging

2. © Janice Regan, CMPT 300, May 2007 1 Translation Lookaside buffers  TLB (associative memory): a hardware device that allows translation of virtual addresses to physical addresses without reference to the paging table  TLB stores the translations (page table entries, and virtual page addresses) for the most recently or heavily used pages for fast reference.  The commonest usage pattern for a process is to use the same few pages many times  TLB can give a significant savings by not requiring reuse of the paging table mechanism for each reference.  Usually holds only a few references (<64)

3. © Janice Regan, CMPT 300, May 2007 2 Finding an address: TLB  How do we find an address in physical memory in a system using TLB?  The page number of the virtual page is compared to all the pages in the TLB. (simultaneously).  If a match is found (and the protections allow access) the page frame number is extracted from the appropriate TLB entry and prepended to the virtual offset to give the physical address  Otherwise load the required page into the TLB replacing on that is already there. This is done by using the normal page table lookup process to find the correct page

4. © Janice Regan, CMPT 300, May 2007 3 Operation: paging and TLB Check TLB Page in TLB Y MMU generated Physical address continue N Access page table Page in memory Y Update TLB N Read page From disk memory full N Update Page table Y Page replacement

5. © Janice Regan, CMPT 300, May 2007 4 Inverted page tables  We have seen that a 32 bit system will have a page table of 4MBytes, a lot but possible.  What about a 64 bit system using the same page size, with larger will still be huge (2 52 * 4 bytes) or 15 million GBytes. This is not possible!  To reduce page table size use an inverted page table with one entry per page frame, rather than one entry per page. Fewer entries and only one table regardless of the number of active processes  The problem with the inverted page table is that the page in virtual memory can no longer be found using an index into a page table, the entire page table must be searched to find the desired entry. THIS IS SLOW!

6. Virtual to Physical: Inverted  If we have one entry in our page table for each page frame, how do we find the entry for a particular page  If pages of virtual memory can be placed in any page frame, then we must check every page frame looking for the page number of the page we are trying to find  Can speed up access by assigning particular pages of virtual memory be loaded only into particular page frames. (remember our cache replacement algorithms) © Janice Regan, CMPT 300, May 2007 5

7. Assigning page frames  How do we assign pages of virtual memory to particular page frames.  More pages of virtual than physical memory so must assign more than one page of virtual memory to some or all page frames  Can use a hash function that translates a label in the virtual page to an index in the physical page frame number. For example you could hash based on the page number © Janice Regan, CMPT 300, May 2007 6

8. Algorithm for hashing 1. Take the label from the virtual page 2. Apply the hashing function to give an index into the page frame table 3. If the indicated page frame is empty load the page in that page frame 4. If the indicated pate frame is occupied add 1 to the label and repeat the previous step 2 and 3 © Janice Regan, CMPT 300, May 2007 7

9. Algorithm for referencing 1. Take the label for the virtual page containing the reference 2. apply the hashing function to give an index into the page frame table 3. If the indicated page frame is empty the referenced page has not been stored in the page frame table: generate a page fault 4. If the indicated page frame is occupied check the hash value, 1. if it matches access the page © Janice Regan, CMPT 300, May 2007 8

10. 9 Page replacement  When a new page is placed in physical memory how do we decide which page it replaces?  Ideally we wish to remove a page that is not likely to be accessed in the near future (to prevent extra page faults)  How do we know which pages are likely to be accessed?  Assume pages that have been recently accessed are more likely to be used again

11. © Janice Regan, CMPT 300, May 2007 10 Page table entries (1)  Order and details of contents are architecture dependent but each entry in the page table includes  The page frame number of the page frame holding that page in memory (if there is one)  A flag indicating if the page is in a page frame at the present time  A flag indicating if the page in physical memory has been changed since in was last copied back into virtual memory (dirty bit)

12. © Janice Regan, CMPT 300, May 2007 11 Page table entries (2)  Each entry in the page table consists of  A flag indicating if the page has been accessed Used to determine which pages have been recently used, This information is used by the page replacement algorithms to determine which frames to replace  Protection information indicating what kinds of access are allowed  Caching flag set to indicate page should not be cached Memory that refers to hardware registers should not be cached

13. © Janice Regan, CMPT 300, May 2007 12 Page replacement information used  The page table includes a flag to indicate if the page has been accessed.  OS has a paging management time period defined. Each time this time period ends the accessed bit (R bit) for each page is reset to 0  Each time the page is accessed the R bit is set to 1, and the last accessed time is updated to reflect the time of the most recent access

14. © Janice Regan, CMPT 300, May 2007 13 Page replacement information used  Page table includes a flag (dirty bit) to indicate if the page has been modified since it was last synced with virtual memory.  The flag is reset when the page is saved to virtual memory  When a page is removed from physical memory If the dirty bit is set it will be written to virtual memory If the dirty bit is not set it will be abandoned and overwritten

15. © Janice Regan, CMPT 300, May 2007 14 Simple page replacement: FIFO  First in first out page replacement  Maintain a list of pages presently in page frames  When a page is placed in a page frame in physical memory add it to the end of the list  When a page fault occurs and all slots in physical memory are full remove the first page in the list from memory and replace it with the new page.  Problem: if the page removed is heavily and continuously used it will then have to be reloaded almost immediately (as soon as it is next accessed)

16. © Janice Regan, CMPT 300, May 2007 15 Simple page replacement: NRU  Not recently used page replacement (NRU)  Use the accessed and modified bits in the page table entries. Gives 4 possibilities  Not referenced not modified  Not referenced modified (reference cleared on clock interrupt)  Referenced not modified  Reference modified  When a page fault occurs, find any page in group 1, failing that any page in group 2, failing that any page in group 3, failing that any page in group 4. If there is more than one page in the lowest group containing pages randomly choose one page from the group of pages.

17. © Janice Regan, CMPT 300, May 2007 16 Page replacement: 2 nd chance  Second chance page replacement  A modification to FIFO  Maintain a list of pages presently in page frames  When a page is placed in a page frame in physical memory add it to the end of the list  When a page fault occurs and all slots in physical memory are full Check the R (accessed) bit on the first entry If it is one move the first entry to be the end of the list and clear R Repeat if necessary until a page with R=0 is found Remove that first page with R=0 from physical memory and replace it with the new page.

18. © Janice Regan, CMPT 300, May 2007 17 Clock page replacement  Implementation of second chance  Keep page references in a circular buffer with a pointer to the oldest entry  When page fault occurs look at R bit of that entry, if one clear R bit and advance hand, if one replace  After replacement advance clock hand 1

19. © Janice Regan, CMPT 300, May 2007 18 Simple page replacement: LRU  Least Recently Used replacement (LRU)  Expensive to implement  Using an actual linked list that must be updated with each memory access is prohibitive  In rare cases may have hardware counter to count instructions and keep last access time value of the counter as part of the page table reference information  More likely to implement a variant in software. The variant simulates a hardware counter in software to implement a similar algorithm called aging

20. © Janice Regan, CMPT 300, May 2007 19 Aging algorithm  A K bit software counter is associated with each page, the counter is initialized to 0  At the end of each time interval the OS scans to determine which pages are in physical memory  For each of these pages the bits in the page counters are shifted right 1 bit and the value of the R flag for the page replaces the leftmost bit, and the R bit is reset to 0.  The page with the smallest value in its counter is chosen as the page to be replaced by the new page  Aging is a commonly used algorithm

21. © Janice Regan, CMPT 300, May 2007 20 Aging 101011101011 10000000 00000000 10000000 00000000 10000000 110010110010 11000000 10000000 01000000 00000000 11000000 01000000 110101110101 11100000 11000000 00100000 10000000 01100000 10100000 End of 1 st clock interval Each clock (time) interval includes several memory accesses There may be a tie that cannot be resolved (value of counter for multiple pages may be identical.) In case of a non zero tie we do not know which of the tied counters were accessed first or least frequently within each time interval In case of a zero tie do not know which was accessed most recently (one may be 9 time intervals ago, one 7,000 time intervals ago, with an 8 bit counter we can no longer remember to differentiate) 00000000 0000000 Initial counters R counter End of 2 nd clock intervalEnd of 3 rd clock interval

22. © Janice Regan, CMPT 300, May 2007 21 Working set Replacement  Demand paging: pages are loaded as needed not preloaded at start of the process  Working set: set of pages that the process is currently using. Currently usually defined as within the last n ms  If physical memory is too small to hold the whole working set many page faults will occur. In extreme cases this causes thrashing or continuous page faulting bringing the system to an effective halt  When a process is swapped may want to keep track of its present working set so that those pages can be pre reloaded (prepaging) into memory when the swapped process is restored.  The working set tends to change slowly over time. Why?

23. © Janice Regan, CMPT 300, May 2007 22 Thrashing: CPU Utilization  Starting new processes will reduce the number of page frames available to each process. Each process will load some set of frames into memory  When the number of page frames needed to hold all these sets exceeds the number of available page frames the number of page faults begin to increase  As the page fault rate increases, processes may be suspended to reduce the page fault rate. The system may try to optimize performance by starting new jobs to replace those swapped. System throughput is greatly decreased  Solution: do not load a process unless there is room for its working set of pages in physical memory CPU utilization Number of simultaneous processes

24. © Janice Regan, CMPT 300, May 2007 23 How does the working set vary?  If we use demand paging the working set will vary rapidly when a new process begins running  The pages for that process are not in memory  Each time a new page is accessed it will cause a page fault, the page will then be loaded into physical memory and become part of the processes working set  Since the process is likely to frequently access a small number of pages at any given time the content of the working set will rapidly converge to this set of frequently accessed pages  If we continue to use demand paging as the process continues to run, the number of new pages needed after the initial period will be small (like moving onto the next page of commands). The contents of the working set will then remain quite constant, with only occasional addition or deletions

25. © Janice Regan, CMPT 300, May 2007 24 Implementation: Defining a working set  OS must keep track of which pages are part of a processes working set  When a process is swapped out of physical memory, all its pages may be swapped out  The working set will give us a good idea of the pages we should load when we bring the swapped process back into physical memory (we may want to preload these rather than wait for them to be requested)  Not practical to keep a list of each access (for example storing page number each time a page is accessed for the last N accesses)  Instead use which pages have been accessed in the last time interval (that is the R bit). This means the pages accessed in the last N seconds of CPU time used by the process

26. © Janice Regan, CMPT 300, May 2007 25 Working set replacement  Find a page not in the working set and replace that page  Each entry must contain the time of last access  The page table entry for each page is scanned  If R=1 the page has been accessed this time interval and is part of working set. Its last referenced time is updated to the present time. If R=1 for all pages in memory a random page is evicted  If R=0 the difference between the present time and the last accessed time is determined. If that time difference is larger than the time interval then the page is no longer considered to be part of the working set. It may be removed and replaced with the new page If that time difference is less than the time interval, the page is still in the working set. If all pages in physical memory are still in the working set the oldest of the pages in the working set with R=0 is chosen for eviction

27. © Janice Regan, CMPT 300, May 2007 26 Implementation: working set replacement  The implementation suggested in the previous slide is expensive since the entire page table must be scanned for each replacement  The WSClock implementation is more efficient and is commonly used (Linux)  Begin by creating a circular buffer to hold page table entries that contain the time of last access and the R and M bits for each page.  As pages are loaded into physical memory add the page table entries in to the circular buffer

28. © Janice Regan, CMPT 300, May 2007 27 WSClock: adding new pages  At first, while there are still empty page frames each new page is just added to the circular buffer of pages. 22221 23321 25111 26661 New entry 22221 23321 25111 26661 New entry 27611 0 0 1 11 1 0 0 0 time R bit M bit

29. © Janice Regan, CMPT 300, May 2007 28 WSClock: example 1  Later when all page frames are already full we must select a page frame to replace with the new frame 24221 23320 25110 16660 18550 26161 27531 16050 Current time: 3010 Current time interval: 1000 1 1 0 1 1 0 0 1 24221 23321 25110 16660 18550 26161 27531 16050 1 1 0 1 1 0 0 1

30. © Janice Regan, CMPT 300, May 2007 29 WSClock: Page Fault step 1  Examine the page pointed to by the clock hand  If R bit is 1, then the page has been referenced during the current time interval, it is part of the working set and not a candidate for removal. Set the R bit to 0 and advance the clock hand to the next possible page  Otherwise the page might be a candidate for replacement proceed to step 2 to determine if it is

31. WSClock: Page Fault step 2  Examine the page pointed to by the clock hand  If R (accessed) bit is 0, then check if it is in working set window (if present time – last accessed time is less than duration of the current time interval). If it is in the working set window the page is not a candidate for removal, set the R bit to 0 and advance the clock hand to the next page Otherwise the page might be a candidate for replacement proceed to step 3 to determine if it is © Janice Regan, CMPT 300, May 2007 30

32. WSClock: Page Fault step 3  Examine the page pointed to by the clock hand  Check to see if the dirty bit is 1 If the dirty bit is 1, then the page has been changed, and the changes have not yet been written back to memory. If we choose this page we would have to wait for it to be written back to disk. Initiate writing back to disk, and advance clock hand to the next page (remember this) Otherwise the page may be selected as the page to be replaced. © Janice Regan, CMPT 300, May 2007 31

33. © Janice Regan, CMPT 300, May 2007 32 WSClock: Page Fault step 4  If the clock hand has advanced one full rotation (back to where it started)  If a write has been scheduled continue until the algorithm finds a clean page (one that has finished writing)  If no write has been scheduled choose the next clean page  If no write has been scheduled and no clean page exists then choose the next page

34. © Janice Regan, CMPT 300, May 2007 33 WSClock: Page Fault step 5  When a page is selected for replacement  The page does not need to be written to disk (it is already synchronized with the disk copy of the page)  The R bit is set to 1 (loading the page counts as an access)  The M bit is set to 0 (the page is synched)  The present time is recorded in the entry

35. © Janice Regan, CMPT 300, May 2007 34 WSClock: example 1  Later when all page frames are already full we must select a page frame to replace with the new frame 24221 23320 25110 16660 18550 26161 27531 16050 Current time: 3010 Current time interval: 1000 1 1 0 1 1 0 0 1 24221 23321 25110 16660 18550 26161 27531 16050 1 1 0 1 1 0 0 1

36. © Janice Regan, CMPT 300, May 2007 35 WSClock: example 1  On a page fault, new page is needed,  Examine the page pointed to by the clock hand  The R bit is 1, then the page has been referenced during the current time interval, it is part of the working set and not a candidate for removal advance the clock hand by 1 (reset the R bit to 0)  The R bit is 0 check if it is in working set window present time – last accessed time = 3010 - 2511 = 499 499 < duration of the current time interval ( 1000 ) The page is in the working set advance the clock hand by 1

37. © Janice Regan, CMPT 300, May 2007 36 WSClock: example 2 + 3  Later when all page frames are already full we must select a page frame to replace with the new frame 24221 23320 25110 16660 18550 26161 27531 16050 Current time: 3010 Current time interval: 1000 1 1 0 1 1 0 0 1 24221 23320 25110 16660 18550 26161 27531 16050 1 1 0 1 1 0 0 1

38. © Janice Regan, CMPT 300, May 2007 37 WSClock: example 2 Examine the page pointed to by the clock hand  The R bit is 0 check if it is in working set window present time – last accessed time = 3010 - 1666 = 1344 1344 > duration of the current time interval ( 1000 ) The page is not in the working set The modified bit (dirty bit) is 1 so start a print of the page frame to virtual memory, then advance the clock hand

39. © Janice Regan, CMPT 300, May 2007 38 WSClock: example 3 Examine the page pointed to by the clock hand  The R bit is 0 check if it is in working set window present time – last accessed time = 3010 - 1855 = 1155 1155 > duration of the current time interval ( 1000 ) The page is not in the working set The modified bit (dirty bit) is 0 so this page frame is a candidate for replacement Replace the page frame with the new page from virtual memory

40. © Janice Regan, CMPT 300, May 2007 39 WSClock: example 4 Current time: 3010 Current time interval: 1000 24221 23320 25110 16660 30101 26161 27531 16050 1 1 0 1 1 0 0 1