the page-fault rate

Suppose you read a thousand words in a book, and for each word you only occasionally need to walk to the library to fetch a missing chapter. The page-fault rate is the fraction of your word-lookups that turn into a library trip. If 1 in 1000 lookups needs a trip, your rate is 0.001; if 1 in 10 does, it is 0.1, and you will spend almost all your time walking. The same number describes a program: out of all its memory references, what fraction cause a page fault?

Concretely, the page-fault rate is usually written as a probability p, between 0 (no reference ever faults) and 1 (every reference faults). It is measured over some run: faults divided by total memory references. Because a memory access that hits in RAM is extremely fast and a page fault that hits the disk is extremely slow, p has an outsized effect on real performance — even a tiny p drags the average way up. This is the central input to the effective-access-time formula: effective access time equals (1 minus p) times the fast in-memory access time, plus p times the much larger page-fault service time.

Why it matters: the harsh arithmetic of demand paging lives in this one number. Because servicing a fault is on the order of a hundred thousand times slower than a memory access, you need p to be vanishingly small — often below one fault in a hundred thousand or a million references — just to keep the slowdown tolerable. A rate that sounds low in everyday terms, like 'one fault per thousand accesses,' would in fact make memory access hundreds of times slower on average. Keeping the page-fault rate low is therefore the whole performance game of virtual memory, and it is achieved by exploiting locality, giving each process enough frames, and replacing the right pages.