Bölüm 9: Sanal Bellek
Giriş
Öğrenme Çıktıları
Sanal belleğin amacını açıklamak; geçerli–geçersiz biti, sayfa hatası işleme adımları ve komutun yeniden başlatılmasını anlatmak.
Sayfa hatası olasılığıyla etkin erişim süresini (EAT) hesaplamak; HDD, SSD ve sıkıştırılmış takas arasındaki farkı yorumlamak.
fork() sonrasında yazınca kopyalamayı ve bellek eşlemeli dosyaların sayfa önbelleğiyle ilişkisini izlemek.
FIFO, OPT, LRU, ikinci şans, saat, NRU, yaşlandırma, çalışma kümesi ve WSClock’u bir referans dizisi üzerinde elle çalıştırmak.
Eşit/orantılı ve yerel/genel tahsisi karşılaştırmak; thrashing’i çalışma kümesi ve PFF ile açıklamak.
Sayfa boyutu, TLB erimi, program yapısı, sabitleme, buddy/slab; Linux (MGLRU, zswap) ve Windows yaklaşımlarını tanımak.
Giriş
Sayfalama ve TLB
- Sanal adres = (p, d); sayfa tablosu p’yi bir çerçeveye çevirir, bağıl konum d aynen kalır.
- TLB son çevirileri önbellekler; isabet oranı %99’un üstündedir, ıskada sayfa tablosu (x86-64’te 4 ya da 5 düzey) yürünür.
- Her girdi: çerçeve no, geçerli (present), R (accessed), M (dirty), koruma bitleri (R/W, U/S, NX).
- Girdi geçersizse sayfa hatası oluşur; sayfa bellekte değilse yedekleme deposundan getirilir ve gerekirse seçilen bir kurban sayfanın yerine yüklenir.
Giriş
Neden Sanal Bellek?
- Programın tamamı nadiren kullanılır: hata işleme kodu, seyrek seçenekler, gereğinden büyük ayrılmış diziler.
- Takas (swapping): sürecin tamamını belleğe getirir/diske götürür; büyük süreçte pahalıdır.
- Sanal bellek: mantıksal belleği fiziksel bellekten ayırır; süreç kısmen bellekteyken çalışır.
- Kazançlar: program fiziksel bellekle sınırlı değildir; süreç başına daha az çerçeve → daha çok süreç; yükleme ve takas için daha az G/Ç; paylaşım kolaylaşır.
- Şişkin (bloat) yazılımı elle parçalara bölmek (eski overlay yöntemi) gerekmez; bunu İS sayfa düzeyinde yapar.
Giriş
Sanal Adres Alanı
- Sürecin bellekteki mantıksal görünümü: 0’dan başlayan bitişik adresler. Fiziksel bellek ise dağınık çerçevelerden oluşur; eşlemeyi MMU yapar.
- Yığın en yüksek kullanıcı adresinden aşağı, heap yukarı büyür; aradaki kullanılmayan alan boşluktur ve sayfa ya da çerçeve harcamaz.
- Yığın/heap yeni bir sayfaya taşınana kadar o sayfa için fiziksel bellek gerekmez (seyrek adres alanı).
- x86-64: 48 bit sanal adres (kullanıcıya 128 TiB); 5 düzeyli sayfalamayla 57 bit. ASLR bölgelerin yerini her çalıştırmada rastgeleler.
- Sanal bellek iki yolla kurulabilir: talebe bağlı sayfalama (bugün evrensel) ve talebe bağlı kesimleme (tarihsel: Burroughs, OS/2).
Linux’ta bir sürecin bölgeleri: cat /proc/self/maps; her satır bir sanal bellek alanıdır (VMA).
Giriş
Paylaşımlı Sayfalar ve Kütüphaneler
- Sanal bellek, sayfaları birden çok süreç arasında paylaştırmayı kolaylaştırır: aynı çerçeve birden çok sayfa tablosunda görünür.
- Paylaşımlı kütüphane (libc, libstdc++): salt okunur kod sayfaları her süreçte kendi adresinde eşlenir, fiziksel kopya bir tanedir.
- Paylaşımlı bellek ile süreçler arası iletişim: iki süreç aynı bölgeyi eşler.
fork()sırasında sayfalar kopyalanmadan paylaşılır (yazınca kopyalama).- Yazılabilir veri sayfaları ise her süreçte özeldir.
Talebe Bağlı Sayfalama
Talebe Bağlı Sayfalama
- Süreç başlarken hiçbir sayfa yüklenmez (ya da çok az sayfa yüklenir); bir sayfa yalnızca erişildiğinde getirilir (tembel yükleme).
- Daha az G/Ç, daha az bellek, daha hızlı başlatma, daha çok kullanıcı.
- Erişimde: adres geçersizse (hiçbir bölgede değilse) süreç sonlandırılır; geçerli ama bellekte değilse sayfa getirilir.
- Bütün süreçle değil tek tek sayfalarla uğraşan birime sayfalayıcı (pager) denir; “tembel takasçı” (lazy swapper) eski ve yanıltıcı bir addır.
- Saf talebe bağlı sayfalamada ilk komut bile sayfa hatasıyla başlar; yerellik sayesinde hata oranı kısa sürede düşer.
Talebe Bağlı Sayfalama
Geçerli–Geçersiz Biti
- Her girdide bir bit: v = geçerli ve bellekte, i = bellekte değil ya da adres alanında değil. İkisini ayırmak İS’nin işidir.
Başlangıçta tablonun tüm girdileri i (geçersiz/bellekte değil) yapılır; hiçbir çerçeve ayrılmamıştır.
CPU sayfa 2’ye erişir; MMU girdide i görür ve sayfa hatası tuzağı üretir.
Çekirdek adresin geçerli bir bölgede (VMA) olduğunu doğrular, sayfayı boş çerçeve 5’e okur, girdiyi 5, v yapar; komut yeniden çalışır.
Aynı sayfaya sonraki erişimler artık doğrudan çevrilir (TLB’ye de yüklenir).
Sayfa 6 hiçbir bölgede değildir: bu bir geçersiz referanstır; çekirdek süreci SIGSEGV ile sonlandırır.
Talebe Bağlı Sayfalama
Sayfa Hatasının İşlenmesi
Süreç M adresine erişir; sayfa tablosunda girdinin biti i.
1. Referans: MMU girdiyi okur, sayfa bellekte değil.
2. Tuzak: donanım çekirdeğe geçer; çekirdek referansın geçerli olduğunu doğrular (değilse süreci sonlandırır).
3. Sayfa yedek depoda: sayfanın diskteki yeri bulunur (takas alanı ya da dosya), boş bir çerçeve seçilir.
4. Getir: disk okuma işi çizelgelenir; sayfa çerçeve 7’ye okunur. Bu sırada CPU başka sürece verilir.
5. Tabloyu güncelle: girdiye çerçeve 7 yazılır, bit v yapılır.
6. Yeniden başlat: hataya yol açan komut baştan çalışır; süreç sayfa hiç eksik değilmiş gibi devam eder.
Silberschatz Şekil 10.5’in yeniden çizimi. Sayfa hatası bir hata (fault) türü tuzaktır: kaydedilen PC hatalı komutu gösterir, böylece komut yeniden çalıştırılabilir. x86’da hatalı adres CR2 yazmacına yazılır. Kirli kurban önce diske yazılır; bu sırada çerçeve meşgul işaretlenir.
Talebe Bağlı Sayfalama · Kodu adım adım çalıştır
Adres Çevirisi ve Sayfa Hatası: Kod İzleme
int ceviri(int va) { int p = va >> 12; /* sayfa no */ int d = va & 0xFFF; /* bağıl konum */ int f = tlb_ara(p); /* -1: ıska */ if (f < 0) { if (!pt[p].gecerli) /* bellekte yok */ sayfa_hatasi(p); /* diskten al */ f = pt[p].cerceve; tlb_ekle(p, f); } pt[p].R = 1; return (f << 12) | d; }
TLB’de sayfa 0 ve 1’in çevirisi var; sayfa 2 bellekte (çerçeve 5) ama TLB’de değil, sayfa 3 diskte. İlk çağrı: ceviri(0x2A10).
Üst bitler sayfa numarası, alt 12 bit bağıl konum: 0x2A10 → p = 2, d = 0xA10 (4 KB sayfa).
TLB’de p = 2 yok: ıska, f = −1. Çeviri için sayfa tablosuna gidilir (bellek erişimi).
Girdi 2’nin biti v: sayfa bellekte, sayfa hatası yok; 7. satır atlanır.
f = 5 tablodan okunur ve (2, 5) TLB’ye eklenir: aynı sayfaya bir sonraki erişim tablo yürümeden çevrilir.
R biti 1 olur (yer değiştirme algoritmaları bunu kullanır); fiziksel adres (5 << 12) | 0xA10 = 0x5A10.
ceviri(0x2B04): p = 2, d = 0xB04. TLB’de isabet, f = 5; sayfa tablosuna hiç gidilmez.
Aynı sayfadaki ikinci erişim: if bloğu atlandı, sonuç 0x5B04. Yerellik sayesinde çoğu erişim bu yolu izler.
ceviri(0x3008): p = 3, d = 0x008. TLB’de yok: ıska, f = −1.
Girdi 3’ün biti i: sayfa hatası. Çekirdek sayfayı diskten boş çerçeve 7’ye okur; süreç bu sırada bekler.
Hata işleyicisi girdiyi (v, 7) yaptı; komut yeniden çalışınca f = 7 okunur ve TLB’ye eklenir.
Sonuç 0x7008. Üç çeviride: 1 TLB isabeti, 2 ıska, bunlardan biri sayfa hatası (disk G/Ç’si).
Talebe Bağlı Sayfalama
Sayfa Hatası: Zaman Çizelgesi
Ders kitabındaki 15 adım üç büyük maliyete ayrılır: tuzağı işlemek (µs), sayfayı okumak (HDD’de ms, NVMe’de 10–100 µs), süreci yeniden başlatmak (µs).
1–5. Çekirdeğe tuzak; yazmaçlar ve süreç durumu kaydedilir; kesmenin sayfa hatası olduğu ve referansın geçerli olduğu belirlenir; sayfanın diskteki yeri bulunur.
6–9. Disk/SSD kuyruğuna okuma isteği konur; aygıt beklenir (HDD’de arama + dönme gecikmesi). Bu arada CPU başka bir sürece (B) verilir.
10–13. G/Ç tamamlandı kesmesi gelir; B’nin durumu kaydedilir, kesmenin diskten geldiği anlaşılır, sayfa tablosu güncellenir, A hazır kuyruğuna alınır.
14–15. A’ya yeniden CPU verilince yazmaçları ve sayfa tablosu yüklenir; yarıda kalan komut baştan çalışır.
Talebe Bağlı Sayfalama
Komutu Yeniden Başlatma ve Hata Türleri
Yeniden başlatma sorunu
- Hata komut getirilirken ya da işlenen okunurken olabilir; çoğu durumda komutu baştan çalıştırmak yeter.
- Zor durum: komut bir kısmını değiştirdikten sonra hata alır. Örn. IBM 360
MVCblok taşıma sayfa sınırını aşar; otomatik artırmalı adresleme yazmacı değiştirmiştir. - Motorola 680x0’da üç sözcüklü
MOVE.L 6(A1),2(A0)işlenen okunurken hata alırsa İS komutun nerede başladığını bilemez; bazı CPU’lar bu yüzden her komuttan önce PC’yi gizli bir yazmaca kopyalar. - Çözümler: komut başlamadan iki ucu da yoklamak; eski değerleri geçici yazmaçlarda tutup geri almak. Modern CPU’larda kesin istisnalar (precise exceptions) bunu donanımda garanti eder.
Hata türleri (Linux)
| Tür | Ne olur? |
|---|---|
| Küçük (minor) | Sayfa zaten bellekte (sayfa önbelleği, paylaşımlı kütüphane, sıfır sayfa, COW): yalnızca tablo güncellenir, G/Ç yok. |
| Büyük (major) | Sayfa diskten/takastan okunmalı: G/Ç ve bekleme var. |
| Geçersiz | Bölge yok ya da izin ihlali: SIGSEGV. |
$ /usr/bin/time -v ./prog | grep -i fault $ ps -o min_flt,maj_flt -p PID $ perf stat -e page-faults,major-faults ./prog
Performans
Etkin Erişim Süresi (EAT)
EAT = (1 − p) × ma + p × sayfa hatası süresi
ma: bellek erişimi (100 ns); hata süresi: tuzak + okuma + yeniden başlatma. p = 0 → hiç hata yok.
EAT = 100(1 − p) + 25.000.000 p = 100 + 24.999.900 p
p = 0,001 → EAT = 25.099,9 ns ≈ 25 µs
Bin erişimde bir hata, belleği yaklaşık 251 kat yavaşlatır.
110 > 100 + 24.999.900 p → p < 4,0 × 10⁻⁷
yani 2,5 milyon erişimde birden az hata
p < 0,0000004: hata oranı son derece düşük tutulmalıdır.
NVMe (100 µs ile), p = 0,001 → EAT ≈ 199,9 ns; %10 için p < 1,0 × 10⁻⁴
zram, p = 0,001 → EAT ≈ 109,9 ns
Hızlı depolama cezayı iki üç büyüklük mertebesi (250–2500 kat) küçültür ama bellek hâlâ yüzlerce kat hızlıdır; bu yüzden yer değiştirme algoritmaları önemini korur.
Silberschatz 10e aynı hesabı 200 ns ve 8 ms ile yapar: p = 0,001 → 8,2 µs (41 kat). zram/zswap: sayfa RAM’de sıkıştırılmış durur, “okuma” bir sıkıştırma çözme işlemidir.
Talebe Bağlı Sayfalama
Sayfalar Nereden Gelir?
- Dosya destekli sayfalar (kod, salt okunur veri,
mmapedilmiş dosya): temizse atılır, gerektiğinde dosyadan yeniden okunur. - Anonim sayfalar (heap, yığın, değiştirilmiş veri): dosyası yoktur; atılmadan önce takas alanına yazılmalıdır.
- Sıfırla-doldur (zero-fill-on-demand): bss ve yeni heap sayfaları ilk erişimde sıfırlanmış bir çerçeveyle karşılanır; eski verinin sızmaması için şarttır.
- İS bir boş çerçeve havuzu tutar; hata anında arama yapmak gerekmez. Havuz azalınca geri kazanım başlar.
- Takas alanı ayrı bölüm ya da dosya olabilir; Linux’ta
swapon --show.
Talebe Bağlı Sayfalama
Yedekleme Deposu (Takas Alanı)
- Statik: süreç başlarken tüm boyu kadar bitişik takas alanı ayrılır; başlangıç adresi süreç tablosunda. Kod, veri ve yığın için ayrı alanlar olabilir; yığın büyüyebilir.
- Dinamik: önceden yer ayrılmaz; sayfa diske çıkarken bir yuva bulunur, adresi sayfa başına disk eşleminde tutulur. Değişmemiş kod sayfaları hiç takas edilmez, çalıştırılabilir dosyadan yeniden okunur.
- Yer: ayrı bir disk/bölüm (Linux takas bölümü) ya da dosya sistemindeki dosya (
swapfile, Windowspagefile.sys).
Yazınca Kopyalama
Yazınca Kopyalama (Copy-on-Write)
fork()ebeveynin bütün sayfalarını kopyalamaz; ebeveyn ve çocuk aynı sayfaları paylaşır, yazılabilir sayfalar iki tarafta da salt okunur + COW işaretlenir.- Biri yazınca koruma hatası oluşur; çekirdek o tek sayfayı kopyalar ve yazana yazılabilir kopyayı eşler.
- Hiç değiştirilmeyen sayfalar (kod, salt okunur veri) sonsuza dek paylaşılır;
fork()+exec()neredeyse bedavaya gelir. - Kopya için çerçeve, sıfırla-doldur havuzundan alınır.
vfork()sayfa tablosunu bile kopyalamaz (ebeveyn bekler); bugünposix_spawn()tercih edilir.
Paylaşılan birim dosya değil sayfadır: yalnızca yazılan sayfa kopyalanır, diğerleri ortak kalır.
Yazınca Kopyalama · Kodu adım adım çalıştır
fork() ve COW: Adım Adım
int x = 1; /* veri: D */ int main(void) { char *b = malloc(4096); /* heap: H */ b[0] = 'a'; pid_t pid = fork(); if (pid == 0) { /* çocuk */ printf("%d\n", x); /* okuma */ x = 2; /* yazma */ _exit(0); } wait(NULL); b[0] = 'b'; /* ebeveyn */ return 0; }
Ebeveyn D (veri) ve H (heap) sayfalarını yazılabilir olarak kullanıyor.
fork(): yalnızca sayfa tabloları kopyalanır; iki taraf da salt okunur (RO), referans sayıları 2.
Çocuk x’i okur: okuma izinli olduğundan hata yok, kopya yok.
Çocuk x = 2 yazar → koruma hatası. Çekirdek COW’u tanır: f3’ü ayırır, D’yi kopyalar, çocuğa RW eşler.
Çocuk çıkar: eşlemeleri kaldırılır, f3 boşa düşer, f2’nin referans sayısı da 1’e iner.
Ebeveyn H’ye yazar → hata; referans sayısı 1 olduğundan kopyalamaya gerek yok, sayfa yalnızca yazılabilir yapılır.
Bellek Eşlemeli Dosyalar
Bellek Eşlemeli Dosyalar
mmap()bir dosyayı adres alanının bir bölgesine eşler; dosyaread()/write()yerine bellek erişimiyle okunup yazılır.- Sayfalar talebe bağlı getirilir; ilk erişim (küçük ya da büyük) sayfa hatası üretir. Kirli sayfalar arka planda ya da
msync()/munmap()ile dosyaya yazılır. MAP_SHARED: değişiklikler dosyaya ve aynı dosyayı eşleyen herkese görünür → paylaşımlı bellek ile IPC.MAP_PRIVATE: yazmalar COW ile özel kopyaya gider, dosya değişmez (çalıştırılabilirlerin veri bölümü böyle yüklenir).MAP_ANONYMOUS: dosyasız bölge (mallocbüyük bloklar). Windows:MapViewOfFile.
Bellek Eşlemeli Dosyalar · Kodu adım adım çalıştır
mmap: Adım Adım
int fd = open("veri.bin", O_RDWR); struct stat st; fstat(fd, &st); /* 12 KiB = 3 sayfa */ char *p = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); close(fd); /* eşleme sürer */ char c = p[0]; /* sayfa 0 */ p[5000] = 'x'; /* sayfa 1 */ msync(p, st.st_size, MS_SYNC); munmap(p, st.st_size);
Dosya açılır ve boyutu öğrenilir: 12 KiB, yani 3 sayfa.
mmap yalnızca bir VMA oluşturur: tablo girdileri boş, henüz hiçbir sayfa okunmadı.
close(fd) eşlemeyi bozmaz; VMA dosyaya kendi referansını tutar.
p[0] → sayfa hatası; blok 0 sayfa önbelleğine okunur (büyük hata), girdi geçerli olur.
p[5000]: 5000 / 4096 → sayfa 1; hata, okuma, yazma → sayfa kirli (M=1).
msync kirli sayfayı dosyaya yazar; M temizlenir. Sayfa 2’ye hiç dokunulmadı, hiç okunmadı.
munmap VMA’yı kaldırır; sayfalar önbellekte kalabilir, başka süreç dosyayı açarsa küçük hata ile kullanır.
Sayfa Yer Değiştirme
Boş Çerçeve Yoksa: Sayfa Yer Değiştirme
- Bellek çoğunlukla doludur (boş RAM boşa harcanmış RAM’dir). Seçenekler: süreci sonlandırmak (kabul edilemez), bütün süreci takaslamak ya da tek bir sayfayı değiştirmek.
Sayfa hatası: istenen sayfa diskte bulundu ama boş çerçeve yok.
1. Yer değiştirme algoritması bir kurban çerçeve seçer.
2. Kurban kirliyse (M = 1) takasa/dosyaya yazılır; temizse yazmaya gerek yok: G/Ç yarıya iner.
3. Kurbanın girdisi i yapılır (ve TLB’den silinir: çok çekirdekte TLB shootdown).
4. İstenen sayfa boşalan çerçeveye okunur.
5. Yeni girdi v yapılır; tuzağa yol açan komut yeniden başlatılır.
İki karar var: çerçeve tahsisi (sürece kaç çerçeve?) ve yer değiştirme (hangi sayfa çıkar?). Amaç: en az sayfa hatası; aynı sayfanın tekrar tekrar gidip gelmesini önlemek.
Sayfa Yer Değiştirme
Algoritmaları Değerlendirmek
- Algoritma bir referans dizisi (yalnızca sayfa numaraları) üzerinde çalıştırılır, sayfa hatası sayılır.
- Adres izinden elde edilir; ardışık aynı sayfalar tek sayılır. 100 baytlık sayfalarla
0100 0432 0101 0612 0102 …→1 4 1 6 1 6 1 6 1 6 1. - Bu bölümün ortak dizisi (Silberschatz), 3 çerçeve:
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
- Beklenen: çerçeve sayısı arttıkça hata azalır; ilk yüklemeler (burada 6 farklı sayfa: 7, 0, 1, 2, 3, 4) kaçınılmazdır.
- Algoritmalar: OPT, FIFO, LRU, ikinci şans, saat, NRU, NFU/yaşlandırma, çalışma kümesi, WSClock.
Sayfa Yer Değiştirme · Adım adım
FIFO: İlk Giren İlk Çıkar
- Sayfalar yüklenme sırasına göre bir kuyrukta tutulur; en son yüklenen sondadır.
- Yer gerekince kuyruğun başındaki en eski sayfa çıkar.
- Uygulaması kolay, bit gerektirmez.
- Kullanımı hiç dikkate almaz: en eski sayfa en yoğun kullanılan sayfa olabilir.
1. referans 7: hata; boş çerçeve 0’a yüklenir. Hata: 1
2. referans 0: hata; boş çerçeve 1’e yüklenir. Hata: 2
3. referans 1: hata; boş çerçeve 2’ye yüklenir. Hata: 3
4. referans 2: hata; kuyruğun başındaki en eski sayfa 7 çıkar, 2 sona girer. Hata: 4
5. referans 0: bellekte → isabet; FIFO sırası değişmez.
6. referans 3: hata; kuyruğun başındaki en eski sayfa 0 çıkar, 3 sona girer. Hata: 5
7. referans 0: hata; kuyruğun başındaki en eski sayfa 1 çıkar, 0 sona girer. Hata: 6
8. referans 4: hata; kuyruğun başındaki en eski sayfa 2 çıkar, 4 sona girer. Hata: 7
9. referans 2: hata; kuyruğun başındaki en eski sayfa 3 çıkar, 2 sona girer. Hata: 8
10. referans 3: hata; kuyruğun başındaki en eski sayfa 0 çıkar, 3 sona girer. Hata: 9
11. referans 0: hata; kuyruğun başındaki en eski sayfa 4 çıkar, 0 sona girer. Hata: 10
12. referans 3: bellekte → isabet; FIFO sırası değişmez.
13. referans 2: bellekte → isabet; FIFO sırası değişmez.
14. referans 1: hata; kuyruğun başındaki en eski sayfa 2 çıkar, 1 sona girer. Hata: 11
15. referans 2: hata; kuyruğun başındaki en eski sayfa 3 çıkar, 2 sona girer. Hata: 12
16. referans 0: bellekte → isabet; FIFO sırası değişmez.
17. referans 1: bellekte → isabet; FIFO sırası değişmez.
18. referans 7: hata; kuyruğun başındaki en eski sayfa 0 çıkar, 7 sona girer. Hata: 13
19. referans 0: hata; kuyruğun başındaki en eski sayfa 1 çıkar, 0 sona girer. Hata: 14
20. referans 1: hata; kuyruğun başındaki en eski sayfa 2 çıkar, 1 sona girer. Hata: 15 Toplam 15 hata (3 ilk yükleme + 12 yer değiştirme).
Kırmızı hücre: hatayla yüklenen sayfa · yeşil: isabet · kırmızı nokta: sayfa hatası. FIFO erişimi değil yüklenmeyi izler: listenin sonunda en son yüklenen sayfa durur.
Sayfa Yer Değiştirme · Adım adım
Belady Anomalisi
Daha çok çerçeve daha az hata getirmeli… FIFO’da her zaman değil. Dizi: 1 2 3 4 1 2 5 1 2 3 4 5
1. referans 1 — 3 çerçeve: hata · 4 çerçeve: hata.
2. referans 2 — 3 çerçeve: hata · 4 çerçeve: hata.
3. referans 3 — 3 çerçeve: hata · 4 çerçeve: hata.
4. referans 4 — 3 çerçeve: hata (1 çıkar) · 4 çerçeve: hata.
5. referans 1 — 3 çerçeve: hata (2 çıkar) · 4 çerçeve: isabet.
6. referans 2 — 3 çerçeve: hata (3 çıkar) · 4 çerçeve: isabet.
7. referans 5 — 3 çerçeve: hata (4 çıkar) · 4 çerçeve: hata (1 çıkar).
8. referans 1 — 3 çerçeve: isabet · 4 çerçeve: hata (2 çıkar).
9. referans 2 — 3 çerçeve: isabet · 4 çerçeve: hata (3 çıkar).
10. referans 3 — 3 çerçeve: hata (1 çıkar) · 4 çerçeve: hata (4 çıkar).
11. referans 4 — 3 çerçeve: hata (2 çıkar) · 4 çerçeve: hata (5 çıkar).
12. referans 5 — 3 çerçeve: isabet · 4 çerçeve: hata (1 çıkar). Sonuç: 9 < 10.
Yığın algoritmaları (OPT, LRU): n çerçevedeki sayfa kümesi her zaman n+1 çerçevedekinin alt kümesidir → anomali olamaz.
Sayfa Yer Değiştirme · Adım adım
OPT: En Uzun Süre Kullanılmayacak Olan
- Gelecekte en geç kullanılacak (ya da hiç kullanılmayacak) sayfa çıkar (Belady, 1966).
- Tanımı kolay, uygulanması imkânsız: İS geleceği bilemez (kristal küre).
- Bir alt sınırdır: diğer algoritmaları kıyaslamak için kullanılır.
- Gerçek sistemde ancak bir izi iki kez çalıştırarak hesaplanabilir.
1. referans 7: hata; boş çerçeve 0’a yüklenir. Hata: 1
2. referans 0: hata; boş çerçeve 1’e yüklenir. Hata: 2
3. referans 1: hata; boş çerçeve 2’ye yüklenir. Hata: 3
4. referans 2: hata; sonraki kullanımlar (7→18, 0→5, 1→14); en uzağa kalan 7 çıkar. Hata: 4
5. referans 0: bellekte → isabet.
6. referans 3: hata; sonraki kullanımlar (2→9, 0→7, 1→14); en uzağa kalan 1 çıkar. Hata: 5
7. referans 0: bellekte → isabet.
8. referans 4: hata; sonraki kullanımlar (2→9, 0→11, 3→10); en uzağa kalan 0 çıkar. Hata: 6
9. referans 2: bellekte → isabet.
10. referans 3: bellekte → isabet.
11. referans 0: hata; sonraki kullanımlar (2→13, 4→yok, 3→12); en uzağa kalan 4 çıkar. Hata: 7
12. referans 3: bellekte → isabet.
13. referans 2: bellekte → isabet.
14. referans 1: hata; sonraki kullanımlar (2→15, 0→16, 3→yok); en uzağa kalan 3 çıkar. Hata: 8
15. referans 2: bellekte → isabet.
16. referans 0: bellekte → isabet.
17. referans 1: bellekte → isabet.
18. referans 7: hata; sonraki kullanımlar (2→yok, 0→19, 1→20); en uzağa kalan 2 çıkar. Hata: 9
19. referans 0: bellekte → isabet.
20. referans 1: bellekte → isabet. Toplam 9 hata (6 yer değiştirme): bu dizi ve 3 çerçeve için alt sınır.
Sayfa Yer Değiştirme · Adım adım
LRU: En Uzun Süredir Kullanılmayan
- Geçmişe bakan OPT: yakın geçmişte kullanılmayan sayfa yakın gelecekte de kullanılmayacaktır (yerellik).
- En uzun süredir kullanılmayan (least recently used) sayfa çıkar.
- İyi sonuç verir ama her erişimde kayıt güncellenmelidir: donanım desteği olmadan pahalı.
- En son kullanılanı atan algoritma MRU’dur; LRU en eski kullanılanı atar.
1. referans 7: hata; boş çerçeve 0’a yüklenir. Hata: 1
2. referans 0: hata; boş çerçeve 1’e yüklenir. Hata: 2
3. referans 1: hata; boş çerçeve 2’ye yüklenir. Hata: 3
4. referans 2: hata; en uzun süredir kullanılmayan 7 çıkar. Hata: 4
5. referans 0: bellekte → isabet; 0 en yeni olur.
6. referans 3: hata; en uzun süredir kullanılmayan 1 çıkar. Hata: 5
7. referans 0: bellekte → isabet; 0 en yeni olur.
8. referans 4: hata; en uzun süredir kullanılmayan 2 çıkar. Hata: 6
9. referans 2: hata; en uzun süredir kullanılmayan 3 çıkar. Hata: 7
10. referans 3: hata; en uzun süredir kullanılmayan 0 çıkar. Hata: 8
11. referans 0: hata; en uzun süredir kullanılmayan 4 çıkar. Hata: 9
12. referans 3: bellekte → isabet; 3 en yeni olur.
13. referans 2: bellekte → isabet; 2 en yeni olur.
14. referans 1: hata; en uzun süredir kullanılmayan 0 çıkar. Hata: 10
15. referans 2: bellekte → isabet; 2 en yeni olur.
16. referans 0: hata; en uzun süredir kullanılmayan 3 çıkar. Hata: 11
17. referans 1: bellekte → isabet; 1 en yeni olur.
18. referans 7: hata; en uzun süredir kullanılmayan 2 çıkar. Hata: 12
19. referans 0: bellekte → isabet; 0 en yeni olur.
20. referans 1: bellekte → isabet; 1 en yeni olur. Toplam 12 hata (9 yer değiştirme): FIFO’dan iyi, OPT’den kötü.
Sayfa Yer Değiştirme · Adım adım
LRU’yu Gerçekleştirmek: Sayaç ve Yığın
- Sayaç (zaman damgası): CPU’da bir mantıksal saat; her erişimde sayfanın girdisine saat değeri yazılır. Kurban: en küçük damga → her hatada tüm tabloyu tarama.
- Her bellek erişiminde tabloya bir yazma demektir; donanım desteği şarttır.
- Yığın: sayfa numaraları bir yığında; erişilen sayfa tepeye taşınır, kurban en alttakidir.
- Güncelleme pahalı, seçim ucuz. İkisi de bugün donanımda yoktur; pratikte yaklaşımlar kullanılır.
4 yığında yoktu: tepeye itilir (push).
7 yığında yoktu: tepeye itilir (push).
0 yığında yoktu: tepeye itilir (push).
7 yığında vardı: ortadan çıkarılıp tepeye konur.
1 yığında yoktu: tepeye itilir (push).
0 yığında vardı: ortadan çıkarılıp tepeye konur.
1 yığında vardı: ortadan çıkarılıp tepeye konur.
2 yığında yoktu: tepeye itilir (push).
1 yığında vardı: ortadan çıkarılıp tepeye konur.
2 yığında vardı: ortadan çıkarılıp tepeye konur.
7 yığında vardı: ortadan çıkarılıp tepeye konur.
1 yığında vardı: ortadan çıkarılıp tepeye konur.
2 yığında vardı: ortadan çıkarılıp tepeye konur. En altta 4 var: bir yer değiştirmede o çıkar.
Sayfa Yer Değiştirme · Adım adım
LRU’yu Gerçekleştirmek: Matris Yöntemi
Tanenbaum’un donanım çözümü: 4 çerçeve, erişim sırası 0 1 2 3 2 1 0 3 2 3. Satırın ikili değeri ne kadar büyükse sayfa o kadar yakın zamanda kullanılmıştır.
Sayfa 0: 0. satır 1, 0. sütun 0 yapılır. Satır değerleri 7, 0, 0, 0 → LRU: 1.
Sayfa 1: 1. satır 1, 1. sütun 0 yapılır. Satır değerleri 3, 11, 0, 0 → LRU: 2.
Sayfa 2: 2. satır 1, 2. sütun 0 yapılır. Satır değerleri 1, 9, 13, 0 → LRU: 3.
Sayfa 3: 3. satır 1, 3. sütun 0 yapılır. Satır değerleri 0, 8, 12, 14 → LRU: 0.
Sayfa 2: 2. satır 1, 2. sütun 0 yapılır. Satır değerleri 0, 8, 13, 12 → LRU: 0.
Sayfa 1: 1. satır 1, 1. sütun 0 yapılır. Satır değerleri 0, 11, 9, 8 → LRU: 0.
Sayfa 0: 0. satır 1, 0. sütun 0 yapılır. Satır değerleri 7, 3, 1, 0 → LRU: 3.
Sayfa 3: 3. satır 1, 3. sütun 0 yapılır. Satır değerleri 6, 2, 0, 14 → LRU: 2.
Sayfa 2: 2. satır 1, 2. sütun 0 yapılır. Satır değerleri 4, 0, 13, 12 → LRU: 1.
Sayfa 3: 3. satır 1, 3. sütun 0 yapılır. Satır değerleri 4, 0, 12, 14 → LRU: 1.
Sayfa Yer Değiştirme · Adım adım
İkinci Şans (Second Chance)
- FIFO’nun iyileştirilmiş hâli: baştaki sayfanın R (referans) bitine bakılır.
- R = 0 → sayfa eski ve kullanılmamış: hemen atılır.
- R = 1 → R temizlenir, sayfa sona taşınır (ikinci şans) ve arama sürer.
- Sorun: sayfaları liste içinde sürekli taşımak gereksiz iştir → saat algoritması.
Sayfalar FIFO sırasında; zaman 20’de sayfa hatası oluşur ve yer gerekir.
Baştaki A’nın R biti 1: yakın zamanda kullanılmış. Atmak yerine ikinci şans verilir.
A’nın R’si 0 yapılır ve yeni yüklenmiş gibi sona taşınır (zaman 20).
Yeni baş B: R = 0 → hem eski hem kullanılmamış: kurban.
B atılır, yeni sayfa I sona eklenir. Tüm R’ler 1 olsaydı liste bir tur dönüp saf FIFO gibi davranırdı.
Tanenbaum MOS Şekil 3-15 (yeniden çizim).
Sayfa Yer Değiştirme · Adım adım
Saat (Clock) Algoritması
- İkinci şansla aynı karar, farklı yapı: çerçeveler dairesel listede durur, bir el (işaretçi) en eski sayfayı gösterir; sayfa taşınmaz.
- Yüklenen ya da erişilen sayfanın R’si 1 olur. El yalnızca hata anında döner.
- El sayfa tablosunda değil, çerçeve listesinde döner.
1. referans 7: hata; boş çerçeve 0’a yüklenir. Hata: 1
2. referans 0: hata; boş çerçeve 1’e yüklenir. Hata: 2
3. referans 1: hata; boş çerçeve 2’ye yüklenir. Hata: 3
4. referans 2: hata; R=1 olan 7, 0, 1 için R ← 0 ve el ilerler; elin gösterdiği 7’nin R’si 0 → çıkar. Hata: 4
5. referans 0: bellekte → isabet; donanım R ← 1 yapar, el hareket etmez.
6. referans 3: hata; R=1 olan 0 için R ← 0 ve el ilerler; elin gösterdiği 1’in R’si 0 → çıkar. Hata: 5
7. referans 0: bellekte → isabet; donanım R ← 1 yapar, el hareket etmez.
8. referans 4: hata; R=1 olan 2, 0, 3 için R ← 0 ve el ilerler; elin gösterdiği 2’nin R’si 0 → çıkar. Hata: 6
9. referans 2: hata; elin gösterdiği 0’ın R’si 0 → çıkar. Hata: 7
10. referans 3: bellekte → isabet; donanım R ← 1 yapar, el hareket etmez.
11. referans 0: hata; R=1 olan 3, 4, 2 için R ← 0 ve el ilerler; elin gösterdiği 3’ün R’si 0 → çıkar. Hata: 8
12. referans 3: hata; elin gösterdiği 4’ün R’si 0 → çıkar. Hata: 9
13. referans 2: bellekte → isabet; donanım R ← 1 yapar, el hareket etmez.
14. referans 1: hata; R=1 olan 2, 0, 3 için R ← 0 ve el ilerler; elin gösterdiği 2’nin R’si 0 → çıkar. Hata: 10
15. referans 2: hata; elin gösterdiği 0’ın R’si 0 → çıkar. Hata: 11
16. referans 0: hata; elin gösterdiği 3’ün R’si 0 → çıkar. Hata: 12
17. referans 1: bellekte → isabet; donanım R ← 1 yapar, el hareket etmez.
18. referans 7: hata; R=1 olan 1, 2, 0 için R ← 0 ve el ilerler; elin gösterdiği 1’in R’si 0 → çıkar. Hata: 13
19. referans 0: bellekte → isabet; donanım R ← 1 yapar, el hareket etmez.
20. referans 1: hata; elin gösterdiği 2’nin R’si 0 → çıkar. Hata: 14 Toplam 14 hata: FIFO’dan (15) bir az, LRU’dan (12) çok.
Sayfa Yer Değiştirme · Kodu adım adım çalıştır
Saat Algoritması: Kod İzleme
int kurban_sec(void) { while (cer[el].R == 1) { /* 2. şans */ cer[el].R = 0; el = (el + 1) % N; } int k = el; /* kurban */ el = (el + 1) % N; return k; } void hata(int p) { int k = kurban_sec(); if (cer[k].M) diske_yaz(k); /* kirli */ cer[k].sayfa = p; cer[k].R = 1; cer[k].M = 0; }
Dört çerçeve dolu, el çerçeve 2’de. Sayfa 9 için hata oluştu: hata(9) bir kurban arar.
Çerçeve 2’de s5’in R’si 1: yakın zamanda kullanılmış. R ← 0 (ikinci şans) ve el 3’e ilerler.
Çerçeve 3’te s6’nın R’si 1: yakın zamanda kullanılmış. R ← 0 (ikinci şans) ve el 0’a ilerler.
Çerçeve 0’da s3’ün R’si 1: yakın zamanda kullanılmış. R ← 0 (ikinci şans) ve el 1’e ilerler.
Çerçeve 1’de R = 0: döngü biter. k = 1 kurbandır; el bir sonraki çerçeveye (2) geçer.
s8’in M (kirli) biti 1: bellekteki kopya diskte yok. Atılmadan önce diske yazılır (ek G/Ç).
s9 çerçeve 1’e yüklenir: R = 1, M = 0. Tam bir tur dönüldü; üç sayfanın R’si artık 0.
hata(4): el çerçeve 2’de ve R = 0 (önceki turda sıfırlandı, o zamandan beri kullanılmadı). Kurban hemen bulunur: k = 2.
s5 temiz (M = 0): diskteki kopya güncel, yazmaya gerek yok. Temiz kurban daha ucuzdur.
s4 çerçeve 2’ye yüklendi. İki hatada 3 R biti sıfırlandı, 1 disk yazması yapıldı; el çerçeve 3’te bekliyor.
Sayfa Yer Değiştirme · Adım adım
NRU: Yakın Zamanda Kullanılmayan
- Her sayfada R (erişildi) ve M (değişti) biti; saat kesmesi R’leri periyodik temizler.
- Sınıflar: 0 = (0,0), 1 = (0,1), 2 = (1,0), 3 = (1,1). En düşük boş olmayan sınıftan bir sayfa atılır (eşitlikte burada en eski yüklenen).
- Sınıf 1 mümkündür: değişmiş sayfanın R’si tıkla silinmiştir.
- LRU vs NRU: LRU tam kullanım sırasını izler; NRU yalnızca son saat aralığında kullanıldı mı ve kirli mi diye bakar: kaba ama ucuz.
1. referans 7: hata; boş çerçeve 0’a yüklenir. Hata: 1
2. referans 0*: hata; boş çerçeve 1’e yüklenir. Hata: 2
3. referans 1: hata; boş çerçeve 2’ye yüklenir. Hata: 3
4. referans 2: hata; sınıflar (7→2, 0→3, 1→2); en düşük sınıftan 7 çıkar. Hata: 4 Saat tıkı: tüm R ← 0.
5. referans 0: isabet; R ← 1.
6. referans 3*: hata; sınıflar (2→0, 0→3, 1→0); en düşük sınıftan 1 çıkar. Hata: 5
7. referans 0: isabet; R ← 1.
8. referans 4: hata; sınıflar (2→0, 0→3, 3→3); en düşük sınıftan 2 çıkar. Hata: 6 Saat tıkı: tüm R ← 0.
9. referans 2*: hata; sınıflar (4→0, 0→1, 3→1); en düşük sınıftan 4 çıkar. Hata: 7
10. referans 3: isabet; R ← 1.
11. referans 0: isabet; R ← 1.
12. referans 3: isabet; R ← 1. Saat tıkı: tüm R ← 0.
13. referans 2: isabet; R ← 1.
14. referans 1: hata; sınıflar (2→3, 0→1, 3→1); en düşük sınıftan 0 çıkar (kirli → önce diske yazılır). Hata: 8
15. referans 2*: isabet; R ← 1, yazma → M ← 1.
16. referans 0: hata; sınıflar (2→3, 1→2, 3→1); en düşük sınıftan 3 çıkar (kirli → önce diske yazılır). Hata: 9 Saat tıkı: tüm R ← 0.
17. referans 1: isabet; R ← 1.
18. referans 7: hata; sınıflar (2→1, 1→2, 0→0); en düşük sınıftan 0 çıkar. Hata: 10
19. referans 0: hata; sınıflar (2→1, 1→2, 7→2); en düşük sınıftan 2 çıkar (kirli → önce diske yazılır). Hata: 11
20. referans 1: isabet; R ← 1. Saat tıkı: tüm R ← 0. Toplam 11 hata, 3 kirli sayfa yazımı.
* yazma erişimi · alt satırdaki küçük sayılar: R M · tık her 4 referansta bir.
Sayfa Yer Değiştirme · Adım adım
Geliştirilmiş Saat: (R, M) Sınıfları
- Saat, R ile birlikte M’ye de bakar; temiz sayfayı atmak G/Ç gerektirmez.
- Tur 1: elden başlayarak (0,0) aranır, bitlere dokunulmaz.
- Tur 2: (0,1) aranır; el geçtiği her sayfanın R’sini 0 yapar. Bulunamazsa tur 1’e dönülür (artık hepsi R = 0).
- Eski macOS ve Silberschatz’ın “enhanced second chance” algoritması.
1. referans 7: hata; boş çerçeve 0’a yüklenir. Hata: 1
2. referans 0*: hata; boş çerçeve 1’e yüklenir. Hata: 2
3. referans 1: hata; boş çerçeve 2’ye yüklenir. Hata: 3
4. referans 2: hata; tarama (2 tur) en düşük sınıftaki 7’yi seçer. Hata: 4
5. referans 0: isabet; R ← 1.
6. referans 3*: hata; tarama (1 tur) en düşük sınıftaki 1’i seçer. Hata: 5
7. referans 0: isabet; R ← 1.
8. referans 4: hata; tarama (2 tur) en düşük sınıftaki 2’yi seçer. Hata: 6
9. referans 2*: hata; tarama (1 tur) en düşük sınıftaki 0’ı seçer; kirli olduğu için önce diske yazılır. Hata: 7
10. referans 3: isabet; R ← 1.
11. referans 0: hata; tarama (2 tur) en düşük sınıftaki 4’ü seçer. Hata: 8
12. referans 3: isabet; R ← 1.
13. referans 2: isabet; R ← 1.
14. referans 1: hata; tarama (2 tur) en düşük sınıftaki 0’ı seçer. Hata: 9
15. referans 2*: isabet; R ← 1, yazma → M ← 1.
16. referans 0: hata; tarama (1 tur) en düşük sınıftaki 3’ü seçer; kirli olduğu için önce diske yazılır. Hata: 10
17. referans 1: isabet; R ← 1.
18. referans 7: hata; tarama (1 tur) en düşük sınıftaki 2’yi seçer; kirli olduğu için önce diske yazılır. Hata: 11
19. referans 0: isabet; R ← 1.
20. referans 1: isabet; R ← 1. Toplam 11 hata, 3 kirli yazım.
* yazma erişimi · küçük sayılar: R M. NRU ile aynı dizi; burada R yalnızca el geçerken temizlenir, saat tıkı yoktur.
Sayfa Yer Değiştirme · Adım adım
NFU ve Yaşlandırma (Aging)
- NFU (not frequently used): her sayfaya bir yazılım sayacı; her tıkta sayaç += R. En küçük sayaçlı atılır.
- NFU hiç unutmaz: eskiden çok kullanılan sayfa sonsuza dek kalır. Erişim zamanı kaydedilmez, yalnızca sayaç tutulur.
- Yaşlandırma: önce sağa kaydır, sonra R’yi en sola ekle → yakın geçmiş daha ağır basar.
- LRU’ya iyi yaklaşır; farklar: tık içindeki sıra bilinmez, 8 bit yalnızca 8 tık hatırlar.
Tık 0: R bitleri 1 0 1 0 1 1 sola eklendi.
Tık 1: R bitleri 1 1 0 0 1 0 sola eklendi.
Tık 2: R bitleri 1 1 0 1 0 1 sola eklendi.
Tık 3: R bitleri 1 0 0 0 1 0 sola eklendi.
Tık 4: R bitleri 0 1 1 0 0 0 sola eklendi. Şimdi bir hata olsa sayaç değeri en küçük olan sayfa 3 atılır.
Tanenbaum MOS Şekil 3-17; sayaç değerleri R bitlerinden yeniden hesaplandı.
Sayfa Yer Değiştirme · Adım adım
Yaşlandırma: Ortak Dizide
Aynı dizi, 3 çerçeve, her 4 referansta bir saat tıkı. Yeni yüklenen sayfanın sayacı 0, R’si 1’dir; karşılaştırmada bu aralığın R biti en anlamlı bit sayılır (yoksa yeni sayfa hemen atılırdı).
1. referans 7: hata; boş çerçeve 0’a yüklenir. Hata: 1
2. referans 0: hata; boş çerçeve 1’e yüklenir. Hata: 2
3. referans 1: hata; boş çerçeve 2’ye yüklenir. Hata: 3
4. referans 2: hata; R ve sayaç birlikte (R en anlamlı bit): 7: 100000000, 0: 100000000, 1: 100000000 → en küçük 7 çıkar. Hata: 4 Tık: sayaçlar kaydırıldı, R’ler sola eklendi.
5. referans 0: isabet; R ← 1.
6. referans 3: hata; R ve sayaç birlikte (R en anlamlı bit): 2: 010000000, 0: 110000000, 1: 010000000 → en küçük 1 çıkar. Hata: 5
7. referans 0: isabet; R ← 1.
8. referans 4: hata; R ve sayaç birlikte (R en anlamlı bit): 2: 010000000, 0: 110000000, 3: 100000000 → en küçük 2 çıkar. Hata: 6 Tık: sayaçlar kaydırıldı, R’ler sola eklendi.
9. referans 2: hata; R ve sayaç birlikte (R en anlamlı bit): 4: 010000000, 0: 011000000, 3: 010000000 → en küçük 3 çıkar. Hata: 7
10. referans 3: hata; R ve sayaç birlikte (R en anlamlı bit): 4: 010000000, 0: 011000000, 2: 100000000 → en küçük 4 çıkar. Hata: 8
11. referans 0: isabet; R ← 1.
12. referans 3: isabet; R ← 1. Tık: sayaçlar kaydırıldı, R’ler sola eklendi.
13. referans 2: isabet; R ← 1.
14. referans 1: hata; R ve sayaç birlikte (R en anlamlı bit): 3: 010000000, 0: 011100000, 2: 110000000 → en küçük 3 çıkar. Hata: 9
15. referans 2: isabet; R ← 1.
16. referans 0: isabet; R ← 1. Tık: sayaçlar kaydırıldı, R’ler sola eklendi.
17. referans 1: isabet; R ← 1.
18. referans 7: hata; R ve sayaç birlikte (R en anlamlı bit): 1: 110000000, 0: 011110000, 2: 011000000 → en küçük 2 çıkar. Hata: 10
19. referans 0: isabet; R ← 1.
20. referans 1: isabet; R ← 1. Tık: sayaçlar kaydırıldı, R’ler sola eklendi. Toplam 10 hata.
Kesikli çizgi: saat tıkı. Tek bir kısa dizi algoritmaları sıralamaya yetmez; tık sıklığı ve eşitlik kuralı sonucu değiştirir.
Çalışma Kümesi · Adım adım
Çalışma Kümesi Modeli
- Yerellik: süreç bir süre küçük bir sayfa grubunu kullanır, sonra başka gruba geçer.
- Çalışma kümesi WS(t, Δ): son Δ bellek referansında kullanılan sayfaların kümesi (Denning, 1968).
- Δ küçükse yerellik kaçırılır, büyükse birkaç yerellik üst üste biner; Δ = ∞ tüm program.
- Çalışma kümesi bellekteyse az hata olur; değilse thrashing.
t = 10: pencere 1–10. referanslar; çalışma kümesi {1, 2, 5, 6, 7}, boyut 5. (Silberschatz’taki t1)
t = 14: pencere 5–14. referanslar; çalışma kümesi {1, 2, 3, 4, 5, 6, 7}, boyut 7.
t = 18: pencere 9–18. referanslar; çalışma kümesi {1, 2, 3, 4, 5, 6}, boyut 6.
t = 22: pencere 13–22. referanslar; çalışma kümesi {1, 2, 3, 4}, boyut 4.
t = 26: pencere 17–26. referanslar; çalışma kümesi {3, 4}, boyut 2. (t2): süreç yeni bir yerelliğe geçti.
t = 30: pencere 21–30. referanslar; çalışma kümesi {1, 2, 3, 4}, boyut 4.
t = 37: pencere 28–37. referanslar; çalışma kümesi {2, 3, 4}, boyut 3.
Çalışma Kümesi · Adım adım
Çalışma Kümesi Algoritması
- Kesin tanım (son Δ referans) her erişimde kaydırılan bir yazmaç ister: çok pahalı. Yaklaşım: son τ sanal zaman içinde kullanılan sayfalar.
Her girdide son kullanım zamanı ve R biti. Zaman sanal zamandır: sürecin kendi CPU süresi (tıklarla ölçülür). τ = 500 alalım.
Sayfa hatasında tablo taranır: R = 1 olan sayfalar bu tıkta kullanılmış → zamanları 2204 yapılır, R’leri temizlenir.
R = 0 olanların yaşı hesaplanır: 2204 − 1213 = 991 ve 2204 − 1620 = 584; ikisi de τ’dan büyük → çalışma kümesinde değiller.
Bulunan ilk uygun sayfa (1213) çıkarılır; tarama diğer girdileri güncelleyerek sürer. Hepsi kümedeyse en eski R = 0 sayfa, o da yoksa rastgele (tercihen temiz) bir sayfa seçilir.
Tanenbaum MOS Şekil 3-20 (yeniden çizim). Dezavantaj: her hatada tüm tabloyu taramak.
Çalışma Kümesi · Adım adım
WSClock
- Çalışma kümesi fikri + saatin dairesel listesi (Carr ve Hennessy, 1981): tüm tabloyu taramak gerekmez.
- Kirli eski sayfa hemen atılmaz: yazması çizelgelenir, el temiz bir sayfa arar.
- El tam tur atarsa: en az bir yazma çizelgelendiyse, ilk temizlenen sayfaya kadar döner.
- Hiç yazma yoksa tüm sayfalar kümededir: herhangi bir temiz sayfa; o da yoksa elin altındaki sayfa yazılıp atılır.
Sayfa hatası: el 2014 zamanlı sayfada; R = 1 → bu tıkta kullanılmış, iyi bir kurban değil.
R ← 0, zamanı 2204 yapılır, el ilerler. Sıradaki sayfa: zaman 1213, R = 0.
Yaş = 2204 − 1213 = 991 > τ: çalışma kümesinde değil. Temizse kurban; kirli olsaydı yazması çizelgelenir ve el ilerlerdi.
Yeni sayfa bu çerçeveye yüklenir: zaman 2204, R = 1. El bir sonraki çerçeveye geçer.
Tanenbaum MOS Şekil 3-21 (yeniden çizim). Basit, verimli ve pratikte yaygın bir tasarım.
Çalışma Kümesi · Adım adım
WSClock: Ortak Dizide
Sanal zaman = referans numarası, τ = 4. Dizi ve yazmalar (*) NRU ile aynı. Yazma çizelgelenen sayfa, tur sonunda temizlenmiş kabul edilir.
1. referans 7: hata; boş çerçeve 0’a yüklenir. Hata: 1
2. referans 0*: hata; boş çerçeve 1’e yüklenir. Hata: 2
3. referans 1: hata; boş çerçeve 2’ye yüklenir. Hata: 3
4. referans 2: hata; el taraması: 7: R=1 → R=0, zaman=4; 0: R=1 → R=0, zaman=4; 1: R=1 → R=0, zaman=4; tur bitti, yazma yok: ilk temiz sayfa 7 → kurban. Hata: 4
5. referans 0: isabet; R ← 1.
6. referans 3*: hata; el taraması: 0: R=1 → R=0, zaman=6; 1: R=0, yaş 2 ≤ τ → çalışma kümesinde; 2: R=1 → R=0, zaman=6; tur bitti, yazma yok: ilk temiz sayfa 1 → kurban. Hata: 5
7. referans 0: isabet; R ← 1.
8. referans 4: hata; el taraması: 2: R=0, yaş 2 ≤ τ → çalışma kümesinde; 0: R=1 → R=0, zaman=8; 3: R=1 → R=0, zaman=8; tur bitti, yazma yok: ilk temiz sayfa 2 → kurban. Hata: 6
9. referans 2*: hata; el taraması: 0: R=0, yaş 1 ≤ τ → çalışma kümesinde; 3: R=0, yaş 1 ≤ τ → çalışma kümesinde; 4: R=1 → R=0, zaman=9; tur bitti, yazma yok: ilk temiz sayfa 4 → kurban. Hata: 7
10. referans 3: isabet; R ← 1.
11. referans 0: isabet; R ← 1.
12. referans 3: isabet; R ← 1.
13. referans 2: isabet; R ← 1.
14. referans 1: hata; el taraması: 0: R=1 → R=0, zaman=14; 3: R=1 → R=0, zaman=14; 2: R=1 → R=0, zaman=14; tur bitti, temiz yok: 0 yazılıp atılır. Hata: 8
15. referans 2*: isabet; R ← 1, yazma → M ← 1.
16. referans 0: hata; el taraması: 3: R=0, yaş 2 ≤ τ → çalışma kümesinde; 2: R=1 → R=0, zaman=16; 1: R=1 → R=0, zaman=16; tur bitti, yazma yok: ilk temiz sayfa 1 → kurban. Hata: 9
17. referans 1: hata; el taraması: 3: R=0, yaş 3 ≤ τ → çalışma kümesinde; 2: R=0, yaş 1 ≤ τ → çalışma kümesinde; 0: R=1 → R=0, zaman=17; tur bitti, yazma yok: ilk temiz sayfa 0 → kurban. Hata: 10
18. referans 7: hata; el taraması: 3: R=0, yaş 4 ≤ τ → çalışma kümesinde; 2: R=0, yaş 2 ≤ τ → çalışma kümesinde; 1: R=1 → R=0, zaman=18; tur bitti, yazma yok: ilk temiz sayfa 1 → kurban. Hata: 11
19. referans 0: hata; el taraması: 3: R=0, yaş 5 > τ, kirli → yazma çizelgelendi; 2: R=0, yaş 3 ≤ τ → çalışma kümesinde; 7: R=1 → R=0, zaman=19; tur bitti: yazılan 3 artık temiz → kurban. Hata: 12
20. referans 1: hata; el taraması: 2: R=0, yaş 4 ≤ τ → çalışma kümesinde; 7: R=0, yaş 1 ≤ τ → çalışma kümesinde; 0: R=1 → R=0, zaman=20; tur bitti, yazma yok: ilk temiz sayfa 7 → kurban. Hata: 13 Toplam 13 hata, 2 kirli yazım. Yalnızca 3 çerçeve ve kısa bir dizide çalışma kümesi fikri avantaj sağlamaz.
Sayfa Yer Değiştirme
Algoritmaların Karşılaştırması
| Algoritma | Yorum |
|---|---|
| OPT | Uygulanamaz; kıyaslama için alt sınır. |
| NRU | LRU’ya çok kaba yaklaşım; ucuz. |
| FIFO | Önemli sayfaları atabilir; Belady anomalisi. |
| İkinci şans | FIFO’ya göre büyük iyileşme. |
| Saat | İkinci şansın gerçekçi gerçeklemesi. |
| LRU | Çok iyi ama tam hâli donanım ister. |
| NFU | LRU’ya oldukça kaba yaklaşım (unutmaz). |
| Yaşlandırma | LRU’ya iyi yaklaşan verimli algoritma. |
| Çalışma kümesi | İyi ama uygulaması pahalı. |
| WSClock | İyi ve verimli. |
Sayfa Yer Değiştirme · Adım adım
İş Yükü Politikayı Belirler
Yerellik yoksa hangi sayfanın tutulduğu fark etmez: LRU, FIFO, saat ve rastgele aynı doğruyu izler. Yalnız geleceği bilen OPT öndedir; bellek tüm sayfaları alınca politika önemsizleşir.
Sıcak sayfalar varsa geçmişi kullanan politikalar kazanır: LRU sıcak 20 sayfayı bellekte tutar. Saat, LRU’ya çok yakın sonuç verir; FIFO rastgeleden iyi değildir.
Bellekten biraz büyük döngü LRU’nun en kötü durumudur: atılan sayfa hep en yakında gerekecek olandır, her erişim ıskalar. Kör rastgele seçim burada LRU’yu ezer.
10.000 erişimlik benzetim (rastgele için 5 denemenin ortalaması). Ardışık tarama LRU’yu gerçek sistemlerde de vurur: büyük bir dosyayı bir kez okumak sıcak sayfaları kovabilir. Linux bu yüzden yeni sayfayı önce etkisiz listeye koyar, ancak ikinci erişimde etkin listeye taşır.
Çerçeve Tahsisi
Çerçeve Tahsisi: Eşit ve Orantılı
- Alt sınır: bir komutun dokunabileceği tüm sayfalar aynı anda bellekte olmalıdır (komut + işlenenler + dolaylı adresler sayfa sınırını aşabilir). Bunu mimari belirler.
- Üst sınır: boş fiziksel bellek.
- Eşit: m çerçeve, n süreç → her birine ⌊m / n⌋.
- Orantılı: aᵢ = sᵢ / S × m. Örnek: 10/137 × 62 ≈ 4, 127/137 × 62 ≈ 57.
- Öncelikli: oran boyut yerine (ya da yanında) önceliğe göre kurulur; yüksek öncelikli süreç düşük öncelikliden çerçeve alabilir.
- NUMA’da bir çerçevenin nerede olduğu da önemlidir: süreç, çalıştığı düğüme yakın bellekten beslenmelidir.
Çerçeve Tahsisi · Adım adım
Yerel ve Genel Yer Değiştirme
- Genel: kurban tüm çerçevelerden seçilir; süreç başkasından çerçeve alabilir. Daha yüksek verim, ama bir sürecin süresi diğerlerinin davranışına göre çok değişebilir.
- Linux ve Windows genel geri kazanım kullanır (cgroup/iş nesnesi sınırlarıyla).
- Yerel: süreç yalnızca kendi kümesinden seçer; daha tutarlı performans, ama boşta duran çerçeveler başkasına geçmez.
- Yerel politika çalışma kümesi büyüyüp küçülürken çerçeve sayısını ayarlayan bir mekanizma ister (PFF).
Üç süreç 16 çerçeveyi paylaşıyor; sayılar yaşlandırma sayacı değeridir (küçük = uzun süredir kullanılmamış). A, A6 sayfasında hata yapar.
Yerel: kurban yalnızca A’nın çerçevelerinden seçilir → en küçük değerli A5. A’nın çerçeve sayısı sabit kalır (6).
Genel: tüm çerçeveler aday → en küçük değerli B3 çıkar. A büyür, B küçülür: tahsis dinamik olarak değişir.
Tanenbaum MOS Şekil 3-22 (yeniden çizim).
Thrashing
Thrashing (Boşa Çabalama)
- Süreçlerin etkin sayfaları (çalışma kümeleri) belleğe sığmazsa sayfa hatası oranı tırmanır: atılan sayfa hemen yeniden gerekir.
- Süreçler zamanlarının çoğunu sayfa beklemekle geçirir; disk kuyruğu dolar, CPU kullanımı düşer.
- Eski uzun vadeli çizelgeleyiciler bunu “CPU boşta” diye yorumlayıp yeni süreç ekler → durum daha da kötüleşir (geri besleme döngüsü).
- Neden: Σ |WSᵢ| > bellek. Yerel yer değiştirme thrashing’i bir süreçle sınırlar ama onu çözmez.
- Çare: çoklu programlama derecesini düşürmek (süreç askıya almak/takaslamak), daha çok RAM, ya da sistemin OOM öldürücüsü.
Linux’ta belirti: vmstat 1 çıktısında yüksek si/so ve wa; /proc/pressure/memory (PSI) bellek baskısını yüzde olarak verir.
Thrashing
Thrashing’i Önlemek: Çalışma Kümesi ve PFF
- Çalışma kümesi stratejisi: D = Σ |WSᵢ| toplam talebi verir. D > m ise bir süreç askıya alınır; D yeterince küçükse yeni süreç başlatılır.
- Askıdan dönen süreç için önce çalışma kümesini yüklemek (ön sayfalama) hata fırtınasını önler.
- PFF (sayfa hatası sıklığı): daha doğrudan bir geri besleme. Hata oranı üst sınırı aşarsa sürece çerçeve verilir, alt sınırın altına inerse çerçeve geri alınır.
- Boş çerçeve yokken oran yüksekse süreç askıya alınır ve çerçeveleri dağıtılır.
Thrashing · Kodu adım adım çalıştır
PFF: Kod İzleme
void pff(Surec *s, int p, int t) { if (t - s->son > C) { /* seyrek hata */ for (int i = s->n - 1; i >= 0; i--) if (s->kume[i].R == 0) cikar(s, i); /* kullanılmadı */ } for (int i = 0; i < s->n; i++) s->kume[i].R = 0; /* sıfırla */ ekle(s, p); /* R = 1 ile */ s->son = t; }
Süreç belleksiz başlıyor; eşik C = 2 referans. Her sayfa hatasında pff çağrılır ve son hatadan bu yana geçen süreye bakar.
t = 1, ilk hata (s1): son = 0, aralık 1 ≤ C. Çıkarılacak sayfa yok; s1 R = 1 ile eklenir.
t = 2, s2 hatası: aralık 1 ≤ C, hatalar sık. Hiçbir sayfa atılmaz, R bitleri sıfırlanır ve küme 2 sayfaya büyür.
t = 4, s3 hatası: aralık 2 ≤ C, hatalar sık. Hiçbir sayfa atılmaz, R bitleri sıfırlanır ve küme 3 sayfaya büyür.
t = 9, s4 hatası: aralık 5 > C, hatalar seyrek. Son hatadan beri kullanılmayan (R = 0) s2 çıkarılır; küme küçülür.
t = 11, s5 hatası: aralık 2 ≤ C, hatalar sık. Hiçbir sayfa atılmaz, R bitleri sıfırlanır ve küme 4 sayfaya büyür.
t = 14, s2 hatası: aralık 3 > C, hatalar seyrek. Son hatadan beri kullanılmayan (R = 0) s3, s1 çıkarılır; küme küçülür.
14 referansta 6 hata. Yerellik değişince (1–3’ten 4–5’e) önce hatalar sıklaştı ve küme büyüdü, sonra eski sayfalar seyrek bir hatada bırakıldı.
Tasarım Konuları
Temizleme Politikası ve Sayfalama Daemonu
- Kurbanı hata anında aramak yerine bir sayfalama daemonu periyodik uyanır; boş çerçeve azsa sayfaları önceden serbest bırakır.
- Kirli sayfaları önceden diske yazar: tahliye anında sayfa temizdir, hata yalnızca bir okuma bekler.
- Serbest bırakılan çerçeve hemen silinmez; yeniden gerekirse havuzdan geri alınabilir (küçük hata).
- İki elli saat: öndeki el kirli sayfaları yazdırır / R’yi temizler, arkadaki el uygun sayfaları serbest bırakır.
- Linux:
kswapdbölge başına min / low / high su düzeyleriyle çalışır; kirli dosya sayfalarınıwritebackiş parçacıkları yazar.
Tasarım Konuları
Ön Sayfalama (Prepaging)
- Talebe bağlı sayfalama başlangıçta (ve askıdan dönüşte) hata fırtınası yaşar. Ön sayfalama, gerekecek sayfaları önceden toplu getirir.
- s sayfa önceden getirilir, α oranı kullanılır: kazanç α·s hata, bedel (1 − α)·s gereksiz sayfa. α 0’a yakınsa ön sayfalama kaybettirir.
- Askıya alınan sürecin çalışma kümesini hatırlayıp geri dönüşte yüklemek klasik örnektir.
- Linux: dosyalar için readahead, takas için
page-cluster; uygulamamadvise(MADV_WILLNEED)ya dammap(MAP_POPULATE)ile ipucu verir. - Windows: önceden getirme (Prefetcher) ve SysMain (eski adı SuperFetch) sık kullanılan sayfaları boştayken yükler.
Tasarım Konuları
Sayfa Boyutu
- Ek maliyet = se/p (sayfa tablosu) + p/2 (son sayfadaki iç parçalanma); s: süreç boyutu, e: girdi boyutu.
- Türev sıfır: −se/p² + 1/2 = 0 → p = √(2se). s = 1 MB, e = 8 B → p = √(2²⁴) = 4 KB.
| Küçük sayfa | Büyük sayfa |
|---|---|
| az iç parçalanma | küçük sayfa tablosu |
| yerelliği ince izler, az gereksiz veri | az hata, verimli G/Ç (arama/kurma maliyeti bir kez) |
| çok TLB ıskası | büyük TLB erimi |
2026: x86-64 4 KB (+2 MB, 1 GB); Apple Silicon 16 KB; Android 15+ 16 KB çekirdekleri destekler; bazı ARM64 sunucular 64 KB. 1 KB sayfa yalnızca eski sistemlerde görülür.
Tasarım Konuları
TLB Erimi ve Büyük Sayfalar
- TLB erimi (TLB reach) = TLB girdi sayısı × sayfa boyutu: TLB’den ıskasız erişilebilen bellek miktarı.
- Çalışma kümesi erime sığmıyorsa zaman sayfa yürüyüşüne gider. Girdi sayısını artırmak pahalıdır (ilişkisel bellek); sayfayı büyütmek daha etkilidir.
- Büyük sayfalar: x86-64’te 2 MB ve 1 GB. Linux:
hugetlbfsve şeffaf büyük sayfalar (THP,khugepaged); 6.x çekirdeklerinde çok boyutlu folio/mTHP desteği. Windows: büyük sayfa ayrıcalığı. - Bedeli: iç parçalanma, büyük bitişik bölge bulma (sıkıştırma), sayfa başına daha uzun kopyalama/sıfırlama.
- Veritabanları ve sanal makineler büyük sayfadan en çok yararlanır.
Tasarım Konuları · Kodu adım adım çalıştır
Program Yapısı ve Yerellik
int data[128][128]; /* satır = 1 sayfa */ /* A: sütun sütun */ for (int j = 0; j < 128; j++) for (int i = 0; i < 128; i++) data[i][j] = 0; /* B: satır satır */ for (int i = 0; i < 128; i++) for (int j = 0; j < 128; j++) data[i][j] = 0;
128 × 128 int, sayfa 128 sözcük: her satır ayrı bir sayfa. Sürece 64 çerçeve, hiçbiri dolu değil.
A, sütun 0’da: data[0][0] → sayfa 0’da hata.
Sütun 0 boyunca her i farklı bir sayfa: 128 hata; 64 çerçeveye sığmadığından sayfa 0–63 çoktan atıldı.
Sütun 1: data[0][1] yine sayfa 0’da ama o atıldı → yeniden hata.
Her erişim hata: 128 × 128 = 16.384 hata.
B, satır 0: data[0][0] → sayfa 0’da hata, ardından data[0][1…127] aynı sayfada: isabet.
Satır 1 → sayfa 1’de tek hata; satır başına bir hata.
Toplam 128 hata: aynı iş, 128 kat daha az hata.
C satır öncelikli (row-major), Fortran sütun öncelikli saklar. Yığın iyi, hash tablosu ve işaretçi kovalayan yapılar kötü yerellik gösterir; derleyiciler döngü değiştirme (loop interchange) yapabilir.
Tasarım Konuları
G/Ç Kilitleme ve Sayfa Sabitleme
A, diskten okuma ister; çekirdek DMA’yı tamponun bulunduğu çerçeve 42’nin fiziksel adresiyle programlar.
A bloke olur, aygıt kuyrukta/çalışıyor. Çerçeve 42 bu sırada sıradan bir sayfa gibi görünür.
B sayfa hatası yapar; genel politika 42’yi kurban seçer ve B’nin sayfasını yükler. DMA tamamlanınca B’nin sayfasının üstüne yazar: bozulma.
Çözüm: G/Ç süresince çerçeve kilitlenir (pinned) ve kurban seçilmez; ya da G/Ç çekirdek tamponlarına yapılıp sonra kopyalanır.
- Sabitlenen başka sayfalar: çekirdek kodu ve verisinin bir kısmı, gerçek zamanlı süreçlerin belleği (
mlock(),mlockall()). - Linux sürücüleri kullanıcı sayfalarını
pin_user_pages()ile sabitler (RDMA, GPU, io_uring sabit tamponları). IOMMU, aygıtların da çevrilmiş adres kullanmasını sağlar.
- Yeni yüklenmiş ama henüz hiç çalışmamış düşük öncelikli sürecin sayfası da bir kez kullanılana kadar korunabilir.
- Risk: kilitli sayfa unutulursa çerçeve sonsuza dek kullanılamaz; bu yüzden kilitleme sınırlıdır (
ulimit -l).
Çekirdek Belleği
Çekirdek Belleği: Buddy Sistemi
Çekirdek belleği kullanıcı belleğinden farklıdır: çoğu zaman sayfalanmaz, farklı boyutlu yapılar ister ve DMA için fiziksel olarak bitişik olmalıdır.
Çekirdeğin elinde fiziksel olarak bitişik 256 KB’lik bir bölge var; 21 KB’lik istek geliyor.
Blok iki eş kardeşe (buddy) bölünür: AL ve AR, 128’er KB.
AL yine bölünür: BL, BR (64 KB).
BL bölünür: CL, CR (32 KB). 21 KB’yi karşılayan en küçük 2’nin kuvveti 32 KB’dir → CL verilir.
Bedeli iç parçalanma: istenen 21, verilen 32 KB.
Bırakılınca kardeşler boşsa hızla birleşir (coalescing): kardeşin adresi tek bir bit değiştirerek bulunur.
Linux sayfa ayırıcısı buddy’dir: 0’dan 10’a kadar mertebe (4 KB … 4 MB) listeleri, cat /proc/buddyinfo.
Çekirdek Belleği · Kodu adım adım çalıştır
Buddy Ayırıcı: Kod İzleme
int ayir(int k) { /* 2^k KB */ int j = k; while (bos[j] == NULL) j++; int a = cek(j); while (j > k) { /* böl, sağ yarı boş */ j--; ekle(j, a + (1 << j)); } return a; } void birak(int a, int k) { int b = a ^ (1 << k); /* kardeş */ while (k < MAX && sil(k, b)) { a = a < b ? a : b; /* birleş */ k++; b = a ^ (1 << k); } ekle(k, a); }
Tek boş blok: @0’da 256 KB (mertebe 8). 21 KB’lik istek 32 KB’ye (25) yuvarlanır: A = ayir(5).
bos[5], bos[6], bos[7] boş; ilk dolu liste bos[8]: j = 8. Daha büyük bir blok bölünecek.
256 KB’lik blok listeden alınır: a = 0.
j = 7: blok ikiye bölünür; sağ yarı @128 (128 KB) bos[7]’ye eklenir, sol yarı bölünmeye devam eder.
j = 6: blok ikiye bölünür; sağ yarı @64 (64 KB) bos[6]’ya eklenir, sol yarı bölünmeye devam eder.
j = 5: son bölme; @32 bos[5]’e gider. j = k olduğu için döngü biter ve sol yarı (@0, 32 KB) A’ya verilir.
B = ayir(6): bos[6]’da @64 hazır; bölme gerekmez, hemen döner. İç parçalanma: A’da 32 − 21 = 11 KB.
birak(0, 5): A geri veriliyor. Kardeşin adresi tek bit çevrilerek bulunur: 0 ⊕ 32 = 32.
@32 bos[5]’te: kardeş boş, birleşirler → @0’da 64 KB. Yeni kardeş 0 ⊕ 64 = 64.
@64 bos[6]’da değil (B kullanıyor): birleşme durur, @0 (64 KB) bos[6]’ya eklenir.
birak(64, 6): kardeşi 64 ⊕ 64 = 0 boş → 128 KB’lik @0 oluşur; yeni kardeş @128.
@128 de boş: birleşip 256 KB olur; k = MAX olduğundan durur. Bölge başlangıçtaki gibi tek parça.
Çekirdek Belleği
Buddy: İstek Dizisi Örneği
1 MiB (1024 K) tek boş blokla başlanır; her istek 2’nin bir üst kuvvetine yuvarlanır. Kardeşin adresi adres XOR boyut ile bulunur.
| Olay | Blok | Bölme ya da birleşme | İç parçalanma |
|---|---|---|---|
| A = 70 K | 128 K | 1024 → 512 + 512 → 256 + 256 → 128 + 128 | 58 K |
| B = 35 K | 64 K | 128 → 64 + 64 | 29 K |
| C = 80 K | 128 K | 256 → 128 + 128 | 48 K |
| A bırakılır | — | kardeşi (128–256) bölünmüş, içinde B var → birleşme yok | — |
| D = 60 K | 64 K | B’nin boş kardeşi verilir, bölme gerekmez | 4 K |
| B bırakılır | — | kardeşi D dolu → birleşme yok | — |
| D bırakılır | — | 64 + 64 → 128, A’nın boş 128’iyle → 256 | — |
| C bırakılır | — | 128 + 128 → 256 → 512 → 1024: bellek yine tek blok | — |
A, B ve C için toplam iç parçalanma 58 + 29 + 48 = 135 K. Buddy tahsis ve birleştirmede hızlıdır (boyut başına ayrı boş liste, O(log n)), ama en kötü durumda bloğun yaklaşık yarısı boşa gider.
Çekirdek Belleği
Slab Ayırıcı
Her sık kullanılan çekirdek nesnesi için bir önbellek; önbellek bir ya da daha çok slab’dan, slab bitişik sayfalardan oluşur.
Yeni task_struct isteği (ör. fork()): önce kısmi slabdaki boş nesneye bakılır; bulunur, verilir.
Kısmi slab doldu. Parçalanma yok: nesneler tam boyutludur ve sayfa içinde yan yana paketlenir.
Kısmi ya da boş slab kalmadı: buddy ayırıcıdan yeni sayfalar alınır, yeni slab oluşturulur. Boşalan slablar bellek baskısında geri verilir.
- Bonwick (Solaris, 1994). Yararları: iç parçalanma yok, ayırma/bırakma O(1), önbellekte sıcak ve hazır nesneler, CPU başına listelerle kilitsiz hızlı yol.
- Linux: SLOB 6.4’te, klasik SLAB 6.8’de (2024) kaldırıldı; bugün tek ayırıcı SLUB’dır.
kmalloc()boyut sınıflı slab önbelleklerinden gelir; izleme:slabtop,/proc/slabinfo.
Gerçek Sistemler
Linux: Sayfa Geri Kazanımı
- Boş sayfalar low su düzeyinin altına inince kswapd uyanır; min altında ayırma yapan süreç doğrudan geri kazanım yapar (gecikme!).
- Klasik LRU, saat benzeri iki liste çiftidir: etkin / etkin olmayan, anonim ve dosya için ayrı (ayrıca kilitli sayfalar için unevictable).
vm.swappiness(0–200) anonim ile dosya sayfaları arasındaki tercihi ayarlar. Bellek tükenirse OOM killer bir süreci öldürür.
Gerçek Sistemler
Linux: MGLRU, zswap ve zram
Çok nesilli LRU: sayfalar 4 nesle ayrılır; erişim bitleri sayfa tabloları yürünerek toplanır, kurban en yaşlı nesilden seçilir. Daha az CPU, daha iyi kurban seçimi. /sys/kernel/mm/lru_gen/enabled
Takasın önünde sıkıştırılmış önbellek: anonim sayfa diske gitmeden RAM’de sıkıştırılır; havuz dolunca en eski girdiler gerçek takasa yazılır.
RAM’de sıkıştırılmış blok aygıtı, takas olarak kullanılır. Fedora (33’ten beri), Android ve ChromeOS varsayılan olarak kullanır.
MGLRU ChromeOS ve Android’de varsayılandır; birçok dağıtım çekirdeği derleme seçeneğiyle açar. Sıkıştırma CPU harcar ama diske gitmekten yüzlerce kat ucuzdur.
Gerçek Sistemler
Windows: Çalışma Kümeleri ve Sıkıştırma
- Her sürecin bir çalışma kümesi vardır (en az / en çok sınırlarıyla); hata kümede yer açar ya da kümeyi büyütür.
- Bellek azalınca çalışma kümesi yöneticisi (balance set manager) kümeleri kırpar; kırpılan sayfa hemen silinmez, bekleme ya da değiştirilmiş listeye gider ve küçük hatayla geri alınabilir.
- Bellek sıkıştırma (Windows 10, 2015): kırpılan sayfalar sistem sürecindeki sıkıştırma deposunda tutulur;
pagefile.sys’ye yazmak son çaredir. - Önceden getirme: Prefetcher ve SysMain; büyük sayfalar
VirtualAlloc(MEM_LARGE_PAGES). - macOS/iOS da benzer: sıkıştırılmış bellek, iOS’ta takas yok, baskıda uygulama sonlandırma (Jetsam).
Özet
Özet
Talebe bağlı sayfalama: geçersiz girdi → sayfa hatası → sayfayı getir → tabloyu güncelle → komutu yeniden başlat. COW ve mmap aynı mekanizmayı kullanır.
EAT, hata oranına aşırı duyarlı: HDD’de p = 0,001 belleği 251 kat yavaşlatır. Hızlı SSD ve sıkıştırma cezayı küçültür, yok etmez.
Ortak dizide (3 çerçeve) OPT 9, LRU 12, saat 14, FIFO 15 hata. Pratikte saat, yaşlandırma ve WSClock türevleri; Linux’ta MGLRU.
Tahsis (eşit/orantılı, yerel/genel), thrashing’e karşı çalışma kümesi ve PFF, sayfa boyutu ve TLB erimi, sabitleme, buddy + slab.
Özet
Kontrol Soruları
1 2 3 4 1 2 5 1 2 3 4 5dizisinde FIFO 3 ve 4 çerçeveyle kaç hata yapar? LRU neden bu anomaliyi göstermez?- Bellek erişimi 200 ns, hata hizmeti 8 ms. p = 0,001 için EAT nedir? %10 yavaşlama için p en çok ne olmalı?
- 62 çerçeve, 10 ve 127 sayfalık iki süreç: orantılı tahsis ne verir?
- 64 girdili TLB, 4 KB ve 2 MB sayfa için TLB erimi nedir?
fork()sonrası çocuk 100 sayfadan 3’üne yazıpexec()çağırırsa kaç sayfa kopyalanır?- Küçük (minor) ve büyük (major) sayfa hatasını birer örnekle ayırın.
- Thrashing neden CPU kullanımını düşürür? Çalışma kümesi modeli nasıl önler?
- s = 4 MB, e = 8 B için en uygun sayfa boyutu nedir?
- G/Ç sırasında bir tampon sayfası neden kilitlenmelidir?
- 1 MiB buddy belleğinde 70 K’lık istek hangi boyutta blok alır? İç parçalanma ne kadardır?
Cevaplar
- 9 ve 10 hata. LRU bir yığın algoritmasıdır: n çerçevedeki küme n+1 çerçevedekinin alt kümesidir.
- EAT = 200 × 0,999 + 8.000.000 × 0,001 ≈ 8.199,8 ns ≈ 8,2 µs (41 kat). 220 > 200 + 7.999.800 p → p < 2,5 × 10⁻⁶.
- ⌊10/137 × 62⌋ = 4 ve ⌊127/137 × 62⌋ = 57 çerçeve.
- 64 × 4 KB = 256 KB; 64 × 2 MB = 128 MB.
- Yalnızca yazılan 3 sayfa (COW);
exec()sonra tüm eşlemeleri zaten atar. - Küçük: paylaşımlı kütüphane sayfası zaten sayfa önbelleğinde, sadece tablo güncellenir. Büyük: takastaki sayfa diskten okunur.
- Süreçler hep sayfa G/Ç’si bekler, hazır süreç kalmaz. D = Σ |WSᵢ| > m olunca bir süreç askıya alınır.
- √(2 × 2²² × 8) = √(2²⁶) = 8 KB.
- DMA fiziksel adrese yazar; çerçeve bu arada başka sürece verilirse onun verisi bozulur.
- 128 K; 128 − 70 = 58 K.
Özet
Kaynaklar
- A. Silberschatz, P. B. Galvin, G. Gagne, Operating System Concepts, 10. baskı, Wiley, 2018 — Bölüm 10: Virtual Memory.
- A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı (2014) / 5. baskı (2023), Pearson — Bölüm 3: Memory Management.
- R. H. Arpaci-Dusseau, A. C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces (OSTEP), ostep.org — “Swapping: Mechanisms”, “Swapping: Policies”, “Complete VM Systems”.
- L. A. Belady, “A Study of Replacement Algorithms for a Virtual-Storage Computer”, IBM Systems Journal 5(2), 1966; P. J. Denning, “The Working Set Model for Program Behavior”, CACM 11(5), 1968.
- R. W. Carr, J. L. Hennessy, “WSCLOCK — A Simple and Effective Algorithm for Virtual Memory Management”, SOSP 1981; J. Bonwick, “The Slab Allocator”, USENIX Summer 1994.
- Linux çekirdek belgeleri:
admin-guide/mm/multigen_lru.rst,admin-guide/mm/zswap.rst,admin-guide/mm/transhuge.rst,admin-guide/blockdev/zram.rst. - P. Yosifovich, A. Ionescu, M. Russinovich, D. Solomon, Windows Internals, 7. baskı, Kısım 1, Bölüm 5: Memory management.