Write-allocate vs no-allocate — Hinglish notes

5.4.7 · Hardware › Memory Hierarchy & Caches

Write-Allocate kya hai?

Write-allocate (jise fetch-on-write bhi kehte hain) ek cache policy hai jo kehti hai: write miss hone par, block ko memory se cache mein laao, PHIR write karo.

Poora block kyun fetch karte hain?

Kyunki caches block granularity par operate karte hain, individual bytes par nahi. Cache line ka size typically 64 bytes hota hai. Agar tum sirf 1 byte likh rahe ho, tab bhi cache ko poora block chahiye taaki coherence maintain ho sake aur neighboring addresses ke future reads support ho sakein.

No-Allocate kya hai?

No-allocate (jise write-around ya write-no-allocate bhi kehte hain) ek cache policy hai jo kehti hai: write miss hone par, block ko cache mein laaye bina seedha memory ke next level par likho.

Written data cache ke "around" (usse bachte hue) chala jaata hai.

Yeh Kyun Matter Karta Hai?

Write-allocate aur no-allocate ke beech ka choice in cheezaan ko affect karta hai:

Cache pollution: No-allocate un data ke liye cache space waste karne se bachta hai jo reuse nahi hogi
Memory bandwidth: Write-allocate ko write miss par ek extra memory read chahiye
Latency: Write-allocate mein write miss par zyada latency hoti hai (read + write vs sirf write)
Subsequent accesses mein hit rate: Write-allocate hits badhata hai agar data jaldi reuse hota hai

Write Policies ke Saath Typical Pairing

Derivation: Write-back ko Write-allocate Kyun Chahiye

Socho kya hoga agar write-back + no-allocate use karein:

Address A par write miss hoti hai
No-allocate policy: A ko cache mein mat laao
Write-back policy: Dirty line evict hone par hi memory mein likho

Problem: A par jo write hai usse kaise handle karein? Hum ise cache mein store nahi kar sakte (no-allocate), aur hum ise defer nahi kar sakte (write-back matlab baad mein likhna). Hum majboor ho jaate hain ki seedha memory mein likhein, jo actually write-through behavior hai!

Isliye, write-back consistent rehne ke liye write-allocate zaroori hai.

Worked example Example 1: Write-Allocate with Write-Back

Setup:

Cache: 4 lines, 8 bytes per line, direct-mapped, initially empty
Write-back policy with write-allocate
Memory: sabhi addresses par values hain

Operations:

WRITE to address 0x28 (value = 0xFF)

Step-by-step:

Cache check karo: Address 0x28, line (0x28 >> 3) % 4 = 1 par map hoti hai. Line1 invalid hai. → Write miss
Write-allocate: 0x28 wale block ke liye line 1 allocate karo
Block fetch karo: Memory se 8 bytes (0x28-F) line 1 mein read karo
Write perform karo: Cache mein 0x28 par byte ko 0xFF se update karo
Dirty mark karo: Line 1 ka dirty bit set karo (modify hua hai lekin abhi memory mein nahi gaya) Yeh step kyun? Hum poora block fetch karte hain kyunki cache block granularity par operate karta hai. Block ke baaki bytes (0x29-0x2F) baad mein read ho sakte hain, aur unhe sahi se cached hona chahiye.

Memory traffic: 1 read (8 bytes)

Subsequent READ to 0x29: Cache hit! Koi memory traffic nahi.

Worked example Example 2: No-Allocate with Write-Through

Setup:

Cache: 4 lines, 8 bytes per line, direct-mapped, initially empty
Write-through policy with no-allocate Operations:

WRITE to address 0x28 (value = 0xFF)

Step-by-step:

Cache check karo: Address 0x28, line 1 par map hoti hai. Line 1 invalid hai. → Write miss
No-allocate: Block ko cache mein fetch mat karo
Write-through: Memory mein 0x28 par seedha likho
Cache state: Line 1 invalid hi rehti hai Yeh step kyun? Hum cache ko skip karte hain kyunki hum assume karte hain ki is write ki temporal locality kam hai (jaldi dobara access nahi hogi). Ise cache mein laana ek cache line waste karta.

Memory traffic: 1 write (1 byte, ya memory interface ke hisaab se poora block)

Subsequent READ to 0x28: Cache miss! Memory se padhna padega.

Worked example Example 3: Write-Miss Sequence par Traffic Compare Karna

Scenario: Addresses 0x100, 0x104, 0x108, 0x10C par write karo (sab ek hi block mein hain), phir 0x100 padhna

