Memory-mapped files — Hinglish notes

4.2.30 · Coding › Operating Systems

WHY exist karta hai yeh?

Teen concrete WHYs jo aapko zor se bol paane chahiye:

Double-copying avoid karo — private buffer mein copy karne ki jagah kernel page cache share karo.
Random access free ho jaata hai — byte 5,000,000 par jaana sirf ptr[5000000] hai, koi lseek nahi.
Lazy loading (demand paging) — ek 4 GB mapped file practically kuch nahi cost karti jab tak aap ek page touch nahi karte; sirf wahi pages load hote hain jo aap access karte ho.

WHAT hai yeh, precisely?

Definition

mmap (POSIX)

void *mmap(void *addr, size_t length, int prot,
           int flags, int fd, off_t offset);

File fd ke length bytes ko offset se shuru karke memory mein map karta hai, ek pointer addr return karta hai.

prot: PROT_READ, PROT_WRITE, PROT_EXEC
flags: MAP_SHARED (writes file mein wapas jaate hain + doosre processes unhe dekhte hain) vs MAP_PRIVATE (copy-on-write, writes private rehte hain)

HOW actually kaam karta hai yeh? (mechanism derive karo)

Hum behaviour ko ek fact se derive karte hain: virtual memory pehle se hi virtual pages ko physical frames se page table ke zariye map karta hai, page fault par unhe fill karta hai. Memory-mapping sirf yeh badalta hai ki kya ek page ko back karta hai.

Step 1 — call bookkeeping setup karti hai, data nahi. mmap ek Virtual Memory Area (VMA) banata hai: "virtual range $[V, V + L)$ file region $[o f f, o f f + L)$ ke corresponding hai." Yeh step kyun? Page-table entries ko "not present" set karna OS ko poora real kaam defer karne deta hai — abhi kuch bhi nahi padha jaata.

Step 2 — pehla touch ek page fault cause karta hai. Aap ptr[k] padhte ho. CPU page-table entry ko not present mark hua paata hai → page fault → kernel mein trap. Kyun? Yeh woh hook hai jo OS ko notice karne deta hai ki "aap woh data chahte ho jo loaded nahi hai."

Step 3 — fault handler file se load karta hai. Handler compute karta hai ki woh virtual address kaunsi file page se correspond karta hai, usse disk se ek physical frame mein read karta hai (aksar woh pehle se page cache mein hai → zero disk I/O), aur page-table entry install karta hai. Faulting instruction re-execute hoti hai aur ab succeed karti hai. Kyun re-execute? Taaki program oblivious rahe — use sirf ek normal memory access dikhti hai jo "ek baar slow hua tha."

Step 4 — writes page ko dirty mark karti hain. MAP_SHARED ke saath, likhna dirty bit set karta hai. Kyun? Taaki OS jaane ki yeh page disk se alag hai aur baad mein write back kiya jaana chahiye (msync, munmap, ya reclaim hone par).

Mapping arithmetic jo aapko reproduce kar paana chahiye: $virtual addr V_{a} \Rightarrow file offset = o f f + (V_{a} - V_{base})$ $page number = ⌊ \frac{V _{a} - V _{base}}{P} ⌋, P = page size (typ. 4096 B)$

Yeh step kyun? Kyunki OS sab kuch page boundaries par align karta hai; yeh samajhna explain karta hai ki offset $P$ ka multiple kyun hona chahiye.

Worked examples

Worked example Example 3 —

read() ke bina characters count karna

int fd = open("data.txt", O_RDONLY);
struct stat st; fstat(fd, &st);
char *p = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
long count = 0;
for (off_t i = 0; i < st.st_size; i++)
    if (p[i] == 'a') count++;
munmap(p, st.st_size);

Har step kyun? fstat size deta hai taaki hum exactly file map karein; MAP_PRIVATE kyunki hum sirf padh rahe hain; loop file ko ek plain array ki tarah treat karta hai — loop ke andar koi syscalls nahi, yahi fayda hai.

Forecast-then-Verify

