More on Pagaing

Objectives

1. Understand how pages are selected for replacement.

Notes

• This is chapter 10 section 4
• They state that by over-allocating pages we can have higher CPU utilization
  • Allow more processes to run than we have memory for all pages of all processes
  • A process may need 6 pages, but actually uses 4.
• When a running process needs a page that is not in memory,
  • Find the location of the page in the backing store
  • Find a free frame
    • If there is a free frame use it.
    • If there is not a free frame
      • Find a frame to use with a page-replacement algorithm
      • Write the victim frame to secondary storage (if necessary)
      • Update the victim's page/frame tables
  • Read in the desired page from memory.
  • Update the page/frame tables.
  • Continue the process that had the page fault.
• We discussed the dirty bit, but this is a bit that
  • Is marked with a page is modified.
  • And is used to determine if the frame needs written to the backing store.
• We might also have pages marked as read only, and these will not need to be written as well.
• Tracing paging
  • They discuss how we might evaluate a page replacement algorithm
  • To do this we really need to watch memory accesses
    • This could be millions per second in real computation.
  • Or we could create synthetic data (but this is not the best)
  • Data:
    • In any case we only need the page number.
    • And we only need to track when the page number changes.
      • Consider a loop that does a computation (like Fibonacci)
      • Where the loop code fits on one page
      • We would have repeated accesses to the same page.
      • So we would only record this once.
  • The list of page numbers is called a reference string
  • For their examples they use the reference string

    • 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1 

    • Notice that pages 5 and 6 are not used.
• Random Replacement
  • Easy,
  • Low bookkeeping
  • Somewhat reasonable
  • random.cpp
• First In First Out replacement.
  • Keep a queue of pages
  • Select the one at the front of the queue.
  • fifo.cpp
• Belady's Paradox
  • With some algorithms, like FIFO, the faults can actually go up as the size is increased.
  • Run fifo -d -s {2,3,4}
• Optimal
  • The optimal strategy is to find the page that will not be used for the longest time.
  • Unfortunately we do not know this, and can not know this.
  • I didn't implement it, but the thing to do would be search the reference string
  • But in real life, we do not know the reference string.
• Least recently used.
  • This behaves somewhat close to the optimal algorithm.
  • It is considered good.
  • It does better than FIFO.
  • Implementation is a problem
    • I used a counter.
      • This is fine for small simulations.
      • But maintenance over time is an issue due to overflow.
    • You could use a modified stack
      • When a page is needed
        • If the page is in memory:
          • Remove the page from the stack (is it still a stack?)
          • Push it onto the stack.
        • If it is not there
          • remove the bottom of the stack (is it still a stack?)
          • Remove that page
          • Push the new page onto the stack
    • Hardware is needed in either case.
      • Not in both cases, I needed to update on a page fault and a non-page fault.
      • And this would have to happen every instruction.
      • Doing these in software is way too expensive.
  • see lru and lru2
  • LRU does not suffer from Belady's anomaly
    • It can be proven that any set of pages in n frames is a subset of the pages for n+1 frames for this and similar algorithms.
    • These are know as stack algorithms
• Most systems don't provide sufficient hardware for LRU
• Reference Bit/s
  • Some hardware provides a reference bit in the page table.
  • When the page is accessed, the reference bit is set.
  • This bit can be examined to determine what pages have been accessed.
    • Those with a 0 are candidates for replacement.
    • But we don't have any method to decide among them which to pick.
  • Building on this, we could have an n bit buffer associated with each page.
    • Every so often (context switch or regular timer)
      • Shift the buffer to the right
      • Make the reference bit the left most digit.
      • Clear the reference bits.
    • Assume 4 pages

      At Time Period 1.
      Assume pages 1 and 2 are used
                           old      new
       Page   Ref Bit     Buffer   Buffer 
        0       0          0000    0000
        1       1          0000    1000
        2       1          0000    1000
        3       0          0000    0000
      
      At Time Period 2.
      Assume pages 2 and 3 are used
                           old      new
       Page   Ref Bit     Buffer   Buffer 
        0       0          0000    0000 (0)
        1       0          1000    0100 (4)
        2       1          1000    1100 (12)
        3       1          0000    1000 (8)
      
      

      • We can interpret the buffer values as unsigned ints.
        • The value tells us the page activity
        • We can tell that page 2 is the most used, and most frequently
        • And page 3 was recently used
• Second Chance
  • Use FIFO however
    • Go through the queue
      • Look at the reference bit.
        • If it is a 1, change it to a 0 and move on.
        • If it is a 0, this is the victim.
    • If nothing is selected in the first pass go back again, all reference bits will be 0.
  • This apparently is better than FIFO
• Enhanced second chance
  • Keep two bits per page
    • Bit 0, the page was referenced.
    • Bit 1, the page was written to.
  • Interpret this as an int
    • 00 (0) - not written to or referenced
    • 01 (1) - referenced but not written to
    • 10 (2) - written to but not referenced
    • 11 (3) - both.
  • Keep the pages in a fifo
    • Scan the list, delete first 0, and keep track of lowest value
    • Then scan again if needed and delete the first lowest.
  • This will give preference to selecting non-writeback pages.
• We could maintain access counts
  • Delete the least frequently used
  • delete the most frequently used.
  • Neither of these are great.
    • They are expensive
    • And do not approach optimal.
• Page Buffering
  • Keep a pool of free frames (always)
  • When a page fault occurs
    • But load the new page into one of the pool frames
    • Find a victim page, and clear it, add the frame to the frame pool
  • Some systems extend this by not wiping out pages in the pool.
    • When a page fault occurs, search the pool for the page
• Thrashing
  • High paging is know as thrashing
  • This occurs when a system spends more time paging than making progress.
  • One possibility
    • CPU utilization is low so more processes are allowed to be memory resident.
    • Then a process starts using more diverse memory so it needs more pages.
    • The global paging algorithm takes pages from other processes and gives them to the busy process
    • But this then makes the other processes start having more page faults.
    • And system utilization goes down as more processes are waiting for pages.
  • One way to combat this is to allocate a set of pages to each process and have a per-process paging algorithm.
  • But we can still have some processes thrashing.
• The Working Set model
  • Set a time period Δ
  • Each process keeps a list of processes used in the last Δ time period.
  • This represents the working set of a process.
  • The sum of the sizes of all of the working sets needs to be near that of the available frames.
  • If it is too large, suspend a process and redistribute its frames to the other processes.
  • If it is too small, allow more processes into memory.
  • This will eliminate thrashing but keep high CPU utilization.
  • The selection of Δ is the problem.