Paging, TLB, మరియు page faultలు ఎలా పనిచేస్తాయి?

Question

IT Interview Practice · Accepted Answer

**Paging** మరియు **segmentation** అనేవి virtual address spaceను నిర్వహించే రెండు మార్గాలు; ఆధునిక సిస్టమ్‌లు అత్యధికంగా 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 tableలు పెద్దవి, కాబట్టి అవి **multi-level** (ఒక tree) లేదా hashed, మరియు హార్డ్‌వేర్ **MMU** చేత walk చేయబడతాయి.

## TLB: దాన్ని వేగంగా చేయడం

ప్రతి memory access మీద ఒక multi-level page tableను walk చేయడం సిస్టమ్‌ను నిర్వీర్యం చేస్తుంది. **TLB (Translation Lookaside Buffer)** అనేది CPU లోపల ఇటీవలి virtual→physical అనువాదాల చిన్న, వేగవంతమైన 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 రేట్‌లు సాధారణంగా >99%; ఒక miss ఖరీదైనది, అందుకే **spatial locality** మరియు **huge pages** (2 MB — అదే RAMను కవర్ చేయడానికి తక్కువ entries) వంటి ఫీచర్‌లు పెర్ఫార్మెన్స్‌కు ముఖ్యం.

## Page faults

Page-table entry ప్రకారం page **RAMలో లేకపోతే** (లేదా దాని protection bitలు ఉల్లంఘించబడితే), MMU ఒక **page fault** trapను లేపుతుంది. OS దాన్ని నిర్వహిస్తుంది: page‌ను disk నుండి లోడ్ చేయడం (ఒక *major* fault), ఒక కొత్త pageను సున్నాలతో నింపడం, లేదా copy-on-write. Disk‌ను తాకే page fault లక్షలాది cyclesను ఖర్చు చేస్తుంది — అందుకే working setను RAMలో ఉంచడం ముఖ్యం.

## Segmentation

**Segmentation** మెమరీని **logical unit** ద్వారా — code, data, stack — **variable-size** segmentsగా విభజిస్తుంది, `[segment selector | offset]`గా addressed. ఇది ప్రోగ్రామ్ నిర్మాణానికి సహజంగా మ్యాప్ అవుతుంది కానీ **external fragmentation** (variable-size రంధ్రాలు) బారిన పడుతుంది. స్వచ్ఛమైన segmentation ఎక్కువగా చారిత్రకమైనది; x86 ఒక అవశేష రూపాన్ని ఉంచుకుంటుంది, కానీ Linux దాన్ని చదును చేసి paging మీద ఆధారపడుతుంది.

## ఇది ఎందుకు ముఖ్యం

Paging, TLB, page faultలు "virtual memory" నిజమైన పెర్ఫార్మెన్స్‌ను కలిసే చోటు. మీరు అబ్‌స్ట్రాక్షన్‌లను హార్డ్‌వేర్ ఖర్చుకు అనుసంధానిస్తారో లేదో తనిఖీ చేయడానికి ఇంటర్వ్యూయర్‌లు దీన్ని వాడతారు: huge pages TLB missesను ఎందుకు తగ్గిస్తాయి, page-fault తుఫాను latencyను ఎందుకు కూల్చుతుంది, cache/TLB-స్నేహపూర్వక access నమూనాలు ఎందుకు వేగంగా నడుస్తాయి. ఇది memory-mapped files, copy-on-write, thrashing కోసం కూడా అవసరమైన నేపథ్యం.

Paging

TLB: దాన్ని వేగంగా చేయడం

Page faults

Segmentation

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు