Bölüm 9: Sanal Bellek

İşletim Sistemleri

Talebe bağlı sayfalamaSayfa hatasıEtkin erişim süresi Yazarken kopyalamammapFIFO ve Belady OPT ve LRUSaat, NRU, yaşlanmaÇalışma kümesi, WSClock Tahsis ve thrashingSayfa boyutu, TLB erimiBuddy, slabLinux ve Windows

Sercan KÜLCÜ · Giresun Üniversitesi · Bilgisayar Mühendisliği

Giriş

Öğrenme Çıktıları

Talebe bağlı sayfalama

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.

Performans

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.

COW ve mmap

fork() sonrasında yazarken kopyalamayı ve bellek eşlemeli dosyaların sayfa önbelleğiyle ilişkisini izlemek.

Yer değiştirme

FIFO, OPT, LRU, ikinci şans, saat, NRU, yaşlanma, çalışma kümesi ve WSClock'u bir referans dizisi üzerinde elle çalıştırmak.

Tahsis ve thrashing

Eşit/orantılı ve yerel/genel tahsisi karşılaştırmak; thrashing'i çalışma kümesi ve PFF ile açıklamak.

Tasarım ve gerçek sistemler

Sayfa boyutu, TLB erimi, program yapısı, sabitleme, buddy/slab; Linux (MGLRU, zswap) ve Windows yaklaşımlarını tanımak.

Giriş

Hatırlatma: Sayfalama ve TLB

Bölüm 8'de: sanal adres = (p, d); sayfa tablosu p'yi bir çerçeveye çevirir, ofset 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).
Bu bölümün sorusu: girdi geçersizse ne olur, ve sayfa bellekte değilse nereden ve hangi sayfanın yerine gelir?

Sayfa tablosu yapıları (çok düzeyli, karma, ters), TLB ve kesimleme Bölüm 8'de işlendi; burada yalnızca sanal bellek için gereken kısım kullanılıyor.

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ığıt en yüksek kullanıcı adresinden aşağı, yığın yukarı büyür; aradaki kullanılmayan alan boşluktur ve sayfa ya da çerçeve harcamaz.
Yığıt/yığın 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şılan 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şılan bellek ile süreçler arası iletişim: iki süreç aynı bölgeyi eşler (Bölüm 3).
fork() sırasında sayfalar kopyalanmadan paylaşılır (yazarken kopyalama, birazdan).
Yazılabilir veri sayfaları ise her süreçte özeldir.

Talebe Bağlı Sayfalama

Süreç başlarken hiçbir (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 başvurudur; ç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. Başvuru: MMU girdiyi okur, sayfa bellekte değil.

2. Tuzak: donanım çekirdeğe geçer; çekirdek başvurunun 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.

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 onlarca µ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 başvurunun 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 MVC blok taşıma sayfa sınırını aşar; otomatik artırmalı adresleme yazmacı değiştirmiştir.
Çö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şılan 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)

Formül

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.

HDD: 25 ms = 25 000 000 ns

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.

Hedef: en çok %10 yavaşlama

110 > 100 + 24 999 900 p → p < 4,0 × 10⁻⁷

yani 2,5 milyon erişimde birden az hata

Kaynaktaki 0,0000004 doğrudur: hata oranı son derece düşük tutulmalıdır.

2026: NVMe SSD ≈ 100 µs, zram ≈ 10 µs

