1 / 104

OMSE 510: Computing Foundations 9: Course Cleanup

Explore techniques for efficient memory management, including protection checking and page sharing. Learn about page replacement algorithms and compare them to the optimal algorithm.

rmiles
Download Presentation

OMSE 510: Computing Foundations 9: Course Cleanup

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. OMSE 510: Computing Foundations9: Course Cleanup Chris Gilmore <grimjack@cs.pdx.edu> Portland State University/OMSE Material Borrowed from Jon Walpole’s lectures

  2. Today • Memory Management Finish • Filesystems • Final Sample questions

  3. Memory protection • How is protection checking implemented? • compare page protection bits with process capabilities and operation types on every load/store • sounds expensive! • Requires hardware support! • How can protection checking be done efficiently? • Use the TLB as a protection look-aside buffer • Use special segment registers

  4. Protection lookaside buffer • A TLB is often used for more than just “translation” • Memory accesses need to be checked for validity • Does the address refer to an allocated segment of the address space? • If not: segmentation fault! • Is this process allowed to access this memory segment? • If not: segmentation/protection fault! • Is the type of access valid for this segment? • Read, write, execute …? • If not: protection fault!

  5. Page-grain protection checking with a TLB

  6. Page sharing • In a large multiprogramming system... • Some users run the same program at the same time • Why have more than one copy of the same page in memory??? • Goal: • Share pages among “processes” (not just threads!) • Cannot share writable pages • If writable pages were shared processes would notice each other’s effects • Text segment can be shared

  7. Page sharing Physical memory Process 1 address space Process 1 page table Stack (rw) Process 2 address space Process 2 page table Data (rw) Instructions (rx)

  8. Page sharing • “Fork” system call • Copy the parent’s virtual address space • ... and immediately do an “Exec” system call • Exec overwrites the calling address space with the contents of an executable file (ie a new program) • Desired Semantics: • pages are copied, not shared • Observations • Copying every page in an address space is expensive! • processes can’t notice the difference between copying and sharing unless pages are modified!

  9. Page sharing • Idea:Copy-On-Write • Initialize new page table, but point entries to existing page frames of parent • Share pages • Temporarily mark all pages “read-only” • Share all pages until a protection fault occurs • Protection fault (copy-on-write fault): • Is this page really read only or is it writable but temporarily protected for copy-on-write? • If it is writable • copy the page • mark both copies “writable” • resume execution as if no fault occurred

  10. On Page replacement.. Paging performance: • Paging works best if there are plenty of free frames. • If all pages are full of dirty pages... • Must perform 2 disk operations for each page fault

  11. Page replacement • Assume a normal page table • User-program is executing • A PageInvalidFault occurs! • The page needed is not in memory • Select some frame and remove the page in it • If it has been modified, it must be written back to disk • the “dirty” bit in its page table entry tells us if this is necessary • Figure out which page was needed from the faulting addr • Read the needed page into this frame • Restart the interrupted process by retrying the same instruction

  12. Page replacement algorithms • Which frame to replace? • Algorithms: • The Optimal Algorithm • First In First Out (FIFO) • Not Recently Used (NRU) • Second Chance / Clock • Least Recently Used (LRU) • Not Frequently Used (NFU) • Working Set (WS) • WSClock

  13. The optimal page replacement algorithm • Idea: • Select the page that will not be needed for the longest time

  14. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c d Page 0 a Frames 1 b 2 c 3 d Page faults Optimal page replacement • Replace the page that will not be needed for the longest • Example: a a a a b b b b c c c c d d d d X

  15. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c d Page 0 a Frames 1 b 2 c 3 d Page faults Optimal page replacement • Select the page that will not be needed for the longest time • Example: a a a a a a a a a b b b b b b b b b c c c c c c c c c d d d d e e e e e X X

  16. The optimal page replacement algorithm • Idea: • Select the page that will not be needed for the longest time • Problem: • Can’t know the future of a program • Can’t know when a given page will be needed next • The optimal algorithm is unrealizable

  17. The optimal page replacement algorithm • However: • We can use it as a control case for simulation studies • Run the program once • Generate a log of all memory references • Use the log to simulate various page replacement algorithms • Can compare others to “optimal” algorithm

  18. FIFO page replacement algorithm • Always replace the oldest page … • “Replace the page that has been in memory for the longest time.”

  19. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c a Page 0 a Frames 1 b 2 c 3 d Page faults FIFO page replacement algorithm • Replace the page that was first brought into memory • Example: Memory system with 4 frames: a a a b c c c c d d X

  20. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c a Page 0 a Frames 1 b 2 c 3 d Page faults FIFO page replacement algorithm • Replace the page that was first brought into memory • Example: Memory system with 4 frames: a a a a a b b b c c c c e e d d d d X

  21. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c a Page 0 a Frames 1 b 2 c 3 d Page faults FIFO page replacement algorithm • Replace the page that was first brought into memory • Example: Memory system with 4 frames: a a a a a a a c c b b b b b b b c c c c e e e e e e d d d d d d d a X X X

  22. FIFO page replacement algorithm • Always replace the oldest page. • “Replace the page that has been in memory for the longest time.” • Implementation • Maintain a linked list of all pages in memory • Keep it in order of when they came into memory • The page at the front of the list is oldest • Add new page to end of list

  23. FIFO page replacement algorithm • Disadvantage: • The oldest page may be needed again soon • Some page may be important throughout execution • It will get old, but replacing it will cause an immediate page fault

  24. Page table: referenced and dirty bits • Each page table entry (and TLB entry) has a • Referenced bit - set by TLB when page read / written • Dirty / modified bit - set when page is written • If TLB entry for this page is valid, it has the most up to date version of these bits for the page • OS must copy them into the page table entry during fault handling • On Some Hardware... • ReadOnly bit but no dirty bit

  25. Page table: referenced and dirty bits • Idea: • Software sets the ReadOnly bit for all pages • When program tries to update the page... • A trap occurs • Software sets the Dirty Bit and clears the ReadOnly bit • Resumes execution of the program

  26. Not recently used page replacement alg. • Use the Referenced Bit and the Dirty Bit • Initially, all pages have • Referenced Bit = 0 • Dirty Bit = 0 • Periodically... (e.g. whenever a timer interrupt occurs) • Clear the Referenced Bit

  27. Not recently used page replacement alg. • When a page fault occurs... • Categorize each page... • Class 1: Referenced = 0 Dirty = 0 • Class 2: Referenced = 0 Dirty = 1 • Class 3: Referenced = 1 Dirty = 0 • Class 4: Referenced = 1 Dirty = 1 • Choose a victim page from class 1 … why? • If none, choose a page from class 2 … why? • If none, choose a page from class 3 … why? • If none, choose a page from class 4 … why?

  28. Second chance page replacement alg. • Modification to FIFO • Pages kept in a linked list • Oldest is at the front of the list • Look at the oldest page • If its “referenced bit” is 0... • Select it for replacement • Else • It was used recently; don’t want to replace it • Clear its “referenced bit” • Move it to the end of the list • Repeat • What if every page was used in last clock tick? • Select a page at random

  29. Clock algorithm (same as second chance) • Maintain a circular list of pages in memory • Set a bit for the page when a page is referenced • Clock sweeps over memory looking for a victim page that does not have the referenced bit set • If the bit is set, clear it and move on to the next page • Replaces pages that haven’t been referenced for one complete clock revolution

  30. Least recently used algorithm (LRU) • Keep track of when a page is used. • Replace the page that has been used least recently.

  31. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c d Page 0 a Frames 1 b 2 c 3 d Page faults LRU page replacement • Replace the page that hasn’t been referenced in the longest time

  32. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c d Page 0 a Frames 1 b 2 c 3 d Page faults LRU page replacement • Replace the page that hasn’t been referenced in the longest time a a a a a a a a a a b b b b b b b b b b c c c c e e e e e d d d d d d d d d c c X X X

  33. Least recently used algorithm (LRU) • But how can we implement this? • Implementation #1: • Keep a linked list of all pages • On every memory reference, • Move that page to the front of the list. • The page at the tail of the list is replaced. • “on every memory reference...” • Not feasible in software

  34. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c d Page 0 a Frames 1 b 2 c 3 d Page faults LRU implementation • Take referenced and put at head of list

  35. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c d Page 0 a Frames 1 b 2 c 3 d Page faults A C B D C A B D LRU implementation • Take referenced and put at head of list a a b b c c d d

  36. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c d Page 0 a Frames 1 b 2 c 3 d Page faults A C B D D A C B C A B D B D A C LRU implementation • Take referenced and put at head of list a a a a b b b b c c c c d d d d X

  37. Time 0 1 2 3 4 5 6 7 8 9 10 Requests c a d b e b a b c d Page 0 a Frames 1 b 2 c 3 d Page faults A B E D C B A E D C B A B E D A B A E D A C B D D A C B C A B D B D A C E B D A LRU implementation • Take referenced and put at head of list a a a a a a a a a a b b b b b b b b b b c c c c e e e e e d d d d d d d d d c c X X X

  38. Least recently used algorithm (LRU) • But how can we implement this? • … without requiring every access to be recorded? • Implementation #2: • MMU (hardware) maintains a counter • Incremented on every clock cycle • Every time a page table entry is used • MMU writes the value to the entry • “timestamp” / “time-of-last-use” • When a page fault occurs • Software looks through the page table • Idenitifies the entry with the oldest timestamp

  39. Not frequently used algorithm (NFU) • Associate a counter with each page • On every clock interrupt, the OS looks at each page. • If the Reference Bit is set... • Increment that page’s counter & clear the bit. • The counter approximates how often the page is used. • For replacement, choose the page with lowest counter.

  40. Not frequently used algorithm (NFU) • Problem: • Some page may be heavily used • ---> Its counter is large • The program’s behavior changes • Now, this page is not used ever again (or only rarely) • This algorithm never forgets! • This page will never be chosen for replacement!

  41. Modified NFU with aging • Associate a counter with each page • On every clock tick, the OS looks at each page. • Shift the counter right 1 bit (divide its value by 2) • If the Reference Bit is set... • Set the most-significant bit • Clear the Referenced Bit 100000 =32 010000 = 16 001000 = 8 000100 = 4 100010 = 34 111111 = 63

  42. Paged Memory Mangement • Concepts….

  43. Working set page replacement • Demand paging • Pages are only loaded when accessed • When process begins, all pages marked INVALID • Locality of Reference • Processes tend to use only a small fraction of their pages • Working Set • The set of pages a process needs • If working set is in memory, no page faults • What if you can’t get working set into memory?

  44. Working set page replacement • Thrashing • If you can’t get working set into memory pages fault every few instructions • No work gets done

  45. Working set page replacement • Prepaging (prefetching) • Load pages before they are needed • Main idea: • Indentify the process’s “working set” • How big is the working set? • Look at the last K memory references • As K gets bigger, more pages needed. • In the limit, all pages are needed.

  46. WSClock page replacement algorithm • All pages are kept in a circular list (ring) • As pages are added, they go into the ring. • The “clock hand” advances around the ring. • Each entry contains “time of last use”. • Upon a page fault... • If Reference Bit = 1... • Page is in use now. Do not evict. • Clear the Referenced Bit. • Update the “time of last use” field.

  47. WSClock page replacement algorithm • If Reference Bit = 0 • If the age of the page is less than T... • This page is in the working set. • Advance the hand and keep looking • If the age of the page is greater than T... • If page is clean • Reclaim the frame and we are done! • If page is dirty • Schedule a write for the page • Advance the hand and keep looking

  48. Summary

  49. Theory and practice • Identifying victim frame on each page fault typically requires two disk accesses per page fault • Alternative  the O.S. can keep several pages free in anticipation of upcoming page faults. In Unix: low and high water marks

  50. Free pages and the clock algorithm • The rate at which the clock sweeps through memory determines the number of pages that are kept free: • Too high a rate --> Too many free pages marked • Too low a rate --> Not enough (or no) free pages marked • Large memory system considerations • As memory systems grow, it takes longer and longer for the hand to sweep through memory • This washes out the effect of the clock somewhat • Can use a two-handed clock to reduce the time between the passing of the hands

More Related