Presentation on theme: "Rensselaer Polytechnic Institute CSC 432 – Operating Systems David Goldschmidt, Ph.D."— Presentation transcript:
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
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
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
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
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
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?
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