Bölüm 8: Bellek Yönetimi

İşletim Sistemleri
Bellek hiyerarşisi ve önbellekTaban ve limit yazmaçlarıAdres bağlama ve MMU Dinamik yükleme ve bağlamaTakasBitişik tahsis ve uyan algoritmaları Parçalanma ve biteşlemSayfalamaTLB ve erişim süresi Hiyerarşik, hash, ters tablolarx86-64 ve büyük sayfalarKesimleme, x86 ve ARMv8
Sercan KÜLCÜ · Giresun Üniversitesi · Bilgisayar Mühendisliği

Giriş

Öğrenme Çıktıları

Soyutlama

Bellek hiyerarşisini, önbellek satırlarını ve ortalama erişim süresini, adres alanını, koruma ve yer değiştirme problemlerini açıklamak.

Adresler

Bağlama zamanlarını, mantıksal/fiziksel adresi ve MMU’nun taban-limit denetimini açıklamak.

Bağlama

Dinamik yüklemeyi, statik ve dinamik bağlamayı, PLT/GOT ile paylaşımlı kütüphaneleri ve takası tartışmak.

Bitişik tahsis

Uyan algoritmalarını uygulamak; iç/dış parçalanmayı, biteşlemi ve bağlı listeyi çözümlemek.

Sayfalama

Adresi (p, d) olarak bölmek, sayfa tablosu ve TLB ile çeviri yapmak, etkin erişim süresini hesaplamak.

Gerçek sistemler

Hiyerarşik, hash ve ters tabloları; x86-64 dört/beş düzeyli sayfalamayı, büyük sayfaları, kesimlemeyi ve ARMv8’i karşılaştırmak.

Giriş

Bellek Hiyerarşisi ve Bellek Yöneticisi

  • CPU’nun doğrudan erişebildiği depolama yalnızca yazmaçlar ve ana bellektir; disk ancak G/Ç ile.
  • Bellek birimi yalnızca bir akış görür: adres + okuma ya da adres + veri + yazma. Adresin nereden geldiğini bilmez.
  • Yazmaç bir saat döngüsünde okunur; DRAM erişimi yüzlerce döngü sürer ve CPU durur (stall). Aradaki boşluğu önbellek kapatır.
  • Programcı belleğin sınırsız, hızlı, kalıcı ve korumalı olmasını ister; gerçek çözüm hiyerarşidir.
  • Bellek yöneticisi: boş/dolu alanı izler, süreçlere tahsis eder, geri alır, süreçleri birbirinden korur.
Yazmaçlar< 1 ns~1 KBL1 / L2 önbellek1–5 nsKB–MBL3 önbellek10–20 ns10–100+ MBAna bellek (DRAM)80–120 ns8–512 GBSSD (NVMe)10–100 µsTBHDD / teyp5–10 msTB+hızlı, küçük, pahalıyavaş, büyük, ucuz, kalıcıgecikme

Değerler 2026 itibarıyla tipik mertebelerdir; çekirdek ve modele göre değişir. Önbellek donanımca, ana bellek işletim sistemince yönetilir.

Bellek Donanımı

Ana Bellek Türleri

TürÖzellikKullanım
RAM (rastgele erişimli)Okunur ve yazılır, hızlı, uçucu. DRAM yenileme ister; SRAM daha hızlı ve pahalı.Ana bellek (DRAM: DDR5, LPDDR5X), önbellekler (SRAM)
ROM (salt okunur)Üretimde yazılır, değiştirilemez, kalıcı, ucuz.Basit aygıtlar, mikrodenetleyicilerde sabit kod
EEPROM / FlashElektrikle silinip yeniden yazılabilir, kalıcı; yazma yavaş ve yazma ömrü sınırlı.UEFI/BIOS ürün yazılımı (SPI flash), SSD, USB bellek, telefon ve müzik çalar depolaması (NAND flash)
CMOS / NVRAMPil ya da flash ile korunan küçük alan.Saat, önyükleme ayarları
Bugünkü bilgisayarlarda BIOS/UEFI kodu ROM’da değil flash bellekte durur; bu yüzden güncellenebilir. Taşınabilir müzik çalarlar da disk değil NAND flash kullanır.

Bellek Donanımı

Önbellek Satırları

  • Bellek, önbellek satırlarına (cache line, genelde 64 bayt) bölünür: satır 0 = 0–63, satır 1 = 64–127, …
  • Adres a için satır numarası ⌊a / 64⌋, satır içi konum a mod 64.
  • CPU bir sözcük okurken donanım önce önbelleğe bakar: isabet (hit) → L1’de ~4–5 tur; ıska (miss) → alt düzey ya da DRAM, yüzlerce tur.
  • Önbellek pahalı olduğundan küçüktür; bu yüzden düzeyler (L1, L2, L3) hâlinde kurulur.
  • Neden işe yarar? Zamansal yerellik (az önce kullanılan yine kullanılır) ve uzamsal yerellik (komşu adresler birlikte kullanılır).
Adres 200 (64 B satır):11001000satır no = 3satır içi bağıl konum = 8 (6 bit)satır 00–63satır 164–127satır 2128–191satır 3192–255

Bellek Donanımı · Animasyon

Bir Okuma Hiyerarşide Nasıl İlerler?

CPU(yazmaç)L1~1 nsL2~4 nsL3~15 nsDRAM~80 nstoplam gecikme: 0 ns

CPU x değişkenini okumak istiyor (LOAD R1, [x]). Önce en yakın ve en hızlı düzeye bakılır.

CPU(yazmaç)L1~1 nsıskaL2~4 nsL3~15 nsDRAM~80 nstoplam gecikme: ~1 ns

L1’de yok: ıska (miss). ~1 ns kaybedildi; aramaya bir alt düzeyde devam edilir.

CPU(yazmaç)L1~1 nsıskaL2~4 nsıskaL3~15 nsıskaDRAM~80 nstoplam gecikme: ~20 ns

L2 ve L3’te de ıska. Her düzey biraz daha büyük ama daha yavaştır; toplam ~20 ns.

CPU(yazmaç)L1~1 nsıskasatırL2~4 nsıskasatırL3~15 nsıskasatırDRAM~80 nstoplam gecikme: ~100 ns

Veri DRAM’den gelir (~80 ns). Tek bir sözcük değil, 64 baytlık satırın tamamı L3, L2 ve L1’e yerleştirilir.

CPU(yazmaç)L1~1 nssatırL2~4 nssatırL3~15 nssatırDRAM~80 nsisabet!toplam gecikme: ~1 ns

Aynı satırdaki bir veriye ikinci erişim artık L1 isabeti (hit): ~1 ns. Önbellek, yerellik sayesinde işe yarar.

Bellek Donanımı · Kodu adım adım çalıştır

Kod İzleme: Doğrudan Eşlemeli Önbellek

Erişim sırası0864256072Önbellek (4 küme)kümeblok (etiket)0—1—2—3—

Başlangıçta önbellek boş (−1). 64 B satır, 4 küme, doğrudan eşleme: her blok tek bir kümeye gidebilir.

Erişim sırası0864256072Önbellek (4 küme)kümeblok (etiket)0—1—2—3—

adres[0] = 0 → blok = 0 / 64 = 0, küme = 0 mod 4 = 0.

Erişim sırası0M864256072Önbellek (4 küme)kümeblok (etiket)0blok 01—2—3—

Küme 0 boş → ıska; blok 0 yüklenir.

Erişim sırası0M864256072Önbellek (4 küme)kümeblok (etiket)0blok 01—2—3—

adres[1] = 8 → blok = 8 / 64 = 0, küme = 0 mod 4 = 0.

Erişim sırası0M8H64256072Önbellek (4 küme)kümeblok (etiket)0blok 01—2—3—

etiket[0] = 0 = blok → isabet. 8, 0 ile aynı 64 baytlık satırda: uzamsal yerellik.

Erişim sırası0M8H64256072Önbellek (4 küme)kümeblok (etiket)0blok 01—2—3—

adres[2] = 64 → blok = 64 / 64 = 1, küme = 1 mod 4 = 1.

Erişim sırası0M8H64M256072Önbellek (4 küme)kümeblok (etiket)0blok 01blok 12—3—

Küme 1 boş → ıska; blok 1 yüklenir.

Erişim sırası0M8H64M256072Önbellek (4 küme)kümeblok (etiket)0blok 01blok 12—3—

adres[3] = 256 → blok = 256 / 64 = 4, küme = 4 mod 4 = 0.

Erişim sırası0M8H64M256M072Önbellek (4 küme)kümeblok (etiket)0blok 41blok 12—3—

Küme 0’da blok 0 var → ıska; blok 4 onu dışarı atar (çakışma ıskası).

Erişim sırası0M8H64M256M072Önbellek (4 küme)kümeblok (etiket)0blok 41blok 12—3—

adres[4] = 0 → blok = 0 / 64 = 0, küme = 0 mod 4 = 0.

Erişim sırası0M8H64M256M0M72Önbellek (4 küme)kümeblok (etiket)0blok 01blok 12—3—

Küme 0’da blok 4 var → ıska; blok 0 onu dışarı atar (çakışma ıskası).

Erişim sırası0M8H64M256M0M72Önbellek (4 küme)kümeblok (etiket)0blok 01blok 12—3—

adres[5] = 72 → blok = 72 / 64 = 1, küme = 1 mod 4 = 1.

Erişim sırası0M8H64M256M0M72HÖnbellek (4 küme)kümeblok (etiket)0blok 01blok 12—3—

etiket[1] = 1 = blok → isabet. 72, 64 ile aynı satırda.

Erişim sırası0M8H64M256M0M72HÖnbellek (4 küme)kümeblok (etiket)0blok 01blok 12—3—

Döngü bitti: 2 isabet, 4 ıska (isabet oranı %33). 0 ve 256 aynı kümeye düştüğü için birbirini kovdu; 2 yollu küme ilişkili önbellek bunu önlerdi. (Burada etiket yerine blok numarasının tamamı saklandı.)

int adres[6] = {0, 8, 64, 256, 0, 72};
int etiket[4] = {-1, -1, -1, -1};
int isabet = 0, iska = 0;
for (int i = 0; i < 6; i++) {
  int blok = adres[i] / 64;
  int kume = blok % 4;
  if (etiket[kume] == blok) isabet++;
  else { etiket[kume] = blok; iska++; }
}

Bellek Donanımı · Kodu adım adım çalıştır

Kod İzleme: Ortalama Bellek Erişim Süresi

/* L1, L2, L3, DRAM erişim süresi (ns) */
double sure[4] = {1, 4, 20, 80};
double iska[3] = {0.10, 0.40, 0.50};
double t = sure[3];         /* DRAM */
for (int k = 2; k >= 0; k--)
  t = sure[k] + iska[k] * t;
printf("ortalama = %.1f ns\n", t);
L11 nsıska %10t(L1) = ?L24 nsıska %40t(L2) = ?L320 nsıska %50t(L3) = ?DRAM80 nst(DRAM) = ?

Dört düzey: erişim süreleri ve her önbellek düzeyinin ıska oranı. Bir düzeyde ıska olursa istek bir alttakine iner.

L11 nsıska %10t(L1) = ?L24 nsıska %40t(L2) = ?L320 nsıska %50t(L3) = ?DRAM80 nst(DRAM) = 80.0 nst = 80

En alt düzey DRAM her isteği karşılar: oradan başlayınca t = 80 ns.

L11 nsıska %10t(L1) = ?L24 nsıska %40t(L2) = ?L320 nsıska %50t(L3) = ?DRAM80 nst(DRAM) = 80.0 ns

k = 2 ≥ 0: bir üst düzeye (L3) çıkılır.

L11 nsıska %10t(L1) = ?L24 nsıska %40t(L2) = ?L320 nsıska %50t(L3) = 60.0 nsDRAM80 nst(DRAM) = 80.0 nst = 20 + 0.50 × 80.0 = 60.0

L3 her istekte 20 ns harcar; isteklerin %50’sinde alttaki düzeyin 80 ns’si eklenir: t = 60 ns.

L11 nsıska %10t(L1) = ?L24 nsıska %40t(L2) = ?L320 nsıska %50t(L3) = 60.0 nsDRAM80 nst(DRAM) = 80.0 ns

k = 1 ≥ 0: bir üst düzeye (L2) çıkılır.

L11 nsıska %10t(L1) = ?L24 nsıska %40t(L2) = 28.0 nsL320 nsıska %50t(L3) = 60.0 nsDRAM80 nst(DRAM) = 80.0 nst = 4 + 0.40 × 60.0 = 28.0

L2 her istekte 4 ns harcar; isteklerin %40’ında alttaki düzeyin 60 ns’si eklenir: t = 28 ns.

L11 nsıska %10t(L1) = ?L24 nsıska %40t(L2) = 28.0 nsL320 nsıska %50t(L3) = 60.0 nsDRAM80 nst(DRAM) = 80.0 ns

k = 0 ≥ 0: bir üst düzeye (L1) çıkılır.

L11 nsıska %10t(L1) = 3.8 nsL24 nsıska %40t(L2) = 28.0 nsL320 nsıska %50t(L3) = 60.0 nsDRAM80 nst(DRAM) = 80.0 nst = 1 + 0.10 × 28.0 = 3.8

L1 her istekte 1 ns harcar; isteklerin %10’unda alttaki düzeyin 28 ns’si eklenir: t = 3,8 ns.

L11 nsıska %10t(L1) = 3.8 nsL24 nsıska %40t(L2) = 28.0 nsL320 nsıska %50t(L3) = 60.0 nsDRAM80 nst(DRAM) = 80.0 ns

k = −1: döngü biter.

L11 nsıska %10t(L1) = 3.8 nsL24 nsıska %40t(L2) = 28.0 nsL320 nsıska %50t(L3) = 60.0 nsDRAM80 nst(DRAM) = 80.0 nsortalama = 3.8 ns

