mirror of
https://github.com/kuhyx/praca_magisterska.git
synced 2026-07-04 13:43:05 +02:00
601 lines
27 KiB
Markdown
601 lines
27 KiB
Markdown
# Pytanie 10: Zarządzanie pamięcią - stronicowanie i segmentacja
|
||
|
||
## Pytanie
|
||
**"Scharakteryzować problemy i mechanizmy zarządzania pamięcią. Porównać cechy i przeznaczenie mechanizmów stronicowania i segmentacji."**
|
||
|
||
Przedmiot: SOI (Systemy Operacyjne)
|
||
|
||
---
|
||
|
||
## 📚 Odpowiedź główna
|
||
|
||
### Wprowadzenie
|
||
|
||
**Zarządzanie pamięcią** to jeden z kluczowych zadań systemu operacyjnego:
|
||
- Przydzielanie pamięci procesom
|
||
- Ochrona pamięci między procesami
|
||
- Efektywne wykorzystanie ograniczonego zasobu
|
||
- Abstrakcja (programista nie musi znać fizycznych adresów)
|
||
|
||
---
|
||
|
||
## 1. Problemy zarządzania pamięcią
|
||
|
||
### 1.1 Fragmentacja
|
||
|
||
#### Fragmentacja zewnętrzna (External Fragmentation)
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ Pamięć fizyczna: │
|
||
│ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ ┌────┐ │
|
||
│ │PROC│ │FREE│ │PROC│ │FREE│ │PROC│ │FREE│ │PROC│ │
|
||
│ │ A │ │ 2K │ │ B │ │ 3K │ │ C │ │ 1K │ │ D │ │
|
||
│ └────┘ └────┘ └────┘ └────┘ └────┘ └────┘ └────┘ │
|
||
│ │
|
||
│ Suma wolnej pamięci: 6K │
|
||
│ Ale nie można przydzielić bloku 5K! (fragmentacja) │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
**Problem:** Wolna pamięć jest rozproszona w małych, nieciągłych blokach.
|
||
|
||
#### Fragmentacja wewnętrzna (Internal Fragmentation)
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ Przydzielono blok 4KB, proces potrzebuje 3.5KB: │
|
||
│ ┌────────────────────────────────────────┐ │
|
||
│ │ WYKORZYSTANE (3.5KB) │ ZMARNOWANE (0.5KB) │ │
|
||
│ └────────────────────────────────────────┘ │
|
||
│ ↑ │
|
||
│ Fragmentacja wewnętrzna │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
**Problem:** Przydzielony blok jest większy niż potrzeba.
|
||
|
||
### 1.2 Ochrona pamięci
|
||
|
||
- Proces A nie może czytać/pisać pamięci procesu B
|
||
- Jądro chronione przed aplikacjami użytkownika
|
||
- Mechanizmy: rejestry bazowy/graniczny, bity ochrony, ringi
|
||
|
||
### 1.3 Relokacja
|
||
|
||
**Problem:** Program kompilowany z założeniem konkretnych adresów musi działać pod różnymi adresami.
|
||
|
||
**Rozwiązania:**
|
||
- Relokacja statyczna (loader)
|
||
- Relokacja dynamiczna (MMU - Memory Management Unit)
|
||
|
||
### 1.4 Współdzielenie
|
||
|
||
- Biblioteki współdzielone (DLL, .so)
|
||
- Pamięć współdzielona między procesami
|
||
- Copy-on-Write (COW)
|
||
|
||
### 1.5 Ograniczona pamięć fizyczna
|
||
|
||
- Więcej procesów niż RAM
|
||
- Rozwiązanie: pamięć wirtualna + swap
|
||
|
||
---
|
||
|
||
## 2. Mechanizmy zarządzania pamięcią
|
||
|
||
### 2.1 Partycjonowanie stałe (Fixed Partitioning)
|
||
|
||
```
|
||
┌────────────────────────────────────────────────────────────────┐
|
||
│ Pamięć podzielona na stałe partycje: │
|
||
│ ┌──────────┬──────────┬──────────┬──────────┐ │
|
||
│ │ Partycja │ Partycja │ Partycja │ Partycja │ │
|
||
│ │ 1MB │ 2MB │ 4MB │ 8MB │ │
|
||
│ └──────────┴──────────┴──────────┴──────────┘ │
|
||
│ │
|
||
│ Zalety: Proste, brak fragmentacji zewnętrznej │
|
||
│ Wady: Fragmentacja wewnętrzna, maks. rozmiar procesu ograniczony│
|
||
└────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 2.2 Partycjonowanie dynamiczne (Dynamic Partitioning)
|
||
|
||
```
|
||
┌────────────────────────────────────────────────────────────────┐
|
||
│ Partycje tworzone według potrzeb: │
|
||
│ ┌─────┬───────────┬────────┬─────────────────────────────┐ │
|
||
│ │ P1 │ P2 │ P3 │ WOLNA │ │
|
||
│ │ 3MB │ 5MB │ 2MB │ 10MB │ │
|
||
│ └─────┴───────────┴────────┴─────────────────────────────┘ │
|
||
│ │
|
||
│ Zalety: Brak fragmentacji wewnętrznej, elastyczność │
|
||
│ Wady: Fragmentacja zewnętrzna! │
|
||
└────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
**Algorytmy przydziału:**
|
||
|
||
| Algorytm | Opis | Zalety | Wady |
|
||
|----------|------|--------|------|
|
||
| **First Fit** | Pierwszy wystarczający blok | Szybki | Fragmentacja na początku |
|
||
| **Best Fit** | Najmniejszy wystarczający | Oszczędza duże bloki | Wiele małych fragmentów |
|
||
| **Worst Fit** | Największy blok | Pozostawia użyteczne resztki | Niszczy duże bloki |
|
||
| **Next Fit** | First Fit od ostatniego miejsca | Rozproszenie | Fragmentacja |
|
||
|
||
---
|
||
|
||
## 3. Stronicowanie (Paging)
|
||
|
||
### Idea
|
||
|
||
Dzielimy pamięć na **równe bloki** (strony/ramki):
|
||
- **Strona (Page)** - blok pamięci wirtualnej (4KB typowo)
|
||
- **Ramka (Frame)** - blok pamięci fizycznej (ten sam rozmiar)
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ PAMIĘĆ WIRTUALNA PAMIĘĆ FIZYCZNA │
|
||
│ (przestrzeń adresowa) (RAM) │
|
||
│ │
|
||
│ ┌─────────┐ ┌─────────┐ │
|
||
│ │ Strona 0│─────────────────────────│ Ramka 5 │ │
|
||
│ ├─────────┤ ├─────────┤ │
|
||
│ │ Strona 1│──────────┐ │ Ramka 1 │ │
|
||
│ ├─────────┤ │ ├─────────┤ │
|
||
│ │ Strona 2│────┐ │ │ Ramka 2 │←──────────┐ │
|
||
│ ├─────────┤ │ │ ├─────────┤ │ │
|
||
│ │ Strona 3│ │ └─────────────→│ Ramka 3 │ │ │
|
||
│ └─────────┘ │ ├─────────┤ │ │
|
||
│ │ │ Ramka 4 │ │ │
|
||
│ │ ├─────────┤ │ │
|
||
│ └───────────────────→│ Ramka 7 │ │ │
|
||
│ └─────────┘ │ │
|
||
│ │ │
|
||
│ TABLICA STRON (Page Table) Strona 2 → Ramka 7────┘ │
|
||
│ ┌──────────────────────┐ │
|
||
│ │ Strona │ Ramka │Flagi│ │
|
||
│ │ 0 │ 5 │ RW │ │
|
||
│ │ 1 │ 3 │ R │ │
|
||
│ │ 2 │ 7 │ RW │ │
|
||
│ │ 3 │ - │ INV │ ← Strona nie w pamięci (page fault) │
|
||
│ └──────────────────────┘ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### Translacja adresu
|
||
|
||
```
|
||
Adres wirtualny (32-bit, strony 4KB):
|
||
┌────────────────────────┬──────────────┐
|
||
│ Numer strony (20b) │ Offset (12b) │
|
||
└────────────────────────┴──────────────┘
|
||
│ │
|
||
↓ │
|
||
Tablica stron │
|
||
│ │
|
||
↓ │
|
||
┌────────────────────────┬──────────────┐
|
||
│ Numer ramki (20b) │ Offset (12b) │
|
||
└────────────────────────┴──────────────┘
|
||
Adres fizyczny
|
||
```
|
||
|
||
### Wielopoziomowe tablice stron
|
||
|
||
**Problem:** Tablica stron dla 32-bit przestrzeni z 4KB stronami = 2²⁰ wpisów × 4B = **4MB per proces!**
|
||
|
||
**Rozwiązanie:** Hierarchiczna tablica stron
|
||
|
||
```
|
||
Adres wirtualny (32-bit, 2 poziomy):
|
||
┌────────────┬────────────┬──────────────┐
|
||
│ Katalog(10)│ Tabela(10) │ Offset (12) │
|
||
└────────────┴────────────┴──────────────┘
|
||
│ │ │
|
||
↓ ↓ │
|
||
┌──────────┐ ┌──────────┐ │
|
||
│ Page │ │ Page │ │
|
||
│Directory │→ │ Table │→ Ramka + Offset
|
||
└──────────┘ └──────────┘
|
||
```
|
||
|
||
**64-bit (x86-64):** 4 poziomy (PML4 → PDPT → PD → PT)
|
||
|
||
### TLB (Translation Lookaside Buffer)
|
||
|
||
**Problem:** Każdy dostęp do pamięci wymaga 2+ odczytów (tablica + dane).
|
||
|
||
**Rozwiązanie:** Cache translacji adresów
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ TLB │
|
||
│ ┌───────────────────────────────────────────────────────────┐ │
|
||
│ │ Strona wirtualna │ Ramka fizyczna │ Flagi │ ASID │ │
|
||
│ │ 0x12345 │ 0x789AB │ RW │ 42 │ │
|
||
│ │ 0x12346 │ 0x789AC │ R │ 42 │ │
|
||
│ │ ... │ ... │ ... │ ... │ │
|
||
│ └───────────────────────────────────────────────────────────┘ │
|
||
│ │
|
||
│ TLB hit: ~1 cykl │
|
||
│ TLB miss: ~100+ cykli (page walk) │
|
||
│ Hit rate: >99% typowo │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### Zalety i wady stronicowania
|
||
|
||
| Zalety | Wady |
|
||
|--------|------|
|
||
| Brak fragmentacji zewnętrznej | Fragmentacja wewnętrzna (ostatnia strona) |
|
||
| Prosta alokacja (bitmapa ramek) | Narzut tablicy stron |
|
||
| Łatwe współdzielenie (COW) | TLB miss kosztowny |
|
||
| Pamięć wirtualna naturalna | Nie odpowiada strukturze programu |
|
||
|
||
---
|
||
|
||
## 4. Segmentacja (Segmentation)
|
||
|
||
### Idea
|
||
|
||
Dzielimy pamięć na **logiczne segmenty** odpowiadające strukturze programu:
|
||
- Segment kodu
|
||
- Segment danych
|
||
- Segment stosu
|
||
- Segment bibliotek
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ PRZESTRZEŃ LOGICZNA PAMIĘĆ FIZYCZNA │
|
||
│ │
|
||
│ ┌─────────────────┐ ┌─────────────────────┐ │
|
||
│ │ Segment 0 │ │ │ │
|
||
│ │ (Kod) │─────────────────│→ 0x1000 - 0x3FFF │ │
|
||
│ │ Rozmiar: 12KB │ │ │ │
|
||
│ └─────────────────┘ ├─────────────────────┤ │
|
||
│ ┌─────────────────┐ │ │ │
|
||
│ │ Segment 1 │─────────────────│→ 0x8000 - 0xBFFF │ │
|
||
│ │ (Dane) │ │ │ │
|
||
│ │ Rozmiar: 16KB │ ├─────────────────────┤ │
|
||
│ └─────────────────┘ │ │ │
|
||
│ ┌─────────────────┐ │ │ │
|
||
│ │ Segment 2 │─────────────────│→ 0xF000 - 0xF7FF │ │
|
||
│ │ (Stos) │ │ │ │
|
||
│ │ Rozmiar: 2KB │ └─────────────────────┘ │
|
||
│ └─────────────────┘ │
|
||
│ │
|
||
│ TABLICA SEGMENTÓW │
|
||
│ ┌───────────────────────────────────────────────────────────┐ │
|
||
│ │ Segment │ Baza │ Limit │ Prawa │ │ │
|
||
│ │ 0 │ 0x1000 │ 12KB │ RX │ (kod - execute) │ │
|
||
│ │ 1 │ 0x8000 │ 16KB │ RW │ (dane - read/write) │ │
|
||
│ │ 2 │ 0xF000 │ 2KB │ RW │ (stos) │ │
|
||
│ └───────────────────────────────────────────────────────────┘ │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### Translacja adresu
|
||
|
||
```
|
||
Adres logiczny:
|
||
┌────────────────────┬──────────────────────┐
|
||
│ Numer segmentu (s) │ Offset (d) │
|
||
└────────────────────┴──────────────────────┘
|
||
│ │
|
||
↓ │
|
||
Tablica segmentów │
|
||
┌──────┬───────┐ │
|
||
│ Baza │ Limit │ │
|
||
└──────┴───────┘ │
|
||
│ │ │
|
||
│ Sprawdź: d < Limit?
|
||
│ │ │
|
||
↓ ↓ │
|
||
Adres fizyczny = Baza + Offset
|
||
```
|
||
|
||
### Ochrona w segmentacji
|
||
|
||
Każdy segment ma **prawa dostępu:**
|
||
- **R** (Read) - odczyt dozwolony
|
||
- **W** (Write) - zapis dozwolony
|
||
- **X** (Execute) - wykonanie dozwolone
|
||
|
||
```
|
||
Segment kodu: RX (wykonaj, nie modyfikuj)
|
||
Segment danych: RW (czytaj/pisz, nie wykonuj)
|
||
Segment stosu: RW (bez wykonywania - ochrona przed exploitami)
|
||
```
|
||
|
||
### Zalety i wady segmentacji
|
||
|
||
| Zalety | Wady |
|
||
|--------|------|
|
||
| Odpowiada strukturze programu | Fragmentacja zewnętrzna |
|
||
| Naturalna ochrona (per segment) | Segmenty o zmiennej wielkości |
|
||
| Łatwe współdzielenie (cały segment) | Kompaktowanie potrzebne |
|
||
| Dynamiczny wzrost segmentów | Skomplikowana alokacja |
|
||
|
||
---
|
||
|
||
## 5. Porównanie: Stronicowanie vs Segmentacja
|
||
|
||
| Cecha | Stronicowanie | Segmentacja |
|
||
|-------|---------------|-------------|
|
||
| **Jednostka** | Strona (stały rozmiar) | Segment (zmienny rozmiar) |
|
||
| **Widoczność dla programisty** | Niewidoczna | Widoczna (logiczne jednostki) |
|
||
| **Fragmentacja zewnętrzna** | ❌ Brak | ✅ Występuje |
|
||
| **Fragmentacja wewnętrzna** | ✅ Występuje | ❌ Brak |
|
||
| **Tablica** | Tablica stron (duża) | Tablica segmentów (mała) |
|
||
| **Ochrona** | Per strona (mniej naturalna) | Per segment (naturalna) |
|
||
| **Współdzielenie** | Per strona | Per segment (całe moduły) |
|
||
| **Pamięć wirtualna** | Łatwa (strony na dysk) | Trudniejsza |
|
||
|
||
---
|
||
|
||
## 6. Segmentacja ze stronicowaniem (Hybrid)
|
||
|
||
### Intel x86 (tryb chroniony)
|
||
|
||
Kombinacja obu mechanizmów:
|
||
|
||
```
|
||
Adres logiczny (Selector:Offset)
|
||
│
|
||
↓
|
||
SEGMENTACJA
|
||
(Segment → Adres liniowy)
|
||
│
|
||
↓
|
||
Adres liniowy
|
||
│
|
||
↓
|
||
STRONICOWANIE
|
||
(Strona → Ramka)
|
||
│
|
||
↓
|
||
Adres fizyczny
|
||
```
|
||
|
||
**Praktyka:** Współczesne OS (Linux, Windows) używają **flat memory model** - wszystkie segmenty pokrywają całą przestrzeń adresową, efektywnie wyłączając segmentację.
|
||
|
||
### Zalety hybrydowego podejścia
|
||
|
||
1. **Ochrona** z segmentacji (kod vs dane vs stos)
|
||
2. **Brak fragmentacji zewnętrznej** ze stronicowania
|
||
3. **Pamięć wirtualna** ze stronicowania
|
||
|
||
---
|
||
|
||
## 7. Pamięć wirtualna (Virtual Memory)
|
||
|
||
### Idea
|
||
|
||
Nie wszystkie strony muszą być w RAM - część może być na dysku (swap).
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────────┐
|
||
│ │
|
||
│ PAMIĘĆ WIRTUALNA RAM DYSK (Swap) │
|
||
│ ┌─────────────┐ ┌──────────┐ ┌──────────────┐ │
|
||
│ │ Strona 0 │ ────→│ Ramka 2 │ │ │ │
|
||
│ │ Strona 1 │ │ │ │ Strona 3 │ │
|
||
│ │ Strona 2 │ ────→│ Ramka 5 │ │ Strona 5 │ │
|
||
│ │ Strona 3 │ ─────────────────────→ │ │ │
|
||
│ │ Strona 4 │ ────→│ Ramka 1 │ │ │ │
|
||
│ │ Strona 5 │ ─────────────────────→ │ │ │
|
||
│ └─────────────┘ └──────────┘ └──────────────┘ │
|
||
│ │
|
||
│ Page fault: Strona 3 → załaduj z dysku do RAM │
|
||
└─────────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### Algorytmy zastępowania stron
|
||
|
||
| Algorytm | Opis | Właściwości |
|
||
|----------|------|-------------|
|
||
| **FIFO** | Najstarsza strona | Prosty, anomalia Bélády'ego |
|
||
| **LRU** | Najdawniej używana | Optymalny offline, kosztowny |
|
||
| **LRU Approximation** | Clock, Second Chance | Praktyczny kompromis |
|
||
| **LFU** | Najrzadziej używana | Dobre dla hot data |
|
||
| **OPT** | Najdalej używana | Teoretycznie optymalny, niemożliwy |
|
||
|
||
### Algorytm Clock (Second Chance)
|
||
|
||
```
|
||
┌───┐
|
||
┌──→│ 1 │──┐ Bit referencji:
|
||
│ └───┘ │ 1 = używana ostatnio
|
||
│ ↓ 0 = kandydat do usunięcia
|
||
┌───┐ ┌───┐
|
||
│ 0 │ │ 1 │ Wskazówka zegara:
|
||
└───┘ └───┘ - Jeśli bit=1: zeruj, idź dalej
|
||
↑ │ - Jeśli bit=0: zastąp tę stronę
|
||
│ ┌───┐ │
|
||
└───│ 0 │←─┘
|
||
└───┘
|
||
↑
|
||
wskazówka
|
||
```
|
||
|
||
---
|
||
|
||
## 🧠 Mnemoniki
|
||
|
||
### "STRONY RÓWNE, SEGMENTY LOGICZNE":
|
||
- **Strony** = wszystkie takie same (4KB)
|
||
- **Segmenty** = różne rozmiary, logiczny podział
|
||
|
||
### "PAGE = Physical Allocation Generates Equality":
|
||
- Fizyczne ramki równej wielkości
|
||
- Brak fragmentacji zewnętrznej
|
||
|
||
### "SEGMENT = Software Entity with Guarded Memory, ENforcing Type safety":
|
||
- Logiczne jednostki programu
|
||
- Ochrona per segment
|
||
|
||
### "TLB = Translation Lightning-fast Buffer":
|
||
- Cache dla translacji adresów
|
||
- Hit = 1 cykl, Miss = 100+ cykli
|
||
|
||
### "LRU = Last Recently Used → pierwszy do usunięcia":
|
||
- Najdawniej używana = najlepsza do wyrzucenia
|
||
|
||
---
|
||
|
||
## ❓ Możliwe pytania dodatkowe (follow-up)
|
||
|
||
### Q1: "Co to jest Page Fault i jak jest obsługiwany?"
|
||
|
||
**Odpowiedź:**
|
||
|
||
**Page Fault** = wyjątek gdy strona nie jest w RAM (bit valid=0 w tablicy stron).
|
||
|
||
```
|
||
1. Proces odwołuje się do adresu w stronie 5
|
||
2. MMU sprawdza tablicę stron: strona 5 invalid
|
||
3. Page Fault exception
|
||
4. OS:
|
||
a) Znajdź stronę na dysku (swap)
|
||
b) Znajdź wolną ramkę (lub zwolnij przez algorytm zastępowania)
|
||
c) Załaduj stronę z dysku do RAM
|
||
d) Zaktualizuj tablicę stron (valid=1, ramka=X)
|
||
e) Wznów instrukcję
|
||
5. Proces kontynuuje (nie wie, że był page fault)
|
||
```
|
||
|
||
---
|
||
|
||
### Q2: "Wyjaśnij anomalię Bélády'ego"
|
||
|
||
**Odpowiedź:**
|
||
|
||
**Anomalia Bélády'ego** = więcej ramek → więcej page faults (dla FIFO)!
|
||
|
||
```
|
||
Sekwencja odwołań: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
|
||
|
||
3 ramki (FIFO): 9 page faults
|
||
4 ramki (FIFO): 10 page faults (!!)
|
||
|
||
Wniosek: FIFO nie jest "stack algorithm" - nie ma tej właściwości:
|
||
"Strony w pamięci z N ramkami ⊆ strony z N+1 ramkami"
|
||
|
||
LRU nie ma tej anomalii (jest stack algorithm).
|
||
```
|
||
|
||
---
|
||
|
||
### Q3: "Co to jest thrashing?"
|
||
|
||
**Odpowiedź:**
|
||
|
||
**Thrashing** = system spędza więcej czasu na page faults niż na wykonywaniu kodu.
|
||
|
||
```
|
||
Przyczyna: Zbyt mało RAM dla working set procesów
|
||
|
||
Working set = zbiór stron aktywnie używanych przez proces
|
||
|
||
Symptomy:
|
||
- CPU utilization spada
|
||
- Dysk ciągle pracuje (swap in/out)
|
||
- System "zamiera"
|
||
|
||
Rozwiązania:
|
||
- Zwiększ RAM
|
||
- Zmniejsz multiprogramming
|
||
- Working set model (przydziel RAM proporcjonalnie)
|
||
- Swap na SSD
|
||
```
|
||
|
||
---
|
||
|
||
### Q4: "Jak działa Copy-on-Write?"
|
||
|
||
**Odpowiedź:**
|
||
|
||
**COW** = odroczenie kopiowania do momentu modyfikacji.
|
||
|
||
```
|
||
fork() bez COW:
|
||
Rodzic: [Strona A] [Strona B] [Strona C]
|
||
↓ kopiowanie
|
||
Dziecko: [Strona A'] [Strona B'] [Strona C']
|
||
→ Kosztowne!
|
||
|
||
fork() z COW:
|
||
Rodzic: [Strona A (RO)] [Strona B (RO)] [Strona C (RO)]
|
||
↓ shared ↓ shared ↓ shared
|
||
Dziecko: [Strona A (RO)] [Strona B (RO)] [Strona C (RO)]
|
||
→ Szybkie! (tylko tablice stron)
|
||
|
||
Dziecko pisze do Strony B:
|
||
1. Page fault (strona RO)
|
||
2. OS kopiuje Stronę B → B'
|
||
3. Dziecko dostaje B' (RW), rodzic zachowuje B (RW)
|
||
```
|
||
|
||
---
|
||
|
||
### Q5: "Jaki jest typowy rozmiar strony i dlaczego?"
|
||
|
||
**Odpowiedź:**
|
||
|
||
| Rozmiar | Zalety | Wady |
|
||
|---------|--------|------|
|
||
| **Mały (1KB)** | Mała fragmentacja wewnętrzna | Duża tablica stron |
|
||
| **Duży (64KB)** | Mała tablica stron | Duża fragmentacja wewnętrzna |
|
||
| **4KB (typowy)** | Kompromis | Kompromis |
|
||
|
||
**Dlaczego 4KB?**
|
||
- Rozmiar bloku dysku (sektor 512B × 8 lub 4K native)
|
||
- Rozsądna fragmentacja (~2KB średnio)
|
||
- Rozsądna tablica stron
|
||
- Historyczne (VAX, Unix)
|
||
|
||
**Huge Pages (2MB, 1GB):**
|
||
- Dla dużych aplikacji (bazy danych)
|
||
- Mniej wpisów TLB
|
||
- Mniej page faults
|
||
|
||
---
|
||
|
||
### Q6: "Jak segmentacja jest używana w x86-64?"
|
||
|
||
**Odpowiedź:**
|
||
|
||
**x86-64 praktycznie nie używa segmentacji:**
|
||
|
||
```
|
||
CS, DS, ES, SS → Baza = 0, Limit = maksymalny
|
||
→ Efektywnie "flat model"
|
||
|
||
Wyjątki:
|
||
- FS, GS → używane dla Thread Local Storage (TLS)
|
||
- CS → poziom uprzywilejowania (ring 0/3)
|
||
```
|
||
|
||
**Powód:** Segmentacja komplikuje pamięć wirtualną i nie jest potrzebna z ochroną per-strona (NX bit, SMEP, SMAP).
|
||
|
||
---
|
||
|
||
## 🎯 Kluczowe punkty do zapamiętania
|
||
|
||
1. **Stronicowanie** = równe strony/ramki, brak fragmentacji zewnętrznej
|
||
2. **Segmentacja** = logiczne jednostki, fragmentacja zewnętrzna
|
||
3. **Współczesne OS** = stronicowanie (segmentacja wyłączona)
|
||
4. **TLB** = cache translacji, kluczowy dla wydajności
|
||
5. **Page fault** = strona nie w RAM, załaduj z dysku
|
||
6. **Thrashing** = za mało RAM, ciągłe page faults
|
||
|
||
---
|
||
|
||
## 📖 Źródła do pogłębienia
|
||
|
||
1. Silberschatz, Galvin - "Operating System Concepts"
|
||
2. Tanenbaum - "Modern Operating Systems"
|
||
3. Intel Manual Vol. 3 - System Programming Guide
|
||
4. Linux kernel documentation - Memory Management
|