Operating system 37 demand paging
- 1. Operating System 37 Demand Paging Prof Neeraj Bhargava Vaibhav Khanna Department of Computer Science School of Engineering and Systems Sciences Maharshi Dayanand Saraswati University Ajmer
- 2. Demand Paging • Could bring entire process into memory at load time • Or bring a page into memory only when it is needed – Less I/O needed, no unnecessary I/O – Less memory needed – Faster response – More users • Similar to paging system with swapping (diagram on right) • Page is needed reference to it – invalid reference abort – not-in-memory bring to memory • Lazy swapper – never swaps a page into memory unless page will be needed – Swapper that deals with pages is a pager
- 3. Demand Paging • With swapping, pager guesses which pages will be used before swapping out again • Instead, pager brings in only those pages into memory • How to determine that set of pages? – Need new MMU functionality to implement demand paging • If pages needed are already memory resident – No difference from non demand-paging • If page needed and not memory resident – Need to detect and load the page into memory from storage • Without changing program behavior • Without programmer needing to change code
- 4. Basic Concepts of Demand Paging • A demand-paging system is similar to a paging system, discussed earlier, with a little difference that it uses - swapping. • Processes reside on secondary memory (which is usually a disk). • When we want to execute a process, we swap it into memory. • Rather than swapping the entire process into memory, however, we use a lazy swapper, which swaps a page into memory only when that page is needed. • Since we are now viewing a process as a sequence of pages, rather than one large contiguous address space, the use of the term swap will not technically correct. • A swapper manipulates entire processes, whereas a pager is concerned with the individual pages of a process. • We shall thus use the term pager, rather than swapper, in connection with demand paging.
- 5. Basic Concepts of Demand Paging • When a process is to be swapped in, the pager guesses which pages will be used before the process in swapped out again. • Instead of swapping in a whole process, the pager brings only those necessary pages into memory. • Thus, it avoids reading into memory pages that will not be used anyway, decreasing the swap time and the amount of physical memory needed.
- 6. Basic Concepts of Demand Paging • With this scheme, we need some form of hardware support to distinguish between those pages that are in memory and those pages that are on the disk. • The valid-invalid bit scheme described earlier can be used for this purpose. • This time, however, when this bit is set to “valid”, this value indicates that the associated page is both legal and in memory. • If the bit is set to “invalid,” this value indicates that the page either is not valid (that is, not in the logical address space of the process), or is valid but is currently on the disk not in the memory.
- 7. Basic Concepts of Demand Paging • The page-table entry for a page that is not currently in memory is simply marked invalid, or contains the address of the page on disk. • Notice that marking a page invalid will have no effect if the process never attempts to access that page. • Hence, if we guess right and only those pages that are actually needed are brought into the memory, the process will run exactly as though we had brought in all pages. • While the process executes and accesses pages that are memory resident, execution proceeds normally.
- 8. Valid-Invalid Bit • With each page table entry a valid–invalid bit is associated (v in-memory – memory resident, i not-in- memory) • Initially valid–invalid bit is set to i on all entries • Example of a page table snapshot: • During MMU address translation, if valid–invalid bit in page table entry is i page fault
- 9. Page Table When Some Pages Are Not in Main Memory
- 10. Page Fault • If there is a reference to a page, first reference to that page will trap to operating system: page fault 1. Operating system looks at another table to decide: – Invalid reference abort – Just not in memory 2. Find free frame 3. Swap page into frame via scheduled disk operation 4. Reset tables to indicate page now in memory Set validation bit = v 5. Restart the instruction that caused the page fault
- 11. Steps in Handling a Page Fault
- 12. Steps in Handling a Page Fault • 1. We check an internal table (usually kept with the process control block) for the process under consideration, to determine whether the reference was a valid or invalid memory access. • 2. If the reference was invalid, we terminate the process. If it was valid, but we have not yet brought in that page into memory, we now page in the latter. • 3. We find a free frame (by taking one from the free-frame list, for example). • 4. We schedule a disk operation to read the desired page into the newly allocated frame. • 5. When the disk read is complete, we modify the internal table kept with the process and the page table to indicate that the page is now in memory. • 6. We restart the instruction that was interrupted by the illegal address trap. The process can now access the page as though it had always been in memory.
- 13. Handling Page Fault • It is important to realize that, because we save the state (registers, condition code, instruction counter) of the interrupted process when the page fault occurs, we can restart the process in exactly the same place and state, except that the desired page is now in memory and is accessible. • In this way, we are able to execute a process, even though portions of it are not (yet) in memory. • When the process tries to access locations that are not in memory, the hardware traps to the operating system (page fault). • The operating system reads the desired page into memory and restarts the process as though the page had always been in memory.
- 14. Aspects of Demand Paging • Extreme case – start process with no pages in memory – OS sets instruction pointer to first instruction of process, non-memory-resident -> page fault – And for every other process pages on first access – Pure demand paging • Actually, a given instruction could access multiple pages -> multiple page faults – Consider fetch and decode of instruction which adds 2 numbers from memory and stores result back to memory – Pain decreased because of locality of reference • Hardware support needed for demand paging – Page table with valid / invalid bit – Secondary memory (swap device with swap space) – Instruction restart
- 15. Instruction Restart • Consider an instruction that could access several different locations – block move – auto increment/decrement location – Restart the whole operation? • What if source and destination overlap?
- 16. Performance of Demand Paging • Stages in Demand Paging (worse case) 1. Trap to the operating system 2. Save the user registers and process state 3. Determine that the interrupt was a page fault 4. Check that the page reference was legal and determine the location of the page on the disk 5. Issue a read from the disk to a free frame: 1. Wait in a queue for this device until the read request is serviced 2. Wait for the device seek and/or latency time 3. Begin the transfer of the page to a free frame 6. While waiting, allocate the CPU to some other user 7. Receive an interrupt from the disk I/O subsystem (I/O completed) 8. Save the registers and process state for the other user 9. Determine that the interrupt was from the disk 10. Correct the page table and other tables to show page is now in memory 11. Wait for the CPU to be allocated to this process again 12. Restore the user registers, process state, and new page table, and then resume the interrupted instruction
- 17. Performance of Demand Paging (Cont.) • Three major activities – Service the interrupt – careful coding means just several hundred instructions needed – Read the page – lots of time – Restart the process – again just a small amount of time • Page Fault Rate 0 p 1 – if p = 0 no page faults – if p = 1, every reference is a fault • Effective Access Time (EAT) EAT = (1 – p) x memory access + p (page fault overhead + swap page out + swap page in )
- 18. Assignment • Explain the concept and usage of Demand Paging • Explain the Steps in Handling a Page Fault