Her erişimin %10’u L1’i ıskalasa da ortalama 3,8 ns: DRAM’in 80 ns’sinden yaklaşık 21 kat hızlı. Hiyerarşiyi işe yarar kılan yüksek isabet oranıdır.

Bellek Donanımı

Önbellek Tasarım Soruları

1. Ne zaman yerleştirilir?Genelde ıskada; donanım ayrıca sıradaki satırları önceden getirir (prefetch).
2. Hangi satıra konur?Eşleme: doğrudan eşlemeli, k yollu küme ilişkili ya da tam ilişkili.
3. Yer gerekince hangisi çıkar?Değiştirme politikası: LRU’ya yakın yaklaşımlar, rastgele, FIFO.
4. Çıkan nereye gider?Değiştirilmişse ("kirli") alt düzeye yazılır (write-back); ya da her yazma hemen aşağı iletilir (write-through).
BoyutBüyük önbellek daha çok isabet ama daha yavaş ve pahalı.
DeğiştirmePerformans ile donanım karmaşıklığı arasında denge.
TutarlılıkÇok çekirdekte aynı satırın kopyaları güncel kalmalı (MESI gibi protokoller).

Aynı dört soru İS’nin yönettiği "önbelleklerde" de karşımıza çıkar: sayfa önbelleği, sanal bellek, TLB.

Giriş

Soyutlama Olmadan Bellek

  • İlk bilgisayarlarda (1960’lar öncesi ana bilgisayarlar, 1980’ler öncesi kişisel bilgisayarlar) her program fiziksel belleği doğrudan görürdü: MOV REGISTER1, 1000 fiziksel 1000 adresini okur.
  • Bellekte aynı anda iki program olamaz: ikisi de aynı fiziksel adreslere yazar, biri diğerini ezer.
  • (a) ve (c)’de kullanıcı programındaki bir hata işletim sistemini çökertebilir.
  • (b) bazı gömülü sistemlerde, (c) MS-DOS’lu ilk PC’lerde kullanıldı (BIOS sürücüleri ROM’da).
  • Bugün de MMU’suz mikrodenetleyiciler böyle çalışır; çoğu en azından MPU (bellek koruma birimi) ile bölgeleri korur.
Kullanıcı programıİS (RAM)(a)0İS (ROM)Kullanıcı programı(b)0Sürücüler (ROM)Kullanıcı programıİS (RAM)(c)00xFFF…

Giriş · Adım adım

Yer Değiştirme Problemi

(a) A programıJMP 240ADD4MOV8⋮MOV24ADD28⋮…16380(b) B programıJMP 280MOV REG1, 284ADD8⋮MOV24CMP28⋮…16380ikisi de 0’dan başlayacakşekilde derlendi (16 KB)

A ve B 16 KB’lık iki program; ikisi de 0 adresinden başlayacağı varsayılarak derlendi.

(a) A programıJMP 240ADD4MOV8⋮MOV24ADD28⋮…16380(b) B programıJMP 280MOV REG1, 284ADD8⋮MOV24CMP28⋮…16380(c) ikisi birlikteJMP 240ADD4MOV8⋮MOV24ADD28⋮JMP 2816384MOV REG1, 2816388ADD16392⋮MOV16408CMP16412⋮

İşletim sistemi önce A’yı 0’a, ardından B’yi hemen üstüne, 16384’e yükler.

(a) A programıJMP 240ADD4MOV8⋮MOV24ADD28⋮…16380(b) B programıJMP 280MOV REG1, 284ADD8⋮MOV24CMP28⋮…16380(c) ikisi birlikteJMP 240ADD4MOV8⋮MOV24ADD28⋮JMP 2816384MOV REG1, 2816388ADD16392⋮MOV16408CMP16412⋮A’yaatlar!

B’nin ilk komutu JMP 28 mutlak adres kullanır: fiziksel 28’e, yani A’nın ADD komutuna atlar ve program çöker.

(a) A programıJMP 240ADD4MOV8⋮MOV24ADD28⋮…16380(b) B programıJMP 280MOV REG1, 284ADD8⋮MOV24CMP28⋮…16380(c) ikisi birlikteJMP 240ADD4MOV8⋮MOV24ADD28⋮JMP 1641216384MOV REG1, 2816388ADD16392⋮MOV16408CMP16412⋮+16384

Statik yer değiştirme (IBM 360): yükleyici her adres sözcüğüne başlangıç adresini ekler: JMP 16412. Yükleme yavaşlar.

(a) A programıJMP 240ADD4MOV8⋮MOV24ADD28⋮…16380(b) B programıJMP 280MOV REG1, 284ADD8⋮MOV24CMP28⋮…16380(c) ikisi birlikteJMP 240ADD4MOV8⋮MOV24ADD28⋮JMP 1641216384MOV REG1, 2816388ADD16392⋮MOV16408CMP16412⋮+16384sabit 28 değişmemeli!

Ama MOV REG1, 28’deki 28 bir sabittir, değişmemelidir. Yükleyici hangi sözcüğün adres olduğunu bilmek için ek yer değiştirme bilgisi ister.

Adres Alanı

Adres Alanı: Taban ve Limit Yazmaçları

  • Adres alanı: bir sürecin kullanabileceği adresler kümesi. Her sürecin kendine ait, diğerlerinden bağımsız adres alanı vardır.
  • Çözülmesi gereken iki problem: koruma (başkasının alanına erişememe) ve yer değiştirme (her yere yüklenebilme).
  • En basit donanım: taban (başlangıç fiziksel adresi) ve limit (uzunluk) yazmaçları. Program bitişik bir alana olduğu gibi yüklenir.
  • Yazmaçlar yalnızca çekirdek modunda ayrıcalıklı komutlarla yüklenir; bağlam değiştirmede yeni sürecin değerleri konur.
  • CDC 6600 böyle çalışıyordu. Intel 8088’in kesim yazmaçları ise yalnızca taban idi; limit olmadığından koruma yoktu.
İşletim sistemi0süreç256000süreç (aktif)300040süreç4209408800001024000300040taban120900limit

Adres Alanı · Adım adım

Donanımsal Adres Koruması

CPUadres300.040≥ taban ?evet< taban+limit ?Bellekİşletim sistemine tuzak: adresleme hatasıhayırhayırtaban = 300.040limit = 120.900geçerli: 300.040 … 420.939

300.040 = taban: ilk geçerli adres; iki karşılaştırma da geçer, erişim yapılır.

CPUadres356.000≥ taban ?evet< taban+limit ?Bellekİşletim sistemine tuzak: adresleme hatasıhayırhayırtaban = 300.040limit = 120.900geçerli: 300.040 … 420.939

356.000 aralığın içinde; erişim yapılır. Denetim her erişimde, paralel donanımla yapılır.

CPUadres420.939≥ taban ?evet< taban+limit ?Bellekİşletim sistemine tuzak: adresleme hatasıhayırhayırtaban = 300.040limit = 120.900geçerli: 300.040 … 420.939

420.939 = taban + limit − 1: son geçerli adres.

CPUadres420.940≥ taban ?evet< taban+limit ?Bellekİşletim sistemine tuzak: adresleme hatasıhayırhayırtaban = 300.040limit = 120.900geçerli: 300.040 … 420.939

420.940 = taban + limit: ikinci karşılaştırma başarısız → tuzak. Çekirdek süreci genellikle sonlandırır (Unix’te SIGSEGV).

CPUadres299.999≥ taban ?evet< taban+limit ?Bellekİşletim sistemine tuzak: adresleme hatasıhayırhayırtaban = 300.040limit = 120.900geçerli: 300.040 … 420.939

299.999 tabandan küçük: ilk karşılaştırma başarısız → başka sürecin alanı korunur.

Kullanıcı modundaki her erişim denetlenir. Çekirdek modunda denetim yapılmaz; işletim sistemi tüm belleğe erişebilmelidir (Silberschatz Şekil 9.2).

Adres Alanı

Adres Bağlama Zamanları

Kaynakmain.cNesnemain.oÇalıştırılabilira.outBellektekisüreçderleyicibağlayıcıyükleyici+ diğer .o, statik .a+ dinamik .so (ld.so)MMUher erişimdederleme zamanıyükleme zamanıyürütme zamanı
Bağlama zamanıÜretilen kodKonum değişirseDonanım
DerlemeMutlak kod (ör. MS-DOS .COM)yeniden derlegerekmez
YüklemeYeri değiştirilebilir kod; yükleyici adresleri düzeltiryeniden yüklegerekmez
YürütmeMantıksal adresler; süreç çalışırken taşınabilirhiçbir şeyMMU (taban-limit, sayfalama)

Kaynakta adresler semboliktir (count); derleyici onları göreli adrese (“modül başından 14 bayt”), bağlayıcı/yükleyici mutlak adrese (74014) bağlar. Modern genel amaçlı sistemlerin hepsi yürütme zamanı bağlama kullanır.

Adres Alanı

Mantıksal ve Fiziksel Adres, MMU

  • Mantıksal (sanal) adres: CPU’nun ürettiği adres. Fiziksel adres: bellek biriminin gördüğü, adres yazmacına (MAR) yüklenen adres.
  • Derleme ve yükleme zamanı bağlamada ikisi aynıdır; yürütme zamanı bağlamada farklıdır.
  • Mantıksal adres alanı: programın ürettiği adresler kümesi; fiziksel adres alanı: bunlara karşılık gelen fiziksel adresler.
  • Çalışma anındaki dönüşümü MMU (bellek yönetim birimi) donanımı yapar. Program fiziksel adresleri hiç görmez.
  • Bugünkü işlemcilerde MMU, TLB’leri ve sayfa tablosu yürüyücüsüyle birlikte her çekirdeğin içindedir.
CPU yongasıCPUMMUsanalfiziksel adresveri yoluBellekDisk denetleyici

Adres Alanı · Adım adım

MMU ile Dinamik Yer Değiştirme

CPUmantıksal346< limit ?3.000limit yazmacıevet+14.000taban (yer değiştirme)fiziksel14.346Bellekhayırtuzak: adresleme hatası

Mantıksal 346 < 3.000 → fiziksel 346 + 14.000 = 14.346. Program 0 ile 2.999 arasını görür.

CPUmantıksal2.999< limit ?3.000limit yazmacıevet+14.000taban (yer değiştirme)fiziksel16.999Bellekhayırtuzak: adresleme hatası

2.999 son geçerli mantıksal adres → 16.999.

CPUmantıksal3.500< limit ?3.000limit yazmacıevet+14.000taban (yer değiştirme)fiziksel—Bellekhayırtuzak: adresleme hatası

3.500 ≥ limit → toplama yapılmadan tuzak. Karşılaştırma mantıksal adres üzerinden olduğu için taban değeri ne olursa olsun aynıdır.

CPUmantıksal28< limit ?16.384limit yazmacıevet+16.384taban (yer değiştirme)fiziksel16.412Bellekhayırtuzak: adresleme hatası

Önceki örnekteki B programı: taban = limit = 16.384. JMP 28 değişmeden kalır, MMU 28 + 16.384 = 16.412 üretir. Statik yer değiştirmeye gerek kalmaz.

Silberschatz’ın yer değiştirme yazmacı Tanenbaum’un taban yazmacıdır. Her erişimde bir toplama ve bir karşılaştırma gerekir; toplama, elde yayılımı yüzünden özel devre olmadan yavaştır.

Bağlama ve Yükleme · Kodu adım adım çalıştır

Dinamik Yükleme

#include <dlfcn.h>
#include <stdio.h>

int main(void) {
  void *h = dlopen("libm.so.6", RTLD_LAZY);
  if (!h) { puts(dlerror()); return 1; }
  double (*kok)(double) =
      (double (*)(double)) dlsym(h, "sqrt");
  printf("%.3f\n", kok(2.0));
  dlclose(h);
  return 0;
}
mainheaplibcyığınsürecin adres alanı0yüksek

Program başladı: adres alanında yalnız main, libc, heap ve yığın (stack) var; libm yüklü değil.

mainheaplibmlibcyığınsürecin adres alanı0yüksek

dlopen: dinamik bağlayıcı (ld.so) dosyayı bulur, mmap ile adres alanına eşler. Yükleme şimdi, programın isteğiyle olur.

mainheaplibmlibcyığınsürecin adres alanı0yüksek

dlsym sembol tablosunda sqrt’u arar ve o sürecin adres alanındaki adresini döndürür.

mainheaplibmlibcyığınsürecin adres alanı0yüksek

Fonksiyon işaretçisiyle çağrı yapılır; çıktı 1.414.

mainheaplibcyığınsürecin adres alanı0yüksek

dlclose: referans sayısı 0’a inince kütüphane adres alanından çıkarılır.

Rutin çağrılana kadar belleğe alınmaz; kullanılmayan kod hiç yüklenmez. Donanım desteği gerekmez, program böyle tasarlanır; işletim sistemi kütüphane sağlar (dlopen, Windows’ta LoadLibrary/GetProcAddress). glibc 2.34’ten beri -ldl gerekmez.

Bağlama ve Yükleme

Statik ve Dinamik Bağlama

Statik bağlamaDinamik bağlama
Kim, ne zaman?Bağlayıcı (ld), derlemeden sonraDinamik bağlayıcı (ld.so), yüklemede/çalışırken
Dosya.a, .lib.so, .dll, .dylib
BellekHer programda ayrı kopyaKod sayfaları bir kez bellekte, paylaşılır
GüncellemeYeniden bağlamak gerekirKütüphaneyi değiştirmek yeter (sürüm: soname)
RiskBüyük dosya, güvenlik yaması gecikirSürüm uyuşmazlığı (“DLL cehennemi”)
  • Statik: kütüphane rutinleri ikili dosyaya kopyalanır (ld *.o -lc -lm).
  • Dinamik: dosyada yalnızca bir taslak (stub) kalır; adres yürütme zamanında çözülür.
