§21.1–21.3Swap Space … The Page Fault

Every assumption so far has kept address spaces small enough to fit in memory — all of them, at once. Real systems drop that: they add a level to the memory hierarchy memory hierarchy The layered arrangement of storage — small fast caches, then RAM, then big slow disks at the bottom; swapping adds that bottom level to the virtual-memory story so address spaces can exceed physical memory. defined in ch. 21 — open in glossary , a device with more capacity than memory and (necessarily) less speed — classically a hard disk. (If the big thing were fast, we’d just call it memory.)

Why want this? Ease of use: with a large address space you allocate naturally and never wonder whether memory has room. The contrast is instructive — older systems used memory overlays, with programmers manually staging code and data into memory before every use. Try imagining it; yuck. And beyond one process, multiprogramming practically demands swapping: early machines could not possibly hold every page of every running program.

21.1 Swap Space

Reserve disk space for moving pages back and forth — swap space swap space Disk space reserved for pages pushed out of memory, read and written in page-sized units; its size caps how many pages a system can have in use, and the OS tracks each swapped page's disk address (stashed in the PTE's PFN bits). defined in ch. 21 — open in glossary — read and written in page-sized units, with the OS remembering each swapped page’s disk address. A tiny system, mid-juggle:

Three processes share four frames, each with the rest of its pages parked on disk; Proc 3 is entirely swapped out (hence: not running). The system is pretending — convincingly — that memory is far larger than it is. One footnote: swap isn’t the only disk region in this game. Code pages have a pristine copy inside the program binary on disk, so the OS can discard them from memory freely and re-read them later — no swap copy needed.

21.2 The Present Bit

The machinery, top down: TLB hit — as ever, fast. TLB miss — walk the page table; and now the PTE’s present bit present bit PTE bit saying whether the page is in physical memory or swapped to disk; the hinge on which chapter 21's swapping turns (x86 fuses it with validity into a single P bit). defined in ch. 18 — open in glossary speaks. Present = 1: the page is in memory, extract the PFN, install, retry. Present = 0: the page is valid but living on disk. Accessing it is a page fault page fault An access to a page that is valid but not present in physical memory (present bit = 0) — really a page MISS, but the hardware can only raise an exception and let the OS make things better. The OS then fetches the page from swap. defined in ch. 21 — open in glossary , and the OS’s page-fault handler page-fault handler The OS code that services a page fault: find (or evict for) a free frame, issue the disk read, mark the PTE present with the new PFN, and retry the instruction — always software, even with hardware-managed TLBs (disk is slow enough that nobody cares, and hardware wants no part of swap I/O). defined in ch. 21 — open in glossary takes the stage.

21.3 The Page Fault

Whatever the TLB style — hardware-managed or software-managed — page faults are serviced by the OS, in essentially every system. Step through the whole life of one:

The essential trick sits in the PTE: while a page is absent, the bits that would hold its PFN hold its disk address instead. Fault → look up the disk address → read the page into a frame → flip present to 1, write the real PFN → retry. And note what the process experiences during the milliseconds of disk work: nothing. It’s blocked, off the CPU, while other ready processes run — one more place the OS overlaps I/O with computation to keep the machine busy.