Recall Forecast: Process A ek file

MAP_SHARED map karta hai aur byte 0 par 'X' likhta hai. Process B ke paas wahi file MAP_SHARED mapped hai. Kya B ko 'X' dikhega? Agar B ne MAP_PRIVATE use kiya hota to? MAP_SHARED: Haan — dono same page-cache frame map karte hain, isliye B ko 'X' instantly dikhai deta hai (koi disk round-trip zaruri nahi). MAP_PRIVATE: Nahi — B ke pehle write par use ek copy-on-write private copy milti hai; A ke writes (aur B ke bhi) ek doosre ko visible nahi hote. (Un pages ke reads ke liye jo B ne kabhi nahi likha, B shayad A ka data tab bhi dekhe jab tak COW trigger na ho — implementation-dependent hai, isliye is par rely mat karo.)

Common mistakes (steel-manned)

The 80/20 core

Recall Feynman: ek 12-saal ke bacche ko explain karo

Ek library mein ek behad badi kitaab imagine karo. Normally use padhne ke liye aap jo bhi page chahiye use photocopy karte ho aur copies ghar le jaate ho — slow aur wasteful. Memory-mapping aisa hai jaise aapko jadu ka chashma mile: aap use pehenate ho aur kitaab seedhi aapki table par appear ho jaati hai. Lekin trick yeh hai ki pages blank rehte hain jab tak aap actually kisi ko dekhte nahi — jis pal aapki nazar kisi page par padti hai, woh instantly fill ho jaata hai (yahi "page fault" hai). Agar aap "shared" chashme se kisi page par koi note likhte ho, toh wahi shared chashma pehnne wala aapka dost bhi aapka note dekh sakta hai, kyunki aap dono same page dekh rahe ho, copies nahi.

Connections

Virtual Memory — mmap poori tarah iske page-table + page-fault machinery par built hai.
Demand Paging — woh lazy-loading mechanism jo mmap reuse karta hai.
Page Cache — jis cheez par MAP_SHARED pages actually point karte hain.
Copy-on-Write — MAP_PRIVATE aur fork() copies kaise defer karte hain.
File Descriptors and read-write syscalls — woh alternative jise mmap replace karta hai.
Shared Memory (IPC) — same file ka MAP_SHARED ek IPC channel hai.
SIGBUS and SIGSEGV — woh faults jo tab aate hain jab mapping galat use ho.

mmap file ko kya appear karata hai?

Process ke virtual address space ka ek region, jise read/write syscalls ki jagah pointers ke zariye access kiya jaata hai.

mmap, read() se repeated access ke liye faster kyun hai?

Yeh kernel page cache se private user buffer mein copy karna avoid karta hai — process seedha page cache par point karta hai.

mmap ke andar file pages actually kab load hote hain?

Lazily, pehle access par, page fault ke zariye (demand paging) — mmap() ke time par nahi.

MAP_SHARED aur MAP_PRIVATE mein kya fark hai?

SHARED: writes file mein jaate hain aur doosre mappers ko visible hote hain. PRIVATE: copy-on-write, writes local rehte hain aur file ko kabhi hit nahi karte.

mmap ke offset argument par kya constraint lagti hai?

Yeh system page size ka multiple hona chahiye (jaise 4096), warna EINVAL.

10000-byte file (4096 B pages) sequentially padhne mein kitne page faults?

ceil(10000/4096) = 3 major faults.

MAP_SHARED page par likhna immediately kya karta hai, aur woh disk tak kab pahunchta hai?

Yeh page cache update karta hai aur dirty bit set karta hai; disk write-back msync/munmap/reclaim/flush daemon tak deferred rehta hai.

Dirty mapped pages ko disk par abhi force karne wali call kaunsi hai?

msync(addr, length, MS_SYNC).

File ke end se aage whole pages access karne par kaunsa signal milta hai?

SIGBUS.

Base Vb aur file offset off wali mapping mein virtual address Va ka file offset kya hoga?

off + (Va - Vb).