6.4Effective access time with page faults
The idea
Effective access time with page faults: EAT = (1 − p)·m + p·s. Because s is so much bigger than m, p must be tiny.
Think of it like this: A road trip where each rare breakdown costs a day: even one breakdown per thousand trips adds up.
Why it exists
It tells you why page-fault rate is the single most important number in a virtual-memory system.
How it works
- Convert everything to the same unit (ns).
- Service time s = disk read + (fraction dirty) × write-back + overhead.
- EAT = (1 − p)·m + p·s.
- To keep the slowdown at x%, solve (1 − p)m + ps = m(1 + x/100) for p.
Worked example: m = 100 ns, s = 8 ms, p = 0.001
EAT = 0.999 × 100 + 0.001 × 8 000 000 = 99.9 + 8000 ≈ 8100 ns: about 81 times slower than memory.
Now play with it
- →Use the calculator: halve the fault rate and read the new EAT.
- →Make half of the victims dirty to see s grow.
p = 0.001 with an 8 ms fault already slows memory by a factor of about 80. Keeping the slowdown near 10% needs p around one in ten million.
Check yourself
With m = 200 ns and s = 8 ms, the fault rate that gives an EAT of 220 ns is about
Exam notes (the dense version)
With page-fault rate p, memory access time m and page-fault service time s: EAT = (1 − p)·m + p·s. Because s is about a million times m, even p = 0.001 makes the system dramatically slower, so exam questions ask what p keeps the slowdown within a given percentage. If a fraction of victims are dirty, the service time includes writing the victim back: s = read time + (fraction dirty) × write time. Combine with TLB and page-table terms when the question says so.
Previous year questions: Virtual Memory (9)
PYQs are grouped by topic, so this is the full set for Virtual Memory; try the ones that match this subtopic. Open all 9 on the topic page.