What is the Dirty Bit in Paging?
Learn what the dirty bit in a page table entry does, how it avoids unnecessary writebacks, and how eviction uses it — interview question answered.
Expected Interview Answer
The dirty bit (also called the modified bit) is a single flag in each page table entry that the hardware sets whenever a process writes to that page in memory, letting the OS know whether the page must be written back to disk before it can be evicted or can simply be discarded.
When a page is first loaded, its dirty bit starts cleared, meaning the copy in RAM matches the copy on disk (or it has never been written). The moment any store instruction writes to an address inside that page, the MMU automatically sets the dirty bit — this happens transparently in hardware, with no OS involvement, because checking on every write in software would be far too slow. When the page replacement algorithm later chooses this page as a victim to evict, the OS checks the dirty bit: if clear, the page is identical to its on-disk copy and can simply be dropped, since a fresh copy can be re-read from disk later without any writeback; if set, the OS must first write the modified contents back to the swap file or backing file before reusing the frame, or the changes would be lost. This distinction matters enormously for performance because writing to disk is expensive, so a page replacement policy that also considers the dirty bit (preferring to evict clean pages before dirty ones, all else equal) reduces costly writebacks and improves overall paging throughput.
- Avoids unnecessary disk writebacks for unmodified (clean) pages
- Guarantees modified data is not silently lost on eviction
- Set automatically by hardware — no per-write OS overhead
- Informs smarter page-replacement decisions (prefer evicting clean pages)
AI Mentor Explanation
The dirty bit is like a groundskeeper marking a pitch as “needs re-rolling” the moment any player’s footmarks or divots change its surface, while an unused pitch stays marked clean. When the ground needs to be reassigned to a different match, a clean pitch can simply be handed over as-is, but a dirty one must be re-rolled and repaired first before reuse — otherwise the damage carries over incorrectly. Tracking this with one marker avoids re-rolling every pitch by default, saving significant groundstaff time.
Step-by-Step Explanation
Step 1
Page loaded, bit clear
A page is brought into a frame; its dirty bit starts at 0, meaning RAM matches disk.
Step 2
Write occurs, bit set
Any store instruction to that page causes the MMU to automatically set the dirty bit to 1.
Step 3
Page chosen for eviction
The page replacement algorithm selects this frame as a victim to free for another page.
Step 4
Conditional writeback
If the dirty bit is set, the OS writes the page back to disk first; if clear, it is simply discarded and reused.
What Interviewer Expects
- Clear definition of what sets and clears the dirty bit
- Explanation of why it avoids unnecessary disk writebacks
- Understanding that hardware, not software, sets the bit on write
- Connection to page replacement policy decisions
Common Mistakes
- Confusing the dirty bit with the reference/accessed bit
- Thinking the OS must manually check every write to set the bit
- Forgetting that a clean page can be discarded without a writeback
- Not connecting the dirty bit to eviction/writeback cost savings
Best Answer (HR Friendly)
“The dirty bit is a small flag the hardware sets automatically the moment a program writes to a page in memory. It tells the operating system whether that page’s copy on disk is now out of date. When the OS needs to reclaim that memory, an unmodified, clean page can just be thrown away since disk already has the right copy, but a modified, dirty page has to be saved back to disk first so the changes are not lost.”
Code Example
struct pte {
unsigned frame : 20;
unsigned present : 1;
unsigned dirty : 1; /* set by hardware MMU on any write */
unsigned accessed: 1;
};
static struct pte page_table[NUM_PAGES];
/* Called by the page replacement algorithm when frame is chosen as a victim */
void evict_page(int page_number) {
struct pte *entry = &page_table[page_number];
if (entry->dirty) {
write_page_to_disk(entry->frame); /* must persist changes first */
}
/* clean pages need no writeback -- disk copy is already correct */
entry->present = 0;
entry->dirty = 0;
}Follow-up Questions
- What sets the reference (accessed) bit, and how does it differ from the dirty bit?
- How does the dirty bit interact with page replacement algorithms like second-chance?
- Why is the dirty bit set by hardware instead of software?
- What happens if a dirty page is evicted without a writeback?
MCQ Practice
1. The dirty bit in a page table entry is set when?
The dirty (modified) bit is set by the MMU the moment any write instruction modifies data inside that page.
2. When a clean (non-dirty) page is chosen for eviction, the OS?
A clean page has not diverged from its on-disk copy, so it can be dropped without any writeback cost.
3. What is the main performance benefit of tracking the dirty bit?
By knowing which pages actually changed, the OS only pays the writeback cost for pages that truly need it.
Flash Cards
What is the dirty bit? — A page table flag set by hardware whenever a write occurs to that page, signaling it differs from its disk copy.
What happens on eviction if the dirty bit is clear? — The page is discarded without a writeback, since disk already has the correct copy.
What happens on eviction if the dirty bit is set? — The OS must write the page back to disk before reusing the frame.
Who sets the dirty bit? — The hardware MMU, automatically, on every write — not the OS in software.