Copy-on-write — Hinglish notes

4.2.29 · Coding › Operating Systems

Copy-on-write HAI KYA?

OS memory mein copying ki "unit" page hoti hai (typically $4 KB$ ). Trigger mechanism ek page fault hai jo read-only mark page par write karne se hota hai.

Yahan milta hai yeh:

fork() — child parent ka address space share karta hai jab tak koi write na kare.
mmap(... MAP_PRIVATE) — file pages shared rehte hain jab tak write na ho.
Filesystems (ZFS, Btrfs) aur VM memory mein snapshots.

YEH EXIST KYUN KARTA HAI? (kaunsi problem solve karta hai)

Do fayde:

Speed: fork() $O (number of pages)$ ban jaata hai table setup ke liye, data copy ke liye $O (memory size)$ nahi.
Memory: pages shared (deduplicated) rehte hain jab tak koi write na kare — bahut achha jab kai processes read-only code/data share karte hain.

HOW karta hai yeh kaam, step by step?

Jab ek process duplicate hoti hai (e.g. fork()):

Child ko apne page tables milte hain, lekin har entry same physical frames point karti hai jo parent ke hain.
Saare shared writable pages dono page tables mein read-only mark ho jaate hain, aur internally COW flag ho jaate hain.
OS har physical frame ka reference count track karta hai: kitne mappings usse share kar rahe hain.
Reading? Theek hai — read-only reads allow karta hai. Koi fault nahi, koi copy nahi.
COW page par write karna → CPU page fault raise karta hai (read-only page par write).
Fault handler check karta hai: "Kya yeh COW page hai?" Haan →
- Ek naya frame allocate karo, purani page ka content usmein copy karo.
- Writer ka PTE naye frame ki taraf point karo, use writable mark karo, purane frame ka refcount kam karo.
- Agar purana refcount $1$ tak girta hai, toh remaining owner ka page phir se writable banaya ja sakta hai (use COW rakhne ki zarurat nahi).
Faulting instruction dobara execute karo; ab write private copy par hoti hai.

Worked example

fork() phir ek single write — Har step kyun? Parent ke paas 3 pages hain: code C, data D, stack S.

fork(): child ke tables C, D, S point karte hain; sab read-only + COW mark; refcounts = 2 each. Kyun? Abhi kuch copy karne se bachna — shayad koi likhta hi nahi.
Child chalta hai, code C baar baar read karta hai. Koi copy nahi hoti. Kyun? Read-only pages par reads allowed hain; sharing safe hai.
Child page D mein ek variable likhta hai → page fault. Kyun? D ko read-only is liye mark kiya tha taaki pehla write pakda jaa sake.
Handler D → D′ copy karta hai, child ka D entry ab D′ (writable) point karta hai. refcount(D) → 1. Kyun? Sirf changed page duplicate hoti hai; C aur S abhi bhi shared hain.
Result: 3 ki jagah 1 page copy hua. Baaki ki memory aur time bach gayi.

Formula Cost model — first principles se nikala gaya

Maano $N$ = address space mein total pages, $W$ = distinct pages ki sankhya jo fork ke baad kisi bhi process ne likha, $c_{t}$ = ek page-table entry setup karne ki cost, $c_{c}$ = ek page ka data copy karne ki cost.

Eager copy (no COW): sab kuch pehle copy karo: $T_{eager} = N (c_{t} + c_{c})$ Kyun? $N$ pages mein se har ek ke liye naya frame ( $c_{c}$ ) aur table entry ( $c_{t}$ ) chahiye.

Copy-on-write: abhi $N$ entries setup karo, baad mein sirf $W$ likhe gaye pages copy karo (har likhा gaya page ek baar fault karta hai, ek baar copy hota hai): $T_{cow} = N c_{t} + W c_{c}$ Kyun? Table setup unavoidable hai, lekin data copying defer hoti hai aur sirf likhe gaye pages tak limited hai.

Savings: $T_{eager} - T_{cow} = (N - W) c_{c}$ Kyunki $c_{c} ≫ c_{t}$ ( $4 KB$ copy karna ≫ ek PTE likhna), aur usually $W ≪ N$ (khaas kar jab exec() fork ke baad aata hai, $W \approx 0$ ), COW ek bahut bada faayda hai.

Common mistakes

Recall Feynman: 12 saal ke bacche ko samjhao

Tum aur tumhara dost dono ek hi comic padhna chahte ho. Do comics khareedne ki jagah, tum ek ek share karte ho. Rule yeh hai: koi usmein kuch nahi likha. Jis waqt tum kisi character par moochh banana chahte ho, tum copier par bhaago, sirf woh page copy karo, apni copy par moochh banao, aur shared comic ko apne dost ke liye saaf chod do. Tumne poori comic kabhi copy nahi ki — sirf woh ek page jo change karna tha. Yehi copy-on-write hai: share karo jab tak change na karo, phir sirf changed part copy karo.

Active recall

Copy-on-write kya hai?

Ek technique jisme multiple consumers data ki ek read-only physical copy share karte hain; pehla write sirf affected page ki copy trigger karta hai, jiske baad writer ke paas private copy hoti hai.

OS-level COW mein copying ki unit kya hoti hai?

Ek memory page (typically 4 KB).

COW write ko kaunsa hardware mechanism detect karta hai?

Ek page fault, jo isliye raise hota hai kyunki shared page read-only mark hoti hai.

fork() COW kyun use karta hai?

Pura address space eagerly copy karna bekar hai (aksar turant exec() se phek diya jaata hai); COW shuruaat mein kuch copy nahi karta aur sirf woh pages duplicate karta hai jo actually likhe jaate hain.

Fork ke baad, shared pages read-only kaun mark karta hai — child ya dono?

Dono parent aur child, taaki jo bhi pehle likhe woh copy trigger kare.

COW time cost formula kya hai?

T_{co w} = N c_{t} + W c_{c}

, jahan

N

=pages,

W

=written pages,

c_{t}

=table-entry cost,

c_{c}

=page-copy cost.

COW eager copying se worse kab hota hai?

Jab lagbhag har page likha jata hai (

W \approx N

), kyunki table setup + saari copies + per-page fault overhead pay karna padta hai.

COW mein reference count kya track karta hai?

Kitne mappings abhi ek diye gaye physical frame ko share kar rahe hain.

COW page copy hone ke baad aur refcount 1 hone par kya hota hai?

Remaining owner ka page phir se writable banaya ja sakta hai (ab COW nahi), toh aage ke writes fault nahi karte.

Kya shared pages sirf read karne wali process kabhi copy trigger karti hai?

Nahi — read-only pages par reads allowed hain, toh koi fault aur koi copy nahi hoti.

Connections

fork() system call — COW ka primary user.
Page tables and PTE flags — read-only / COW bits yahan rehte hain.
Page faults — woh trap jo copy trigger karta hai.
Virtual memory — COW ek virtual-memory optimization hai.
Demand paging — sibling "lazy" technique (access par load vs write par copy).
mmap and MAP_PRIVATE — file-backed COW.
Reference counting — yeh jaanne ke liye use hota hai ki sharing kab khatam hoti hai.
Snapshots in filesystems (ZFS/Btrfs) — block level par COW.