NVMe, 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 üç 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 (40 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, mmap edilmiş dosya): temizse atılır, gerektiğinde dosyadan yeniden okunur.
Anonim sayfalar (yığın, yığıt, 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 yığın 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.

Yazarken Kopyalama

Yazarken 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ün posix_spawn() tercih edilir.

Kaynaktaki “dosyalar değiştirilmedikçe ortak kullanılır” ifadesi düzeltildi: paylaşılan birim sayfadır, dosya değil.

Yazarken 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);  /* yığın: 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 (yığın) sayfalarını yazılabilir olarak kullanıyor.

fork(): yalnızca sayfa tabloları kopyalanır; iki taraf da salt okunur (RO), başvuru 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, f1 ve f2'nin başvuru sayısı 1'e iner.

Ebeveyn H'ye yazar → hata; başvuru sayısı 1 olduğundan kopyalamaya gerek yok, sayfa yalnızca yazılabilir yapılır.

Bellek Eşlemeli Dosyalar

mmap() bir dosyayı adres alanının bir bölgesine eşler; dosya read()/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şılan 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 (malloc bü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 başvurusunu 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 3 ya da 6 farklı sayfa) kaçınılmazdır.
Algoritmalar: OPT, FIFO, LRU, ikinci şans, saat, NRU, NFU/yaşlanma, ç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ı. Kaynaktaki “en son erişilen sayfa listenin sonunda” ifadesi düzeltildi: FIFO erişimi değil yüklenmeyi izler.

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ı.
Kaynaktaki “En Son Kullanılan” adı yanlıştı: o, 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çeklemek: 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çeklemek: 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.
Kaynaktaki “sayfa tablosundaki işaretçi” ifadesi düzeltildi: el ç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'nin 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'nin 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'nin R'si 0 → çıkar. Hata: 8

12. referans 3: hata; elin gösterdiği 4'nin 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'nin R'si 0 → çıkar. Hata: 11

16. referans 0: hata; elin gösterdiği 3'nin 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'nin 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 · 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şlayıp (0,0) ara, bitlere dokunma.

Tur 2: (0,1) ara; geçtiğin her sayfanın R'sini 0 yap. Bulunamazsa tur 1'e dön (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'yi 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'yi 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'yi 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'yi 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'yi 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şlanma (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. Kaynaktaki “erişim zamanları kaydedilir, uzun günlük tutulur” ifadesi yanlıştı.

Yaşlanma: ö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şlanma: 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 başvurusunda kullanılan sayfaların kümesi (Denning, 1968). Kaynaktaki “k adet en son erişilen sayfa” tanımı düzeltildi.

Δ 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 t₁)

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. (t₂): 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 k başvuru) her erişimde kaydırılan bir yazmaç ister: çok pahalı. Yaklaşım: son τ sanal zaman içinde kullanılan sayfalar. Kaynaktaki “tau: time of actively used” açıklaması bu anlamda düzeltildi.

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şlanma	LRU'ya iyi yaklaşan verimli algoritma.
Çalışma kümesi	İyi ama uygulaması pahalı.
WSClock	İyi ve verimli.

Kendi dizinizi deneyin: etkileşimli sayfa yer değiştirme simülatörü (FIFO, OPT, LRU, LFU, ikinci şans). * R/M bitli algoritmalar yazma ve tık bilgisi de kullanır; kısa tek bir dizi genel sıralama vermez. Kaynaktaki “NFU LRU'ya yakınsar, adil” yorumu Tanenbaum'a göre düzeltildi.

Ç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üreci çalıştığı düğüme yakın bellekten besle.

Ç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şlanma 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 (kaynaktaki 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.

Sayfa hataları ile yerellikler arasında bağ vardır: yeni bir yerelliğe geçişte hata oranında tepe oluşur, çalışma kümesi yüklenince oran düşer.

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: kswapd bölge başına min / low / high su seviyeleriyle çalışır; kirli dosya sayfalarını writeback iş 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; uygulama madvise(MADV_WILLNEED) ya da mmap(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. Kaynaktaki “1 KB tipik” bilgisi eskidi; başlık da “sayfa tablosu boyutu” değil sayfa boyutu.

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: hugetlbfs ve ş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ığıt iyi, karma tablo 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ı).

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. Buddy sistemi Bölüm 8'de görüldü; burada çekirdek açısından kısa bir tekrar.

Ç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: A_L ve A_R, 128'er KB.

A_L yine bölünür: B_L, B_R (64 KB).

B_L bölünür: C_L, C_R (32 KB). 21 KB'yi karşılayan en küçük 2'nin kuvveti 32 KB'dir → C_L 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

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 seviyesinin 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

MGLRU (6.1, 2022)

Ç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

zswap

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.

zram

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

Mekanizma

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.

Performans

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.

Politika

Ortak dizide (3 çerçeve) OPT 9, LRU 12, saat 14, FIFO 15 hata. Pratikte saat, yaşlanma ve WSClock türevleri; Linux'ta MGLRU.

Sistem

Tahsis (eşit/orantılı, yerel/genel), thrashing'e karşı çalışma kümesi ve PFF, sayfa boyutu ve TLB erimi, sabitleme, buddy + slab.

Ana fikir: yerellik sayesinde süreçlerin yalnızca çalışma kümeleri bellekte olmalıdır; İS'nin işi, bu kümeyi az G/Ç ile bellekte tutmaktır.

Özet

Kontrol Soruları

1 2 3 4 1 2 5 1 2 3 4 5 dizisinde FIFO 3 ve 4 çerçeveyle kaç hata yapar? LRU neden bu anomaliyi göstermez?
Bellek erişimi 200 ns, hata servisi 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ıp exec() ç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?

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 (40 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şılan 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.

Ö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ı (2022), 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ı, Bölüm 1, Kısım 5: Memory management.

Son

Bölüm 9: Sanal Bellek

Sonraki bölüm: Dosya Sistemleri