Rensselaer Polytechnic Institute CSC 432 – Operating Systems David Goldschmidt, Ph.D.

 A noncontiguous memory allocation scheme avoids the external fragmentation problem  Slice up physical memory into fixed-sized blocks called frames ▪ Sizes typically range from 2 16 and up!  Slice up logical memory into fixed-sized blocks called pages  Allocate pages into frames ▪ Note that frame size equals page size

 When a process of size n pages is ready to run, operating system finds n free frames  The OS keeps track of pages via a page table main memory process P i == in use == free

 Page tables map logical memory addresses to physical memory addresses

 Covers a logical address space of size 2 m with page size 2 n page number page offset p d (m – n)(n)

 Use page table caching at the hardware level to speed address translation  Hardware-level translation look-aside buffer (TLB)

 Segmentation is a memory-management scheme that corresponds to logical segments of a user program  A segment resides in a contiguous block of memory  Segments are numbered and referred to by a pair

 Logical segments map to physical memory

 A segment table maps a pair to a physical address  Each table entry has:  A segment base containing the starting physical address where the segment resides  A segment limit specifying the length of the segment

 Only part of a process needs to be loaded into memory for it to start its execution  Virtual memory further separates logical memory and physical memory  Logical (or virtual) address space can be larger than physical address space  Allows physical address space to be shared by several processes  Enables quicker process creation

 Unused pages are stored on disk

 Multiple processes can share common libraries or data by mapping virtual pages to shared physical pages  More efficient use of physical memory space

 When a page of memory is requested, if it’s not in physical memory, load page from disk  i.e. on demand  Less I/O required  Less physical memory  Faster user response times (usually)  More user processes

 Virtual memory policies include:  The fetch policy governs when a page should be loaded into memory  The placement policy specifies where a page is loaded into physical memory  The replacement policy determines which existing page in memory should be replaced

 Page allocation:  In a static allocation scheme, the number of frames per process is fixed  In a dynamic allocation scheme, the number of frames per process varies  In an equal allocation scheme, all processes have an equal number of frames  In a proportional allocation scheme, processes are allocated frames in proportion to size, priority, etc.

 Associate a valid/invalid bit with each page table entry  Initially set all entries to i  During address translation, if valid/invalid bit is v, page is already in memory  Otherwise, if bit is i, a page fault occurs v v v v i i i …. frame # valid/invalid bit page table

 Page faults are trapped by the OS:  When an invalid reference occurs in the page table  When a page is not yet in the page table  Page fault recovery:  Get free frame from physical memory  Swap desired page into free frame  Reset page table entry  Set validation bit to v  Restart instruction that caused the page fault

 Page faults are costly!

 The page fault rate p is in the range [0.0, 1.0]:  If p is 0.0, no page faults occur  If p is 1.0, every page request is a page fault  Typically p is very low....  The effective memory-access time is  (1 – p) x physical-memory-access + p x ( page-fault-overhead + swap-page-out + swap-page-in + restart-overhead )

 Given:  Memory access time is 200 nanoseconds  Average page-fault service time is 8 milliseconds  The effective memory access time is  (1 – p) x 200ns + p x 8ms =  200ns – 200ns p + p x 8,000,000ns =  200ns + 7,999,800 p

 If a process does not have enough pages, the page-fault rate is high, leading to thrashing  Process is busy swapping pages in and out of memory  Low CPU utilization  Operating system might think it needs to increase the degree of multiprogramming! ▪ More processes added, further degrading performance

 Remember the Principle of Locality

 Future memory references in a given process will likely be local to previous memory references  This phenomenon is called the principle of locality  A process executes in a series of phases, spending a finite amount of time performing memory references in each phase

 Example graph of page faults versus total number of allocated frames

 Operating system should allocate enough frames for the current locality of a process:  What happens when too few frames are allocated?  What happens when too many frames are allocated?

 Example of a single process:

 Dynamic page fault frequency scheme

 How do we identify the victim?

 Page replacement algorithms include:  First-in-first-out (FIFO)  Optimal (OPT)  Least recently used (LRU)  Least frequently used (LFU)  Page fault frequency scheme (introduced earlier)  Working set apply these algorithms to a page reference stream

 The above is a 3-frame memory  How many page faults occur if we use a 4-frame memory instead?

 Reference string: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5  How many page faults occur with a 3-frame memory?  How many page faults occur with a 4-frame memory?

 Belady’s Anomaly:  More frames may lead to more page faults!

 Replace pages that will not be used for the longest amount of time FIFO: OPT:

 Replace pages that have not been used for the longest amount of time

 Similar to LRU, but replace least frequently used pages  Requires usage counts  Initial page replacements are swapped out quickly because their usage counts are 1

 For each process, maintain a working set of pages referenced by the process during the most recent w page references  How do we choose w?

 Let d be the sum of the sizes of the working sets of all active processes  Let F be the total number of frames  If d < F, then the operating system can allow additional processes to enter the system  If d > F, then the operating system must suspend one or more active processes ▪ Otherwise thrashing will occur!

 Windows XP uses demand paging with clustering (which loads pages surrounding the page fault)  Processes are assigned a working set minimum and a working set maximum  The working set minimum is the minimum number of pages a process is guaranteed to have in physical memory  Likewise, a process may be assigned pages up to its working set maximum

 When the amount of free memory in the system falls below a threshold, automatic working set trimming is performed  Increases the amount of free memory  Removes pages from processes that have pages in excess of their working set minimum