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 को map करती है। एक 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)** हाल की virtual→physical translations का एक छोटा, तेज़ cache है जो CPU के अंदर होता है:

```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 को cover करने के लिए कम entries) जैसी सुविधाएँ performance के लिए मायने रखती हैं।

## Page faults

अगर page-table entry कहती है कि page **RAM में नहीं है** (या उसके protection bits का उल्लंघन हुआ है), तो MMU एक **page fault** trap उठाती है। OS इसे संभालता है: page को disk से load करता है (एक *major* fault), एक नए page को zero-fill करता है, या copy-on-write। एक page fault जो disk तक जाता है लाखों cycles की कीमत लेता है — इसीलिए working set को RAM में रखना मायने रखता है।

## Segmentation

**Segmentation** memory को **logical unit** के अनुसार बाँटती है — code, data, stack — **परिवर्तनशील आकार** के segments में, जिन्हें `[segment selector | offset]` के रूप में address किया जाता है। यह program संरचना से स्वाभाविक रूप से map होती है पर **external fragmentation** (परिवर्तनशील आकार के छेद) से ग्रस्त होती है। शुद्ध segmentation बहुत हद तक ऐतिहासिक है; x86 एक अवशेषी रूप रखता है, पर Linux इसे सपाट कर देता है और paging पर निर्भर रहता है।

## यह क्यों महत्वपूर्ण है

Paging, TLB, और page faults वह जगह हैं जहाँ "virtual memory" असली performance से मिलती है। Interviewers इसका उपयोग यह जाँचने के लिए करते हैं कि क्या आप abstractions को hardware cost से जोड़ते हैं: huge pages TLB misses क्यों घटाते हैं, page-fault का तूफ़ान latency को क्यों डुबो देता है, और cache/TLB-अनुकूल access patterns क्यों तेज़ चलते हैं। यह memory-mapped files, copy-on-write, और thrashing के लिए भी आवश्यक पृष्ठभूमि है।

Paging

TLB: इसे तेज़ बनाना

Page faults

Segmentation

यह क्यों महत्वपूर्ण है

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