Süreç 1kodverilibc.soyığınSüreç 2kodverilibc.soyığınlibc kodutek kopyafiziksel bellek

Bağlama ve Yükleme · Adım adım

Tembel Bağlama: PLT ve GOT

maincall printf@pltPLT girdisijmp *GOT[printf]GOT[printf]→ çözücüld.so çözücü_dl_runtime_resolvelibc: printfgerçek kod1. çağrı

Derleyici printf’in adresini bilmez; çağrı küçük bir PLT (procedure linkage table) taslağına gider. Kitaplardaki taslak (stub) budur.

maincall printf@pltPLT girdisijmp *GOT[printf]GOT[printf]→ çözücüld.so çözücü_dl_runtime_resolvelibc: printfgerçek kod1. çağrı

PLT, GOT (global offset table) içindeki adrese dolaylı atlar. Başlangıçta GOT girdisi çözücüyü gösterir.

maincall printf@pltPLT girdisijmp *GOT[printf]GOT[printf]→ çözücüld.so çözücü_dl_runtime_resolvelibc: printfgerçek kodadresi yaz1. çağrı

ld.so çözücüsü sembolü yüklü kütüphanelerde arar, bulduğu adresi GOT’a yazar.

maincall printf@pltPLT girdisijmp *GOT[printf]GOT[printf]→ printfld.so çözücü_dl_runtime_resolvelibc: printfgerçek kod1. çağrı

Çözücü printf’e atlar. Kod sayfaları değişmedi; yalnızca sürece özel GOT sayfası değişti, bu yüzden kod paylaşılabilir kalır.

maincall printf@pltPLT girdisijmp *GOT[printf]GOT[printf]→ printfld.so çözücü_dl_runtime_resolvelibc: printfgerçek kod2. ve sonraki çağrılar

Sonraki çağrılar PLT → GOT → printf: yalnızca bir dolaylı atlama. Güvenlik için birçok dağıtım -z now (tam RELRO) ile tüm sembolleri yüklemede çözüp GOT’u salt okunur yapar.

Kitaplardaki “taslak kendini rutinin adresiyle değiştirir” anlatımı kavramsaldır; ELF sistemlerinde değişen kod değil, GOT girdisidir. Bunu işletim sistemi değil kullanıcı alanındaki dinamik bağlayıcı yapar.

Bağlama ve Yükleme

Kütüphane Oluşturma: Statik ve Paylaşımlı

Statik kütüphane

$ gcc -c func.c -o func.o
$ ar rcs libfunc.a func.o
$ gcc main.c -o main -static -L. -lfunc
$ ./main
  • ar nesne dosyalarını arşivler; bağlayıcı yalnızca gereken nesneleri kopyalar.
  • -static libc’nin de statik sürümünü (libc.a) ister.

Paylaşımlı kütüphane

$ gcc -fPIC -c func.c -o func.o
$ gcc -shared -o libfunc.so func.o
$ gcc main.c -o main -L. -lfunc
$ export LD_LIBRARY_PATH=$(pwd)
$ ./main
$ ldd ./main   (libfunc.so => ./libfunc.so)
  • -fPIC: konumdan bağımsız kod; mutlak adres yerine PC’ye göreli adresleme, veriye GOT üzerinden erişim.
  • Böylece aynı fiziksel sayfa her süreçte farklı sanal adrese eşlenebilir (ASLR).
  • LD_LIBRARY_PATH yerine kalıcı çözüm: -Wl,-rpath,'$ORIGIN' ya da ldconfig.
statik: her programda ayrı kopyamain1funcmain2funcpaylaşımlı: tek kopya, iki eşlememain1main2libfunc.so

Modern dağıtımlar programları da konumdan bağımsız (PIE) derler; böylece programın kendisi de ASLR ile rastgele adrese yüklenir.

Takas

Takas (Swapping)

  • Standart takas: bir sürecin tamamı geçici olarak yedekleme deposuna (disk) yazılır, sonra geri getirilir.
  • Toplam bellek ihtiyacı fiziksel belleği aşabilir; çoklu programlama derecesi artar.
  • Geri gelen süreç başka adrese yerleşebilir → yürütme zamanı bağlama gerekir.
  • Bedel: 100 MB süreç, 50 MB/s disk → 2 s dışarı + 2 s içeri = 4 s (Silberschatz).
  • Bekleyen G/Ç’si olan süreç takas edilmez (DMA eski adrese yazar) ya da G/Ç çekirdek tamponlarından yapılır.
İşletim sistemikullanıcı alanıP1(P2 için yer)ana bellekP1P2yedekleme deposu① dışarı② içeri

Takas

Sayfa Takası ve Modern Sistemler

  • Bütün süreci taşımak bugün kabul edilemez: 1 GiB süreç, 3 GB/s NVMe → gidiş-dönüş ≈ 0,72 s.
  • Linux, Windows, macOS sayfa takas eder: yalnızca uzun süredir kullanılmayan (soğuk) sayfalar dışarı gider, 4 KiB’lık bir sayfa onlarca µs’de gelir.
  • Diske gitmeden önce sıkıştırma: Linux zswap ve zram, Windows bellek sıkıştırma, macOS sıkıştırıcı.
  • Mobil: flash ömrü ve enerji yüzünden geleneksel takas yok ya da sınırlı; Android zram + lmkd, iOS sıkıştırma + uygulama sonlandırma (jetsam).
ana bellekP1 s0P2 s3P1 s2P3 s1takas alanıP1 s1P1 s4P2 s0P3 s0P2 s1sayfa dışarısayfa içeri

Bitişik Tahsis

Bitişik Bellek Tahsisi

  • Bellek iki bölgeye ayrılır: işletim sistemi ve kullanıcı süreçleri. Linux ve Windows çekirdeği yüksek adreslere koyar.
  • Her süreç tek, bitişik bir bölgede; koruma taban-limit ile.
  • Sabit bölümleme (IBM OS/360 MFT): bölüm sayısı = çoklu programlama derecesi; küçük süreç büyük bölümde → iç parçalanma.
  • Değişken bölümleme (MVT): bölüm süreç kadar; boş bloklara delik (hole) denir.
  • Süreçler büyür: veri kesimi (malloc) ve yığın için pay bırakılır. Takastan dönen süreç payıyla birlikte değil, kullandığı kadar getirilir.
(a)B (büyüme payı)BA (büyüme payı)AİS(b)B yığını ↓büyüme alanıB veri + kodA yığını ↓büyüme alanıA veri + kod

Bitişik Tahsis · Adım adım

Değişken Bölümleme

01024 KİS128 K896 Kdelikler: 896 K @ 128

Bellekte yalnız işletim sistemi var.

01024 KİS128 KA320 K576 Kdelikler: 576 K @ 448

A (320 K) gelir; ilk uygun boşluğa yerleşir.

01024 KİS128 KA320 KB224 K352 Kdelikler: 352 K @ 672

B (224 K) gelir; ilk uygun boşluğa yerleşir.

01024 KİS128 KA320 KB224 KC288 K64 Kdelikler: 64 K @ 960

C (288 K) gelir; ilk uygun boşluğa yerleşir.

01024 KİS128 K320 KB224 KC288 K64 Kdelikler: 320 K @ 128, 64 K @ 960

A sonlanır: 128–448 arası 320 K delik olur.

01024 KİS128 KD256 K64 KB224 KC288 K64 Kdelikler: 64 K @ 384, 64 K @ 960

D (256 K) A’nın deliğine girer; geriye 64 K’lık küçük bir delik kalır.

01024 KİS128 KD256 K288 KC288 K64 Kdelikler: 288 K @ 384, 64 K @ 960

B sonlanır: alanı solundaki 64 K delikle birleşir → 288 K. Bitişik delikler hemen birleştirilir.

01024 KİS128 KD256 KE192 K96 KC288 K64 Kdelikler: 96 K @ 576, 64 K @ 960

E (192 K) 288 K deliğe girer. Toplam boş 160 K ama iki parçaya dağılmış: dış parçalanma büyüyor.

  • İşletim sistemi tahsisli bölümleri ve delikleri bir tabloda (ya da listede) tutar.
  • Süreç gelince yeterince büyük bir delik bulunur, artan kısım delik olarak kalır; süreç bitince alanı deliğe döner ve komşularla birleşir.

Bitişik Tahsis

Yerleştirme Algoritmaları

İlk uyan (first fit)

Liste baştan taranır, ilk yeterli delikte durulur. Hızlı; başta küçük delikler birikir.

Sonraki uyan (next fit)

Arama son kalınan yerden sürer; ilk uyandan biraz kötü çıkar (Bays, 1977).

En iyi uyan (best fit)

Bütün liste taranır, ihtiyaca en yakın delik seçilir. Yavaş; işe yaramaz çok küçük delikler bırakır.

En kötü uyan (worst fit)

Kalan parça işe yarasın diye en büyük delik seçilir. Benzetimlerde iyi sonuç vermez.

Hızlı uyan (quick fit)

Sık istenen boyutlar için ayrı listeler (4 K, 8 K, 12 K …). Bulmak hızlı, birleştirmek pahalı.

Ortak iyileştirme

Süreçler ve delikler için ayrı listeler. Bugünkü malloc gerçeklemeleri (jemalloc, tcmalloc) boyut sınıfları kullanır.

Benzetimlere göre (Silberschatz, Knuth) zaman ve bellek kullanımında ilk uyan ve en iyi uyan, en kötü uyandan iyidir; ilk uyan genellikle daha hızlıdır.

Bitişik Tahsis · Kodu adım adım çalıştır

En İyi Uyan: Kod İzleme

int en_iyi(int delik[], int n, int istek) {
  int en = -1;
  for (int i = 0; i < n; i++)
    if (delik[i] >= istek &&
        (en == -1 || delik[i] < delik[en]))
      en = i;
  if (en != -1) delik[en] -= istek;
  return en;
}
/* delik = 120, 450, 230, 300, 180 (K) */
/* en_iyi(delik, 5, 210); en_iyi(delik, 5, 160); */
istek = 210 K120[0]450[1]230[2]300[3]180[4]

Delik listesi 120, 450, 230, 300, 180 K. İlk istek 210 K; en = −1 (aday yok).

istek = 210 K120[0]450[1]230[2]300[3]180[4]

[0] = 120 < 210: sığmaz, atla.

istek = 210 K120[0]450[1]230[2]300[3]180[4]

[1] = 450 ≥ 210 ve ilk aday → en = 1.

istek = 210 K120[0]450[1]230[2]300[3]180[4]

[2] = 230 ≥ 210 ve 450’den küçük → yeni en iyi en = 2.

istek = 210 K120[0]450[1]230[2]300[3]180[4]

[3] = 300 sığar ama mevcut en iyi 230 daha küçük: değişmez.

istek = 210 K120[0]450[1]230[2]300[3]180[4]

[4] = 180 < 210: sığmaz, atla.

istek = 210 K120[0]450[1]20[2]300[3]180[4]

Seçilen [2] deliğinden 210 K ayrılır; geriye 20 K’lık küçük bir delik kalır. Dönüş: 2. İlk uyan aynı istek için 450’yi bölerdi.

istek = 160 K120[0]450[1]20[2]300[3]180[4]

İkinci istek 160 K; delik [2] artık 20 K. Tarama yine baştan, tüm listeyi gezer.

istek = 160 K120[0]450[1]20[2]300[3]180[4]

[0] = 120 sığmaz; [1] = 450 ≥ 160 ve ilk aday → en = 1.

istek = 160 K120[0]450[1]20[2]300[3]180[4]

[2] = 20 sığmaz; [3] = 300 ≥ 160 ve 450’den küçük → yeni en iyi en = 3.

istek = 160 K120[0]450[1]20[2]300[3]180[4]

[4] = 180 ≥ 160 ve 300’den küçük → yeni en iyi en = 4.

istek = 160 K120[0]450[1]20[2]300[3]20[4]

Seçilen [4] deliğinden 160 K ayrılır; geriye 20 K’lık küçük bir delik kalır. Dönüş: 4. En iyi uyan iki kez işe yaramaz 20 K’lık delik bıraktı.

Bitişik Tahsis · Adım adım

Yerleştirme: Örnek

100 K500 K200 K300 K600 Kİlk uyanSonraki uyanEn iyi uyanEn kötü uyan

Delikler sırasıyla 100, 500, 200, 300, 600 K. İstekler sırayla: 212, 417, 112, 426 K.

100 K500 K200 K300 K600 Kİlk uyan212288212 K → 500 K boşluk (kalan 288 K)Sonraki uyan212288212 K → 500 K boşluk (kalan 288 K)En iyi uyan21288212 K → 300 K boşluk (kalan 88 K)En kötü uyan212388212 K → 600 K boşluk (kalan 388 K)

212 K: ilk/sonraki uyan 500’e, en iyi uyan 300’e (kalan 88), en kötü uyan 600’e koyar.

100 K500 K200 K300 K600 Kİlk uyan212288417183417 K → 600 K boşluk (kalan 183 K)Sonraki uyan212288417183417 K → 600 K boşluk (kalan 183 K)En iyi uyan4178321288417 K → 500 K boşluk (kalan 83 K)En kötü uyan41783212388417 K → 500 K boşluk (kalan 83 K)

417 K: ilk ve sonraki uyan 600’e; en iyi ve en kötü uyan 500’e (kalan 83).

100 K500 K200 K300 K600 Kİlk uyan212112176417183112 K → 288 K boşluk (kalan 176 K)Sonraki uyan21228841711271112 K → 183 K boşluk (kalan 71 K)En iyi uyan417831128821288112 K → 200 K boşluk (kalan 88 K)En kötü uyan41783212112276112 K → 388 K boşluk (kalan 276 K)

