1 / 29

Project: Page Replacement Algorithms

Project: Page Replacement Algorithms. Textbook: pages 496-500 ICS 145B L. Bic. Assignment. implement different page replacement algorithms (global and local) generate reference strings test and compare algorithms using reference strings. Overall Organization. generate reference string RS.

jeanette-stewart
Download Presentation

Project: Page Replacement Algorithms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Project: Page Replacement Algorithms Textbook: pages 496-500 ICS 145B L. Bic

  2. Assignment • implement different page replacement algorithms (global and local) • generate reference strings • test and compare algorithms using reference strings

  3. Overall Organization generate reference string RS parameters: P, p, e, m, t, len file f initialize memory and aux structures repeat for each element r of RS { if (r is not in main memory) { record page fault replace an existing page with r } record other statistical data } page replacement algorithm plot and interpret data

  4. Global page replacement • assume single-process system • virtual memory: P pages [0..P-1] • reference string RS: sequence of integers, p • each p is in range 0..P-1 • main memory: F frames [0..F-1]; • implement as array M[F] • each M[f] contains page number p • page replacement: if p (from RS) not in M, select f, replace resident page: M[f]=p

  5. Global page replacement • optimal (MIN): replace page that will not be referenced for the longest time in the future Time t | 0| 1 2 3 4 5 6 7 8 9 10 RS | | c a d b e b a b c d Frame 0| a| a a a a a a a a a d Frame 1| b| b b b b b b b b b b Frame 2| c| c c c c c c c c c c Frame 3| d| d d d d e e e e e e IN | | e d OUT | | d a • at page fault: search RS for most distant pg

  6. Global page replacement • random replacement: • generate random number r in range 0..F-1 • replace page in M[r]

  7. Global page replacement • FIFO: replace oldest page Time t | 0| 1 2 3 4 5 6 7 8 9 10 RS | | c a d b e b a b c d Frame 0|>a|>a >a >a >a e e e e >e d Frame 1| b| b b b b >b >b a a a >a Frame 2| c| c c c c c c >c b b b Frame 3| d| d d d d d d d >d c c IN | | e a b c d OUT | | a b c d e • maintain array index of oldest page • increment (mod F) when page replaced

  8. Global page replacement • LRU: replace least recently used page Time t | 0| 1 2 3 4 5 6 7 8 9 10 RS | | c a d b e b a b c d Frame 0| a| a a a a a a a a a d Frame 1| b| b b b b b b b b b b Frame 2| c| c c c c e e e e e d Frame 3| d| d d d d d d d d c c IN | | e c d OUT | | c d e Q.end | d| c a d b e b a b c d | c| d c a d b e b a b c | b| b d c a d d e e a b Q.head | a| a b b c a a d d e a

  9. Global page replacement • LRU: • for the purposes of measurements, implement the queue directly in M; no need to maintain additional array (Q) • at each reference to p: • find i where M[i] == p • if p is not resident, set i=0 and record a page fault • M[k] = M[k+1] for i  k < F-1 (shift elements) • M[F-1] = p

  10. Global page replacement • second-chance algorithm … 4 5 6 7 8 9 10 … b e b a b c d … >a/1 e/1 e/1 e/1 e/1 >e/1 d/1 … b/1 >b/0 >b/1 b/0 b/1 b/1 >b/0 … c/1 c/0 c/0 a/1 a/1 a/1 a/0 … d/1 d/0 d/0 >d/0 >d/0 c/1 c/0 … e a c d • maintain • current pointer • array U[F] of use-bits

  11. Global page replacement • third-chance algorithm • u-bit set at every reference (read or write) • w-bit set at write reference • to select a page, cycle through frames, resetting bits, until uw==00: uw  uw 1 1 0 1 1 0 0 0 0 1 0 0 * (remember modification) 0 0 select

  12. Global page replacement … 0 | 1 2 3 4 5 … | c aw d bw e … >a/10 |>a/10 >a/11 >a/11 >a/11 a/00* … b/10 | b/10 b/10 b/10 b/11 b/00* … c/10 | c/10 c/10 c/10 c/10 e/10 … d/10 | d/10 d/10 d/10 d/10 >d/00 … | e • maintain • current pointer • array U[F] of use-bits • array W[F] of write-bits • no need to maintain marker bits (asterisk)

  13. Local page replacement • pages are not selected from fixed M[F] • instead, each process has a working set ws • working set grows and shrinks dynamically with program behavior: • if p (from RS) is not in ws, include it • ws shrinks based on algorithm (limited by )

  14. Local page replacement • working set model (=3) • uses trailing window of size +1 (=WS) Time t | 0| 1 2 3 4 5 6 7 8 9 10 RS | a| c c d b c e c e a d Page a | x| x x x - - - - - x x Page b | -| - - - x x x x - - - Page c | -| x x x x x x x x x x Page d | x| x x x x x x - - - x Page e | x| x - - - - x x x x x IN | | c b e a d OUT | | e a d b

  15. Local page replacement • working set model • maintain array WIN[+1] • WIN represents sliding window (queue): contains last +1 references from RS • at each reference, p: • slide WIN to the right such that: • p becomes the right-most element of WIN • the left-most element, q, drops out of WIN • if p was not already in WIN, record a page fault • if q no longer in WIN, ws shrinks by 1

  16. Local page replacement • optimal (VMIN) with =3 • uses forward-looking sliding window (WS) Time t | 0| 1 2 3 4 5 6 7 8 9 10 RS | d| c c d b c e c e a d Page a | -| - - - - - - - - x - Page b | -| - - - x - - - - - - Page c | -| x x x x x x x - - - Page d | x| x x x - - - - - - x Page e | -| - - - - - x x x - - IN | | c b e a d OUT | | d b c e a

  17. Local page replacement • VMIN • use WIN[+1] as with WS model • WIN is forward-looking sliding window: contains future +1 references from RS • at each reference, p: • slide WIN to the right such that: • the the left-most element drops out of WIN • p becomes the new left-most element of WIN • the reference, q, that is  steps in future becomes the right-most element of WIN • if q was not already in WIN, record a page fault (will occur  steps in future)

  18. Local page replacement • page fault frequency • if time between page faults <, grow resident set: add new page to resident set • if time between page faults , shrink resident set: add new page but remove all pages not referenced since last page fault

  19. Local page replacement • page fault frequency Time t | 0| 1 2 3 4 5 6 7 8 9 10 RS | | c c d b c e c e a d Page a | x| x x x - - - - - x x Page b | -| - - - x x x x x - - Page c | -| x x x x x x x x x x Page d | x| x x x x x x x x - x Page e | x| x x x - - x x x x x IN | | c b e a d OUT | | ae bd

  20. Local page replacement • PFF • maintain virtual memory representation, VM: • VM[p].res -- page p is resident/not resident • VM[p].u -- use bit for page p • at each reference to p: VM[p].u=1 • at page fault: • set VM[p].res=1 • record page fault • if time between page faults  : remove all resident pages with VM[p].u=0 • reset u-bit of all pages (VM[*].u=0)

  21. Generating reference strings • no locality: pick random number in [0..P-1] • typical behavior: • periods of stable WS • punctuated by transitions: WS grows rapidly, then settles into new stable size

  22. Generating reference strings • model typical behavior: • locus of reference  |---------|-------|------------------------------------| 0 p p+e P-1 • stable period: • assume constant rate in one direction (1 step every m references) • transition: • generate new locus with probability t • locus defined by p, e, m, t

  23. Generating reference strings • algorithm to generate RS: • select P, p, e, m, t • repeat until RS generated: • pick m random numbers in [p..p+e]; include in RS • generate random number 0 <= r <= 1; • if (r < t) generate new p else increment p (mod P)

  24. Choosing simulation constants • P: size of VM (# pages) • e: size of working set (# pages) • P and e need to be chosen together: e<P, but: • if e is too close to P, working sets overlap after transitions • if e is too small, the program will rarely revisit previous locations (important for LRU to benefit) • suggestion: e varies from 2 to P/10, P=500 or 1000 • p random number within [0..P-1] • m: # of times a page is referenced • typically, m100 (see page 267, fig 8-13b) • t: length of stable period • random number in [0..1]; typically, t<0.1 (i.e., thousands of instructions are executed between transitions)

  25. Choosing simulation constants • length of RS: • must be large to make behavior statistically significant • suggestion: >100,000 • write vs read access (for 3rd chance algorithm) • assume 10% (or less) of write accesses • f: number of frames • must be chosen together with P and e • generally e<f<P • with e approaching (or exceeding) f, thrashing is observed • with f approaching P, # page faults approaches 0 • suggestion: set f=P/10; vary e from 2 to f • : window size • typically:   e

  26. Performance evaluations 1. global a. how much is gained using FIFO over Random; or LRU over FIFO b. how close is LRU to optimal (MIN) c. how effective are 2nd-chance and 3rd-chance in approximating LRU (for 3rd chance, assume that some percentage of requests are write ops) • compare in terms of • average numbers of page faults • relative overhead

  27. Performance evaluations 2. local • how close is WS to optimal (VMIN) b. how does page fault rate vary with  (for WS, VMIN, or PFF) c. how close is PFF to WS • compare in terms of • average numbers of page faults • average size of working set (e.g., # of page faults will be the same for VMIN and WS but the average working set size will be smaller for VMIN) • relative overhead (if applicable)

  28. Performance evaluations 3. local versus global • choose local algorithm • for a given , determine: • average size of working set (# frames) • number of page faults • use # frames for a global replacement • determine number of page faults • compare number of faults for local and global • relative overhead (if applicable)

  29. Summary of tasks • develop page replacement algorithms • develop program to generate reference strings • compare performance: • individuals: (1a || 2a) && 2b • groups of 3: 1c && 2a && 3 • deliverables • commented/documented code • report presenting choices made, results obtained (plots, tables, interpretations), conclusions drawn

More Related