Paging, TLB, અને page faults કેવી રીતે કામ કરે છે?

Question

IT Interview Practice · Accepted Answer

**Paging** અને **segmentation** એ virtual address space ને ગોઠવવાની બે રીતો છે; આધુનિક systems ભારે પ્રમાણમાં paging-આધારિત છે (ક્યારેક ઉપર segmentation ના પાતળા સ્તર સાથે).

## Paging

Virtual અને physical memory ને નિશ્ચિત-કદના **pages** અને **frames** (સામાન્ય રીતે 4 KB) માં કાપવામાં આવે છે. એક **page table** virtual page → physical frame મૅપ કરે છે. Address એક **page number** (table માં index) અને એક **offset** માં વિભાજિત થાય છે:

```text
 virtual address  =  [ page number | offset ]
                          │            │
              page table[page] = frame │
                          ▼            ▼
 physical address =  [   frame    | offset ]
```

Page tables મોટા હોય છે, તેથી તે **multi-level** (એક tree) કે hashed હોય છે, અને hardware **MMU** દ્વારા walk કરાય છે.

## TLB: તેને ઝડપી બનાવવું

દરેક memory access પર multi-level page table walk કરવું અપંગ કરી નાખે તેવું હોય. **TLB (Translation Lookaside Buffer)** એ CPU ની અંદરની તાજેતરની virtual→physical translations ની નાની, ઝડપી cache છે:

```text
CPU needs addr → TLB hit?  ── yes ──▶ get frame immediately (~1 cycle)
                    │
                    └── no (TLB miss) → walk the page table, fill the TLB (slower)
```

TLB hit rates સામાન્ય રીતે >99% હોય છે; miss ખર્ચાળ છે, એટલે જ **spatial locality** અને **huge pages** (2 MB — એ જ RAM આવરવા ઓછી entries) જેવી સુવિધાઓ performance માટે મહત્વની છે.

## Page faults

જો page-table entry કહે કે page **RAM માં નથી** (કે તેની protection bits નું ઉલ્લંઘન થયું છે), તો MMU એક **page fault** trap ઊભો કરે છે. OS તેને સંભાળે છે: disk માંથી page લોડ કરવો (એક *major* fault), નવા page ને zero-fill કરવો, કે copy-on-write. Disk ને અડતો page fault લાખો cycles નો ખર્ચ કરે છે — તેથી working set ને RAM માં રાખવું મહત્વનું છે.

## Segmentation

**Segmentation** memory ને **logical unit** — code, data, stack — પ્રમાણે **variable-size** segments માં વિભાજિત કરે છે, જે `[segment selector | offset]` તરીકે address થાય છે. તે program structure સાથે કુદરતી રીતે મૅપ થાય છે પણ **external fragmentation** (variable-size છિદ્રો) થી પીડાય છે. શુદ્ધ segmentation મોટે ભાગે ઐતિહાસિક છે; x86 એક અવશેષ સ્વરૂપ રાખે છે, પણ Linux તેને flatten કરે છે અને paging પર આધાર રાખે છે.

## આ શા માટે મહત્વનું છે

Paging, TLB, અને page faults એ છે જ્યાં "virtual memory" વાસ્તવિક performance ને મળે છે. Interviewers આનો ઉપયોગ એ તપાસવા કરે છે કે તમે abstractions ને hardware cost સાથે જોડો છો કે નહીં: huge pages શા માટે TLB misses ઘટાડે છે, page-fault storm શા માટે latency ને ડૂબાડે છે, અને cache/TLB-friendly access patterns શા માટે ઝડપી ચાલે છે. Memory-mapped files, copy-on-write, અને thrashing માટે પણ આ આવશ્યક પૃષ્ઠભૂમિ છે.

Paging

TLB: તેને ઝડપી બનાવવું

Page faults

Segmentation

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો