What Are Write Policies?
Imagine you have a small notebook (that’s your cache memory) where you quickly jot down important notes from a huge textbook (your main memory).
Now, when you edit or write something in your notebook, the question is:
👉 When and how should this change also be updated in the big textbook?
This decision — when and where the updated data should go — is what write policies are all about.
They define how data written into the cache gets updated in the main memory.
💡 Why Do We Need Write Policies?
Your computer’s CPU is super fast, but the main memory (RAM) is much slower.
To keep things quick, the CPU works mostly with cache.
But when cache data changes, main memory eventually needs to know — otherwise, both will have different versions of the same data.
That’s like updating your notes in the notebook but forgetting to change the textbook later — confusion guaranteed! 😅
So, to avoid that, we use write policies — rules that decide how cache and main memory stay in sync.
⚙️ Types of Write Policies
There are two main write policies and a few helpful variations.
Let’s understand them one by one — with simple examples and diagrams.
🟢 1️⃣ Write-Through Policy
In this method, every time you write data to the cache, you also write it immediately to main memory.
Think of it like this:
Whenever you note something in your small notebook, you also write the same thing right away in the big textbook. ✏️📘
⚙️ How It Works
- The CPU updates both cache and main memory simultaneously.
- So, both always have exactly the same data.
- The main memory is never “out of date.”
📊 Diagram — Write-Through Policy
+-----------+
| CPU |
+-----+-----+
|
Write Data ↓
|
+-----------+
| CACHE | ← Updated
+-----+-----+
|
Write Data ↓ (at same time)
|
+-----------+
| MAIN MEMORY | ← Updated immediately
+-----------+💡 Pros:
- Very simple to manage.
- Main memory always stays consistent with cache.
⚠️ Cons:
- Slower writes (because every write goes to both cache and main memory).
- More traffic between cache and memory.
🟡 2️⃣ Write-Back Policy
Now here’s a smarter approach.
In write-back, the CPU writes data only to the cache first.
The main memory isn’t updated immediately — it’s updated later, when that cache block is replaced or removed.
Think of it like writing notes in your notebook first, and when the page is full or you’re done with it, then you copy the final version neatly into the textbook. ✍️📗
⚙️ How It Works
- CPU writes only to cache.
- A dirty bit (a small flag) is set to mark that the data in cache has changed.
- When the cache block is replaced, that data is written back to main memory.
📊 Diagram — Write-Back Policy
+-----------+
| CPU |
+-----+-----+
|
Write Data ↓
|
+-----------+
| CACHE | ← Updated only here
| Dirty Bit = 1 |
+-----+-----+
|
(Main memory updated later)
|
+-----------+
| MAIN MEMORY | ← Updated only when block replaced
+-----------+💡 Pros:
- Faster write operations (since CPU doesn’t wait for memory).
- Less data traffic between cache and memory.
⚠️ Cons:
- Main memory can temporarily hold outdated data.
- Extra hardware (dirty bits) needed to track changes.
⚖️ Quick Comparison Table
| Feature | Write-Through | Write-Back |
|---|---|---|
| Update timing | Immediately | When block is replaced |
| Speed | Slower | Faster |
| Memory consistency | Always consistent | May be temporarily outdated |
| Traffic between cache and memory | High | Low |
| Complexity | Simple | More complex |
| Dirty Bit needed? | No | Yes |
🧩 Variations of Write Policies
Sometimes, systems add extra tricks to improve performance or balance between speed and consistency:
🔹 Write Buffer
Used with write-through.
A small buffer temporarily holds data before writing it to memory, so the CPU doesn’t have to wait.
Think of it like dropping letters in an “outbox” — you don’t walk to the post office for every letter.
🔹 Write Allocate (Fetch on Write)
Used with write-back.
When the CPU writes to a memory location that’s not in cache, it first loads that block into cache, then updates it.
It’s like fetching the notebook page before making edits.
🔹 No-Write Allocate (Write Around)
Used with write-through.
If the data isn’t in cache, it’s written directly to main memory without loading it into cache.
Kind of like writing straight into the textbook without bothering with the notebook.
🧾 Summary — The Big Picture
Let’s bring everything together:
| Policy | Description | Example |
|---|---|---|
| Write-Through | Writes happen in both cache and main memory immediately. | You update both your notebook and textbook at the same time. |
| Write-Back | Writes occur only in cache first; main memory updated later. | You write in your notebook first, then copy to textbook later. |
| Write Buffer | Temporary holding space for write data. | Outbox for letters. |
| Write Allocate | Load block to cache before writing. | Fetch page before editing. |
| No-Write Allocate | Write directly to memory, skip cache. | Write directly in textbook. |
🧠 Why Write Policies Matter
The choice between write-through and write-back depends on what a system values more:
- If data accuracy and consistency are top priority → use Write-Through.
- If speed and performance are more important → use Write-Back.
Modern computers often combine both, depending on the situation, to get the best of both worlds. ⚡
About the Author
