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)** என்பது 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-இலிருந்து ஏற்றுதல் (ஒரு *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 கட்டமைப்புக்கு இயற்கையாக map ஆகிறது ஆனால் **external fragmentation** (variable-size holes) பாதிக்கிறது. தூய segmentation பெருமளவு வரலாற்று ரீதியானது; x86 ஒரு எச்சவடிவத்தை வைத்திருக்கிறது, ஆனால் Linux அதை தட்டையாக்கி paging-ஐ நம்பியுள்ளது.

## இது ஏன் முக்கியம்

Paging, TLB, மற்றும் page faults "virtual memory" உண்மையான performance-ஐச் சந்திக்கும் இடம். நீங்கள் abstractions-ஐ hardware cost-உடன் இணைக்கிறீர்களா என்று சரிபார்க்க interviewers இதைப் பயன்படுத்துகிறார்கள்: huge pages ஏன் TLB misses-ஐக் குறைக்கின்றன, ஒரு page-fault புயல் ஏன் latency-ஐ மூழ்கடிக்கிறது, மற்றும் cache/TLB-நட்பு access patterns ஏன் வேகமாக இயங்குகின்றன. இது memory-mapped files, copy-on-write, மற்றும் thrashing-க்கும் அத்தியாவசிய பின்னணி.

Paging

TLB: அதை வேகமாக்குதல்

Page faults

Segmentation

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்