Write-Allocate + Write-Back:

WRITE 0x100: Miss → fetch block, write in cache, dirty bit set
WRITE 0x104: Hit → write in cache
WRITE 0x108: Hit → write in cache
WRITE 0x10C: Hit → write in cache
READ 0x100:  Hit → read from cache

Memory reads: 1 (initial fetch)
Memory writes: 0 (eviction tak nahi)
Total memory traffic: 1 read

No-Allocate + Write-Through:

WRITE 0x100: Miss → write to memory directly
WRITE 0x104: Miss → write to memory directly
WRITE 0x108: Miss → write to memory directly
WRITE 0x10C: Miss → write to memory directly
READ 0x100:  Miss → read from memory

Memory reads: 1
Memory writes: 4
Total memory traffic: 5 operations

Fark kyun hai? Write-allocate block ko cache karke spatial locality exploit karta hai (nearby addresses par writes). No-allocate har write ko independently treat karta hai.

Har Policy Kab Use Karein

Write-allocate ke fayde:

High temporal/spatial locality wale workloads ke liye better
Block reuse hone par memory traffic kam karta hai
Write-back optimization enable karta hai (dirty writes batch mein)

No-allocate ke fayde:

Streaming writes ke liye better (bada sequential data ek baar likha jaata hai)
One-time writes se cache pollution se bachata hai
Write miss par kam latency (fetch delay nahi)
Kuch ISAs mein streaming stores ya uncached writes mein use hota hai

Worked example Example 4: Real-World Use Case

Video Frame Buffer Write (streaming):

// Writing pixels to frame buffer
for (int i = 0; i < 1920*1080; i++) {
    framebuffer[i] = pixel_value;  // Write once, never read again
}

Best policy: No-allocate + write-through

Kyun? In writes ki temporal locality bilkul zero hai. Frame buffer typically ek special memory region se map hota hai. Har block ko cache mein laane se:

Useful cache data evict hoti (pollution)
Aisa block fetch karne mein time waste hota jo hum padhenge nahi
Koi fayda nahi kyunki hum ek baar likhte hain aur phir reuse nahi karte

Modern ISAs non-temporal store instructions dete hain (jaise x86 par movnti) jo no-allocate behavior implement karte hain.

Common mistake Common Mistake: "No-allocate hamesha slow hoti hai kyunki subsequent reads miss karte hain"

Kyun sahi lagta hai: Aap sochte ho "agar main write-allocate karunga, to data next read ke liye cache mein hoga!"

Steel-man: Yeh reasoning sahi hai AGAR data jaldi reuse hoti hai. Galti yeh assume karna hai ki saari writes ke baad reads aati hain.

Fix: Access pattern consider karo:

Agar write ke baad usi block ko read kiya jaaye: write-allocate jeet jaata hai
Agar write isolated hai (streaming writes, initialization, I/O): no-allocate jeet jaata hai, kyunki isse bachta hai:
- Fetch bandwidth (unnecessary data padhna)
- Cache pollution (useful data evict karna)
- Fetch latency (memory read par block karna)

Example: Ek bada array zero se initialize karna jo turant read nahi hoga:

memset(buffer, 0, 1_000_000);  // No-allocate better

Common mistake Common Mistake: "Write-allocate hamesha likhne se pehle fetch karta hai"

Kyun sahi lagta hai: Definition kehti hai "memory se block fetch karo."

Steel-man: Yeh partial block writes ke liye sach hai (poori cache line se kam likhna). Tumhe block ke baaki bytes ka data chahiye.

Fix: Kuch modern caches full-line writes ko optimize karte hain (poori cache line likhna):

Agar write line ke saare bytes cover karta hai, to fetch skip karo
Seedha poori cache line overwrite karo
Ise write-allocate with no-fetch-on-full-line kehte hain (kabhi kabhi "write-validate" ya "full-line-write optimization")

Ise write-combining se confuse mat karo: write-combining adjacent writes ko buffer aur merge karta hai taaki memory ko bade bursts mein issue kar sake — yeh ek write-buffering technique hai, cache fill/allocation policy nahi.

Example: Ek poora 64-byte cache line likhna:

uint64_t line[8];  // 64 bytes
memcpy(cache_line_addr, line, 64);  // May skip fetch

Zyaadatar caches simplicity ke liye phir bhi fetch karte hain, lekin high-performance caches is case ko detect kar lete hain.