112 K: ilk uyan 288’lik artığa; sonraki uyan son kaldığı 183’e (kalan 71); en iyi uyan 200’e; en kötü uyan 388’e.

100 K500 K200 K300 K600 Kİlk uyan212112176417183426 K beklerSonraki uyan21228841711271426 K beklerEn iyi uyan417831128821288426174426 K → 600 K boşluk (kalan 174 K)En kötü uyan41783212112276426 K bekler

426 K: yalnız en iyi uyan yerleştirebilir (600 K hâlâ bütün). Diğerlerinde toplam boş alan yeter ama tek parça yok: dış parçalanma.

Etkileşimli simülatör: Bellek Tahsisi Simülatörü: ilk/sonraki/en iyi/en kötü uyan farklı isteklerle çalıştırılır, parçalanma ölçülür.

Bitişik Tahsis

İç ve Dış Parçalanma

  • Dış parçalanma: isteği karşılayacak toplam boş bellek var, ama bitişik değil. Değişken bölümlemenin sorunudur.
  • %50 kuralı (Knuth): ilk uyan ile N tahsisli blok varken yaklaşık 0,5 N blok parçalanmaya gider → belleğin üçte biri kullanılamaz.
  • İç parçalanma: verilen blok istenenden büyüktür; fark bloğun içinde boşa gider. Sabit bölümleme, sayfalama ve buddy’de görülür.
  • Çözümler: sıkıştırma (dış), sürecin adres alanının bitişik olmamasına izin vermek (sayfalama, kesimleme).
Dış parçalanmaP1P2P3403040110 K boş, ama en büyük parça 40 Kistek 60 K ✗İç parçalanmasüreç 18.462 B2 B18.464 B blok verildi; 2 B boşa (artığı izlemekdelikten pahalı olduğundan)

Bitişik Tahsis · Adım adım

Sıkıştırma (Compaction)

01024 KİS128 KP1160 K96 KP2192 K64 KP3128 K160 KP464 K

Başlangıç: dört süreç arasında 96 + 64 + 160 + 32 = 352 K boş alan, ama en büyük delik 160 K.

01024 KİS128 KP1160 KP2192 KP3128 KP464 K

P2 aşağı kaydırılır: 384 → 288. Taşınan sürecin taban yazmacı güncellenir.

01024 KİS128 KP1160 KP2192 KP3128 KP464 K

P3: 640 → 480.

01024 KİS128 KP1160 KP2192 KP3128 KP464 K

P4: 928 → 608. Artık tek bir 352 K’lık delik var. Toplam 384 K kopyalandı.

  • Sıkıştırma (compaction): süreçleri bir uca kaydırıp delikleri tek bloğa toplamak. Yalnızca yürütme zamanı bağlamada (taban yazmacı) mümkün.
  • Pahalı: Tanenbaum’a göre 16 GB bellek, 8 ns’de 8 bayt kopyalayarak ≈ 16 s; bugünkü ≈20 GB/s kopyalama hızıyla bile ≈ 0,9 s ve bu sırada süreçler durur.
  • Veri sıkıştırma (compression) ile karıştırılmamalı: amaç veriyi küçültmek değil, blokları bitiştirmektir.
  • Bugün: Linux, büyük sayfa için bitişik fiziksel çerçeve üretmek amacıyla sayfa göçü yapar (kcompactd).

Boş Alan Yönetimi

Boş Bellek Takibi: Biteşlem ve Bağlı Liste

(a) bellek, 32 birimABCDE08162432(b) biteşlem11111000111111111100111111111000(c) bağlı liste (S = süreç, D = delik, başlangıç, uzunluk)S 0 5D 5 3S 8 6S 14 4D 18 2S 20 6S 26 3D 29 3
BiteşlemBağlı liste
YapıHer tahsis birimine 1 bit (0 boş, 1 dolu)Her süreç/delik için düğüm (S/D, başlangıç, uzunluk)
BoyutSabit: birim 4 B ise belleğin 1/33’ü; 16 GiB, 4 KiB birim → 512 KiBSüreç + delik sayısıyla orantılı
Aramak ardışık 0 bulmak yavaşDelik listesi gezilir; adrese göre sıralı tutulursa birleştirme kolay

Boş Alan Yönetimi · Kodu adım adım çalıştır

Biteşlemde Boş Alan Arama: Kod İzleme

/* k ardışık boş (0) birim ara */
int bul(const char bit[], int n, int k) {
  int bas = 0, uz = 0;
  for (int i = 0; i < n; i++) {
    if (bit[i] == 0) {
      if (uz == 0) bas = i;  /* yeni koşu */
      if (++uz == k) return bas;
    } else
      uz = 0;                /* koşu bozuldu */
  }
  return -1;
}
10110203140506071819turuncu: süren boş koşu · yeşil: bulunan alan

Bellek 10 birim; dolu birimler 1. k = 3 birimlik bir süreç için ardışık üç 0 aranıyor.

10110203140506071819ituruncu: süren boş koşu · yeşil: bulunan alan

bit[0] = 1: dolu birim, uz = 0 kalır.

10110203140506071819ituruncu: süren boş koşu · yeşil: bulunan alan

bit[1] = 1: dolu birim, uz = 0 kalır.

10110203140506071819ituruncu: süren boş koşu · yeşil: bulunan alan

bit[2] = 0 ve önceki koşu yok → yeni koşu bas = 2, uz = 1.

10110203140506071819ituruncu: süren boş koşu · yeşil: bulunan alan

bit[3] = 0 → koşu uzar: uz = 2; henüz k’ye ulaşmadı.

10110203140506071819ituruncu: süren boş koşu · yeşil: bulunan alan

bit[4] = 1: 2 birimlik koşu yetmeden bozuldu → uz = 0. 2–3 arasındaki delik bu süreç için küçük.

10110203140506071819ituruncu: süren boş koşu · yeşil: bulunan alan

bit[5] = 0 ve önceki koşu yok → yeni koşu bas = 5, uz = 1.

10110203140506071819ituruncu: süren boş koşu · yeşil: bulunan alan

bit[6] = 0 → koşu uzar: uz = 2; henüz k’ye ulaşmadı.

10110203140506071819ituruncu: süren boş koşu · yeşil: bulunan alan

bit[7] = 0 → uz = 3 = k: koşu yeterli, başlangıç 5 döndürülür.

10110203140506071819turuncu: süren boş koşu · yeşil: bulunan alan

Ayırıcı 5, 6, 7. bitleri 1 yapar. Arama dizinin başından doğrusal ilerler; büyük biteşlemde bu yüzden yavaştır.

Boş Alan Yönetimi · Adım adım

Bağlı Listede Serbest Bırakma

X sonlanmadan önceAXBsonraAdelikB

Komşuların ikisi de süreç: X’in düğümü D’ye çevrilir, liste uzunluğu değişmez.

X sonlanmadan önceAXdeliksonraAdelik

Sağda delik: X ile sağdaki delik birleşir, bir düğüm silinir.

X sonlanmadan öncedelikXBsonradelikB

Solda delik: soldaki delik X kadar uzar, X’in düğümü silinir.

X sonlanmadan öncedelikXdeliksonradelik

İki yanda delik: üç düğüm tek deliğe iner, iki düğüm silinir. Önceki düğümü bulmak için çift bağlı liste kullanmak kolaylık sağlar.

  • Liste adrese göre sıralı tutulursa birleştirme komşulara bakarak sabit zamanda yapılır.
  • Delikleri ayrı bir listede, boyuta göre sıralı tutmak en iyi uyanı hızlandırır (ilk uyan = en iyi uyan olur) ama serbest bırakmayı yavaşlatır.
  • Delik listesi deliklerin kendi içinde saklanabilir: her deliğin ilk sözcükleri boyut ve sonraki delik işaretçisidir.

Boş Alan Yönetimi · Adım adım

malloc İçinde: Başlık ve Gömülü Boş Liste

heap: 4.096 BBboş: boy 4.080B = 16 B başlık: kullanımdaysa {boy, sihirli sayı}, boşsa {boy, sonraki}boş liste:head → [4.080] → NULLkütüphane heap’i mmap/sbrk ile alır ve tamamını tek boş parça yapar: 4.096 − 16 = 4.080

Başlangıç: tek boş parça. Boş listenin düğümü parçanın kendi içinde durur; ayrı bir veri yapısı için malloc çağrılamaz.

heap: 4.096 BBp1: 200Bboş: boy 3.864B = 16 B başlık: kullanımdaysa {boy, sihirli sayı}, boşsa {boy, sonraki}boş liste:head → [3.864] → NULLmalloc(200) 216 B kullanır: 4.080 − 216 = 3.864; p1 başlığın hemen arkasını gösterir

p1 = malloc(200): ilk uyan parça bölünür. Başlığa boy ve sihirli sayı yazılır.

heap: 4.096 BBp1: 200Bp2: 100Bp3: 300Bboş: 3.432B = 16 B başlık: kullanımdaysa {boy, sihirli sayı}, boşsa {boy, sonraki}boş liste:head → [3.432] → NULL3.864 − (100 + 16) − (300 + 16) = 3.432

p2 = malloc(100), p3 = malloc(300): aynı bölme tekrarlanır.

heap: 4.096 BBp1: 200Bboş: 100Bp3: 300Bboş: 3.432B = 16 B başlık: kullanımdaysa {boy, sihirli sayı}, boşsa {boy, sonraki}boş liste:head → [100] → [3.432] → NULLfree(p2): başlık = (char *)p2 − 16 → boy 100 okunur, parça listenin başına eklenir

free(p2) boyut almaz: boy başlıktan okunur. Artık 150 B’lık istek 100’lük parçaya sığmaz: dış parçalanma.

heap: 4.096 BBboş: boy 316Bp3: 300Bboş: 3.432B = 16 B başlık: kullanımdaysa {boy, sihirli sayı}, boşsa {boy, sonraki}boş liste:head → [316] → [3.432] → NULLfree(p1): komşu boş parçayla birleşir: 216 + 116 = 332 B → boy 332 − 16 = 316

free(p1): adrese göre komşu iki boş parça birleştirilir; liste kısalır.

Sihirli sayıBaşlıktaki sabit desen bozulmuşsa (taşma, çift free, yanlış işaretçi) kütüphane bunu fark edip programı durdurabilir.
Gerçek istekmalloc(n) en az n + başlık bayt tüketir; hizalama için yukarı yuvarlanır (glibc: 16 B).
Sistem çağrısı mı?Hayır, kütüphane işlevidir. Yer bitince brk/sbrk ile heap’i büyütür; büyük istekleri (glibc’de ≥ 128 KiB) doğrudan mmap ile alır.

Sayfalama

Sayfalama: Temel Fikir

  • Fiziksel bellek sabit boyutlu çerçevelere (frame), mantıksal bellek aynı boyutta sayfalara (page) bölünür.
  • Sürecin fiziksel alanı bitişik olmak zorunda değil → dış parçalanma yok; yalnızca son sayfada iç parçalanma.
  • N sayfalık süreç için N boş çerçeve yeter; işletim sistemi boş çerçeveleri izler.
  • Sayfa tablosu sayfa numarasını çerçeve numarasına eşler; her sürecin kendi tablosu vardır.
  • Yedekleme deposu da aynı boyutlu bloklara bölünür.
mantıksal belleksayfa 0sayfa 1sayfa 2sayfa 3sayfa tablosu01142337fiziksel bellek01sayfa 023sayfa 24sayfa 1567sayfa 3

Sayfalama

Adresin Bölünmesi: (p, d)

p: sayfa numarasım − n bitd: sayfa içi konumn bitmantıksal adres alanı 2^m, sayfa boyutu 2^n32 bit, 4 KiB:p = 20 bitd = 12 bit
ÖrnekHesapSonuç
32 bit adres, 4 KiB sayfa4096 = 212 → d 12 bit, p = 32 − 12 = 20 bit220 = 1.048.576 sayfa
0x12345678p = 0x12345678 >> 12, d = 0x12345678 & 0xFFFp = 0x12345 (74.565), d = 0x678 (1656)
16 bit adres, 4 KiB (Tanenbaum)8196 = 2·4096 + 4p = 2, d = 4
48 bit (x86-64), 4 KiBp = 48 − 1236 bit sayfa numarası

Sayfa boyutu 2’nin kuvveti olduğu için bölme ve kalan birer bit kaydırma ve maskeleme işlemidir; donanım bunu bedavaya yapar. Fiziksel adres = çerçeve × sayfa boyutu + d.

Sayfalama · Adım adım

Sayfa Tablosu ile Çeviri

mantıksala0b1c2d3e4f5g6h7i8j9k10l11m12n13o14p15sayfa tablosu05162132fiziksel bellek (32 bayt)0çerçeve 04ijklçerçeve 18mnopçerçeve 212çerçeve 316çerçeve 420abcdçerçeve 524efghçerçeve 628çerçeve 7

Sayfa boyutu 4 bayt, fiziksel bellek 32 bayt (8 çerçeve). 16 baytlık mantıksal bellek a…p; sayfa tablosu 0→5, 1→6, 2→1, 3→2.

mantıksala0b1c2d3e4f5g6h7i8j9k10l11m12n13o14p15sayfa tablosu05162132fiziksel bellek (32 bayt)0çerçeve 04ijklçerçeve 18mnopçerçeve 212çerçeve 316çerçeve 420abcdçerçeve 524efghçerçeve 628çerçeve 7adres 0 → p = 0, d = 05 × 4 + 0 = 20

Mantıksal 0 (a): sayfa 0, konum 0 → çerçeve 5 → fiziksel 20.

mantıksala0b1c2d3e4f5g6h7i8j9k10l11m12n13o14p15sayfa tablosu05162132fiziksel bellek (32 bayt)0çerçeve 04ijklçerçeve 18mnopçerçeve 212çerçeve 316çerçeve 420abcdçerçeve 524efghçerçeve 628çerçeve 7adres 3 → p = 0, d = 35 × 4 + 3 = 23

