What is Prepaging?
Learn what prepaging is -- batch-loading predicted pages before reference -- with examples and OS interview questions answered.
Expected Interview Answer
Prepaging is a memory management optimization where the OS loads a batch of pages it predicts a process will need into RAM before they are actually referenced, instead of waiting for each individual page fault, in order to reduce the total number of costly faults at startup or after a process is swapped back in.
Rather than the fault-and-fetch-one-page-at-a-time approach of pure demand paging, prepaging uses knowledge of a process’s likely working set, often recorded from its behavior before it was last suspended or swapped out, to load several related pages in a single batched I/O operation. This is especially effective right after a process resumes from being swapped out entirely, since the OS can reload its entire previously known working set at once instead of forcing dozens of individual faults as execution resumes. The tradeoff is that prepaging can waste I/O and memory if the prediction is wrong and some prefetched pages are never actually used, so its benefit depends heavily on how accurately the OS can predict locality. In practice, prepaging is combined with demand paging: an initial batch is prefetched, and any pages the prediction missed still fall back to normal fault-driven loading.
- Reduces the number of individual page faults at process resume
- Uses one batched I/O operation instead of many small ones
- Exploits known locality from a process's prior working set
- Complements demand paging as a hybrid loading strategy
AI Mentor Explanation
Prepaging is like a groundskeeper who, remembering exactly which parts of the outfield a fielding side used heavily in the previous session, mows and marks that whole known patch in one batch before play resumes, instead of waiting for each fielder to individually walk onto unprepared grass. If the prediction is right, play resumes smoothly with almost no delay. But if the team rearranges its field completely, some of that pre-mowed grass goes unused and the effort on it is wasted, while any newly occupied ground still needs a fresh preparation pause.
Step-by-Step Explanation
Step 1
Record prior working set
When a process is suspended or swapped out, the OS records the set of pages it had resident.
Step 2
Process resumes
When the process is scheduled to run again, the OS decides to prepage instead of relying purely on demand faults.
Step 3
Batch load
The recorded working-set pages are fetched together in one larger I/O operation rather than many small ones.
Step 4
Fallback to demand paging
Any page not correctly predicted still faults normally and is loaded on first reference.
What Interviewer Expects
- Clear definition of loading pages before they are referenced, based on prediction
- Comparison against pure demand paging as the baseline
- Awareness that mispredicted pages waste memory and I/O
- Knowledge of the common use case: reloading a process after it is swapped back in
Common Mistakes
- Claiming prepaging always improves performance regardless of prediction accuracy
- Confusing prepaging with the working-set model itself rather than a loading strategy
- Forgetting that prepaging still needs a fallback to demand paging for misses
- Not identifying process resume-from-swap as the classic prepaging scenario
Best Answer (HR Friendly)
“Prepaging is when the operating system tries to guess ahead of time which pages a program is about to need, based on what it used recently, and loads them all in one batch instead of waiting to be asked for each one individually. It can make things feel much faster when the guess is right, but if the guess is wrong it wastes memory and disk time loading things that never actually get used.”
Code Example
struct pte {
int present;
int frame;
};
/* Recorded from the process’s state before it was last swapped out */
int prior_working_set[MAX_WS];
int prior_working_set_count;
void prepage_on_resume(struct pte *table) {
/* Batch-load every page that was resident before suspension */
for (int i = 0; i < prior_working_set_count; i++) {
int page_num = prior_working_set[i];
int frame = allocate_frame();
load_page_from_backing_store(page_num, frame);
table[page_num].present = 1;
table[page_num].frame = frame;
}
/* Any page NOT in the prior working set still faults normally later */
}Follow-up Questions
- How does prepaging reduce the fault storm seen right after a process resumes?
- What happens when a prepaged page is never actually used?
- How does the working-set model inform which pages to prepage?
- When would prepaging perform worse than pure demand paging?
MCQ Practice
1. What does prepaging do differently from pure demand paging?
Prepaging proactively loads a batch of pages the OS predicts will be needed, instead of waiting for individual page faults.
2. When is prepaging most commonly applied?
Since the OS knows a swapped-out process's prior resident pages, it can batch-reload that known working set on resume.
3. What is the main risk of prepaging?
If the predicted pages are not actually referenced, the memory and I/O spent loading them is wasted, unlike demand paging which loads only what is used.
Flash Cards
What is prepaging? — Proactively loading a predicted batch of pages before they are referenced, instead of waiting for a fault.
When is prepaging typically used? — When a process resumes after being swapped out, reloading its recorded prior working set in one batch.
What is the risk of prepaging? — Mispredicted pages waste memory and I/O if they are never actually referenced.
How does prepaging interact with demand paging? — It is combined with it -- any page the prediction missed still falls back to normal fault-driven loading.