4.1.12
Intuition The big pictureEk cache memory data ki copies rakhta hai. Reads easy hain — bas copy padh lo. Writes problem hain : ab cache copy aur main memory alag ho sakti hain. Ek write policy do sawaalon ka jawab deti hai:
Jab write HITS kare cache mein → kya hum memory ko abhi update karein (write-through ) ya baad mein (write-back )?Jab write MISS kare cache mein → kya hum block ko pehle cache mein laayein (write-allocate ) ya seedha memory mein likhein (no-write-allocate )?
Neeche sab kuch sirf careful bookkeeping hai taaki "copies" consistent rahe bina zyada slow memory writes kiye.
Definition The consistency problemMemory ke paas "sach" value hai; cache ke paas ek copy hai. CPU write ke baad, copy badal jaati hai. Agar hum woh change propagate nahi karte, toh baad ki read (is CPU se, DMA se, ya kisi aur core se) stale data dekh sakti hai. Ek write policy propagation ka rule hai.
Do design pressures hain:
Speed : main memory (DRAM) mein likhna cache (SRAM) mein likhne se ~100× slow hai. Hum memory writes avoid karna chahte hain.Correctness/Simplicity : memory eventually match karni chahiye. Jitna zyada delay karein, utni zyada bookkeeping (dirty bits) chahiye.
Har write dono — cache block aur main memory — ko immediately update karta hai. Memory hamesha up to date rehti hai.
Definition Write-back (a.k.a. copy-back)Ek write sirf cache block ko update karta hai aur ek per-block dirty bit = 1 set karta hai. Memory lazily update hoti hai — sirf tab jab woh dirty block evict hota hai (replace hota hai).
Intuition WHY write-back usually faster hota haiPrograms baar baar same locations mein write karte hain (loop counters, stack). Write-through har baar ek slow memory write karta hai. Write-back kai writes ko eviction pe ek single memory write mein compress karta hai. Locality ki wajah se yeh bahut bada fayda hai.
Har cache line ko ek extra bit milta hai.
dirty = 0: cache copy == memory (clean). Eviction pe, bas discard karo — koi memory write nahi.dirty = 1: cache copy modify ki gayi hai. Eviction pe, tumhe pehle poora block write back karna zaroori hai.
Isliye write-back ko dirty bit chahiye aur write-through ko nahi (memory kabhi peeche nahi hoti).
Jis block mein hum likhna chahte hain woh cache mein nahi hai. Do choices hain:
Definition Write-allocate (fetch-on-write)Write miss pe, poora block pehle cache mein fetch karo , phir write ko hit ki tarah perform karo. Bet: tum is block ko jald hi dobara touch karoge (locality).
Definition No-write-allocate (write-around)Write miss pe, value seedha memory mein likho aur block ko cache mein mat laao. Bet: yeh ek one-off write hai jise tum jald nahi padhoge.
Intuition Real caches unhe is tarah kyun combine karte hainDo common pairings hain:
Write-back + Write-allocate → modern L1/L2 caches ke liye standard. Hot data ko cache mein rakhta hai, memory traffic minimize karta hai.Write-through + No-write-allocate → simpler; ek missing write memory mein jaati hai aur cache se bahar rehti hai (ise cache karne ka koi point nahi, kyunki write-through vaise bhi memory mein likhta hai).
Policy
Action
Write-through
Cache aur memory mein likho. (aksar ek write buffer ke through taaki CPU stall na ho)
Write-back
Sirf cache mein likho, dirty=1 set karo.
Combination
Action
Write-allocate
Memory se block → cache mein padho, phir cache mein likho.
No-write-allocate
Sirf memory mein value likho; cache unchanged rehta hai.
Agar dirty=1: poora block memory mein write karo, phir naya block load karo.
Agar dirty=0: bas overwrite karo — koi memory write nahi.
Write-back mein, slow t m miss rate m m har write pe t m
Worked example Numbers, "Why this step?" ke saatht c = 1 t m = 50 h = 0.95 m = 0.05 d = 0.3
Write-through: T = 1 + 50 = 51 Kyun? Har write DRAM hit karta hai.
Write-back: T = 1 + 0.05 × 50 × ( 1 + 0.3 ) = 1 + 0.05 × 65 = 1 + 3.25 = 4.25 Kyun? Sirf 5% writes miss hoti hain, aur unme se sirf 30% dirty write-back force karte hain.
⇒ Write-back yahaan ~12× sasta hai. Kyun important hai: yeh gap real CPU design ko drive karta hai.
Worked example Example 1 — Ek sequence trace karo (write-back + write-allocate)Cache empty hai. Stream: W x; W x; R x; W y(evicts x's line). Maano x aur y same line pe map hote hain.
W x — miss → allocate: block load karo, likho, dirty=1. Kyun? Write-allocate miss pe fetch karta hai.W x — hit → cache mein likho, dirty=1. Kyun? Koi memory access nahi; locality capture ki gayi.R x — hit → cache se padho. Kyun? Block abhi bhi cache mein hai.W y x ki line evict karta hai → x dirty hai ⇒ x ka block memory mein likho , phir y handle karo. Kyun? Lazy write-back exactly yahaan hota hai.
Memory mein x ki saari activity ke liye sirf ek baar likha gaya. Write-through 3 baar memory mein likhta.
Worked example Example 2 — Same stream, write-through + no-write-allocate
W x — miss → memory mein seedha likho, cache unchanged. Kyun? No-allocate loading skip karta hai.W x — phir bhi miss (kabhi load nahi hua) → memory mein phir se likho. Kyun? Block kabhi cache nahi hua.R x — miss → block load karo (reads allocate karte hain). Kyun? Reads ko data cache mein chahiye hota hai.W y — miss → seedha memory mein likho.
Memory writes: 3 . Dekho kaise same workload pe bahut zyada memory traffic lagti hai.
Worked example Example 3 — Kyun streaming writes ke liye no-write-allocate suit karta haiEk bahut bada array initialize karna jo tum kabhi read nahi karoge (e.g. memset). Write-allocate har block ko fetch karta — bandwidth waste karta — sirf usse poora overwrite karne ke liye. No-write-allocate seedha write karta hai — koi bekar fetch nahi . Kyun important hai: policy choice access pattern pe depend karta hai, koi universal "best" nahi hai.
Common mistake "Write-back matlab har write pe woh memory mein write back karta hai."Kyun sahi lagta hai: naam suggest karta hai memory mein "back" likhna. Sach: write-back memory mein sirf dirty block ke eviction pe likhta hai, har write pe nahi. Poora point hi per-write memory traffic avoid karna hai. Fix: yaad rakho dirty bit memory write ko defer karta hai.
Common mistake "Write-allocate write HITS ke baare mein hai."Kyun sahi lagta hai: "allocate" general lagta hai. Sach: allocate policies sirf write MISS pe matter karti hain (block abhi wahan nahi hai, toh kya hum jagah banaayein?). Hit pe allocate karne ki koi zaroorat nahi. Fix: Hit→through/back; Miss→allocate/no-allocate. Yeh do independent axes hain.
Common mistake "Write-through hamesha slow hai isliye koi use nahi karta."Kyun sahi lagta hai: cost formula zyada memory traffic dikhata hai. Sach: write-through simpler hai, dirty bits ki zaroorat nahi, aur memory hamesha coherent rakhta hai — multiprocessor coherence ke liye aur jab ek fast write buffer latency hide kare tab bahut accha hai. Fix: speed akela metric nahi hai; simplicity aur coherence bhi matter karte hain.
Common mistake "Tum write-through ko write-allocate ke saath freely mix kar sakte ho."Kyun sahi lagta hai: woh independent axes hain. Sach: technically tum kar sakte ho, lekin yeh rare aur odd hai: tum write miss pe block fetch karoge phir bhi har baar memory mein likhoge — dono ki costs combine kar rahe ho. Natural pairs hain WB+allocate aur WT+no-allocate. Fix: pairs jaano aur kyun har pairing coherent hai.
Write-through memory mein likhta hai har write pe (cache aur memory saath update hote hain).
Write-back memory mein likhta hai sirf tab jab ek dirty block evict hota hai.
Write-back ko har line pe kaunsa bit chahiye aur kyun dirty bit , taaki pata chale ki memory stale hai aur eviction pe likhna zaroori hai.
Kya write-through ko dirty bit chahiye Nahi — memory hamesha current rehti hai.
Write-allocate vs no-write-allocate apply hote hain ek write MISS pe.
Write-allocate ka action write miss pe block ko cache mein fetch karo, phir likho (hit ki tarah treat karo).
No-write-allocate ka action write miss pe seedha memory mein likho, block cache mein mat laao.
Sabse common modern pairing write-back + write-allocate.
Common simple pairing write-through + no-write-allocate.
Average write cost write-through t c + t m
Average write cost write-back t c + m t m ( 1 + d ) m d
Write-back hot loops ke liye kyun faster hai repeated writes cache hit karti hain; slow t m m
Ek memset ke liye best policy jo tum kabhi read nahi karoge no-write-allocate (bekar block fetch avoid karta hai).
Write-through latency ko CPU se kaun hide karta hai ek write buffer .
Write-back mein clean-block eviction pe memory untouched rehti hai (bas copy discard karo).
Recall Feynman: 12-year-old ko explain karoSocho tumhari notebook (cache) class textbook (memory) ki ek copy hai. Jab teacher koi fact change kare, tum ya toh seedha jaake textbook bhi edit kar sakte ho (write-through — safe lekin bahut running) ya bas apni notebook mein fix karo aur page pe ek sticky note lagao (write-back — sticky note dirty bit hai). Tum tabhi textbook theek karne ki taklif lete ho jab us notebook page ki zaroorat kisi aur cheez ke liye ho (eviction). Aur agar koi fact bilkul naya hai aur tumhari notebook mein nahi hai (write miss), tum decide karte ho: pehle poora page notebook mein copy karo (write-allocate) kyunki shayad tum ise dobara use karoge, ya sirf seedha textbook mein scribble karo aur bother mat karo (no-write-allocate) agar yeh ek baar ki cheez hai.
Mnemonic Do axes yaad rakho"HIT decide karta hai THROUGH-ya-BACK; MISS decide karta hai ALLOCATE-ya-nahi."
Aur: "Dirty defers" (dirty bit = write-back memory write ko delay karta hai).
Cache Memory Fundamentals — tags, index, blocks, hit/miss.Cache Replacement Policies — eviction (LRU/random) tab hota hai jab write-back dirty data flush karta hai.Cache Coherence — MESI — write policies M (Modified=dirty) state ko cores mein underlie karte hain.Write Buffers and Store Buffers — write-through memory latency kaise hide karta hai.Memory Hierarchy and AMAT — T w b T w t DMA and I/O Consistency — kyun DMA reads se pehle stale dirty cache lines flush karni padti hain.
Consistency problem: cache copy vs memory
Write-through: update cache and memory
Write-back: update cache only
Locality: repeated writes
Write-allocate: fetch block first
No-write-allocate: write to memory