Mantıksal 3 (d): sayfa 0, konum 3 → çerçeve 5 → fiziksel 23.

mantıksala0b1c2d3e4f5g6h7i8j9k10l11m12n13o14p15sayfa tablosu05162132fiziksel bellek (32 bayt)0çerçeve 04ijklçerçeve 18mnopçerçeve 212çerçeve 316çerçeve 420abcdçerçeve 524efghçerçeve 628çerçeve 7adres 4 → p = 1, d = 06 × 4 + 0 = 24

Mantıksal 4 (e): sayfa 1, konum 0 → çerçeve 6 → fiziksel 24.

mantıksala0b1c2d3e4f5g6h7i8j9k10l11m12n13o14p15sayfa tablosu05162132fiziksel bellek (32 bayt)0çerçeve 04ijklçerçeve 18mnopçerçeve 212çerçeve 316çerçeve 420abcdçerçeve 524efghçerçeve 628çerçeve 7adres 13 → p = 3, d = 12 × 4 + 1 = 9

Mantıksal 13 (n): sayfa 3, konum 1 → çerçeve 2 → fiziksel 9. Sürecin sırası fiziksel bellekte korunmaz; yine de program ardışık görür.

Silberschatz Şekil 9.10’daki örnek. Sayfa tablosu girişinin indisi sayfa numarasıdır; sayfa numarası tabloda saklanmaz.

Sayfalama · Kodu adım adım çalıştır

MMU İçinde Çeviri

/* 16 bit sanal adres, 4 KiB sayfa */
MOV REG, 0
MOV REG, 8192
MOV REG, 20500
MOV REG, 8196
MOV REG, 32780

/* sayfa tablosu (sayfa → çerçeve) */
/* 0→2 1→1 2→6 3→0 4→4 5→3 */
/* 9→5 11→7, diğerleri: yok */
sanal adres 00000000000000000p = 0d = 0çerçeve 2 + d → fiziksel 8192010000000000000

Sayfa 0 → çerçeve 2: 8192. Üst 4 bit sayfa numarası, alt 12 bit aynen kopyalanır.

sanal adres 81920010000000000000p = 2d = 0çerçeve 6 + d → fiziksel 24576110000000000000

8192 = sayfa 2, konum 0 → çerçeve 6: 24576.

sanal adres 205000101000000010100p = 5d = 20çerçeve 3 + d → fiziksel 12308011000000010100

20500 = 5·4096 + 20 → çerçeve 3: 12288 + 20 = 12308.

sanal adres 81960010000000000100p = 2d = 4çerçeve 6 + d → fiziksel 24580110000000000100

8196 = 2·4096 + 4 → 6·4096 + 4 = 24580 (Tanenbaum Şekil 3-10).

sanal adres 327801000000000001100p = 8d = 12sayfa 8 yok → sayfa hatası (tuzak)

32780 = 8·4096 + 12; sayfa 8 eşlenmemiş (mevcut/yok biti 0) → sayfa hatası; işletim sistemi devreye girer.

64 KiB sanal adres alanı (16 sayfa), 32 KiB fiziksel bellek (8 çerçeve → çerçeve numarası 3 bit).

Sayfalama

Sayfa Boyutu ve İç Parçalanma

  • Örnek: sayfa 2.048 B, süreç 72.766 B → 35 sayfa + 1.086 B → 36 çerçeve, son sayfada 962 B iç parçalanma.
  • En kötü durumda iç parçalanma 1 sayfa − 1 bayt, ortalama yarım sayfa.
  • Küçük sayfa: az israf ama büyük sayfa tablosu, çok TLB ıskası. Büyük sayfa: verimli disk G/Ç, az tablo girdisi.
  • Ek yük = s·e/p + p/2 (s süreç boyutu, e girdi boyutu). Türevi sıfır: p = √(2se); s = 1 MiB, e = 8 B → p = 4096.
  • Bugün: x86-64 4 KiB (+ 2 MiB, 1 GiB büyük sayfa), ARM64 4/16/64 KiB, Apple Silicon 16 KiB.
10 K20 K30 K5121 K2 K4 K8 K16 K32 K64 Ken az: 4 KiBsayfa boyutu p (log ölçek)

Sayfalama

Boş Çerçeveler

önceboş çerçeve listesi:14, 13, 18, 20, 15yeni süreç: 4 sayfasayfa 0sayfa 1sayfa 2sayfa 3131415161718192021sonraboş liste: 15sayfa tablosu01411321832013sayfa 114sayfa 015161718sayfa 21920sayfa 321
  • İşletim sistemi bir çerçeve tablosu tutar: her fiziksel çerçeve için boş mu, hangi sürecin hangi sayfası.
  • Kullanıcı süreci adres verdiğinde (ör. read tamponu) çekirdek bunu sürecin sayfa tablosuyla fiziksel adrese çevirir.
  • Bağlam değiştirmede dağıtıcı yeni sürecin sayfa tablosunu etkinleştirir (x86’da CR3): bağlam değiştirme süresi uzar.

Sayfalama

Sayfa Tablosu Girdisi

NX63PK62–59—58–52çerçeve numarası51–12—11–9G8PAT7D6A5PCD4PWT3U/S2R/W1P0x86-64 sayfa tablosu girdisi (64 bit, 4 KiB sayfa)
BitAnlamı (Tanenbaum adı)Kim yazar?
PMevcut/yok (present/absent): 0 ise erişim sayfa hatası üretirİS
R/W, U/S, NXKoruma: yazılabilir mi, kullanıcı modu erişebilir mi, çalıştırılabilir miİS
AErişildi (referenced): okuma ya da yazmada 1 olur; sayfa yer değiştirmede kullanılırdonanım (İS sıfırlar)
DDeğiştirildi (modified, kirli): yazmada 1; kirli sayfa çıkarılırken diske yazılırdonanım
PCD, PWT, PATÖnbellek devre dışı / yazma politikası: bellek eşlemeli G/Ç içinİS
GGlobal: bağlam değiştirmede TLB’den silinmez (çekirdek sayfaları)İS

Disk adresi PTE’de tutulmaz: sayfa bellekte değilse girdinin geri kalan bitleri işletim sistemine aittir (Linux takas girdisini buraya kodlar).

Sayfalama · Adım adım

Geçerli / Geçersiz Biti

süreç: 0 … 10.468sayfa 0sayfa 1sayfa 2sayfa 3sayfa 4sayfa 5sayfa 6sayfa 7sayfa tablosu02g13g24g37g48g59g60ğ70ğ14 bit adres: 0 … 16.383sayfa 2 KiB → 8 sayfag = geçerli, ğ = geçersiz

Süreç 0–10.468 arasını kullanır: sayfa 0–5 geçerli (çerçeve 2, 3, 4, 7, 8, 9), sayfa 6 ve 7 geçersiz.

süreç: 0 … 10.468sayfa 0sayfa 1sayfa 2sayfa 3sayfa 4sayfa 5sayfa 6sayfa 7sayfa tablosu02g13g24g37g48g59g60ğ70ğ14 bit adres: 0 … 16.383sayfa 2 KiB → 8 sayfag = geçerli, ğ = geçersizadres 3.000= 1 × 2048 + 952 → sayfa 1geçerli → çerçeve 3fiziksel = 3 × 2048 + 952 = 7.096

3.000: sayfa 1, konum 952 → çerçeve 3 → 7.096.

süreç: 0 … 10.468sayfa 0sayfa 1sayfa 2sayfa 3sayfa 4sayfa 5sayfa 6sayfa 7sayfa tablosu02g13g24g37g48g59g60ğ70ğ14 bit adres: 0 … 16.383sayfa 2 KiB → 8 sayfag = geçerli, ğ = geçersizadres 10.468= 5 × 2048 + 228 → sayfa 5geçerli → çerçeve 9fiziksel = 9 × 2048 + 228 = 18.660

10.468: sayfa 5’in içinde → 18.660. Sürecin son adresi.

süreç: 0 … 10.468sayfa 0sayfa 1sayfa 2sayfa 3sayfa 4sayfa 5sayfa 6sayfa 7sayfa tablosu02g13g24g37g48g59g60ğ70ğ14 bit adres: 0 … 16.383sayfa 2 KiB → 8 sayfag = geçerli, ğ = geçersizadres 12.000= 5 × 2048 + 1760 → sayfa 5geçerli → çerçeve 9fiziksel = 9 × 2048 + 1760 = 20.192

12.000 program dışında ama sayfa 5 içinde (10.240–12.287) → donanım yakalamaz: 20.192. Sayfa ayrıntı düzeyinin bedeli, iç parçalanma.

süreç: 0 … 10.468sayfa 0sayfa 1sayfa 2sayfa 3sayfa 4sayfa 5sayfa 6sayfa 7sayfa tablosu02g13g24g37g48g59g60ğ70ğ14 bit adres: 0 … 16.383sayfa 2 KiB → 8 sayfag = geçerli, ğ = geçersizadres 12.500= 6 × 2048 + 212 → sayfa 6geçersiz bit → tuzak (koruma hatası)

12.500: sayfa 6, geçersiz → tuzak. İşletim sistemi bunu geçersiz erişim (SIGSEGV) mi yoksa henüz yüklenmemiş sayfa mı diye ayırır.

Tablonun tamamını tutmak yerine sayfa tablosu uzunluk yazmacı (PTLR) da kullanılabilir: uzunluğu aşan sayfa numarası tuzak üretir (Silberschatz Şekil 9.13).

Sayfalama

Koruma Bitleri

Okuma / yazma (R/W)

Kod sayfaları salt okunur eşlenir; koda yazma girişimi koruma hatası üretir.

Kullanıcı / denetçi (U/S)

Çekirdek sayfaları kullanıcı modunda erişilemez. Aynı tabloda hem çekirdek hem süreç eşlemeleri durabilir.

Çalıştırma yasağı (NX / XD)

Veri, yığın ve heap sayfalarında kod çalıştırılamaz. İşletim sistemleri W^X uygular: bir sayfa ya yazılabilir ya çalıştırılabilir.

SMEP / SMAP

Çekirdek modundayken kullanıcı sayfalarındaki kodu çalıştırmayı (SMEP) ve izinsiz veriye erişmeyi (SMAP) engeller.

Koruma anahtarları (PKU)

PTE’deki 4 bitlik anahtar ve kullanıcı yazmacı (PKRU) ile sistem çağrısı olmadan sayfa grubunun iznini değiştirmek.

Geçerli / geçersiz

Erişim izni en kaba düzeyde: sayfa adres alanında hiç yoksa her erişim tuzaktır.

Koruma sayfa ayrıntı düzeyindedir: izin her PTE’de ayrı tutulur ve her erişimde TLB girdisiyle birlikte denetlenir.

Sayfalama

Paylaşımlı Sayfalar

  • Yeniden girilebilir (reentrant), kendini değiştirmeyen kod paylaşılabilir: üç kullanıcı aynı editörü çalıştırırsa kod çerçeveleri bir kez bellekte olur; yalnızca veri sayfaları ayrıdır.
  • Paylaşımlı kütüphaneler (libc) bu şekilde paylaşılır. Sayfa sahibi süreç bitince çerçeve hemen boşaltılamaz: referans sayısı tutulur.
  • fork(): ebeveyn ve çocuk tüm sayfaları yazınca kopyala (COW) ile paylaşır; sayfalar salt okunur işaretlenir, ilk yazmada kopya çıkarılır.
  • Bellek eşlemeli dosya (mmap) ve paylaşımlı bellek (shm_open): iki süreç aynı çerçeveleri görür, kopyalama olmadan iletişim kurar.
P1ed 1 → 3ed 2 → 4ed 3 → 6P1 veri → 1P2ed 1 → 3ed 2 → 4ed 3 → 6P2 veri → 7P3ed 1 → 3ed 2 → 4ed 3 → 6P3 veri → 2fiziksel bellek (çerçeve no. altta)0P11P32ed 13ed 245ed 36P27

TLB

Sayfa Tablosu Nerede? TLB

CPUpdTLB (ilişkisel bellek)sayfaçerçeveisabetfdfiziksel adresFiziksel bellekıskasayfa tablosu (bellekte)PTBRgirdi TLB’ye yüklenir
  • Tablo yazmaçlarda tutulamayacak kadar büyüktür; bellekte durur, başlangıcını PTBR (x86: CR3, ARM: TTBR0/1) gösterir. Ama her erişim iki bellek erişimi olur.
  • TLB (translation look-aside buffer): MMU içindeki küçük, hızlı, ilişkisel (paralel aranan) önbellek; tipik 64 girdi L1 + 1–3 bin girdi L2.
  • Girdiler ASID/PCID ile etiketlenirse bağlam değiştirmede TLB boşaltılmak zorunda kalmaz.

TLB · Adım adım

TLB İsabet ve Iska

erişim dizisi (16 bit, 4 KiB sayfa)0x0010p = 00x2004p = 20x0020p = 00x5010p = 50x9000p = 90x2008p = 20xB004p = 110x0030p = 0TLB (4 girdi, LRU; soldan sağa en eskiden en yeniye)

Sayfa tablosu MMU örneğindeki Tanenbaum tablosu (0→2, 2→6, 5→3, 9→5, 11→7). TLB başlangıçta boş.

erişim dizisi (16 bit, 4 KiB sayfa)0x0010p = 0ıska0x2004p = 20x0020p = 00x5010p = 50x9000p = 90x2008p = 20xB004p = 110x0030p = 0TLB (4 girdi, LRU; soldan sağa en eskiden en yeniye)0 → 2fiziksel2·4096 + 16 = 0x2010

0x0010: sayfa 0 yok → ıska; sayfa tablosundan okunur, TLB’ye yazılır.