Performance Tradeoffs

| Metric | Write-Allocate | No-Allocate | |-----|-------------| | Write miss latency | Zyada (fetch + write) | Kam (sirf write) | | Memory read traffic | Zyada (miss par fetches) | Kam (koi fetch nahi) | | Memory write traffic | Kam (write-back batching) | Zyada (har miss par) | | Cache utilization | Zyada (blocks cached) | Kam (kam pollution) | | Best for | High locality | Low locality |

Recall Feynman Explanation (Simple)

Socho tumhari desk tumhari cache hai, aur bookshelf memory hai.

Write-allocate aise hai: Tumhe ek aisi book mein notes likhne hain jo tumhari desk par nahi hai. To tum:

Book shelf se laate ho (fetch)
Desk par rakhte ho (allocate)
Usme apne notes likhte ho
Desk par rakhte ho, agar jaldi phir chahiye ho

No-allocate aise hai: Tumhe ek aisi book mein notes likhne hain jo tumhari desk par nahi hai. To tum:

Shelf ke paas jaate ho
Seedha shelf par rakhi book mein notes likhte ho
Wahi chhod dete ho (desk par nahi laate)

Kaun sa better hai?

Agar agle 5 minute mein woh book phir chahiye hogi → desk par le aao (write-allocate)
Agar sirf ek quick note likhna hai aur phir touch nahi karoge → shelf par hi likho (no-allocate)

Tumhari desk ka space limited hai, isliye usme aisi books mat rakhna jo dobara use nahi karoge!

Connections

Write-back vs Write-through: Write propagation policy jo allocate decisions ke saath pair hoti hai
Cache Line Size: Write-allocate par allocation ki granularity decide karta hai
Temporal vs Spatial Locality: Principles jo policies ke beech choice guide karte hain
Streaming Stores: ISA instructions jo no-allocate behavior force karte hain
Cache Pollution: Problem jisme no-allocate help karta hai
Write Combining Buffers: Optimization jo memory access se pehle writes batch karta hai
Dirty Bit: Tracking mechanism jo write-back + write-allocate ke liye zaroori hai

#flashcards/hardware

Write-allocate policy mein write miss par kya hota hai?

Memory se poora block cache mein fetch karo, phir cached block mein write perform karo. Line ko valid mark karo (aur write-back hai to dirty bhi).

No-allocate policy mein write miss par kya hota hai?

Data seedha memory ke next level par likho, bina cache line allocate kiye ya block fetch kiye.

Write-back ko write-allocate kyun chahiye?

Write-back writes ko eviction tak defer karta hai, jiske liye data cache mein hona zaroori hai. Agar write miss par allocate nahi karte, to write defer karne ki jagah nahi hoti, aur immediate memory write karna padta hai (jo write-back se contradict karta hai).

Write-through caches ke liye standard pairing kya hai?

Write-through KISI BHI ke saath pair ho sakti hai — write-allocate ya no-allocate — writes ki expected temporal locality ke hisaab se.

No-allocate kab write-allocate se better hai?

Jab writes ki temporal locality kam ho (streaming writes, one-time initialization, I/O operations). Cache pollution aur fetch bandwidth waste se bachata hai.

Write miss par write-allocate ka main disadvantage kya hai?

Likhne se pehle block fetch karne ke karan zyada latency, aur badhta hua memory read traffic.

Write policies ke context mein cache pollution kya hai?

Jab write-allocate aise blocks cache mein laata hai jo reuse nahi honge, potentially useful data evict ho jaata hai aur cache space waste hota hai.

Non-temporal store instruction kya hota hai?

Ek ISA instruction (jaise x86 ka movnti) jo no-allocate behavior ke saath memory mein likhta hai, pollution se bachne ke liye cache bypass karta hai.

Write-allocate single-byte write ke liye bhi poora block kyun fetch karta hai?

Caches block granularity par operate karte hain. Block ke baaki bytes baad mein access ho sakte hain, isliye cache ko coherence maintain karne aur spatial locality support karne ke liye poora block chahiye.

Write-allocate mein fetch skip karne wala optimization kya hai, aur ise kisse confuse nahi karna chahiye?

Full-line-write optimization (write-validate): agar ek write poori cache line cover kare, to fetch skip karo aur seedha poori cache line overwrite karo. Ise write-combining se confuse mat karo, jo adjacent writes ko memory ko issue karne se pehle bursts mein merge karta hai — yeh ek write-buffering technique hai, fill policy nahi.