Bölüm 8: Bellek Yönetimi
Giriş
Öğrenme Çıktıları
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.
Bağlama zamanlarını, mantıksal/fiziksel adresi ve MMU’nun taban-limit denetimini açıklamak.
Dinamik yüklemeyi, statik ve dinamik bağlamayı, PLT/GOT ile paylaşımlı kütüphaneleri ve takası tartışmak.
Uyan algoritmalarını uygulamak; iç/dış parçalanmayı, biteşlemi ve bağlı listeyi çözümlemek.
Adresi (p, d) olarak bölmek, sayfa tablosu ve TLB ile çeviri yapmak, etkin erişim süresini hesaplamak.
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.
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 | Özellik | Kullanı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 / Flash | Elektrikle 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 / NVRAM | Pil ya da flash ile korunan küçük alan. | Saat, önyükleme ayarları |
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).
Bellek Donanımı · Animasyon
Bir Okuma Hiyerarşide Nasıl İlerler?
CPU x değişkenini okumak istiyor (LOAD R1, [x]). Önce en yakın ve en hızlı düzeye bakılır.
L1’de yok: ıska (miss). ~1 ns kaybedildi; aramaya bir alt düzeyde devam edilir.
L2 ve L3’te de ıska. Her düzey biraz daha büyük ama daha yavaştır; toplam ~20 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.
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
Başlangıçta önbellek boş (−1). 64 B satır, 4 küme, doğrudan eşleme: her blok tek bir kümeye gidebilir.
adres[0] = 0 → blok = 0 / 64 = 0, küme = 0 mod 4 = 0.
Küme 0 boş → ıska; blok 0 yüklenir.
adres[1] = 8 → blok = 8 / 64 = 0, küme = 0 mod 4 = 0.
etiket[0] = 0 = blok → isabet. 8, 0 ile aynı 64 baytlık satırda: uzamsal yerellik.
adres[2] = 64 → blok = 64 / 64 = 1, küme = 1 mod 4 = 1.
Küme 1 boş → ıska; blok 1 yüklenir.
adres[3] = 256 → blok = 256 / 64 = 4, küme = 4 mod 4 = 0.
Küme 0’da blok 0 var → ıska; blok 4 onu dışarı atar (çakışma ıskası).
adres[4] = 0 → blok = 0 / 64 = 0, küme = 0 mod 4 = 0.
Küme 0’da blok 4 var → ıska; blok 0 onu dışarı atar (çakışma ıskası).
adres[5] = 72 → blok = 72 / 64 = 1, küme = 1 mod 4 = 1.
etiket[1] = 1 = blok → isabet. 72, 64 ile aynı satırda.
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);
Dört düzey: erişim süreleri ve her önbellek düzeyinin ıska oranı. Bir düzeyde ıska olursa istek bir alttakine iner.
En alt düzey DRAM her isteği karşılar: oradan başlayınca t = 80 ns.
k = 2 ≥ 0: bir üst düzeye (L3) çıkılır.
L3 her istekte 20 ns harcar; isteklerin %50’sinde alttaki düzeyin 80 ns’si eklenir: t = 60 ns.
k = 1 ≥ 0: bir üst düzeye (L2) çıkılır.
L2 her istekte 4 ns harcar; isteklerin %40’ında alttaki düzeyin 60 ns’si eklenir: t = 28 ns.
k = 0 ≥ 0: bir üst düzeye (L1) çıkılır.
L1 her istekte 1 ns harcar; isteklerin %10’unda alttaki düzeyin 28 ns’si eklenir: t = 3,8 ns.
k = −1: döngü biter.
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ı
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, 1000fiziksel 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.
Giriş · Adım adım
Yer Değiştirme Problemi
A ve B 16 KB’lık iki program; ikisi de 0 adresinden başlayacağı varsayılarak derlendi.
İşletim sistemi önce A’yı 0’a, ardından B’yi hemen üstüne, 16384’e yükler.
B’nin ilk komutu JMP 28 mutlak adres kullanır: fiziksel 28’e, yani A’nın ADD komutuna atlar ve program çöker.
Statik yer değiştirme (IBM 360): yükleyici her adres sözcüğüne başlangıç adresini ekler: JMP 16412. Yükleme yavaşlar.
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.
Adres Alanı · Adım adım
Donanımsal Adres Koruması
300.040 = taban: ilk geçerli adres; iki karşılaştırma da geçer, erişim yapılır.
356.000 aralığın içinde; erişim yapılır. Denetim her erişimde, paralel donanımla yapılır.
420.939 = taban + limit − 1: son geçerli adres.
420.940 = taban + limit: ikinci karşılaştırma başarısız → tuzak. Çekirdek süreci genellikle sonlandırır (Unix’te SIGSEGV).
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ı
| Bağlama zamanı | Üretilen kod | Konum değişirse | Donanım |
|---|---|---|---|
| Derleme | Mutlak kod (ör. MS-DOS .COM) | yeniden derle | gerekmez |
| Yükleme | Yeri değiştirilebilir kod; yükleyici adresleri düzeltir | yeniden yükle | gerekmez |
| Yürütme | Mantıksal adresler; süreç çalışırken taşınabilir | hiçbir şey | MMU (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.
Adres Alanı · Adım adım
MMU ile Dinamik Yer Değiştirme
Mantıksal 346 < 3.000 → fiziksel 346 + 14.000 = 14.346. Program 0 ile 2.999 arasını görür.
2.999 son geçerli mantıksal adres → 16.999.
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.
Ö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; }
Program başladı: adres alanında yalnız main, libc, heap ve yığın (stack) var; libm yüklü değil.
dlopen: dinamik bağlayıcı (ld.so) dosyayı bulur, mmap ile adres alanına eşler. Yükleme şimdi, programın isteğiyle olur.
dlsym sembol tablosunda sqrt’u arar ve o sürecin adres alanındaki adresini döndürür.
Fonksiyon işaretçisiyle çağrı yapılır; çıktı 1.414.
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ğlama | Dinamik bağlama | |
|---|---|---|
| Kim, ne zaman? | Bağlayıcı (ld), derlemeden sonra | Dinamik bağlayıcı (ld.so), yüklemede/çalışırken |
| Dosya | .a, .lib | .so, .dll, .dylib |
| Bellek | Her programda ayrı kopya | Kod sayfaları bir kez bellekte, paylaşılır |
| Güncelleme | Yeniden bağlamak gerekir | Kütüphaneyi değiştirmek yeter (sürüm: soname) |
| Risk | Büyük dosya, güvenlik yaması gecikir | Sü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.
Bağlama ve Yükleme · Adım adım
Tembel Bağlama: PLT ve GOT
Derleyici printf’in adresini bilmez; çağrı küçük bir PLT (procedure linkage table) taslağına gider. Kitaplardaki taslak (stub) budur.
PLT, GOT (global offset table) içindeki adrese dolaylı atlar. Başlangıçta GOT girdisi çözücüyü gösterir.
ld.so çözücüsü sembolü yüklü kütüphanelerde arar, bulduğu adresi GOT’a yazar.
Çö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.
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
arnesne dosyalarını arşivler; bağlayıcı yalnızca gereken nesneleri kopyalar.-staticlibc’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_PATHyerine kalıcı çözüm:-Wl,-rpath,'$ORIGIN'ya daldconfig.
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.
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).
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.
Bitişik Tahsis · Adım adım
Değişken Bölümleme
Bellekte yalnız işletim sistemi var.
A (320 K) gelir; ilk uygun boşluğa yerleşir.
B (224 K) gelir; ilk uygun boşluğa yerleşir.
C (288 K) gelir; ilk uygun boşluğa yerleşir.
A sonlanır: 128–448 arası 320 K delik olur.
D (256 K) A’nın deliğine girer; geriye 64 K’lık küçük bir delik kalır.
B sonlanır: alanı solundaki 64 K delikle birleşir → 288 K. Bitişik delikler hemen birleştirilir.
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ı
Liste baştan taranır, ilk yeterli delikte durulur. Hızlı; başta küçük delikler birikir.
Arama son kalınan yerden sürer; ilk uyandan biraz kötü çıkar (Bays, 1977).
Bütün liste taranır, ihtiyaca en yakın delik seçilir. Yavaş; işe yaramaz çok küçük delikler bırakır.
Kalan parça işe yarasın diye en büyük delik seçilir. Benzetimlerde iyi sonuç vermez.
Sık istenen boyutlar için ayrı listeler (4 K, 8 K, 12 K …). Bulmak hızlı, birleştirmek pahalı.
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); */
Delik listesi 120, 450, 230, 300, 180 K. İlk istek 210 K; en = −1 (aday yok).
[0] = 120 < 210: sığmaz, atla.
[1] = 450 ≥ 210 ve ilk aday → en = 1.
[2] = 230 ≥ 210 ve 450’den küçük → yeni en iyi en = 2.
[3] = 300 sığar ama mevcut en iyi 230 daha küçük: değişmez.
[4] = 180 < 210: sığmaz, atla.
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.
İkinci istek 160 K; delik [2] artık 20 K. Tarama yine baştan, tüm listeyi gezer.
[0] = 120 sığmaz; [1] = 450 ≥ 160 ve ilk aday → en = 1.
[2] = 20 sığmaz; [3] = 300 ≥ 160 ve 450’den küçük → yeni en iyi en = 3.
[4] = 180 ≥ 160 ve 300’den küçük → yeni en iyi en = 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
Delikler sırasıyla 100, 500, 200, 300, 600 K. İstekler sırayla: 212, 417, 112, 426 K.
212 K: ilk/sonraki uyan 500’e, en iyi uyan 300’e (kalan 88), en kötü uyan 600’e koyar.
417 K: ilk ve sonraki uyan 600’e; en iyi ve en kötü uyan 500’e (kalan 83).
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.
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.
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).
Bitişik Tahsis · Adım adım
Sıkıştırma (Compaction)
Başlangıç: dört süreç arasında 96 + 64 + 160 + 32 = 352 K boş alan, ama en büyük delik 160 K.
P2 aşağı kaydırılır: 384 → 288. Taşınan sürecin taban yazmacı güncellenir.
P3: 640 → 480.
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
| Biteşlem | Bağ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) |
| Boyut | Sabit: birim 4 B ise belleğin 1/33’ü; 16 GiB, 4 KiB birim → 512 KiB | Süreç + delik sayısıyla orantılı |
| Arama | k 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; }
Bellek 10 birim; dolu birimler 1. k = 3 birimlik bir süreç için ardışık üç 0 aranıyor.
bit[0] = 1: dolu birim, uz = 0 kalır.
bit[1] = 1: dolu birim, uz = 0 kalır.
bit[2] = 0 ve önceki koşu yok → yeni koşu bas = 2, uz = 1.
bit[3] = 0 → koşu uzar: uz = 2; henüz k’ye ulaşmadı.
bit[4] = 1: 2 birimlik koşu yetmeden bozuldu → uz = 0. 2–3 arasındaki delik bu süreç için küçük.
bit[5] = 0 ve önceki koşu yok → yeni koşu bas = 5, uz = 1.
bit[6] = 0 → koşu uzar: uz = 2; henüz k’ye ulaşmadı.
bit[7] = 0 → uz = 3 = k: koşu yeterli, başlangıç 5 döndürülür.
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
Komşuların ikisi de süreç: X’in düğümü D’ye çevrilir, liste uzunluğu değişmez.
Sağda delik: X ile sağdaki delik birleşir, bir düğüm silinir.
Solda delik: soldaki delik X kadar uzar, X’in düğümü silinir.
İ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
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.
p1 = malloc(200): ilk uyan parça bölünür. Başlığa boy ve sihirli sayı yazılır.
p2 = malloc(100), p3 = malloc(300): aynı bölme tekrarlanır.
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.
free(p1): adrese göre komşu iki boş parça birleştirilir; liste kısalır.
free, yanlış işaretçi) kütüphane bunu fark edip programı durdurabilir.malloc(n) en az n + başlık bayt tüketir; hizalama için yukarı yuvarlanır (glibc: 16 B).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.
Sayfalama
Adresin Bölünmesi: (p, d)
| Örnek | Hesap | Sonuç |
|---|---|---|
| 32 bit adres, 4 KiB sayfa | 4096 = 212 → d 12 bit, p = 32 − 12 = 20 bit | 220 = 1.048.576 sayfa |
0x12345678 | p = 0x12345678 >> 12, d = 0x12345678 & 0xFFF | p = 0x12345 (74.565), d = 0x678 (1656) |
| 16 bit adres, 4 KiB (Tanenbaum) | 8196 = 2·4096 + 4 | p = 2, d = 4 |
| 48 bit (x86-64), 4 KiB | p = 48 − 12 | 36 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
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ıksal 0 (a): sayfa 0, konum 0 → çerçeve 5 → fiziksel 20.
Mantıksal 3 (d): sayfa 0, konum 3 → çerçeve 5 → fiziksel 23.
Mantıksal 4 (e): sayfa 1, konum 0 → çerçeve 6 → fiziksel 24.
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 */
Sayfa 0 → çerçeve 2: 8192. Üst 4 bit sayfa numarası, alt 12 bit aynen kopyalanır.
8192 = sayfa 2, konum 0 → çerçeve 6: 24576.
20500 = 5·4096 + 20 → çerçeve 3: 12288 + 20 = 12308.
8196 = 2·4096 + 4 → 6·4096 + 4 = 24580 (Tanenbaum Şekil 3-10).
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.
Sayfalama
Boş Çerçeveler
- İş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.
readtamponu) ç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
| Bit | Anlamı (Tanenbaum adı) | Kim yazar? |
|---|---|---|
| P | Mevcut/yok (present/absent): 0 ise erişim sayfa hatası üretir | İS |
| R/W, U/S, NX | Koruma: yazılabilir mi, kullanıcı modu erişebilir mi, çalıştırılabilir mi | İS |
| A | Erişildi (referenced): okuma ya da yazmada 1 olur; sayfa yer değiştirmede kullanılır | donanım (İS sıfırlar) |
| D | Değiştirildi (modified, kirli): yazmada 1; kirli sayfa çıkarılırken diske yazılır | donanım |
| PCD, PWT, PAT | Önbellek devre dışı / yazma politikası: bellek eşlemeli G/Ç için | İS |
| G | Global: 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.468 arasını kullanır: sayfa 0–5 geçerli (çerçeve 2, 3, 4, 7, 8, 9), sayfa 6 ve 7 geçersiz.
3.000: sayfa 1, konum 952 → çerçeve 3 → 7.096.
10.468: sayfa 5’in içinde → 18.660. Sürecin son adresi.
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.
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
Kod sayfaları salt okunur eşlenir; koda yazma girişimi koruma hatası üretir.
Çekirdek sayfaları kullanıcı modunda erişilemez. Aynı tabloda hem çekirdek hem süreç eşlemeleri durabilir.
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.
Çekirdek modundayken kullanıcı sayfalarındaki kodu çalıştırmayı (SMEP) ve izinsiz veriye erişmeyi (SMAP) engeller.
PTE’deki 4 bitlik anahtar ve kullanıcı yazmacı (PKRU) ile sistem çağrısı olmadan sayfa grubunun iznini değiştirmek.
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.
TLB
Sayfa Tablosu Nerede? TLB
- 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
Sayfa tablosu MMU örneğindeki Tanenbaum tablosu (0→2, 2→6, 5→3, 9→5, 11→7). TLB başlangıçta boş.
0x0010: sayfa 0 yok → ıska; sayfa tablosundan okunur, TLB’ye yazılır.
0x2004: sayfa 2 yok → ıska; sayfa tablosundan okunur, TLB’ye yazılır.
0x0020: sayfa 0 TLB’de → isabet, sayfa tablosuna gidilmez.
0x5010: sayfa 5 yok → ıska; sayfa tablosundan okunur, TLB’ye yazılır.
0x9000: sayfa 9 yok → ıska; sayfa tablosundan okunur, TLB’ye yazılır.
0x2008: sayfa 2 TLB’de → isabet, sayfa tablosuna gidilmez.
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.
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.
TLB · Adım adım hesap
Etkin Erişim Süresi
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
| Konu | Açıklama |
|---|---|
| Donanım yönetimli | x86-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önetimli | MIPS, 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 ıska | Yumuşak ıska: sayfa bellekte, yalnızca TLB’de yok (ns). Sert ıska: sayfa diskte, G/Ç gerekir (µs–ms). |
| ASID / PCID | Girdi 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). |
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).
Sayfa Tablosu Yapıları · Adım adım
İki Düzeyli Çeviri Örneği
Sanal adres 0x00403004 (4.206.596): 4 MiB ile 8 MiB arasında, veri bölgesinde (Tanenbaum Şekil 3-13).
Ü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.
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ı.
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; }
Sanal adres 0x00801A3C (8 MiB’ın biraz üstü). Üst tabloda yalnız girdi 2 geçerli; onun tablosunda girdi 1 → çerçeve 0x2F.
Üst 10 bit: 0x00801A3C >> 22 = 2.
Orta 10 bit: (va >> 12) & 0x3FF = 0x801 & 0x3FF = 1.
Alt 12 bit konum: 0xA3C; çeviride hiç değişmez.
Üst tablonun 2. girdisi geçerli (P = 1): ikinci düzey tablonun çerçevesini verir. Birinci bellek erişimi.
İkinci düzey tablonun 1. girdisi: çerçeve 0x2F, P = 1. İkinci bellek erişimi.
0x2F << 12 = 0x2F000; konumla birleşince fiziksel 0x0002FA3C. Üçüncü erişim veridir.
İkinci adres 0x01403004: p1 = 5, p2 = 3, konum = 0x004.
Ü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
- 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
PSbiti 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üş
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.
CR3 PML4 tablosunun çerçevesini verir; girdi 255 okunur → PDPT tablosunun çerçevesi.
PDPT[504] → sayfa dizini (PD) çerçevesi. Burada PS = 1 olsaydı 1 GiB’lık sayfa bulunmuş olurdu.
PD[145] → son düzey tablo. PS = 1 olsaydı 2 MiB’lık sayfa.
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
- 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
Her kova, aynı hash değerine düşen (sanal sayfa, çerçeve, sonraki) girdilerinin zinciridir. Örnekte 8 kova, h(p) = p mod 8.
Sayfa numarası 26 hash’lenir: kova 2.
Zincirin ilk girdisi p = 10: eşleşmez, sonrakine geçilir.
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
Tabloda süreç başına değil, fiziksel çerçeve başına bir girdi vardır: o çerçevede hangi sürecin hangi sayfası.
Girdi 0: (pid 1, sayfa 0) ≠ (2, 5), sonraki.
Girdi 1: (pid 2, sayfa 3) ≠ (2, 5), sonraki.
Girdi 2: (pid 1, sayfa 5) ≠ (2, 5), sonraki.
Girdi 3: (pid 3, sayfa 1) ≠ (2, 5), sonraki.
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.
Kesimleme · Adım adım
Kesim Tablosu ile Çeviri
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.
(2, 53): 53 < 400 → 4.300 + 53 = 4.353.
(3, 852): 852 < 1.100 → 3.200 + 852 = 4.052.
(1, 399): 399 < 400 → 6.300 + 399 = 6.699.
(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
1.000: üst bitler 00 → kod. 1.000 < 3.072 → 24.576 + 1.000 = 25.576.
4.500: 01 → heap. Konum 4.500 − 4.096 = 404 → 40.960 + 404 = 41.364. Sanal adres + taban (45.460) yanlış olurdu.
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.
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, sabitlerr, verirw.
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).
Kesimleme
Sayfalama ve Kesimleme Karşılaştırması
| Durum | Sayfalama | Kesimleme |
|---|---|---|
| Programcı tekniğin farkında olmalı mı? | Hayır | Evet |
| Kaç doğrusal adres alanı var? | 1 | Çok |
| Toplam adres alanı fiziksel belleği aşabilir mi? | Evet | Evet |
| Kod ve veri ayrılıp ayrı korunabilir mi? | Sayfa bitleriyle evet* | Evet |
| Boyu değişen tablolar kolayca yerleşir mi? | Hayır | Evet |
| 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 |
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
- 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 KiB | 4 KiB (+ 2 MiB, 1 GiB, 512 GiB büyük sayfa) |
| Sanal adres | 48 bit (4 KiB ile 4 düzey, L0–L3); LVA/LPA2 ile 52 bit | Sv39 (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ç etiketi | ASID 8/16 bit | ASID (16 bite kadar) |
| Koruma | AP bitleri, UXN/PXN (çalıştırma yasağı), PAN (≈ SMAP) | R/W/X/U bitleri, SUM |
| TLB | Donanım yürüyüşü; A/D bitleri isteğe bağlı donanımla (v8.1); contiguous biti | Donanım yürüyüşü (çoğu gerçekleme); sfence.vma |
İ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ı
- İş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
| Teknik | Fikir | Artı | Eksi |
|---|---|---|---|
| Taban-limit | Tek bitişik bölge + MMU | Basit, 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 |
| Sayfalama | Sabit sayfa ↔ çerçeve, sayfa tablosu | Dış parçalanma yok, paylaşım, koruma | Tablo boyutu, çift erişim |
| TLB | Çeviri önbelleği, ASID | EES ≈ bellek süresi | Bağlam değiştirme, vurusu |
| Hiyerarşik tablo | Tabloyu sayfala (x86-64: 4/5 düzey) | Seyrek uzay ucuz | Iskada çok erişim |
| Hash / ters | Kullanılan sayfa / çerçeve başına girdi | Küçük tablo | Arama, paylaşım zor |
| Kesimleme | (kesim, konum), kesim tablosu | Mantıksal bölme, koruma | Dış 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
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ı? (asanal 40.000’de başlar,int4 B, sayfa 4 KiB, kod tek sayfada.)dongu: movl $0,(%edi,%eax,4) /* a[i] = 0 */ incl %eax /* i++ */ cmpl $1000,%eax jne dongu
- “Kesimi Seçen Bitler” slaytındaki kesim yazmaçlarıyla sanal 13.000 ve 14.500 adresleri nereye gider?
- 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? free(p + 4)çağrılırsa ne olur?
Cevaplar
- 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.
- 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.
- 4.080 − 3 × 1.016 = 1.032 B. 1.040 > 1.032 olduğundan hayır: ayırıcı heap’i
sbrkya dammapile büyütür. - 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ı
- Taban = 300.040, limit = 120.900 iken 420.940 adresine erişilirse ne olur?
- Delikler 100, 500, 200, 300, 600 K; istekler 212, 417, 112, 426 K. Hangi algoritma hepsini yerleştirir?
- 32 bit adres ve 4 KiB sayfada
0x12345678için p ve d nedir? - Tanenbaum tablosunda (5 → 3) sanal 20.500 hangi fiziksel adrese çevrilir?
- ε = 20 ns, t = 100 ns, α = %90 için tek düzeyli tabloda EES nedir?
- Hiyerarşik sayfa tablosu neden 64 bit sistemlerde de kullanılabilir? x86-64 kaç düzey kullanır?
- x86-64 uzun modda kesimlemeden geriye ne kalmıştır?
- 4 kümeli, 64 B satırlı doğrudan eşlemeli boş önbellekte 0, 128, 256, 0 adreslerine erişiliyor. Kaç isabet olur?
Cevaplar
- Taban + limit = 420.940 aralığın dışında (son geçerli 420.939) → tuzak.
- Yalnızca en iyi uyan; diğerlerinde 426 K bekler (dış parçalanma).
- p = 0x12345 (74.565), d = 0x678 (1.656).
- 3 × 4096 + 20 = 12.308.
- 120 × 0,9 + 220 × 0,1 = 130 ns.
- 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).
- Tabanı kullanılan FS ve GS (TLS, çekirdek başına veri); CS ayrıcalık düzeyini taşır.
- 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.