erişim dizisi (16 bit, 4 KiB sayfa)0x0010p = 0ıska0x2004p = 2ıska0x0020p = 00x5010p = 50x9000p = 90x2008p = 20xB004p = 110x0030p = 0TLB (4 girdi, LRU; soldan sağa en eskiden en yeniye)0 → 22 → 6fiziksel6·4096 + 4 = 0x6004

0x2004: sayfa 2 yok → ıska; sayfa tablosundan okunur, TLB’ye yazılır.

erişim dizisi (16 bit, 4 KiB sayfa)0x0010p = 0ıska0x2004p = 2ıska0x0020p = 0isabet0x5010p = 50x9000p = 90x2008p = 20xB004p = 110x0030p = 0TLB (4 girdi, LRU; soldan sağa en eskiden en yeniye)2 → 60 → 2fiziksel2·4096 + 32 = 0x2020

0x0020: sayfa 0 TLB’de → isabet, sayfa tablosuna gidilmez.

erişim dizisi (16 bit, 4 KiB sayfa)0x0010p = 0ıska0x2004p = 2ıska0x0020p = 0isabet0x5010p = 5ıska0x9000p = 90x2008p = 20xB004p = 110x0030p = 0TLB (4 girdi, LRU; soldan sağa en eskiden en yeniye)2 → 60 → 25 → 3fiziksel3·4096 + 16 = 0x3010

0x5010: sayfa 5 yok → ıska; sayfa tablosundan okunur, TLB’ye yazılır.

erişim dizisi (16 bit, 4 KiB sayfa)0x0010p = 0ıska0x2004p = 2ıska0x0020p = 0isabet0x5010p = 5ıska0x9000p = 9ıska0x2008p = 20xB004p = 110x0030p = 0TLB (4 girdi, LRU; soldan sağa en eskiden en yeniye)2 → 60 → 25 → 39 → 5fiziksel5·4096 + 0 = 0x5000

0x9000: sayfa 9 yok → ıska; sayfa tablosundan okunur, TLB’ye yazılır.

erişim dizisi (16 bit, 4 KiB sayfa)0x0010p = 0ıska0x2004p = 2ıska0x0020p = 0isabet0x5010p = 5ıska0x9000p = 9ıska0x2008p = 2isabet0xB004p = 110x0030p = 0TLB (4 girdi, LRU; soldan sağa en eskiden en yeniye)0 → 25 → 39 → 52 → 6fiziksel6·4096 + 8 = 0x6008

0x2008: sayfa 2 TLB’de → isabet, sayfa tablosuna gidilmez.

erişim dizisi (16 bit, 4 KiB sayfa)0x0010p = 0ıska0x2004p = 2ıska0x0020p = 0isabet0x5010p = 5ıska0x9000p = 9ıska0x2008p = 2isabet0xB004p = 11ıska0x0030p = 0TLB (4 girdi, LRU; soldan sağa en eskiden en yeniye)5 → 39 → 52 → 611 → 7fiziksel7·4096 + 4 = 0x7004çıkarılan: sayfa 0

0xB004: sayfa 11 yok → ıska; sayfa tablosundan okunur, TLB’ye yazılır; dolu olduğu için en uzun süredir kullanılmayan sayfa 0 çıkarılır.

erişim dizisi (16 bit, 4 KiB sayfa)0x0010p = 0ıska0x2004p = 2ıska0x0020p = 0isabet0x5010p = 5ıska0x9000p = 9ıska0x2008p = 2isabet0xB004p = 11ıska0x0030p = 0ıskaTLB (4 girdi, LRU; soldan sağa en eskiden en yeniye)9 → 52 → 611 → 70 → 2fiziksel2·4096 + 48 = 0x2030çıkarılan: sayfa 5

0x0030: sayfa 0 yok → ıska; sayfa tablosundan okunur, TLB’ye yazılır; dolu olduğu için en uzun süredir kullanılmayan sayfa 5 çıkarılır. Toplam: 2 isabet / 8 erişim. Gerçek programlarda yerellik sayesinde oran %99’u aşar.

Etkileşimli simülatör: Sayfalama ve Adres Çevirisi Simülatörü: farklı adreslerle TLB isabet/ıska ve sayfa hatası.

TLB · Adım adım hesap

Etkin Erişim Süresi

TLB arama süresi ε = 20 ns, bellek erişimi t = 100 ns, isabet oranı α.
EES = (t + ε)·α + (2t + ε)·(1 − α) = 2t + ε − t·α

Formül: isabette bir bellek erişimi, ıskada iki (tablo + veri).

İsabet: 20 + 100 = 120 ns; ıska: 20 + 100 + 100 = 220 ns

İki durumun süresi.

α = %80: 120 × 0,80 + 220 × 0,20 = 140 ns (%40 yavaşlama)

%80 isabette ortalama 140 ns: TLB’siz 200 ns’ye göre iyi, ama hâlâ bellekten %40 yavaş.

α = %98: 120 × 0,98 + 220 × 0,02 = 122 ns

%98 isabette 122 ns. Gerçek iş yüklerinde oran genellikle %99’un üzerindedir.

Dört düzeyli tablo (x86-64): ıska = 20 + 4·100 + 100 = 520 ns; α = %98 → 128 ns, α = %99 → 124 ns

Çok düzeyli tabloda ıska çok daha pahalıdır; bu yüzden donanım ara düzeyleri de önbelleğe alır (sayfa yürüme önbelleği) ve TLB isabet oranı daha da önemlidir.

TLB

TLB Yönetimi

KonuAçıklama
Donanım yönetimlix86-64, ARMv8, RISC-V: ıskada MMU sayfa tablosunu kendisi yürür (page walk); işletim sistemi yalnızca tabloyu kurar.
Yazılım yönetimliMIPS, SPARC, Alpha gibi eski RISC’lerde ıska işletim sistemine tuzak olur; çekirdek girdiyi bulup TLB’ye yazar. Bu tüm RISC’ler için geçerli değildir: ARMv8 ve RISC-V donanım yönetimlidir.
Yumuşak / sert ıskaYumuşak ıska: sayfa bellekte, yalnızca TLB’de yok (ns). Sert ıska: sayfa diskte, G/Ç gerekir (µs–ms).
ASID / PCIDGirdi süreç kimliğiyle etiketlenir; bağlam değiştirmede TLB temizlenmez. Meltdown (2018) sonrası KPTI’nin maliyetini PCID azaltır.
Global girdilerÇekirdek eşlemeleri G biti ile işaretlenir, tüm süreçlerde geçerli kalır.
TLB vurusu (shootdown)Çok çekirdekte bir eşleme değişince diğer çekirdeklerin TLB’leri kesmeler (IPI) ile geçersizlenir; yeni işlemcilerde yayın komutları var (AMD INVLPGB).
TLBASID 7 · sayfa 0x400 → 0x1A2ASID 9 · sayfa 0x400 → 0x3F0ASID — · sayfa 0xFFFF8 → 0x001 · Gaynı sanal sayfa, iki süreç: girdiler ASID ile ayrılırG: tüm süreçlerde geçerli (çekirdek)

Sayfa Tablosu Yapıları

Hiyerarşik (İki Düzeyli) Sayfa Tablosu

  • Tek düzeyli tablo, 32 bit ve 4 KiB sayfada 220 girdi × 4 B = 4 MiB; her süreç için ve bitişik olmalı.
  • 64 bitte tek düzey: 252 × 8 B = 32 PiB (≈ 33,6 milyon GiB). 48 bit kullanılsa bile 236 × 8 B = 512 GiB.
  • Çözüm: tabloyu sayfalamak. 32 bit x86: 10 bit üst tablo (sayfa dizini), 10 bit ikinci düzey, 12 bit konum. Bölünen şey PTE değil, sanal adrestir.
  • Yalnız kullanılan bölgelerin ikinci düzey tablosu var: 4 MiB kod + 4 MiB veri + 4 MiB yığın kullanan süreç → 1 + 3 tablo = 16 KiB (4 MiB yerine).
PT110 bitPT210 bitkonum12 bit32 bit sanal adresüst tablo (1024)0: kod1: veri2⋮1023: yığın2. düzey: kod2. düzey: veri2. düzey: yığıngeri kalan 1021 üst girdi: “yok”

Sayfa Tablosu Yapıları · Adım adım

İki Düzeyli Çeviri Örneği

sanal adres 0x00403004 = 4.206.59600000000010000000011000000000100PT1 = 1PT2 = 3konum = 4üst tablo00–4 MiB14–8 MiB28–12 MiB3…

Sanal adres 0x00403004 (4.206.596): 4 MiB ile 8 MiB arasında, veri bölgesinde (Tanenbaum Şekil 3-13).

sanal adres 0x00403004 = 4.206.59600000000010000000011000000000100PT1 = 1PT2 = 3konum = 4üst tablo00–4 MiB14–8 MiB28–12 MiB3…

Üst 10 bit PT1 = 1: üst tablonun 1. girdisi 4–8 MiB bölgesinin ikinci düzey tablosunu gösterir. Her girdi 4 MiB’ı kapsar.

sanal adres 0x00403004 = 4.206.59600000000010000000011000000000100PT1 = 1PT2 = 3konum = 4üst tablo00–4 MiB14–8 MiB28–12 MiB3…2. düzey tablo (4–8 MiB)00x0A210x1C02yok30x1F340x0B7

Sonraki 10 bit PT2 = 3: o tablonun 3. girdisine bakılır (12.288–16.383 bayt aralığındaki sayfa). Mevcut biti 0 olsaydı sayfa hatası.

sanal adres 0x00403004 = 4.206.59600000000010000000011000000000100PT1 = 1PT2 = 3konum = 4üst tablo00–4 MiB14–8 MiB28–12 MiB3…2. düzey tablo (4–8 MiB)00x0A210x1C02yok30x1F340x0B7çerçeve 0x1F3fiziksel 0x1F3004

Girdi çerçeve numarasını verir (örnekte 0x1F3); konum = 4 eklenir → fiziksel 0x1F3004. Iskada 2 tablo erişimi + 1 veri erişimi.

Örnekteki çerçeve numaraları açıklama amaçlıdır. 32 bit x86’da üst tablonun adresi CR3’tedir; her iki düzeydeki tablo tam bir 4 KiB sayfa doldurur (1024 × 4 B).

Sayfa Tablosu Yapıları · Kodu adım adım çalıştır

İki Düzeyli Çeviri: Kod İzleme

/* 32 bit: 10 + 10 + 12 bit */
uint32_t cevir(uint32_t va) {
  uint32_t p1 = va >> 22;
  uint32_t p2 = (va >> 12) & 0x3FF;
  uint32_t d  = va & 0xFFF;
  pte_t e1 = ust[p1];
  if (!e1.p) sayfa_hatasi(va);
  pte_t e2 = e1.tablo[p2];
  if (!e2.p) sayfa_hatasi(va);
  return (e2.cerceve << 12) | d;
}
va = 0x00801A3C0000000010p10000000001p2101000111100d

Sanal adres 0x00801A3C (8 MiB’ın biraz üstü). Üst tabloda yalnız girdi 2 geçerli; onun tablosunda girdi 1 → çerçeve 0x2F.

va = 0x00801A3C0000000010p1 = 20000000001p2101000111100d

Üst 10 bit: 0x00801A3C >> 22 = 2.

va = 0x00801A3C0000000010p1 = 20000000001p2 = 1101000111100d

Orta 10 bit: (va >> 12) & 0x3FF = 0x801 & 0x3FF = 1.

va = 0x00801A3C0000000010p1 = 20000000001p2 = 1101000111100d = 0xA3C

Alt 12 bit konum: 0xA3C; çeviride hiç değişmez.

va = 0x00801A3C0000000010p1 = 20000000001p2 = 1101000111100d = 0xA3Cust[2]: P = 1

Üst tablonun 2. girdisi geçerli (P = 1): ikinci düzey tablonun çerçevesini verir. Birinci bellek erişimi.

va = 0x00801A3C0000000010p1 = 20000000001p2 = 1101000111100d = 0xA3Cust[2]: P = 1tablo[1]: çerçeve 0x2F

İkinci düzey tablonun 1. girdisi: çerçeve 0x2F, P = 1. İkinci bellek erişimi.

va = 0x00801A3C0000000010p1 = 20000000001p2 = 1101000111100d = 0xA3Cust[2]: P = 1tablo[1]: çerçeve 0x2Ffiziksel = 0x0002FA3C

0x2F << 12 = 0x2F000; konumla birleşince fiziksel 0x0002FA3C. Üçüncü erişim veridir.

va = 0x014030040000000101p1 = 50000000011p2 = 3000000000100d = 0x004

İkinci adres 0x01403004: p1 = 5, p2 = 3, konum = 0x004.

va = 0x014030040000000101p1 = 50000000011p2 = 3000000000100d = 0x004ust[5]: yokP = 0 → sayfa hatası (tuzak)

Üst tablonun 5. girdisi geçersiz (P = 0): 20–24 MiB bölgesi için ikinci düzey tablo hiç yok. MMU tuzak üretir; tablo için bellek harcanmamıştır.

Sayfa Tablosu Yapıları

x86-64: Dört ve Beş Düzeyli Sayfalama

