CS 703 Advanced Operating Systems By Mr Farhan

CS 703 - Advanced Operating Systems By Mr. Farhan Zaidi

Lecture No. 27

Overview of today’s lecture n n n n Page replacement Thrashing Working set model Page fault frequency Copy on write Sharing Memory mapped files

Page replacement : Global or local? n So far, we’ve implicitly assumed memory comes from a single global pool (“Global replacement”) q q when process P faults and needs a page, take oldest page on entire system Good: adaptable memory sharing. Example if P 1 needs 20% of memory and P 2 70%, then they will be happy. P 1 q P 2 Bad: too adaptable. Little protection n What happens to P 1 if P 2 sequentially reads array about the size of memory?

Per-process page replacement n n Per-process each process has a separate pool of pages q q q a page fault in one process can only replace one of this process’s frames isolates process and therefore relieves interference from other processes pool barrier P 2 P 1 but, isolates process and therefore prevents process from using other’s (comparatively) idle resources efficient memory usage requires a mechanism for (slowly) changing the allocations to each pool Qs: What is “slowly”? How big a pool? When to migrate?

Thrashing n Thrashing is when the system spends most of its time servicing page faults, little time doing useful work q q could be that there is enough memory but a bad replacement algorithm (one incompatible with program behavior) could be that memory is over-committed n too many active processes

Thrashing: exposing the lie of VM n Thrashing: processes on system require more memory than it has. P 1 P 2 P 3 Real mem q q q n n Each time one page is brought in, another page, whose contents will soon be referenced, is thrown out. Processes will spend all of their time blocked, waiting for pages to be fetched from disk I/O devs at 100% utilization but system not getting much useful work done What we wanted: virtual memory the size of disk with access time of of physical memory What we have: memory with access time = disk access

Making the best of a bad situation n Single process thrashing? q n System thrashing? q n If process does not fit or does not reuse memory, OS can do nothing except contain damage. If thrashing arises because of the sum of several processes then adapt: n figure out how much memory each process needs n change scheduling priorities to run processes in groups whose memory needs can be satisfied (shedding load) n if new processes try to start, can refuse (admission control) Careful: example of technical vs social. q q OS not only way to solve this problem (and others). solution: go and buy more memory.

The working set model of program behavior n The working set of a process is used to model the dynamic locality of its memory usage q q n working set = set of pages process currently “needs” formally defined by Peter Denning in the 1960’s Definition: a page is in the working set (WS) only if it was referenced in the last w references obviously the working set (the particular pages) varies over the life of the program so does the working set size (the number of pages in the WS) n q q

Working set size n The working set size changes with program locality q during periods of poor locality, more pages are referenced within that period of time, the working set size is larger Intuitively, the working set must be in memory, otherwise you’ll experience heavy faulting (thrashing) q when people ask “How much memory does Internet Explorer need? ”, really they’re asking “what is IE’s average (or worst case) working set size? ” q n

Hypothetical Working Set algorithm n n n Estimate for a process Allow that process to start only if you can allocate it that many page frames Use a local replacement algorithm (e. g. LRU Clock) make sure that “the right pages” (the working set) are occupying the process’s frames Track each process’s working set size, and re-allocate page frames among processes dynamically How do we choose w?

How to implement working set? n Associate an idle time with each page frame q q n idle time = amount of CPU time received by process since last access to page’s idle time > T? page not part of working set How to calculate? q q Scan all resident pages of a process n reference bit on? clear page’s idle time, clear use bit n reference bit off? add process CPU time (since last scan) to idle time Unix: n scan happens every few seconds n T on order of a minute or more

Scheduling details: The balance set n n Sum of working sets of all run-able processes fits in memory? Scheduling same as before. If they do not fit, then refuse to run some: divide into two groups q q q n Long term scheduler: q q n active: working set loaded inactive: working set intentionally not loaded balance set: sum of working sets of all active processes Keep moving processes from active -> inactive until balance set less than memory size. Must allow inactive to become active. (if changes too frequently? ) As working set changes, must update balance set…

Some problems n T is magic q what if T too small? Too large? How did we pick it? Usually “try and see” q Fortunately, system’s aren’t too sensitive What processes should be in the balance set? q Large ones so that they exit faster? q Small ones since more can run at once? How do we compute working set for shared pages? q n n

Working sets of real programs Working set size transition, stable n Typical programs have phases:

Working set less important n The concept is a good perspective on system behavior. q n As optimization trick, it’s less important: Early systems thrashed a lot, current systems not so much. Have OS designers gotten smarter? No. It’s the hardware (cf. Moore’s law): q q Obvious: Memory much larger (more available for processes) Less obvious: CPU faster so jobs exit quicker, return memory to free-list faster. Some app can eat as much as you give, the percentage of them that have “enough” seems to be increasing. Very important OS research topic in 80 -90 s, less so now

Page Fault Frequency (PFF) n n PFF is a variable-space algorithm that uses a more ad hoc approach Attempt to equalize the fault rate among all processes, and to have a “tolerable” system-wide fault rate q monitor the fault rate for each process q q if fault rate is above a given threshold, give it more memory n so that it faults less if the fault rate is below threshold, take away memory n should fault more, allowing someone else to fault less

Fault resumption. lets us lie about many things n Emulate reference bits: q q n Emulate non-existent instructions: q n Set page permissions to “invalid”. On any access will get a fault: Mark as referenced Give inst an illegal opcode. When executed will cause “illegal instruction” fault. Handler checks opcode: if for fake inst, do, otherwise kill. Run OS on top of another OS! q q Make OS into normal process linux When it does something “privileged” the real OS will get woken up with a fault. If op allowed, do it, otherwise kill. User-mode Linux, vmware. com linux win 98 linux privileged

Summary n n n n Virtual memory Page faults Demand paging q don’t try to anticipate Page replacement q local, global, hybrid Locality q temporal, spatial Working set Thrashing