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 असतात, आणि हार्डवेअर **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 ते हाताळते: page disk वरून load करा (एक *major* fault), नव्या page ला zero ने भरा, किंवा 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 रचनेशी नैसर्गिकरित्या मॅप होते पण **external fragmentation** (variable-size छिद्रे) भोगते. शुद्ध segmentation बहुतांशी ऐतिहासिक आहे; x86 एक अवशेषरूप ठेवतो, पण Linux ते सपाट करून paging वर अवलंबून राहते.

## हे का महत्त्वाचे आहे

Paging, TLB, आणि page faults हेच ते ठिकाण आहे जिथे "virtual memory" खऱ्या performance ला भेटते. Interviewers हे तपासण्यासाठी वापरतात की तुम्ही abstractions ला हार्डवेअर खर्चाशी जोडता का: huge pages TLB misses का कमी करतात, page-fault वादळ latency का बुडवते, आणि cache/TLB-अनुकूल access patterns वेगवान का चालतात. हे memory-mapped files, copy-on-write, आणि thrashing साठीदेखील अत्यावश्यक पार्श्वभूमी आहे.

Paging

TLB: ते वेगवान करणे

Page faults

Segmentation

हे का महत्त्वाचे आहे

संबंधित प्रश्न