x86-64, 4 düzey (48 bit sanal adres, 256 TiB)işaret63–48PML49 bitPDPT9 bitPD9 bitPT9 bitkonum12 bitx86-64, 5 düzey (LA57: 57 bit, 128 PiB)işaret63–57PML59PML49PDPT9PD9PT9konum12
  • Her tablo 512 girdi × 8 B = 4 KiB, yani tam bir sayfa; 9 bit indis. 4 × 9 + 12 = 48 bit.
  • Üst 16 bit, bit 47’nin kopyası olmalıdır (kanonik adres): alt yarı kullanıcıya, üst yarı çekirdeğe.
  • 5 düzey (Intel Ice Lake sunucu, AMD Zen 4 ve sonrası) 57 bit sanal adres verir; Linux 4.14’ten beri destekler.
  • Hiyerarşik tablo 64 bitte de çalışır: bütün 64 bit adres kullanılmadığı için bugünkü x86-64 ve ARMv8 tam da hiyerarşik tablo kullanır.
  • Bir orta düzey girdisinde PS biti 1 ise yürüyüş orada biter: PD düzeyinde 2 MiB, PDPT düzeyinde 1 GiB büyük sayfa.

Sayfa Tablosu Yapıları · Adım adım

Dört Düzeyli Yürüyüş

VA = 0x00007FFE12345678PML4[255]PDPT[504]PD[145]PT[325]konum 0x678CR30x1A2BPML4 tablosuPDPT tablosuPD tablosuPT tablosu

Kullanıcı yığınına yakın bir adres. Bölünmesi (9+9+9+9+12): PML4 = 255, PDPT = 504, PD = 145, PT = 325, konum = 0x678.

VA = 0x00007FFE12345678PML4[255]PDPT[504]PD[145]PT[325]konum 0x678CR30x1A2BPML4 tablosu[255] → 0x3C4çerçeve 0x1A2BPDPT tablosuPD tablosuPT tablosu

CR3 PML4 tablosunun çerçevesini verir; girdi 255 okunur → PDPT tablosunun çerçevesi.

VA = 0x00007FFE12345678PML4[255]PDPT[504]PD[145]PT[325]konum 0x678CR30x1A2BPML4 tablosu[255] → 0x3C4çerçeve 0x1A2BPDPT tablosu[504] → 0x7D10çerçeve 0x3C4PD tablosuPT tablosu

PDPT[504] → sayfa dizini (PD) çerçevesi. Burada PS = 1 olsaydı 1 GiB’lık sayfa bulunmuş olurdu.

VA = 0x00007FFE12345678PML4[255]PDPT[504]PD[145]PT[325]konum 0x678CR30x1A2BPML4 tablosu[255] → 0x3C4çerçeve 0x1A2BPDPT tablosu[504] → 0x7D10çerçeve 0x3C4PD tablosu[145] → 0x2E95çerçeve 0x7D10PT tablosu

PD[145] → son düzey tablo. PS = 1 olsaydı 2 MiB’lık sayfa.

VA = 0x00007FFE12345678PML4[255]PDPT[504]PD[145]PT[325]konum 0x678CR30x1A2BPML4 tablosu[255] → 0x3C4çerçeve 0x1A2BPDPT tablosu[504] → 0x7D10çerçeve 0x3C4PD tablosu[145] → 0x2E95çerçeve 0x7D10PT tablosu[325] → 0x5A3F7çerçeve 0x2E95fiziksel 0x5A3F7678

PT[325] çerçeve 0x5A3F7’i verir; konum eklenir. TLB ıskasında 4 bellek erişimi + veri erişimi; çerçeve değerleri örnektir.

Sayfa Tablosu Yapıları

Büyük (Huge) Sayfalar

TLB erişim alanı (reach) = girdi sayısı × sayfa boyutu, 1536 girdi4 KiB sayfa6 MiB2 MiB sayfa3 GiB(log ölçek)
  • Büyük çalışma kümeli programlar (veritabanı, sanal makine, yapay zekâ) 4 KiB sayfalarla sürekli TLB ıskası yaşar.
  • 1 GiB’ı 4 KiB ile eşlemek 262.144 PTE = 2 MiB tablo ister; 2 MiB sayfalarla yalnızca 512 PD girdisi (4 KiB).
  • Linux: hugetlbfs (önceden ayrılan 2 MiB / 1 GiB), şeffaf büyük sayfalar (THP, çekirdek kendiliğinden birleştirir), son sürümlerde mTHP (16–64 KiB ara boyutlar). Windows: large pages.
  • Bedel: iç parçalanma ve 2 MiB bitişik fiziksel çerçeve bulma zorunluluğu (buddy ve sıkıştırma burada geri döner).
  • ARMv8’de contiguous biti: 16 komşu 4 KiB girdi tek TLB girdisiyle (64 KiB) tutulabilir.

Sayfa Tablosu Yapıları · Adım adım

Hash Sayfa Tablosu

sanal adres 0x1A0AB → p = 26 (0x1A), d = 0xABh(p) = p mod 8hash tablosu0p=8 → f=4p=16 → f=612p=10 → f=7p=26 → f=3345p=13 → f=167p=31 → f=2

Her kova, aynı hash değerine düşen (sanal sayfa, çerçeve, sonraki) girdilerinin zinciridir. Örnekte 8 kova, h(p) = p mod 8.

sanal adres 0x1A0AB → p = 26 (0x1A), d = 0xABh(p) = p mod 8h(26) = 2hash tablosu0p=8 → f=4p=16 → f=612p=10 → f=7p=26 → f=3345p=13 → f=167p=31 → f=2

Sayfa numarası 26 hash’lenir: kova 2.

sanal adres 0x1A0AB → p = 26 (0x1A), d = 0xABh(p) = p mod 8h(26) = 2hash tablosu0p=8 → f=4p=16 → f=612p=10 → f=7p=26 → f=3345p=13 → f=167p=31 → f=2

Zincirin ilk girdisi p = 10: eşleşmez, sonrakine geçilir.

sanal adres 0x1A0AB → p = 26 (0x1A), d = 0xABh(p) = p mod 8h(26) = 2hash tablosu0p=8 → f=4p=16 → f=612p=10 → f=7p=26 → f=3345p=13 → f=167p=31 → f=2çerçeve 3fiziksel 0x30AB

p = 26 eşleşir → çerçeve 3; fiziksel = 3 × 4096 + 0xAB = 0x30AB.

  • 32 bitten büyük adres alanlarında kullanılır; tablo boyutu kullanılan sayfa sayısıyla orantılıdır, adres alanıyla değil.
  • Kümelenmiş varyant: her girdi birden çok (ör. 16) ardışık sayfayı tutar; seyrek 64 bit uzaylar için uygundur.

Sayfa Tablosu Yapıları · Adım adım

Ters (Inverted) Sayfa Tablosu

mantıksal adres: (pid = 2, p = 5, d = 0x123)ters tablo: çerçeve başına bir girdi0pid 1, sayfa 01pid 2, sayfa 32pid 1, sayfa 53pid 3, sayfa 14pid 2, sayfa 55pid 1, sayfa 26pid 3, sayfa 07pid 2, sayfa 0çerçeve

Tabloda süreç başına değil, fiziksel çerçeve başına bir girdi vardır: o çerçevede hangi sürecin hangi sayfası.

mantıksal adres: (pid = 2, p = 5, d = 0x123)ters tablo: çerçeve başına bir girdi0pid 1, sayfa 01pid 2, sayfa 32pid 1, sayfa 53pid 3, sayfa 14pid 2, sayfa 55pid 1, sayfa 26pid 3, sayfa 07pid 2, sayfa 0çerçeve

Girdi 0: (pid 1, sayfa 0) ≠ (2, 5), sonraki.

mantıksal adres: (pid = 2, p = 5, d = 0x123)ters tablo: çerçeve başına bir girdi0pid 1, sayfa 01pid 2, sayfa 32pid 1, sayfa 53pid 3, sayfa 14pid 2, sayfa 55pid 1, sayfa 26pid 3, sayfa 07pid 2, sayfa 0çerçeve

Girdi 1: (pid 2, sayfa 3) ≠ (2, 5), sonraki.

mantıksal adres: (pid = 2, p = 5, d = 0x123)ters tablo: çerçeve başına bir girdi0pid 1, sayfa 01pid 2, sayfa 32pid 1, sayfa 53pid 3, sayfa 14pid 2, sayfa 55pid 1, sayfa 26pid 3, sayfa 07pid 2, sayfa 0çerçeve

Girdi 2: (pid 1, sayfa 5) ≠ (2, 5), sonraki.

mantıksal adres: (pid = 2, p = 5, d = 0x123)ters tablo: çerçeve başına bir girdi0pid 1, sayfa 01pid 2, sayfa 32pid 1, sayfa 53pid 3, sayfa 14pid 2, sayfa 55pid 1, sayfa 26pid 3, sayfa 07pid 2, sayfa 0çerçeve

Girdi 3: (pid 3, sayfa 1) ≠ (2, 5), sonraki.

mantıksal adres: (pid = 2, p = 5, d = 0x123)ters tablo: çerçeve başına bir girdi0pid 1, sayfa 01pid 2, sayfa 32pid 1, sayfa 53pid 3, sayfa 14pid 2, sayfa 55pid 1, sayfa 26pid 3, sayfa 07pid 2, sayfa 0çerçeveeşleşme: indis 4 = çerçevefiziksel 0x4123

Girdi 4 eşleşir: indisin kendisi çerçeve numarasıdır → 4 × 4096 + 0x123 = 0x4123. Doğrusal arama pahalı olduğundan gerçek sistemler hash tablosu + TLB kullanır.

  • Tablo boyutu fiziksel bellekle orantılı ve sistemde tek: 16 GiB RAM, 4 KiB çerçeve → 4.194.304 girdi; 8 B/girdi ile 32 MiB.
  • Dezavantaj: paylaşımlı bellek zor (çerçeve başına tek sanal sayfa); sayfa hatası işlemek için ayrıca süreç başına dış tablo gerekir. Örnekler: PowerPC/IBM POWER (hash’li ters tablo), IA-64.

Kesimleme

Kesimleme: Neden?

  • Derleyici derleme sırasında birçok tablo kurar: kaynak metin, sembol tablosu, sabitler, ayrıştırma ağacı, çağrı yığını. Hepsi büyüyüp küçülür.
  • Tek boyutlu adres alanında bir tablo dolunca komşusu boş olsa bile çarpışır.
  • Kesimleme: birbirinden bağımsız, değişken uzunluklu birden çok adres alanı. Adres = (kesim no, kesim içi konum).
  • Programcının bakışına uyar: ana program, işlevler, yığın, diziler, sembol tablosu ayrı birimlerdir.
(a) tek boyutlu uzayçağrı yığınıayrıştırma ağacısabitlerkaynak metinsembol tablosusembol tablosu büyüdü,kaynak metne çarpar!(b) ayrı kesimlersembol0kaynak1sabit2ağaç3yığın4her kesim 0’dan başlar, ayrı büyür

Kesimleme · Adım adım

Kesim Tablosu ile Çeviri

kesim tablosulimittaban01.0001.40014006.30024004.30031.1003.20041.0004.700fiziksel bellekkesim 01.400kesim 16.300kesim 24.300kesim 33.200kesim 44.700

Her girdi bir kesimin taban (fiziksel başlangıç) ve limit (uzunluk) değerini tutar; tablonun yeri ve boyu STBR ve STLR yazmaçlarındadır.

kesim tablosulimittaban01.0001.40014006.30024004.30031.1003.20041.0004.700fiziksel bellekkesim 01.400kesim 16.300kesim 24.300kesim 33.200kesim 44.700(s, d) = (2, 53)d < limit ? 53 < 400evet → taban + d4.300 + 53 = 4.353

(2, 53): 53 < 400 → 4.300 + 53 = 4.353.

kesim tablosulimittaban01.0001.40014006.30024004.30031.1003.20041.0004.700fiziksel bellekkesim 01.400kesim 16.300kesim 24.300kesim 33.200kesim 44.700(s, d) = (3, 852)d < limit ? 852 < 1.100evet → taban + d3.200 + 852 = 4.052

(3, 852): 852 < 1.100 → 3.200 + 852 = 4.052.

kesim tablosulimittaban01.0001.40014006.30024004.30031.1003.20041.0004.700fiziksel bellekkesim 01.400kesim 16.300kesim 24.300kesim 33.200kesim 44.700(s, d) = (1, 399)d < limit ? 399 < 400evet → taban + d6.300 + 399 = 6.699

(1, 399): 399 < 400 → 6.300 + 399 = 6.699.

kesim tablosulimittaban01.0001.40014006.30024004.30031.1003.20041.0004.700fiziksel bellekkesim 01.400kesim 16.300kesim 24.300kesim 33.200kesim 44.700(s, d) = (0, 1.222)d < limit ? 1.222 < 1.000hayır → tuzak (adresleme hatası)

(0, 1.222): kesim 0’ın boyu yalnızca 1.000 bayt → tuzak. Denetim olmasaydı 2.622 adresine, yani kesimin dışına erişilirdi.

Silberschatz’ın beş kesimli örneği. Kesimleme, her kesim için ayrı bir taban-limit çiftidir.

Kesimleme · Adım adım

Kesimi Seçen Bitler, Aşağı Büyüyen Yığın

kesimtabanboyyönkoruma00 kod24.5763.072+r-x01 heap40.9602.048+rw-11 yığın32.7682.048−rw-sanal adres 1.00000001111101000kesimkonum (12 bit) = 1.000kesim 00 → kodkonum < boy ? 1.000 < 3.072evet → taban + konum24.576 + 1.000 = 25.576fiziksel bellek24 K42 Kkodheapyığın25.576

1.000: üst bitler 00 → kod. 1.000 < 3.072 → 24.576 + 1.000 = 25.576.

kesimtabanboyyönkoruma00 kod24.5763.072+r-x01 heap40.9602.048+rw-11 yığın32.7682.048−rw-sanal adres 4.50001000110010100kesimkonum (12 bit) = 404kesim 01 → heapkonum < boy ? 404 < 2.048evet → taban + konum40.960 + 404 = 41.364fiziksel bellek24 K42 Kkodheapyığın41.364

4.500: 01 → heap. Konum 4.500 − 4.096 = 404 → 40.960 + 404 = 41.364. Sanal adres + taban (45.460) yanlış olurdu.

