paging, TLB, ਅਤੇ page faults ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

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 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 ਦਰਾਂ ਆਮ ਤੌਰ 'ਤੇ >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 ਨੂੰ ਸਿਫ਼ਰਾਂ ਨਾਲ ਭਰੋ, ਜਾਂ copy-on-write। ਇੱਕ page fault ਜੋ disk ਤੱਕ ਜਾਂਦਾ ਹੈ, ਲੱਖਾਂ cycles ਦੀ ਲਾਗਤ ਲਾਉਂਦਾ ਹੈ — ਇਸੇ ਲਈ working set ਨੂੰ RAM ਵਿੱਚ ਰੱਖਣਾ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ।

## Segmentation

**Segmentation** ਮੈਮੋਰੀ ਨੂੰ **ਤਾਰਕਿਕ ਇਕਾਈ (logical unit)** — code, data, stack — ਦੇ ਆਧਾਰ 'ਤੇ **ਪਰਿਵਰਤਨਸ਼ੀਲ-ਆਕਾਰ** segments ਵਿੱਚ ਵੰਡਦੀ ਹੈ, ਜਿਹਨਾਂ ਨੂੰ `[segment selector | offset]` ਵਜੋਂ address ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਪ੍ਰੋਗਰਾਮ ਦੀ ਬਣਤਰ ਨਾਲ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਮੈਪ ਹੁੰਦੀ ਹੈ ਪਰ **external fragmentation** (ਪਰਿਵਰਤਨਸ਼ੀਲ-ਆਕਾਰ ਦੇ ਖੱਪੇ) ਤੋਂ ਪੀੜਤ ਹੁੰਦੀ ਹੈ। ਸ਼ੁੱਧ segmentation ਵੱਡੇ ਪੱਧਰ 'ਤੇ ਇਤਿਹਾਸਕ ਹੈ; x86 ਇੱਕ ਅਵਸ਼ੇਸ਼ੀ ਰੂਪ ਰੱਖਦਾ ਹੈ, ਪਰ Linux ਇਸਨੂੰ ਸਮਤਲ ਕਰ ਦਿੰਦਾ ਹੈ ਅਤੇ paging 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

Paging, TLB, ਅਤੇ page faults ਉਹ ਥਾਂ ਹਨ ਜਿੱਥੇ "virtual memory" ਅਸਲੀ performance ਨਾਲ ਮਿਲਦੀ ਹੈ। ਇੰਟਰਵਿਊ ਲੈਣ ਵਾਲੇ ਇਸਨੂੰ ਇਹ ਜਾਂਚਣ ਲਈ ਵਰਤਦੇ ਹਨ ਕਿ ਕੀ ਤੁਸੀਂ abstractions ਨੂੰ ਹਾਰਡਵੇਅਰ ਲਾਗਤ ਨਾਲ ਜੋੜਦੇ ਹੋ: huge pages TLB misses ਕਿਉਂ ਘਟਾਉਂਦੇ ਹਨ, ਇੱਕ page-fault ਤੂਫ਼ਾਨ latency ਨੂੰ ਕਿਉਂ ਡੋਬ ਦਿੰਦਾ ਹੈ, ਅਤੇ cache/TLB-ਦੋਸਤਾਨਾ access patterns ਤੇਜ਼ ਕਿਉਂ ਚੱਲਦੇ ਹਨ। ਇਹ memory-mapped files, copy-on-write, ਅਤੇ thrashing ਲਈ ਵੀ ਜ਼ਰੂਰੀ ਪਿਛੋਕੜ ਹੈ।

Paging

TLB: ਇਸਨੂੰ ਤੇਜ਼ ਬਣਾਉਣਾ

Page faults

Segmentation

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