kesimtabanboyyönkoruma00 kod24.5763.072+r-x01 heap40.9602.048+rw-11 yığın32.7682.048−rw-sanal adres 16.00011111010000000kesimkonum (12 bit) = 3.712kesim 11 → yığınaşağı büyür: negatif konum = 3.712 − 4.096 = −384|−384| ≤ 2.048 → geçerli32.768 − 384 = 32.384fiziksel bellek24 K42 Kkodheapyığın32.384

16.000: 11 → yığın. Yığın aşağı büyüdüğü için konumdan en büyük kesim boyu (4.096) çıkarılır: −384 → 32.384.

kesimtabanboyyönkoruma00 kod24.5763.072+r-x01 heap40.9602.048+rw-11 yığın32.7682.048−rw-sanal adres 7.00001101101011000kesimkonum (12 bit) = 2.904kesim 01 → heapkonum < boy ? 2.904 < 2.048hayır → tuzak (koruma hatası)fiziksel bellek24 K42 Kkodheapyığın

7.000: 01 → heap ama konum 2.904 ≥ 2.048: donanım tuzak üretir, İS süreci SIGSEGV ile sonlandırır.

Örnekte sanal adres 14 bittir (16 KiB). Üst iki bit en çok dört kesim, kalan 12 bit kesim başına en çok 4 KiB verir. Kesim yazmacındaki yön biti yığını, koruma bitleri paylaşımı mümkün kılar: r-x kod kesimi birçok süreçte aynı çerçevelere eşlenebilir, ona yazma girişimi koruma hatasıdır.

Kesimleme

Kesimlemenin Artı ve Eksileri

Avantajlar

  • Büyüyen/küçülen tablolar birbirini etkilemez.
  • Kesimler ayrı derlenebilir; bir işlev değişince diğerlerinin adresi değişmez.
  • Kütüphane bir kesime konup paylaşılabilir.
  • Kesim başına koruma: kod x, sabitler r, veri rw.

Dezavantajlar

  • Değişken uzunluk → dış parçalanma (dama tahtası), sıkıştırma.
  • Kesim bütünüyle bellekte olmalı; çözüm kesimleri sayfalamak (MULTICS, Intel 386).
(a)K0 4KK1 8KK2 5KK3 8KK4 7K(b)K0 4KK7 5K3KK2 5KK3 8KK4 7K(c)K0 4KK7 5K3KK2 5KK5 4K4KK4 7K(d)K0 4KK7 5KK2 5KK5 4KK4 7K7K(b)–(c) dış parçalanma (dama tahtası), (d) sıkıştırma

Kesimleme

Sayfalama ve Kesimleme Karşılaştırması

DurumSayfalamaKesimleme
Programcı tekniğin farkında olmalı mı?HayırEvet
Kaç doğrusal adres alanı var?1Çok
Toplam adres alanı fiziksel belleği aşabilir mi?EvetEvet
Kod ve veri ayrılıp ayrı korunabilir mi?Sayfa bitleriyle evet*Evet
Boyu değişen tablolar kolayca yerleşir mi?HayırEvet
Kullanıcılar arasında işlev paylaşımı kolay mı?Paylaşımlı sayfalarla*Evet
Parçalanmaİç (son sayfa)Dış
Neden icat edildi?Fiziksel bellekten büyük doğrusal adres alanıProgram ve veriyi bağımsız mantıksal uzaylara ayırmak; paylaşım, koruma
sayfalama: tek doğrusal alan, eşit sayfalarkesimleme: ayrı mantıksal alanlarkodveriyığınsembol

Tanenbaum Şekil 3-32’den uyarlandı. * Tanenbaum burada sayfalama için “hayır” der; modern R/W/NX bitleri ve paylaşımlı sayfalar aynı işi sayfa düzeyinde yapar.

Gerçek Mimariler

x86: Kesimleme + Sayfalama ve Düz Model

seçicikonum (32 bit)mantıksal adres (seçici : konum)GDT / LDTtanımlayıcı: taban, limit+doğrusal adreskesimlemesayfalamaCR3 →sayfa tablolarıfiziksel
  • 8086 gerçek mod: fiziksel = kesim × 16 + konum (20 bit, 1 MiB); koruma yok.
  • 80386 korumalı mod: 16 bitlik seçici (13 bit indis, tablo seçimi, RPL) GDT/LDT’den 8 baytlık tanımlayıcı seçer; taban + konum = doğrusal adres, sonra iki düzeyli sayfalama. MULTICS fikrinin donanımdaki karşılığı.
  • Linux ve Windows 32 bitte bile tüm kesimlerin tabanını 0, limitini 4 GiB yaparak düz model kullandı: kesimleme fiilen kapalı, koruma sayfalarla.
  • x86-64 uzun mod: CS, DS, ES, SS tabanı donanımca 0 sayılır, limit denetlenmez. Yalnızca FS ve GS tabanı kullanılır: kullanıcıda iş parçacığı yerel depolama (TLS), çekirdekte çekirdek başına veri.

Gerçek Mimariler

ARMv8-A ve RISC-V Notu

ARMv8-A (AArch64)RISC-V
Sayfa (granül)4, 16 veya 64 KiB; Apple Silicon ve bazı Android 15+ aygıtlar 16 KiB4 KiB (+ 2 MiB, 1 GiB, 512 GiB büyük sayfa)
Sanal adres48 bit (4 KiB ile 4 düzey, L0–L3); LVA/LPA2 ile 52 bitSv39 (3 düzey), Sv48 (4), Sv57 (5)
Tablo tabanıTTBR0_EL1 alt yarı (kullanıcı), TTBR1_EL1 üst yarı (çekirdek)satp (mod + ASID + kök çerçeve)
Süreç etiketiASID 8/16 bitASID (16 bite kadar)
KorumaAP bitleri, UXN/PXN (çalıştırma yasağı), PAN (≈ SMAP)R/W/X/U bitleri, SUM
TLBDonanım yürüyüşü; A/D bitleri isteğe bağlı donanımla (v8.1); contiguous bitiDonanım yürüyüşü (çoğu gerçekleme); sfence.vma
işaret uzantısı (25)VPN[2] 9VPN[1] 9VPN[0] 9konum 12Sv39: 3 düzey × 512 girdi; satp kök tablonun çerçevesini ve ASID’i tutar

İki mimaride de kesimleme yoktur: düz sanal adres, çok düzeyli sayfa tablosu, TLB ve ASID. x86-64 ile aynı fikirler, farklı adlar.

Uygulama Sorunları

Politika ve Mekanizma Ayrımı

kullanıcı alanıçekirdek alanıKullanıcı süreciDış sayfalayıcıHata işleyiciMMU işleyicisiDisk1 sayfa hatası2 gereken sayfa3 iste4 geldi5 işte sayfa6 eşle
  • İşletim sistemi sayfalamaya dört anda katılır: süreç oluşturma (tablo kurulur), bağlam değiştirme (tablo etkinleşir, TLB), sayfa hatası ve süreç sonu (çerçeveler ve takas alanı bırakılır).
  • Mekanizma çekirdekte: makineye bağlı MMU işleyicisi ve makineden bağımsız sayfa hatası işleyicisi. İlke (hangi sayfa ne zaman nereye) kullanıcı alanındaki dış sayfalayıcıda (Mach).
  • Esneklik ve modülerlik kazanılır; bedeli kullanıcı/çekirdek sınırını birçok kez geçmektir.
  • Bugünkü karşılığı: Linux userfaultfd (sanal makinelerin canlı göçü, CRIU), mikro çekirdeklerde (seL4, Fuchsia) kullanıcı alanı sayfalayıcıları.

Özet

Özet

TeknikFikirArtıEksi
Taban-limitTek bitişik bölge + MMUBasit, hızlıDış parçalanma, paylaşım zor
Değişken bölümlemeİlk/en iyi uyan ile delik seçimiİç parçalanma yok%50 kuralı, sıkıştırma
SayfalamaSabit sayfa ↔ çerçeve, sayfa tablosuDış parçalanma yok, paylaşım, korumaTablo boyutu, çift erişim
TLBÇeviri önbelleği, ASIDEES ≈ bellek süresiBağlam değiştirme, vurusu
Hiyerarşik tabloTabloyu sayfala (x86-64: 4/5 düzey)Seyrek uzay ucuzIskada çok erişim
Hash / tersKullanılan sayfa / çerçeve başına girdiKüçük tabloArama, paylaşım zor
Kesimleme(kesim, konum), kesim tablosuMantıksal bölme, korumaDış parçalanma; x86-64’te düz model

Bugünkü genel amaçlı sistemler: düz sanal adres alanı + çok düzeyli sayfalama + TLB + büyük sayfalar; fiziksel çerçeveler için buddy, çekirdek nesneleri için slab (SLUB).

Alıştırmalar

Alıştırmalar

  1. for (i = 0; i < 1000; i++) a[i] = 0; döngüsü aşağıdaki dört komuta derlenir. Doğrusal sayfa tablosu var, TLB yok: toplam kaç bellek erişimi olur? TLB olsaydı? (a sanal 40.000’de başlar, int 4 B, sayfa 4 KiB, kod tek sayfada.)
    dongu: movl $0,(%edi,%eax,4)  /* a[i] = 0 */
           incl %eax              /* i++      */
           cmpl $1000,%eax
           jne  dongu
  2. “Kesimi Seçen Bitler” slaytındaki kesim yazmaçlarıyla sanal 13.000 ve 14.500 adresleri nereye gider?
  3. 16 B başlıklı ayırıcıda 4.096 B heap’ten üç kez malloc(1000) yapılır. Boş parçanın boyu kaçtır? Dördüncü malloc(1040) karşılanabilir mi?
  4. free(p + 4) çağrılırsa ne olur?
Cevaplar
  1. Her tur 4 komut getirme + 1 yazma = 5 erişim ve her biri için bir PTE okuma: 10 × 1.000 = 10.000. TLB ile 5.000 erişim + 3 ıska (kod sayfası ve dizinin yayıldığı 9 ve 10 numaralı sayfalar) = 5.003.
  2. 13.000: kesim 11, konum 712 → −3.384; |−3.384| > 2.048 → tuzak. 14.500: konum 2.212 → −1.884 → 32.768 − 1.884 = 30.884.
  3. 4.080 − 3 × 1.016 = 1.032 B. 1.040 > 1.032 olduğundan hayır: ayırıcı heap’i sbrk ya da mmap ile büyütür.
  4. Ayırıcı başlığı p + 4 − 16’da arar; orada geçerli başlık yoktur. Tanımsız davranıştır; sihirli sayı denetimi varsa program durdurulur.

Özet

Kontrol Soruları

  1. Taban = 300.040, limit = 120.900 iken 420.940 adresine erişilirse ne olur?
  2. Delikler 100, 500, 200, 300, 600 K; istekler 212, 417, 112, 426 K. Hangi algoritma hepsini yerleştirir?
  3. 32 bit adres ve 4 KiB sayfada 0x12345678 için p ve d nedir?
  4. Tanenbaum tablosunda (5 → 3) sanal 20.500 hangi fiziksel adrese çevrilir?
  5. ε = 20 ns, t = 100 ns, α = %90 için tek düzeyli tabloda EES nedir?
  6. Hiyerarşik sayfa tablosu neden 64 bit sistemlerde de kullanılabilir? x86-64 kaç düzey kullanır?
  7. x86-64 uzun modda kesimlemeden geriye ne kalmıştır?
  8. 4 kümeli, 64 B satırlı doğrudan eşlemeli boş önbellekte 0, 128, 256, 0 adreslerine erişiliyor. Kaç isabet olur?
Cevaplar
  1. Taban + limit = 420.940 aralığın dışında (son geçerli 420.939) → tuzak.
  2. Yalnızca en iyi uyan; diğerlerinde 426 K bekler (dış parçalanma).
  3. p = 0x12345 (74.565), d = 0x678 (1.656).
  4. 3 × 4096 + 20 = 12.308.
  5. 120 × 0,9 + 220 × 0,1 = 130 ns.
  6. Sanal adresin hepsi kullanılmaz (48/57 bit); yalnız kullanılan bölgelerin tabloları vardır. 4 (48 bit) ya da 5 (57 bit, LA57).
  7. Tabanı kullanılan FS ve GS (TLS, çekirdek başına veri); CS ayrıcalık düzeyini taşır.
  8. Bloklar 0, 2, 4, 0 → kümeler 0, 2, 0, 0. 256 bloğu 0’ı kovar → 0 isabet, 4 ıska.

Özet

Kaynaklar

  • A. Silberschatz, P. B. Galvin, G. Gagne, Operating System Concepts, 10. baskı, Wiley, 2018 — Bölüm 9: Main Memory.
  • A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı (2014) / 5. baskı (2023), Pearson — Bölüm 3: Memory Management (§3.1–3.3, 3.5–3.7).
  • R. H. Arpaci-Dusseau, A. C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces (OSTEP), ostep.org — “Address Spaces”, “Address Translation”, “Segmentation”, “Free-Space Management”, “Paging”, “TLBs”, “Smaller Tables”.
  • D. E. Knuth, The Art of Computer Programming, Cilt 1, §2.5 Dynamic Storage Allocation (%50 kuralı).
  • Intel 64 and IA-32 Architectures Software Developer’s Manual, Cilt 3A, Bölüm 4–5 (Paging, Protection); Arm Architecture Reference Manual for A-profile (VMSAv8-64); RISC-V Privileged Specification (Sv39/48/57).
  • U. Drepper, “How To Write Shared Libraries”, 2011; Linux çekirdek belgeleri: mm/, “Transparent Hugepage Support”, userfaultfd.

Son

Bölüm 8: Bellek Yönetimi
Sonraki bölüm: Sanal Bellek · Terim sözlüğü
1 / 1