Bölüm 11: Giriş/Çıkış

İşletim Sistemleri
G/Ç donanımı ve veri yollarıAygıt yazmaçları, kapı ve bellek eşlemeli G/ÇYoklama (programlanmış G/Ç)Kesmeler, vektörler, MSI-XDMA, dağıt-topla, IOMMUG/Ç yazılım katmanlarıTamponlama, önbellek, biriktirmeBloke eden, eş zamansız G/Ç, io_uringSaatler ve zamanlayıcılarDiskler ve disk çizelgelemeSSD, NVMe, blk-mqRAID ve kararlı depolama
Sercan KÜLCÜ · Giresun Üniversitesi · Bilgisayar Mühendisliği

Giriş

Öğrenme Çıktıları

Donanım

Denetleyici, aygıt yazmaçları, PCIe/USB/NVMe veri yolları; kapı ve bellek eşlemeli G/Ç’yi açıklamak.

Aktarım yöntemleri

Yoklama, kesme güdümlü G/Ç ve DMA’yı karşılaştırmak; MSI-X ve IOMMU’nun rolünü söylemek.

Yazılım katmanları

Kesme işleyicisi, sürücü, aygıttan bağımsız katman ve kullanıcı kütüphanesini bir read() yolunda izlemek.

Arayüzler

Bloke eden, bloke etmeyen ve eş zamansız G/Ç’yi; epoll ve io_uring’i ayırt etmek.

Diskler

Erişim süresini hesaplamak; FCFS, SSTF, SCAN, C-SCAN, LOOK, C-LOOK toplam kafa hareketini bulmak.

SSD ve RAID

FTL, aşınma dengeleme, TRIM ve blk-mq’yu; RAID 0/1/5/6/10 ve XOR eşliği ile kurtarmayı açıklamak.

Giriş

G/Ç Sistemine Genel Bakış

İşlemci (SoC)çekirdekler · bellek denetleyicisiPCIe kök kompleksi · APICDRAM (DDR5)ana bellekbellek yoluGPUPCIe 5.0 x16NVMe SSDPCIe 4.0/5.0 x4USB4 / Thunderbolt40–80 Gb/sYonga seti (PCH)G/Ç denetleyicileriDMI ≈ PCIe x4/x8SATAHDD / optikUSB 3.xklavye, fareEthernetNICWi-Fi / BTM.2 kartSesHD Audiodenetleyici + aygıt
  • İşletim sistemi aygıtlara komut verir, durumlarını okur, kesmeleri yakalar ve hataları ele alır.
  • Uygulamalara aygıttan bağımsız, katmanlı ve tek tip bir arayüz sunar.
  • Çekirdek kodunun büyük bölümü aygıt sürücüleridir (Linux kaynak kodunun yaklaşık %60–70’i drivers/).

Giriş

Veri Yolları: PCIe, USB4, SATA

  • Veri yolu: bileşenler arasında veri, adres ve denetim sinyallerini taşıyan bağlantı. Eski PC’lerde paylaşılan paralel yol (ISA, PCI); bugün noktadan noktaya seri hatlar (PCIe, USB, SATA).
  • PCIe bir hat (lane) tam çift yönlüdür; bağlantı x1, x4, x8, x16 hat birleştirir. Bant genişliği her yönde ayrı ayrıdır.
BağlantıHam hızEtkin veri hızıNot
PCIe 4.016 GT/s / hat≈ 1,97 GB/s / hat; x4 ≈ 7,9 GB/s128b/130b kodlama; NVMe SSD’ler
PCIe 5.032 GT/s / hat≈ 3,94 GB/s / hat; x16 ≈ 63 GB/sGPU, 14 GB/s sınıfı SSD
PCIe 6.064 GT/s (PAM4)≈ 7,6 GB/s / hat; x16 ≈ 121 GB/sFLIT + FEC; sunucularda yaygınlaşıyor
USB 2.0 / 3.2480 Mb/s / 5–20 Gb/s≤ 60 MB/s / ≤ 2,5 GB/sAna makine yoklamalı protokol
USB4 v1 / v240 / 80 Gb/sPCIe, DisplayPort tünellemeThunderbolt 4/5 ile uyumlu
SATA III6 Gb/s≈ 600 MB/s (8b/10b)AHCI: tek kuyruk, 32 komut
Ethernet1 / 10 / 100 / 400 Gb/s125 MB/s … 50 GB/sVeri merkezi: 400–800 GbE

Hesap: PCIe 4.0 hattı 16 GT/s × 128/130 ÷ 8 = 1,97 GB/s. FireWire, 56K modem ve 10/100 Mb/s Ethernet tarihseldir. Pentium dönemindeki kuzey köprüsü kalktı: bellek denetleyicisi CPU’ya taşındı (AMD 2003, Intel 2008); hızlı aygıtlar PCIe ile doğrudan CPU’ya, yavaşlar yonga setine bağlanır.

Giriş

Aygıt Veri Hızları

1 B/s1 KB/s1 MB/s1 GB/s100 GB/sKlavye10 B/sFare (1 kHz oyun faresi)8 KB/sGigabit Ethernet125 MB/sHDD (7200 rpm, ardışık)250 MB/sSATA SSD550 MB/sUSB 3.2 Gen 21,25 GB/sUSB4 (40 Gb/s)5 GB/sNVMe PCIe 4.0 x47 GB/sNVMe PCIe 5.0 x414 GB/s400 GbE50 GB/sDDR5-6400 (bir kanal)51,2 GB/sPCIe 5.0 x1663 GB/slogaritmik eksen: her çizgi 1000 kat

Klavye ile PCIe 5.0 x16 arasında ≈ 6 × 109 kat fark var: aynı işletim sistemi hem saniyede birkaç tuşu hem saniyede milyonlarca NVMe isteğini yönetmelidir. Değerler tipik üst sınırlardır; gerçek hız sinyal kalitesi, protokol yükü ve aygıta bağlıdır.

Giriş

Aygıt Sınıfları: Blok, Karakter, Ağ

SınıfÖrnekÖzellikTipik arayüz
BlokHDD, SSD, USB bellek, SD kartSabit boyutlu, adreslenebilir bloklar (512 B / 4 KiB); her blok bağımsız okunur/yazılırread, write, lseek; dosya sistemi, mmap
KarakterKlavye, fare, seri port, yazıcı, sesBayt akışı; adreslenemez, konum (seek) yokread/write, ioctl; /dev/ttyS0
AğEthernet, Wi-FiPaket tabanlı; ne blok ne karakterSoket API’si (send, recv); /dev’de dosyası yok
DiğerSaatler, zamanlayıcılar, GPUNe akış ne blok: kesme üretir ya da bellek eşlemelidirtimerfd, DRM/KMS, mmap
$ ls -l /dev/nvme0n1 /dev/ttyS0
brw-rw---- 1 root disk    259, 0  nvme0n1   b = blok, ana/yan numara 259,0
crw-rw---- 1 root dialout   4, 64 ttyS0     c = karakter

Ağ arabirimleri karakter aygıtı değildir; Unix/Linux’ta ağ ayrı bir sınıftır. Blok boyutu bugün çoğunlukla 512 B (öykünmeli) ya da 4 KiB’dir; sınıflandırma kesin değildir (teyp ve saatler sınıfa tam uymaz).

G/Ç Donanımı

Aygıt Denetleyicileri

Mekanik kısımplaka, kafa, motorDenetleyici (elektronik kısım)Yazmaçlardurum, komutTamponsektör / izECC + DMAhata düzeltmeSistem yoluPCIe / SATA / USBbağlayıcıseri bit akışı:öncülveri: 512 B = 4096 bit (ya da 4 KiB)ECC
  • G/Ç birimi = mekanik/aygıt kısmı + elektronik denetleyici (yonga ya da kart; bağlayıcı ile aygıta bağlanır).
  • Öncül (preamble) senkronizasyon deseni ile silindir/sektör numarasını taşır. Denetleyici bit akışını bloğa çevirir, ECC ile hatayı düzeltir, bloğu kendi tamponuna koyar; sonra belleğe aktarır.
  • Açılışta ve sıcak takmada İS yolları tarar (PCIe yapılandırma alanı, USB tanımlayıcıları), aygıt kimliğini okur ve uygun sürücüyü yükler: tak-çalıştır.
  • İşletim sistemi aygıtla değil denetleyiciyle konuşur; SATA/NVMe gibi standart arayüzler sayesinde tek sürücü birçok üreticinin aygıtını sürer.
  • Modern diskler 4 KiB fiziksel sektör kullanır (Advanced Format); dışarıya 512 B gösterenlere 512e denir.

G/Ç Donanımı

Aygıt Yazmaçları: Durum, Komut, Veri

Durum (status)BUSYRDYERRDRQ––––CPU okurKomut (command)WRITECMDRDYREADIRQEN––––CPU yazarVeri çıkışı (data-out)01000001CPU → aygıtVeri girişi (data-in)????????aygıt → CPUbit 7bit 0
  • Denetleyicinin genellikle dört yazmacı vardır: durum (meşgul, hazır, hata), komut (ne yapılacağı), veri girişi ve veri çıkışı.
  • Yazmaçlara yazmak = komut vermek; okumak = durum öğrenmek. Ayrıca büyük veri tamponları (ör. çerçeve tamponu, NIC halkaları) olabilir.
  • Yazmaç düzeni aygıta özgüdür; bu ayrıntıyı yalnız sürücü bilir. Bit adları burada örnek amaçlıdır.

G/Ç Donanımı

Kapı Eşlemeli ve Bellek Eşlemeli G/Ç

(a) Ayrı uzaylar(b) Bellek eşlemeli(c) HibritBellekG/Çkapıları0 … 2ⁿ−10 … 0xFFFFaygıt yazmaçlarıBellek← adres aralığıtek adres alanıtamponlarBellekkontrolkapılarıör. eski PC’de VGA
Kapı (x86)Aygıt
0x20–0x218259 kesme denetleyicisi
0x40–0x438254 zamanlayıcı (PIT)
0x60, 0x648042 klavye denetleyicisi
0x3F8–0x3FFCOM1 seri port
0xCF8–0xCFFPCI yapılandırma
in  al, 0x60          ; kapı: özel komut
mov eax, [rbx+0x14]   ; MMIO: sıradan yükleme

Linux: inb()/outb()  ·  ioremap() + readl()/writel()
/proc/ioports  ·  /proc/iomem

Kapı eşlemeli G/Ç’de CPU özel IN/OUT komutları ve ayrı bir adres alanı kullanır; bellek eşlemelide aygıt yazmacı sıradan bir bellek adresidir ve adres çözücü erişimi ilgili aygıta yönlendirir. ARM ve RISC-V yalnız MMIO kullanır; PCIe aygıtları da yazmaçlarını BAR’lar ile MMIO olarak sunar.

G/Ç Donanımı

Bellek Eşlemeli G/Ç: Artılar ve Eksiler

Bellek eşlemeli G/Ç: artılar

  • Özel komut gerekmez; sürücü tamamen C ile yazılabilir (volatile işaretçi).
  • Koruma sayfa tablosuyla gelir: yazmaç sayfası kullanıcı uzayına eşlenmezse erişilemez; istenirse tek bir sürece verilebilir (VFIO, DPDK).
  • Her bellek komutu yazmaçla çalışır: TEST, AND gibi komutlar doğrudan yazmaç üzerinde.

Eksiler

  • Önbellek: durum yazmacı önbelleğe alınırsa güncel değer görülmez → sayfa önbelleklenemez işaretlenir (PAT/MTRR, ioremap).
  • Birden çok yol: bellek ayrı hızlı yolda ise G/Ç aygıtı adresi göremez → yönlendirme köprü/kök kompleks tarafından adres aralıklarıyla yapılır.
  • Derleyici erişimleri yeniden sıralayabilir: volatile ve bellek bariyerleri gerekir.
(a) tek yolCPUBellekG/Çtüm adresler tek yolda(b) çift yolCPUBellekG/Çhızlı bellek yoluG/Ç yolu

Programlanmış G/Ç · Kodu adım adım çalıştır

Yoklama: El Sıkışma Adım Adım

while (status & BUSY)
    ;          /* meşgul bekleme */
command = WRITE;
data_out = 'A';
command |= CMDRDY;
/* --- denetleyici tarafı --- */
/* CMDRDY görüldü → BUSY = 1 */
/* komutu oku, baytı aygıta yaz */
/* CMDRDY = ERR = BUSY = 0 */
CPUsürücüDenetleyici1BUSY0CMDRDY0WRITE0ERRdata-out = —denetleyici yazmaçları

Sürücü durum yazmacını tekrar tekrar okur: denetleyici önceki işi bitirmediği için BUSY = 1. CPU bu sırada başka iş yapamaz.

CPUsürücüDenetleyici0BUSY0CMDRDY0WRITE0ERRdata-out = —denetleyici yazmaçları

BUSY 0 oldu: döngüden çıkılır. Bu bekleme süresi aygıta bağlıdır; birkaç döngüden milisaniyelere kadar sürebilir.

CPUsürücüDenetleyici0BUSY0CMDRDY1WRITE0ERRdata-out = —denetleyici yazmaçları

Komut yazmacına WRITE biti yazılır: yapılacak iş yazma.

CPUsürücüDenetleyici0BUSY0CMDRDY1WRITE0ERRdata-out = 0x41denetleyici yazmaçları

Gönderilecek bayt ('A' = 0x41) veri çıkış yazmacına konur.

CPUsürücüDenetleyici0BUSY1CMDRDY1WRITE0ERRdata-out = 0x41denetleyici yazmaçları

CMDRDY = 1: “komut hazır”. Bu bit denetleyiciye işin başlayabileceğini söyler.

CPUsürücüDenetleyici1BUSY1CMDRDY1WRITE0ERRdata-out = 0x41denetleyici yazmaçları

Denetleyici CMDRDY’yi görür ve BUSY = 1 yapar: artık meşgul olduğunu ana makineye bildirir.

CPUsürücüDenetleyici1BUSY1CMDRDY1WRITE0ERRdata-out = 0x41denetleyici yazmaçları

Denetleyici komut yazmacını okur (WRITE), veri çıkış yazmacındaki baytı alır ve aygıta gönderir.

CPUsürücüDenetleyici0BUSY0CMDRDY1WRITE0ERRdata-out = 0x41denetleyici yazmaçları

İş bitti: CMDRDY, ERR ve BUSY temizlenir (ERR = 0 → başarılı). Sonraki bayt için döngü baştan başlar.

Programlanmış G/Ç (PIO): her bayt için CPU bu el sıkışmayı kendisi yürütür. Basittir, ama bekleme boyunca CPU boşa döner; CPU başka sürece geçip bir baytı kaçırırsa (ör. tampon taşması) veri kaybolabilir.

Programlanmış G/Ç · Kodu adım adım çalıştır

Programlanmış G/Ç: Yazıcı Örneği

copy_from_user(buffer, p, count);
for (i = 0; i < count; i++) {
    while (*printer_status_reg != READY)
        ;   /* meşgul bekleme */
    *printer_data_register = p[i];
}
return_to_user();
CPUPIO döngüsüyazıcı

Kullanıcının “ABCD” dizisi çekirdek tamponuna kopyalanır (copy_from_user); kullanıcı belleği doğrudan kullanılmaz.

CPUPIO döngüsüyazıcı

i = 0: durum READY olana kadar döngü döner.

CPUPIO döngüsüyazıcıA

'A' veri yazmacına yazılır; yazıcı karakteri basar ve yeniden meşgul olur.

CPUPIO döngüsüyazıcıA

i = 1: yazıcı meşgul, CPU durum yazmacını yoklar.

CPUPIO döngüsüyazıcıAB

'B' veri yazmacına yazılır; yazıcı karakteri basar ve yeniden meşgul olur.

CPUPIO döngüsüyazıcıAB

i = 2: yazıcı meşgul, CPU durum yazmacını yoklar.

CPUPIO döngüsüyazıcıABC

'C' veri yazmacına yazılır; yazıcı karakteri basar ve yeniden meşgul olur.

CPUPIO döngüsüyazıcıABC

i = 3: yazıcı meşgul, CPU durum yazmacını yoklar.

CPUPIO döngüsüyazıcıABCD

'D' veri yazmacına yazılır; yazıcı karakteri basar ve yeniden meşgul olur.

CPUPIO döngüsüyazıcıABCD

Döngü bitti; sürece dönülür. CPU tüm süre boyunca bu sürece bağlı kaldı: 4 karakterlik iş, yazıcının hızıyla sınırlı.

Tanenbaum’un yazıcı örneği. Yazıcı saniyede 100 karakter basıyorsa her karakter için CPU ≈ 10 ms bekler; bu sürede milyonlarca komut çalıştırabilirdi. Gömülü sistemlerde CPU’nun başka işi yoksa PIO yine de mantıklıdır.

Kesmeler · Adım adım

Kesme Donanımı: Hattan MSI’ya

DiskdenetleyiciKlavyedenetleyiciYazıcıdenetleyiciKesme denetleyicisi(I/O APIC)CPUyerel APICBellek / PCIe kök kompleksi

Aygıtların her biri kesme denetleyicisine bağlıdır; denetleyici CPU’nun tek kesme girişini paylaştırır ve öncelik belirler.

DiskdenetleyiciKlavyedenetleyiciYazıcıdenetleyiciKesme denetleyicisi(I/O APIC)CPUyerel APIC① iş bitti: IRQBellek / PCIe kök kompleksi

① Disk denetleyicisi işini bitirince kendi kesme hattına (IRQ) sinyal verir.

DiskdenetleyiciKlavyedenetleyiciYazıcıdenetleyiciKesme denetleyicisi(I/O APIC)CPUyerel APIC① iş bitti: IRQ② kesmeBellek / PCIe kök kompleksi

② Denetleyici başka kesme işlenmiyorsa ya da bu daha öncelikliyse CPU’ya kesme iletir; değilse istek bekletilir (CPU onaylayana kadar hat etkin kalır).

DiskdenetleyiciKlavyedenetleyiciYazıcıdenetleyiciKesme denetleyicisi(I/O APIC)CPUyerel APIC① iş bitti: IRQ② kesme③ onay + vektörBellek / PCIe kök kompleksi

③ CPU kesmeyi kabul eder; denetleyici vektör numarasını yola koyar. CPU bu sayıyı kesme vektör tablosunda indis olarak kullanır.

DiskdenetleyiciKlavyedenetleyiciYazıcıdenetleyiciKesme denetleyicisi(I/O APIC)CPUyerel APICBellek / PCIe kök kompleksiMSI: 0xFEE0_0000 bölgesine vektör 0x41 yazılır

Modern PCIe: MSI/MSI-X. Kablo yok; aygıt özel bir adrese (x86’da 0xFEE0_0000 bölgesi) vektörü içeren bir bellek yazması gönderir, yerel APIC bunu kesmeye çevirir.

Eski PC: iki 8259 PIC, 15 IRQ hattı. Bugün x86’da I/O APIC + çekirdek başına yerel APIC (x2APIC), ARM’da GIC. Denetleyicinin “adres satırına sayı koyması” anlatımı yalnızca bu tarihsel PIC düzeni için geçerlidir.

Kesmeler

Vektörler, Öncelik, NMI ve İstisnalar

VektörOlayTür
0Bölme hatasıhata (fault)
1 / 3Hata ayıklama / kesme noktasıtuzak (trap)
2NMI (maskelenemez kesme)kesme
6Geçersiz işlem koduhata
13Genel koruma hatasıhata
14Sayfa hatasıhata
18Makine denetimiiptal (abort)
32–255Aygıt kesmeleri, IPI, APIC zamanlayıcımaskelenebilir
vektör 14IDT (IDTR yazmacı gösterir)0bölme_hatası…14sayfa_hatası…32aygıt kesmesiişleyici
  • Kesme vektör tablosu (x86: IDT, 256 giriş): vektör → işleyici adresi. 0–31 işlemci istisnalarına ayrılmıştır.
  • Maskelenebilir kesmeler kritik bölgede ertelenebilir (cli/sti); NMI ertelenemez: donanım hatası, bellek ECC, izleme köpeği.
  • Öncelik: APIC vektör sınıfına göre sıralar; yüksek öncelikli kesme düşük öncelikli işleyiciyi kesebilir.
  • Kesme zinciri: aygıt sayısı vektörden fazlaysa her girdi bir işleyici listesine işaret eder (paylaşılan IRQ).
  • Hata (sayfa hatası): komut tamamlanamaz, işleyiciden sonra aynı komut yeniden çalışır. Tuzak (sistem çağrısı, int3): sonraki komuttan devam edilir.
  • MSI-X: işlev başına 2048 vektöre kadar; NVMe ve NIC her kuyruk için ayrı vektör alır ve kesmeyi kuyruğun çekirdeğine yönlendirir (/proc/interrupts, irqbalance).

Kesmeler · Adım adım

Kesme İşleme Adım Adım

A çalışırkullanıcıDonanımPC, PSW kaydıIDT → ISRgiriş koduISRaygıt + EOIB uyanırhazır kuyruğuÇizelgeleyiciMMU, yazmaçlariretkullanıcıya dönüşçekirdek yığını(boş)mod:kullanıcıkesmeler:açıkçalışan:Abekleyen: B (okuma)

Süreç A çalışıyor; B bir disk okumasının bitmesini bekliyor. Disk kesme isteği gelir. CPU o anki komutu bitirir, sonra kesmeyi kabul eder.

A çalışırkullanıcıDonanımPC, PSW kaydıIDT → ISRgiriş koduISRaygıt + EOIB uyanırhazır kuyruğuÇizelgeleyiciMMU, yazmaçlariretkullanıcıya dönüşçekirdek yığınıRIP, CSRFLAGS (PSW)RSP, SSmod:çekirdekkesmeler:maskeliçalışan:—bekleyen: B (okuma)

Donanım PC (RIP), PSW (RFLAGS) ve yığın işaretçisini çekirdek yığınına iter, çekirdek moduna geçer, kesmeleri maskeler.

A çalışırkullanıcıDonanımPC, PSW kaydıIDT → ISRgiriş koduISRaygıt + EOIB uyanırhazır kuyruğuÇizelgeleyiciMMU, yazmaçlariretkullanıcıya dönüşçekirdek yığınıRIP, CSRFLAGS (PSW)RSP, SSdiğer yazmaçlarmod:çekirdekkesmeler:maskeliçalışan:giriş kodubekleyen: B (okuma)

Vektör numarası IDT’de indis olur → işleyici adresi. Giriş kodu (assembly) donanımın kaydetmediği yazmaçları kaydeder; ISR için bağlam ve yığın hazırdır.

A çalışırkullanıcıDonanımPC, PSW kaydıIDT → ISRgiriş koduISRaygıt + EOIB uyanırhazır kuyruğuÇizelgeleyiciMMU, yazmaçlariretkullanıcıya dönüşçekirdek yığınıRIP, CSRFLAGS (PSW)RSP, SSdiğer yazmaçlarmod:çekirdekkesmeler:maskeliçalışan:ISRbekleyen: B (okuma)

ISR aygıtın durumunu okur, veriyi alır ve denetleyiciye onay (EOI) gönderir; yeni kesmeler artık gelebilir. Uzun iş alt yarıya ertelenir.

A çalışırkullanıcıDonanımPC, PSW kaydıIDT → ISRgiriş koduISRaygıt + EOIB uyanırhazır kuyruğuÇizelgeleyiciMMU, yazmaçlariretkullanıcıya dönüşçekirdek yığınıRIP, CSRFLAGS (PSW)RSP, SSdiğer yazmaçlarmod:çekirdekkesmeler:maskeliçalışan:ISRB hazır

Bekleyen süreç B bloke durumundan hazır kuyruğuna alınır.

A çalışırkullanıcıDonanımPC, PSW kaydıIDT → ISRgiriş koduISRaygıt + EOIB uyanırhazır kuyruğuÇizelgeleyiciMMU, yazmaçlariretkullanıcıya dönüşçekirdek yığınıRIP, CSRFLAGS (PSW)RSP, SSdiğer yazmaçlarmod:çekirdekkesmeler:maskeliçalışan:çizelgeleyiciB hazır

Çizelgeleyici sıradakini seçer (burada B). B’nin sayfa tablosu MMU’ya yüklenir (x86: CR3), yazmaçları süreç tablosu/yığından geri alınır.

A çalışırkullanıcıDonanımPC, PSW kaydıIDT → ISRgiriş koduISRaygıt + EOIB uyanırhazır kuyruğuÇizelgeleyiciMMU, yazmaçlariretkullanıcıya dönüşçekirdek yığınıB’nin bağlamımod:kullanıcıkesmeler:açıkçalışan:BB hazır

iret: kaydedilen PC ve PSW geri yüklenir, kullanıcı moduna dönülür, kesmeler açılır. B kaldığı komuttan devam eder.

Bu sıra Tanenbaum’un kesme işleyicisi adımlarını izler. Çizelgeleyici A’yı da seçebilir; seçim politikaya bağlıdır. Ayrıntılı benzetim: Kesme, DMA ve G/Ç Akışı Simülatörü.

Kesmeler · Adım adım

Kesin ve Kesin Olmayan Kesmeler

(a) Kesin kesme: PC = 316300bitti304bitti308bitti312bitti316başlamadı320başlamadı324başlamadı328başlamadı332başlamadıPC

Kesin kesme: PC bilinen yere kaydedilir; PC’den önceki her komut tamamen bitmiş, sonrakilerin hiçbiri başlamamıştır; PC’deki komutun durumu bilinir.

(b) Kesin olmayan: komutlar farklı aşamalarda300bitti304%60308bitti312%30316%80320başlamadı324%50328başlamadı332%20

Kesin olmayan kesme: boru hattı / sıra dışı yürütmede komutlar yarım kalmıştır. Yeniden başlatmak için ya donanım geri alır ya da işletim sistemi çok miktarda iç durumu kaydedip çözümlemelidir.

  • Boru hattında aynı anda birçok komut farklı aşamalardadır; üstün ölçekli işlemcide komutlar sıra dışı tamamlanır. “PC” tek başına durumu anlatmaz.
  • Modern x86, ARM ve RISC-V işlemciler kesin kesme sağlar: yeniden sıralama arabelleği (ROB) komutları program sırasıyla emekliye ayırır; kesmede sonraki komutların etkileri atılır. Bedeli yonga alanı ve karmaşıklıktır.

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

Kesme Güdümlü G/Ç: Yazıcı Örneği

/* sistem çağrısı */
copy_from_user(buffer, p, count);
enable_interrupts();
while (*printer_status_reg != READY) ;
*printer_data_register = p[0];
i = 1; count = count - 1;
scheduler();      /* süreç bloke */
/* kesme hizmet yordamı */
if (count == 0) {
    unblock_user();
} else {
    *printer_data_register = p[i];
    count = count - 1;
    i = i + 1;
}
acknowledge_interrupt();
return_from_interrupt();
yazıcısüreç: çalışıyorCPU: süreç

“ABC” çekirdek tamponuna kopyalanır, yazıcı kesmeleri açılır.

yazıcıAsüreç: çalışıyorCPU: süreç

Yazıcı hazır olunca yalnız ilk karakter yazılır.

yazıcıAsüreç: blokeCPU: başka süreç

Sayaçlar güncellenir ve çizelgeleyici çağrılır: süreç bloke, CPU başka bir süreci çalıştırır.

yazıcıABsüreç: blokeCPU: ISR

1. kesme: 'A' basıldı. count ≠ 0 → p[1] = 'B' yazılır.

yazıcıABsüreç: blokeCPU: ISR

Kesme onaylanır ve kesilen sürece dönülür. CPU yazıcı beklerken boşa dönmedi.

yazıcıABCsüreç: blokeCPU: ISR

2. kesme: 'B' basıldı → p[2] = 'C' yazılır.

yazıcıABCsüreç: hazırCPU: ISR

3. kesme: count == 0 → tüm karakterler basıldı, kullanıcı süreci hazır kuyruğuna alınır.

Her karakter için bir kesme: 3 karakter → 3 kesme. Kesme yordamındaki 13. ve 14. satırlar i ve count’u her karakterden sonra günceller. Bedel: kesme başına bağlam kaydı ve işleyici süresi (≈ 1–2 µs).

Kesmeler

Üst Yarı, Alt Yarı ve Hibrit Yoklama

Üst yarı (hardirq)

Gerçek ISR: kısa tutulur, kesmeler kısmen kapalıdır. Aygıtı onaylar, veriyi tampona alır, alt yarıyı planlar.

Alt yarı

Ertelenmiş iş: Linux’ta softirq, tasklet, workqueue ya da iş parçacıklı IRQ (request_threaded_irq); Windows’ta ISR + DPC.

Kesme birleştirme

NIC ve NVMe birkaç tamamlanmayı tek kesmede bildirir (coalescing): daha az kesme, biraz daha fazla gecikme.

NAPI: kesme + yoklama

Yoğun ağ trafiğinde sürücü kesmeyi kapatıp kuyruğu yoklar, trafik azalınca kesmeye döner. Hibrit en iyisidir.

Saf yoklama ne zaman?

Olay hızı çok yüksek ve gecikme kritikse: DPDK/SPDK, NVMe yoklamalı kuyruklar, io_uring IOPOLL. Bir çekirdek tamamen yoklamaya ayrılır.

Kesme fırtınası

Hatalı aygıt sürekli kesme üretirse sistem kilitlenir; çekirdek “nobody cared” ile hattı kapatır, kesme hızını sınırlar.

DMA

Doğrudan Bellek Erişimi (DMA)

  • Bayt bayt aktarımda CPU zamanı boşa gider; DMA denetleyicisi blok aktarımını CPU olmadan yapar. CPU yalnız kurulum ve bitiş kesmesiyle uğraşır.
  • Yazmaçlar: bellek adresi, bayt sayısı, denetim (G/Ç kapısı, yön: okuma/yazma, birim: bayt/sözcük, patlama boyutu). Çok kanallı denetleyici aynı anda birçok aktarımı yönetir.
  • Anakartta tek bir DMA denetleyicisi düzeni yalnız tarihsel 8237 için geçerlidir. Bugün aygıtların çoğunda kendi DMA motoru vardır ve belleğe doğrudan PCIe yazması yapar.
(a) üçüncü taraf DMA (8237, anakartta)CPUDMAkanal 0–7AygıtBellek(b) veri yolu yöneticisi (bus master)CPUNVMe / NIC / GPUkendi DMA motoruBellek

DMA · Adım adım

DMA Aktarımı Adım Adım

CPUDMA denetleyicisiadres0x7A000sayaç4096denetimoku → bellekDisk denetleyicisitampon (sektör)boşDiskAna bellektampon @ 0x7A000sistem yolu① programla

① CPU DMA denetleyicisini (adres = 0x7A000, sayaç = 4096, yön) ve disk denetleyicisini (sektörü oku) programlar, sonra başka işe döner.

CPUDMA denetleyicisiadres0x7A000sayaç4096denetimoku → bellekDisk denetleyicisitampon (sektör)ECC doğrulandıDiskAna bellektampon @ 0x7A000sistem yoludiskten tampona

Disk denetleyicisi sektörü kendi tamponuna okur ve ECC ile doğrular. Tampon sayesinde yol meşgulken veri kaybolmaz.

CPUDMA denetleyicisiadres0x7A000sayaç4096denetimoku → bellekDisk denetleyicisitampon (sektör)ECC doğrulandıDiskAna bellektampon @ 0x7A000sistem yolu② adres + okuma isteği

② DMA denetleyicisi yolu ister, bellek adresini yola koyar ve disk denetleyicisine okuma isteği gönderir.

CPUDMA denetleyicisiadres0x7A000sayaç4096denetimoku → bellekDisk denetleyicisitampon (sektör)ECC doğrulandıDiskAna bellektampon @ 0x7A000sistem yolu③ veri doğrudan belleğe

③ Disk denetleyicisi sözcüğü doğrudan belleğe yazar; CPU veri yolunda yer almaz.

CPUDMA denetleyicisiadres0x7A004sayaç4092denetimoku → bellekDisk denetleyicisitampon (sektör)ECC doğrulandıDiskAna bellektampon @ 0x7A000sistem yolu④ onay; adres++, sayaç−−

④ Disk denetleyicisi onay gönderir; DMA adresi artırır, sayacı azaltır. Sayaç 0 olana kadar ②–④ tekrarlanır.

CPUDMA denetleyicisiadres0x7B000sayaç0denetimoku → bellekDisk denetleyicisitampon (sektör)ECC doğrulandıDiskAna bellektampon @ 0x7A000sistem yolu⑤ sayaç = 0 → kesme

⑤ Sayaç 0: DMA denetleyicisi CPU’yu kesmeyle uyarır. İşletim sistemi açtığında veri zaten bellektedir.

Döngü çalma (cycle stealing): DMA her sözcük için yolu kısa süre alır, CPU belleğe erişirken biraz yavaşlar. Patlama (burst) modunda yol bir blok boyunca tutulur. Geçişsiz (fly-by) modda veri aygıttan belleğe doğrudan gider; aksi halde DMA önce okuyup sonra yazar.

DMA

Dağıt-Topla ve IOMMU

Dağıt-topla (scatter-gather)tanımlayıcı listesi0x7A00040960x3100040960x9C0002048fiziksel bellek (bitişik değil)0x7A0000x310000x9C000tek komut, üç parça: ek kopya yokIOMMU (Intel VT-d, AMD-Vi, Arm SMMU)AygıtIOVA 0x1000Kötü aygıtIOVA 0xDEAD000IOMMUtablosuRAM0x7A000✗ engellendi
Dağıt-topla

Aygıta (adres, uzunluk) çiftleri listesi verilir; aygıt bitişik olmayan sayfalara tek işlemde yazar (readv, ağ paketleri, NVMe PRP/SGL).

IOMMU

Aygıtın gördüğü adresi (IOVA) sayfa tablosuyla fiziksele çevirir: koruma (Thunderbolt DMA saldırıları), sanal makineye aygıt atama (VFIO), 32 bit aygıtlara yüksek bellek.

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

DMA ile G/Ç: Yazıcı Örneği

/* sistem çağrısı */
copy_from_user(buffer, p, count);
set_up_DMA_controller();
scheduler();     /* süreç bloke */

/* kesme hizmet yordamı */
acknowledge_interrupt();
unblock_user();
return_from_interrupt();
DMA → yazıcısüreç: çalışıyorCPU: süreç

Veri çekirdek tamponuna kopyalanır.

DMA → yazıcısüreç: çalışıyorCPU: süreç

DMA denetleyicisi programlanır: tampon adresi, sayaç = 3, hedef yazıcı kapısı.

DMA → yazıcıAsüreç: blokeCPU: başka süreç

Süreç bloke edilir; CPU başka iş yapar. DMA karakterleri CPU’suz yazıcıya iletir.

DMA → yazıcıABCsüreç: blokeCPU: başka süreç

Tüm karakterler aktarıldı; bu arada CPU’ya hiç kesme gelmedi.

DMA → yazıcıABCsüreç: blokeCPU: ISR

DMA tek bir kesme üretir: işleyici onaylar.

DMA → yazıcıABCsüreç: hazırCPU: ISR

Kullanıcı süreci uyandırılır ve kesmeden dönülür. Karakter başına değil, tampon başına bir kesme.

DMA, CPU’yu G/Ç’den kurtarır, ama DMA denetleyicisi genellikle CPU’dan yavaştır. Aygıt çok yavaşsa ya da CPU’nun yapacak başka işi yoksa kesme güdümlü G/Ç ya da PIO daha basit ve yeterli olabilir (Tanenbaum).

DMA · Adım adım hesap

Üç Yöntemin Maliyeti

Yazıcı saniyede 1000 karakter basıyor; 4096 karakter yazdırılacak. Kesme işleme maliyeti 2 µs, DMA kurulumu 5 µs.

Yoklama: CPU her karakteri bekler: 4096 × 1 ms = 4,096 s boyunca meşgul.

Programlanmış G/Ç’de CPU, aygıt hızına bağlıdır.

Kesme güdümlü: 4096 kesme × 2 µs = 8,19 ms (işin süresinin %0,2’si).

Bekleme ortadan kalkar; bedel kesme sayısıdır.

DMA: 5 µs kurulum + 1 kesme × 2 µs = ≈ 7 µs; yaklaşık 1170 kat daha az.

Ama DMA yol döngüsü çalar ve kurulumu küçük aktarımlarda kendini geri ödemez.

Yoklama (PIO)4,096 sKesme güdümlü8,19 msDMA≈ 7 µsCPU süresi (log): 1 µs … 10 s

Hız farkı 4 basamaktan fazla. Kısa aktarım, yavaş DMA ya da boşta bekleyen CPU varsa DMA’nın kazancı kaybolur.

Etkileşimli simülatör: Kesme, DMA ve G/Ç Akışı Simülatörü: üç yöntem aynı aktarımla çalıştırılır, CPU kullanımları karşılaştırılır.

G/Ç Yazılımı

G/Ç Yazılımının Hedefleri

Aygıt bağımsızlığı

Program aygıtı bilmeden çalışmalı: sort < girdi dosya, SSD ya da USB bellekte aynı çalışır.

Tek tip adlandırma

Ad aygıt tipine bağlı olmamalı: /dev/nvme0n1, /mnt/usb/rapor.txt; bağlama (mount) ile tek ağaç.

Hata ele alma

Hata donanıma olabildiğince yakın çözülmeli: denetleyici ECC ile düzeltir, sürücü yeniden dener; üst katman ancak gerekirse bilir.

Eş zamanlı / eş zamansız

Donanımda aktarım çoğunlukla eş zamansızdır (kesme güdümlü); kullanıcıya ise bloke eden arayüz sunmak programlamayı kolaylaştırır.

Tamponlama

Gelen paket nereye gideceği belli olmadan bir yere konmalı; ses gibi gerçek zamanlı aygıtlar da tampona dayanır.

Paylaşılan / adanmış

Disk birçok kullanıcıya aynı anda hizmet verir; yazıcı ya da tarayıcı tek kullanıcıya adanır (kilitlenme riski doğar).

G/Ç Yazılımı

G/Ç Yazılım Katmanları

Kullanıcı süreciread(), printf(), biriktirmeSistem çağrısı + VFSfd → dosya, izinler, adlandırmaSayfa önbelleğitamponlama, önbelleklemeDosya sistemi + blok katmanıbağıl konum → LBA, blk-mq, çizelgeleyiciAygıt sürücüsükomut kur, yazmaçlara yazKesme işleyicisitamamlanma, süreci uyandırDonanımdenetleyici + aygıt (DMA)kullanıcıçekirdekdonanımistekyanıt

Her katmanın iyi tanımlı bir görevi ve üst katmana arayüzü vardır. Tanenbaum dört katman sayar: kullanıcı düzeyi G/Ç yazılımı, aygıttan bağımsız yazılım, aygıt sürücüleri, kesme işleyicileri. Linux’ta “aygıttan bağımsız” kısım VFS, sayfa önbelleği, dosya sistemi ve blok katmanına ayrılır.

G/Ç Yazılımı · Adım adım

Bir read() Çağrısının Yolu

Kullanıcı süreciread(), printf(), biriktirmeSistem çağrısı + VFSfd → dosya, izinler, adlandırmaSayfa önbelleğitamponlama, önbelleklemeDosya sistemi + blok katmanıbağıl konum → LBA, blk-mq, çizelgeleyiciAygıt sürücüsükomut kur, yazmaçlara yazKesme işleyicisitamamlanma, süreci uyandırDonanımdenetleyici + aygıt (DMA)kullanıcıçekirdekdonanımn = read(fd, buf, 4096)

Süreç read(fd, buf, 4096) çağırır; libc sarmalayıcısı syscall komutuyla çekirdeğe geçer.

Kullanıcı süreciread(), printf(), biriktirmeSistem çağrısı + VFSfd → dosya, izinler, adlandırmaSayfa önbelleğitamponlama, önbelleklemeDosya sistemi + blok katmanıbağıl konum → LBA, blk-mq, çizelgeleyiciAygıt sürücüsükomut kur, yazmaçlara yazKesme işleyicisitamamlanma, süreci uyandırDonanımdenetleyici + aygıt (DMA)kullanıcıçekirdekdonanımfd → struct file → inode

VFS tanımlayıcıyı açık dosyaya, dosyayı inode’a çevirir; erişim izni açılışta zaten denetlenmiştir.

Kullanıcı süreciread(), printf(), biriktirmeSistem çağrısı + VFSfd → dosya, izinler, adlandırmaSayfa önbelleğitamponlama, önbelleklemeDosya sistemi + blok katmanıbağıl konum → LBA, blk-mq, çizelgeleyiciAygıt sürücüsükomut kur, yazmaçlara yazKesme işleyicisitamamlanma, süreci uyandırDonanımdenetleyici + aygıt (DMA)kullanıcıçekirdekdonanımönbellekte yok: ıska

Sayfa önbelleğine bakılır: istenen sayfa yok. Önbellek sayfası ayrılır, okuma başlatılır.

Kullanıcı süreciread(), printf(), biriktirmeSistem çağrısı + VFSfd → dosya, izinler, adlandırmaSayfa önbelleğitamponlama, önbelleklemeDosya sistemi + blok katmanıbağıl konum → LBA, blk-mq, çizelgeleyiciAygıt sürücüsükomut kur, yazmaçlara yazKesme işleyicisitamamlanma, süreci uyandırDonanımdenetleyici + aygıt (DMA)kullanıcıçekirdekdonanımbağıl konum 0 → LBA 2048

Dosya sistemi dosya bağıl konumunu disk bloğuna (LBA) çevirir; blok katmanı bir bio/istek oluşturup donanım kuyruğuna verir.

Kullanıcı süreciread(), printf(), biriktirmeSistem çağrısı + VFSfd → dosya, izinler, adlandırmaSayfa önbelleğitamponlama, önbelleklemeDosya sistemi + blok katmanıbağıl konum → LBA, blk-mq, çizelgeleyiciAygıt sürücüsükomut kur, yazmaçlara yazKesme işleyicisitamamlanma, süreci uyandırDonanımdenetleyici + aygıt (DMA)kullanıcıçekirdekdonanımSQ’ya komut + kapı zili

NVMe sürücüsü okuma komutunu gönderim kuyruğuna yazar, kapı zili (doorbell) yazmacına yazar. Süreç bloke olur (D durumu).

Kullanıcı süreciread(), printf(), biriktirmeSistem çağrısı + VFSfd → dosya, izinler, adlandırmaSayfa önbelleğitamponlama, önbelleklemeDosya sistemi + blok katmanıbağıl konum → LBA, blk-mq, çizelgeleyiciAygıt sürücüsükomut kur, yazmaçlara yazKesme işleyicisitamamlanma, süreci uyandırDonanımdenetleyici + aygıt (DMA)kullanıcıçekirdekdonanımDMA → önbellek sayfası, MSI-X

SSD veriyi DMA ile önbellek sayfasına yazar, tamamlanma kuyruğuna kayıt ekler ve MSI-X kesmesi üretir.

Kullanıcı süreciread(), printf(), biriktirmeSistem çağrısı + VFSfd → dosya, izinler, adlandırmaSayfa önbelleğitamponlama, önbelleklemeDosya sistemi + blok katmanıbağıl konum → LBA, blk-mq, çizelgeleyiciAygıt sürücüsükomut kur, yazmaçlara yazKesme işleyicisitamamlanma, süreci uyandırDonanımdenetleyici + aygıt (DMA)kullanıcıçekirdekdonanımtamamlandı: süreci uyandır

Kesme işleyicisi tamamlanmayı işler: sayfa “güncel” işaretlenir, bekleyen süreç hazır olur.

Kullanıcı süreciread(), printf(), biriktirmeSistem çağrısı + VFSfd → dosya, izinler, adlandırmaSayfa önbelleğitamponlama, önbelleklemeDosya sistemi + blok katmanıbağıl konum → LBA, blk-mq, çizelgeleyiciAygıt sürücüsükomut kur, yazmaçlara yazKesme işleyicisitamamlanma, süreci uyandırDonanımdenetleyici + aygıt (DMA)kullanıcıçekirdekdonanımcopy_to_user → n = 4096

Süreç çalışınca VFS veriyi önbellekten kullanıcı tamponuna kopyalar ve 4096 döndürür.

Kullanıcı süreciread(), printf(), biriktirmeSistem çağrısı + VFSfd → dosya, izinler, adlandırmaSayfa önbelleğitamponlama, önbelleklemeDosya sistemi + blok katmanıbağıl konum → LBA, blk-mq, çizelgeleyiciAygıt sürücüsükomut kur, yazmaçlara yazKesme işleyicisitamamlanma, süreci uyandırDonanımdenetleyici + aygıt (DMA)kullanıcıçekirdekdonanımikinci okuma: isabet

Aynı veri yeniden okunursa sayfa önbelleğinde isabet: aygıta hiç gidilmez, işlem mikrosaniyeler sürer.

G/Ç Yazılımı

Aygıt Sürücüleri

  • Sürücü aygıta özgü kodu kapsüller: yazmaçları, komutları ve tuhaflıklarını yalnız o bilir. Linux’ta çoğu sürücü çekirdek ağacındadır (in-tree); bazıları üreticiden gelir.
  • Görevleri: parametreleri doğrula, isteği aygıt komutuna çevir (LBA, kuyruk girdisi), gerekirse aygıtı başlat, yazmaçlara yaz, kesmeyi bekle (bloke), hatayı denetle, sonucu döndür.
  • Yeniden girilebilir (reentrant) olmalı: işlerken yeni istek ya da kesme gelebilir. Sıcak tak (hot-plug) ile aygıt çalışırken kaybolabilir.
  • Çekirdekteki hatalı sürücü tüm sistemi çökertir → kullanıcı alanı sürücüleri: MINIX 3, FUSE, VFIO/UIO, DPDK/SPDK; Windows UMDF. Yüklenebilir modüller: modprobe, lsmod.
Kullanıcı programıçekirdekaygıttan bağımsız katmanNVMesürücüsüUSB/HIDsürücüsüAğsürücüsüPCIeNVMe den.SSDxHCI den.klavyeNICkablo

G/Ç Yazılımı

Aygıttan Bağımsız G/Ç Yazılımı

  • Tüm sürücüler için tek tip arayüz: her sınıf aynı işlevleri sunar; çekirdek bir fonksiyon işaretçisi tablosu üzerinden çağırır.
  • Adlandırma: /dev/nvme0n1 → ana numara (sürücü) + yan numara (birim). Koruma: aygıt dosyasının izinleri.
  • Aygıttan bağımsız blok boyutu, tamponlama, hata raporlama, adanmış aygıtların ayrılması ve bırakılması bu katmandadır.
struct file_operations nvme_fops = {
  .open           = nvme_open,
  .release        = nvme_release,
  .read_iter      = nvme_read,
  .unlocked_ioctl = nvme_ioctl,
  .poll           = nvme_poll,
};
(a) arayüz yokİşletim sistemiSATAAğUSB(b) tek tip arayüzİşletim sistemiopen/read/write/ioctlSATAAğUSB

G/Ç Yazılımı · Adım adım

Ara Belleğe Alma (Tamponlama)

(a) tampon yokkullanıcı süreciçekirdekmodem / aygıther karakterdekesme + süreç uyanır

Tamponsuz: her karakter için kesme gelir ve süreç uyandırılır. Çok sayıda bağlam değiştirme, verimsiz.

(b) kullanıcı alanında tamponkullanıcı süreciçekirdekmodem / aygıtn karaktertampon sayfası bellekte kilitli olmalı

Kullanıcı tamponu: kesme işleyicisi karakterleri doğrudan süreç tamponuna yazar. Tampon sayfası diske atılırsa? Sayfa kilitlenmeli; çok süreç kilitlerse bellek azalır.

(c) çekirdek tamponu + kopyakullanıcı süreciçekirdekmodem / aygıtkullanıcıçekirdekdolunca tek kopya

Çekirdek tamponu: karakterler önce çekirdekte birikir, dolunca tek seferde kullanıcıya kopyalanır. Ama kopyalanırken gelen veri nereye konacak?

(d) çift tamponkullanıcı süreciçekirdekmodem / aygıtkullanıcıtampon 1tampon 2dolankopyalanan

Çift tampon: biri dolarken diğeri kopyalanır; roller sırayla değişir. Daha genel biçimi dairesel tampondur.

(e) ağ üzerinden bir paket: beş kopyakullanıcı (gönderen)çekirdek tamponuağ denetleyicisi tamponukullanıcı (alıcı)çekirdek tamponuağ denetleyicisi tamponu123: kablo45sıfır kopya: sendfile, splice, MSG_ZEROCOPY, io_uring

Ağda bir paket gönderilirken 5 kez kopyalanabilir; her kopya bellek bant genişliği ve gecikme demektir. Bu yüzden sıfır kopya teknikleri geliştirilmiştir.

Tamponlamanın üç nedeni (Silberschatz): üretici ile tüketici arasındaki hız farkı, aktarım boyutu farkı (paketlerin birleştirilmesi) ve kopya anlamı (write döndükten sonra kullanıcı tamponunu değiştirebilmek).

G/Ç Yazılımı · Adım adım

Dairesel Tampon

01234567baş = 0 kuyruk = 0dolu yuva: 0 / 8veri (üretici: ISR / DMA)kuyruk: sonraki yazılacak yuvabaş: sonraki okunacak yuvabaşlangıç: tampon boşboş: baş == kuyruk dolu: (kuyruk + 1) % 8 == baş

Baş ve kuyruk aynı yuvayı gösteriyor: tampon boş.

a0b1c234567baş = 0 kuyruk = 3dolu yuva: 3 / 8veri (üretici: ISR / DMA)kuyruk: sonraki yazılacak yuvabaş: sonraki okunacak yuvaüretici 3 bayt yazdıboş: baş == kuyruk dolu: (kuyruk + 1) % 8 == baş

Kesme işleyicisi gelen 3 baytı kuyruğa yazar; kuyruk ilerler. Tüketici henüz okumadı.

01c234567baş = 2 kuyruk = 3dolu yuva: 1 / 8veri (üretici: ISR / DMA)kuyruk: sonraki yazılacak yuvabaş: sonraki okunacak yuvatüketici 2 bayt okuduboş: baş == kuyruk dolu: (kuyruk + 1) % 8 == baş

Süreç 2 bayt okur; baş ilerler. Okunan yuvalar yeniden kullanılabilir.

01c2d3e4f5g6h7baş = 2 kuyruk = 0dolu yuva: 6 / 8veri (üretici: ISR / DMA)kuyruk: sonraki yazılacak yuvabaş: sonraki okunacak yuvasarma: kuyruk 7 → 0boş: baş == kuyruk dolu: (kuyruk + 1) % 8 == baş

Üretici 5 bayt daha yazar; kuyruk sona gelince başa sarar (mod 8): kuyruk = 0.

i01c2d3e4f5g6h7baş = 2 kuyruk = 1dolu yuva: 7 / 8veri (üretici: ISR / DMA)kuyruk: sonraki yazılacak yuvabaş: sonraki okunacak yuvabir bayt daha: tampon doluboş: baş == kuyruk dolu: (kuyruk + 1) % 8 == baş

'i' yazılınca kuyruk = 1 ve (kuyruk + 1) mod 8 == baş: tampon dolu. Bir yuva boş bırakılarak boş/dolu ayırt edilir. Dolu tamponda üretici bekler ya da veriyi düşürür (ağ paketi kaybı).

Dairesel tamponlar her yerdedir: klavye ve seri port sürücüleri, NIC alma/gönderme halkaları, NVMe gönderim/tamamlanma kuyrukları, io_uring. Tek üretici–tek tüketicide kilit gerekmez; yalnız bellek bariyerleri gerekir.

G/Ç Yazılımı · Kodu adım adım çalıştır

Dairesel Tampon: Kod İzleme

int koy(char c) {          /* üretici */
  int s = (kuy + 1) % N;
  if (s == bas) return -1; /* dolu */
  buf[kuy] = c;
  kuy = s;
  return 0;
}
int al(char *c) {          /* tüketici */
  if (bas == kuy) return -1; /* boş */
  *c = buf[bas];
  bas = (bas + 1) % N;
  return 0;
}
N = 5 yuva; en çok N − 1 = 4 bayt tutulur·0·1·2·3·4baskuy

Tampon boş: bas = kuy = 0. Kesme işleyicisi koy ile yazar, süreç al ile okur; her biri yalnızca kendi indisini değiştirir.

N = 5 yuva; en çok N − 1 = 4 bayt tutulur'a'0·1·2·3·4baskuy

koy('a'): buf[0] = 'a', kuy = 1.

N = 5 yuva; en çok N − 1 = 4 bayt tutulur'a'0'b'1·2·3·4baskuy

koy('b'): buf[1] = 'b', kuy = 2.

N = 5 yuva; en çok N − 1 = 4 bayt tutulur'a'0'b'1'c'2·3·4baskuy

koy('c'): buf[2] = 'c', kuy = 3.

N = 5 yuva; en çok N − 1 = 4 bayt tutulur·0'b'1'c'2·3·4baskuy

al: bas ≠ kuy, tampon boş değil. buf[0] = 'a' okunur, bas = 1. Yuva 0 yeniden kullanılabilir.

N = 5 yuva; en çok N − 1 = 4 bayt tutulur·0'b'1'c'2'd'3·4baskuy

koy('d'): buf[3] = 'd', kuy = 4.

N = 5 yuva; en çok N − 1 = 4 bayt tutulur·0'b'1'c'2'd'3'e'4baskuy

koy('e'): buf[4] = 'e', kuy = 0. kuy sona gelip başa sardı (mod 5).

N = 5 yuva; en çok N − 1 = 4 bayt tutulur·0'b'1'c'2'd'3'e'4baskuy(kuy + 1) mod 5 = 1 = bas → dolu

koy('f'): s = (0 + 1) mod 5 = 1 = bas. Bir yuva hep boş bırakılır; aksi hâlde bas == kuy hem boş hem dolu demek olurdu. Bayt reddedilir (−1).

N = 5 yuva; en çok N − 1 = 4 bayt tutulur·0·1'c'2'd'3'e'4baskuy

al: bas ≠ kuy, tampon boş değil. buf[1] = 'b' okunur, bas = 2. Yuva 1 yeniden kullanılabilir.

G/Ç Yazılımı

Önbellek, Biriktirme ve Hata Ele Alma

Önbellek ≠ tampon

Tampon verinin tek kopyasını geçici tutar; önbellek başka yerde duran verinin hızlı kopyasıdır. Linux sayfa önbelleği ikisini birleştirir; boş RAM önbelleğe gider (free -h: buff/cache).

Biriktirme (spooling)

Adanmış aygıt için kuyruk: kullanıcı dosyayı biriktirme dizinine koyar, tek bir arka plan süreci (CUPS, /var/spool/cups) sırayla yazdırır. Hiçbir süreç yazıcıyı kilitlemez.

Hata ele alma

Programlama hatası (geçersiz fd) → hata kodu (EBADF, EINVAL). Gerçek G/Ç hatası → sürücü yeniden dener; kalıcıysa EIO ve günlük kaydı (dmesg).

Ayırma ve koruma

Adanmış aygıt open ile ayrılır, meşgulse istek kuyruğa alınır ya da EBUSY döner. G/Ç komutları ayrıcalıklıdır; kullanıcı yalnız sistem çağrısıyla G/Ç yapar.

Kullanıcı alanındaki G/Ç yazılımı: printf/scanf gibi kütüphane yordamları biçimlendirme ve kullanıcı tamponlaması yapar (stdio satır/blok tamponu), sonra write/read sistem çağrılarını kullanır.

G/Ç Arayüzleri

Bloke Eden, Bloke Etmeyen ve Eş Zamansız G/Ç

Bloke edenread() veri gelene kadar dönmezçalışırbloke: G/Ç bekleniyorveriyle devamBloke etmeyenhemen döner; hazır olanı ya da EAGAINçalışırEAGAINbaşka işEAGAINbaşka işveridevamEş zamansızistek gönderilir, sonuç sonra bildirilirçalışıristekçalışmaya devam edertamamlandıdevamaygıt verisi hazır
ArayüzModelNot
select / pollhazır olma bildirimiher çağrıda tüm fd listesi taranır: O(n)
epoll (Linux), kqueue (BSD)hazır olma bildirimiilgi listesi çekirdekte; yalnız hazır olanlar döner
io_uring, Windows IOCPtamamlanma bildirimigerçek eş zamansız G/Ç; disk dahil

G/Ç Arayüzleri · Kodu adım adım çalıştır

Olay Döngüsü: epoll

int ep = epoll_create1(0);
for (k = 0; k < nsock; k++)   /* O_NONBLOCK */
    epoll_ctl(ep, EPOLL_CTL_ADD, s[k], &ev);
for (;;) {
  int n = epoll_wait(ep, evs, 64, -1);
  for (int i = 0; i < n; i++) {
    int fd = evs[i].data.fd;
    ssize_t r = read(fd, buf, sizeof buf);
    if (r < 0 && errno == EAGAIN) continue;
    handle(fd, buf, r);
  }
}
ilgi listesi (çekirdekte)hazır listesi(boş)

Bir epoll örneği oluşturulur: çekirdekte ilgi ve hazır listeleri tutan bir nesne.

ilgi listesi (çekirdekte)fd 5fd 6fd 7hazır listesi(boş)

Üç soket (5, 6, 7) bloke etmeyen modda ilgi listesine eklenir. Bu bir kez yapılır; select’teki gibi her turda tekrar verilmez.

ilgi listesi (çekirdekte)fd 5fd 6fd 7hazır listesi(boş)

epoll_wait hiçbir soket hazır değilken süreci bloke eder; CPU boşa dönmez.

ilgi listesi (çekirdekte)fd 5fd 6fd 7hazır listesifd 7

Soket 7’ye paket geldi: NIC kesmesi → ağ yığını → fd 7 hazır listesine eklenir, süreç uyanır. n = 1.

ilgi listesi (çekirdekte)fd 5fd 6fd 7hazır listesifd 7

Yalnız hazır olan fd işlenir: 512 bayt okunur. Maliyet hazır fd sayısıyla orantılıdır, toplamla değil.

ilgi listesi (çekirdekte)fd 5fd 6fd 7hazır listesi(boş)

Veri işlendi; bir sonraki read EAGAIN dönerse beklenecek veri kalmamıştır. Döngü yeniden epoll_wait’e gider.

Tek iş parçacığı on binlerce bağlantıyı yönetir (nginx, Node.js, Redis). epoll “okuyabilirsin” der, işi yine read yapar; disk dosyaları her zaman “hazır” görünür, bu yüzden disk için gerçek eş zamansızlık io_uring ile gelir.

G/Ç Arayüzleri · Adım adım

io_uring: Paylaşılan Halkalar

Uygulama (kullanıcı alanı)Çekirdek: dosya sistemi, blok katmanı, NVMeSQ (gönderim halkası)CQ (tamamlanma halkası)paylaşımlı bellek (mmap)

io_uring (Linux 5.1, 2019): uygulama ile çekirdek iki halkayı paylaşımlı bellekte görür; istek ve sonuç kopyalanmaz.

Uygulama (kullanıcı alanı)Çekirdek: dosya sistemi, blok katmanı, NVMeSQ (gönderim halkası)CQ (tamamlanma halkası)READREADWRITEpaylaşımlı bellek (mmap)SQE’ler yazılır, kuyruk ilerler

Uygulama üç gönderim kaydı (SQE) yazar: iki okuma, bir yazma. Her biri işlem kodu, fd, tampon, bağıl konum taşır.

Uygulama (kullanıcı alanı)Çekirdek: dosya sistemi, blok katmanı, NVMeSQ (gönderim halkası)CQ (tamamlanma halkası)paylaşımlı bellek (mmap)io_uring_enter (ya da SQPOLL çekirdek iş parçacığı)

Tek bir io_uring_enter çağrısı üç isteği birden gönderir. SQPOLL modunda çekirdek iş parçacığı halkayı yoklar: hiç sistem çağrısı gerekmez.

Uygulama (kullanıcı alanı)Çekirdek: dosya sistemi, blok katmanı, NVMeSQ (gönderim halkası)CQ (tamamlanma halkası)40964096512paylaşımlı bellek (mmap)CQE’ler eklenir

Aygıtlar tamamlandıkça çekirdek tamamlanma kayıtlarını (CQE) halkaya ekler; sonuç alanı aktarılan bayt ya da −errno’dur.

Uygulama (kullanıcı alanı)Çekirdek: dosya sistemi, blok katmanı, NVMeSQ (gönderim halkası)CQ (tamamlanma halkası)paylaşımlı bellek (mmap)sistem çağrısız okunur

Uygulama CQE’leri doğrudan bellekten okur ve başı ilerletir. Toplu gönderim + toplu toplama → çok az bağlam değiştirme.

Bu bir tamamlanma modelidir (Windows IOCP gibi): “işin bitti” bildirilir. Ağ, dosya, accept, zamanlayıcı dahil yüzlerce işlem türü vardır. Güvenlik açıkları yüzünden bazı ortamlarda (ör. Android, bazı konteynerler) kapalıdır.

Saatler ve Diğer Aygıtlar

Saat Donanımı

Kristal osilatör1,193182 MHzdarbeSayaçher darbede −10 oluncaKesmeIRQ 0 / vektörTutucu yazmaç = 1193yeniden yükle (kare dalga modu)CPUsaat işleyicisimodlar: tek atım (one-shot) · kare dalga (periyodik)
  • Örnek (8254 PIT): 1 kHz kesme için sayaç = 1.193.182 / 1000 ≈ 1193 → gerçek frekans 1000,15 Hz.
  • Modern x86: TSC (zaman damgası sayacı), HPET, yerel APIC zamanlayıcısı (TSC-deadline modu); ARM: genel zamanlayıcı. Pil destekli RTC kapalıyken tarihi tutar.
  • Saat yazılımı: günün saati, zaman dilimi (quantum) tükenmesi, CPU kullanım muhasebesi, alarm/zamanlayıcılar, izleme köpeği (watchdog), profil çıkarma.
  • Günün saati 64 bit sayaçla tutulmalı: 32 bit time_t 19 Ocak 2038’de taşar.

Saatler ve Diğer Aygıtlar · Adım adım

Saat Yazılımı: Tik ve Tiksiz Çekirdek

(a) periyodik tik: HZ = 250 → 4 ms0481216202428323640zaman (ms)işCPU boşta (derin C durumu isteniyor)zamanlayıcı olayıboşta da 6 gereksiz uyanma: her biri CPU’yu derin uykudan çıkarırhrtimer: ns çözünürlüklü zamanlayıcılar, kırmızı-siyah ağaçta sıralı

Periyodik tik: zamanlayıcı her 1/HZ saniyede kesme üretir (Linux’ta HZ = 100, 250 ya da 1000 → 10, 4, 1 ms). İşleyici süreyi artırır, quantum’u azaltır, süresi dolan zamanlayıcıları çalıştırır.

(b) tiksiz (NO_HZ): bir sonraki olay için tek atım0481216202428323640zaman (ms)işCPU boşta (derin C durumu isteniyor)zamanlayıcı olayıboşta tik yok: zamanlayıcı 30 ms’de bir kez programlanırhrtimer: ns çözünürlüklü zamanlayıcılar, kırmızı-siyah ağaçta sıralı

Tiksiz çekirdek (NO_HZ_IDLE, 2007): CPU boşken tik durdurulur, saat bir sonraki olaya tek atım kurulur. nohz_full tek süreçli çekirdekte çalışırken bile tiki kaldırır (HPC, gerçek zamanlı).

(c) zamanlayıcı listesi: şimdiki zaman 4200Şimdi4200Sonraki sinyal3 tik sonra+3t = 4203+4t = 4207+6t = 4213+2t = 4215+1t = 4216fark (delta) listesi: her tikte yalnız baştaki sayaç azaltılır

Tanenbaum’un örneği: bekleyen sinyaller 4203, 4207, 4213, 4215, 4216’da. Liste yalnız farkları tutar; baştaki 0’a inince olay tetiklenir.

Tiksiz çalışma dizüstü ve sanal makinelerde enerji ile işlemci zamanı kazandırır. Kısa süreli (µs) bekleme için ise yumuşak zamanlayıcılar ve yoklama birlikte kullanılır.

Saatler ve Diğer Aygıtlar · Kodu adım adım çalıştır

Zamanlayıcı Listesi: Kod İzleme

void ekle(Zam *z, int t) {  /* t: tik */
  Zam **p = &bas;
  while (*p && (*p)->fark <= t) {
    t -= (*p)->fark;
    p = &(*p)->sonraki;
  }
  z->fark = t; z->sonraki = *p;
  if (*p) (*p)->fark -= t;
  *p = z;
}
void tik(void) {
  if (bas) bas->fark--;
  while (bas && bas->fark == 0)
    bas = calistir(bas);   /* çıkar */
}
şimdi = 4200kutuda: fark (önceki olaydan sonra)A34203B44207C64213D24215E14216*palt satır: olayın mutlak zamanı

Bekleyen olaylar 4203, 4207, 4213, 4215, 4216’da; liste yalnız farkları tutar: 3, 4, 6, 2, 1. Yeni zamanlayıcı X 10 tik sonra (4210): ekle(X, 10).

şimdi = 4200kutuda: fark (önceki olaydan sonra)A34203B44207C64213D24215E14216*palt satır: olayın mutlak zamanı

A’nın farkı 3 ≤ t: X ondan sonra gelir. t = 7, *p sonraki düğüme geçer.

şimdi = 4200kutuda: fark (önceki olaydan sonra)A34203B44207C64213D24215E14216*palt satır: olayın mutlak zamanı

B’nin farkı 4 ≤ t: X ondan sonra gelir. t = 3, *p sonraki düğüme geçer.

şimdi = 4200kutuda: fark (önceki olaydan sonra)A34203B44207C64213D24215E14216*palt satır: olayın mutlak zamanı

C’nin farkı 6 > t = 3: X, C’den önce girmeli. Döngü biter.

şimdi = 4200kutuda: fark (önceki olaydan sonra)A34203B44207X34210C34213D24215E14216*palt satır: olayın mutlak zamanı

X.fark = 3 olarak araya girer; C’nin farkı 6 − 3 = 3 olur. C’nin mutlak zamanı (4213) değişmedi; yalnız bir düğüm güncellendi.

şimdi = 4201kutuda: fark (önceki olaydan sonra)A24203B44207X34210C34213D24215E14216alt satır: olayın mutlak zamanı

Tik: yalnız baştaki fark azalır → 2.

şimdi = 4202kutuda: fark (önceki olaydan sonra)A14203B44207X34210C34213D24215E14216alt satır: olayın mutlak zamanı

Tik: yalnız baştaki fark azalır → 1.

şimdi = 4203kutuda: fark (önceki olaydan sonra)B44207X34210C34213D24215E14216alt satır: olayın mutlak zamanı

4203: baştaki fark 0 oldu; A çalıştırılıp listeden çıkarılır. Tik başına iş yalnız baştaki sayacı azaltmaktır: liste ne kadar uzun olursa olsun O(1).

Saatler ve Diğer Aygıtlar

Terminaller, Giriş Aygıtları ve Güç Yönetimi

Terminaller ve GUI girişi
  • tty + satır disiplini: kanonik modda satır düzenlenir (geri silme, Enter’da teslim); ham modda her tuş hemen gelir (stty -icanon, editörler).
  • Sözde terminal (pty): terminal öykünücüsü, ssh; ekran denetimi ANSI kaçış dizileriyle.
  • Klavye tarama kodu gönderir (basma/bırakma); sürücü tuş eşlemesiyle karaktere çevirir. USB HID aygıtları ana makine tarafından 125–1000 Hz yoklanır.
  • Linux: input alt sistemi → /dev/input/event* (evdev) → libinput → Wayland birleştiricisi → pencere.
Güç yönetimi
  • ACPI sistem durumları: S0 çalışır (S0ix modern bekleme), S3 RAM’e askı, S4 hazırda bekleme (diske), S5 kapalı.
  • CPU: C durumları (boşta uyku derinliği), P durumları (frekans/gerilim; Linux schedutil).
  • Aygıtlar: D0–D3 durumları, çalışma zamanı güç yönetimi; NVMe APST, PCIe ASPM, Wi-Fi güç tasarrufu, ekranın kararması.
  • İşletim sistemi aygıtları doğru sırayla uyutur/uyandırır ve uyandırma kaynaklarını (klavye, ağ, saat) belirler. Pil ömrünün büyük kısmı boşta geçen süreye bağlıdır.

Diskler

Manyetik Disk Geometrisi

üstten görünümsektörizyandan görünümsilindirkolmilkafabölgeli kayıt (ZBR)32 sektör/iz24 sektör/iz16 sektör/izsanal geometri: düz LBA 0 … N−1
  • Plakalar 5400–7200 rpm (sunucu: 10–15 bin) döner; her yüzeye bir kafa. Aynı yarıçaptaki izler silindiri oluşturur. Dış bölgelerde iz başına daha çok sektör vardır.
  • İşletim sistemi CHS (silindir, kafa, sektör) yerine LBA görür; disk içindeki denetleyici bunu gerçek geometriye, yedek sektörlere ve önbelleğe kendisi çevirir. Eski CHS sınırı: 1024 × 255 × 63 × 512 B ≈ 8,4 GB.

Diskler · Adım adım hesap

Erişim Süresi: Örnek

Erişim süresi = arama (seek) + dönme gecikmesi + aktarım. Disk: 7200 rpm, ortalama arama 8 ms, ortam hızı 200 MB/s; blok 4 KiB.

Aktarım süresi de dahil üç bileşen birlikte sayılmalıdır.

Bir tur = 60.000 / 7200 = 8,33 ms; ortalama dönme gecikmesi = yarım tur = 4,17 ms.

İstenen sektör ortalamada yarım tur uzaktadır.

Aktarım = 4096 B ÷ 200 MB/s = 0,020 ms. Toplam = 8 + 4,17 + 0,02 = 12,19 ms.

Mekanik gecikme baskın: süre neredeyse tamamen arama ve dönmede geçer. CPU bu sürede milyonlarca komut çalıştırabilir; İS beklemez, başka süreç çalıştırır.

Rastgele 4 KiB: 1000 / 12,19 ≈ 82 IOPS → 82 × 4 KiB ≈ 0,34 MB/s. Ardışık 1 MiB: 8 + 4,17 + 5,24 = 17,41 ms → 60 MB/s.

Aynı disk, erişim düzenine göre 180 kat farklı hız verir: yerellik ve çizelgeleme bu yüzden önemli.

arama 8 msdönme 4,17 msaktarım 0,02 ms ← (%0,2)toplam 12,19 ms

Karşılaştırma: NVMe SSD’de 4 KiB rastgele okuma ≈ 50–100 µs ve paralel kuyruklarla 1 milyonun üzerinde IOPS.

Diskler

Disk Biçimlendirme ve Silindir Eğriliği

sektör biçimi (düşük düzey format)öncülveri 512 B / 4 KiBECCeğrilik (skew): izler arası geçişte sektör 0 kaçırılmasıniz 00123456789101112131415iz 11314150123456789101112iz 21011121314150123456789
  • Düşük düzey format fabrikada yapılır: izler, sektörler, öncül, ECC ve yedek sektörler. Biçimlendirilmiş kapasite ham kapasiteden azdır. Üst düzey format ise bir bölüme boş dosya sistemi yazar (önyükleme bloğu, boş alan yönetimi, kök dizin).
  • Eğrilik hesabı (Tanenbaum): 10.000 rpm → tur 6 ms; 300 sektör/iz → sektör başına 20 µs. İz değiştirme 800 µs ise eğrilik = 800 / 20 = 40 sektör.
  • Serpiştirme (interleaving) yavaş denetleyiciler için ardışık sektörleri aralıklı dizerdi; bugün denetleyici tüm izi tampona okuduğundan gereksizdir.
  • Bugünkü diskler: 4 KiB fiziksel sektör (Advanced Format); 512e diskler 512 B öykünür, hizasız yazma okuma-değiştir-yaz gerektirir.

Diskler

Optik Diskler (Kısaca)

CD (1982)DVD (1996)Blu-ray (2006)
Kapasite650–700 MB4,7 / 8,5 / 9,4 / 17 GB25 / 50 GB; BDXL 100–128 GB
Lazer780 nm (kızılötesi)650 nm (kırmızı)405 nm (mavi-mor)
En küçük çukur0,83 µm0,40 µm0,15 µm
İz aralığı1,6 µm0,74 µm0,32 µm
  • Tek bir sarmal iz; çukur ile düzlük arasındaki geçiş 1 bitidir. Basılı disklerde çukurlar kalıpla polikarbonata basılır; lazerle yakılmaz. CD-R/DVD-R’de lazer organik boya katmanını ısıtıp yansıtıcılığı değiştirir.
  • CD-ROM’da her bayt EFM ile 14 bitlik kanal sembolüne çevrilir (bu bir modülasyon kodudur, ECC değildir); hata düzeltme CIRC ile yapılır. 98 çerçeve × 24 veri baytı = 2352 B; mod 1’de bunun 2048 B’ı kullanıcı verisi, kalanı senkron, başlık ve ek ECC/EDC’dir.
  • DVD’nin iki katmanı yarı saydamdır; lazer odağını değiştirerek alttakini okur. Optik ortam bugün çoğunlukla arşiv ve dağıtım içindir; yoğunlukta manyetik ve flash ortamın gerisindedir.
optik: tek sarmal izmanyetik: eş merkezli

Disk Çizelgeleme

Disk Kolu Çizelgeleme

  • Amaç kol hareketini (arama süresi) azaltıp verimi artırmak; sürücü (silindir, istek zamanı) listesini tutar. Ölçüt: toplam kafa hareketi (silindir).
  • Bugün LBA → fiziksel eşleme diskin içindedir; diskin kendisi NCQ ile 32 isteği dönme konumuna göre yeniden sıralar. İşletim sistemi yaklaşık olarak “LBA yakınlığı” ile çizelgeler.
arama: kol silindir değiştirirdönmekırmızı: kafanın silindiri
AlgoritmaFikirSorun
FCFSGeliş sırasıAdil ama kol çok gezer
SSTFKafaya en yakın istek (açgözlü)Uçtaki istekler açlık çekebilir
SCAN (asansör)Bir yönde uca kadar git, dönUçlar ve orta eşit beklemez
C-SCANTek yönde tara, uçtan başa sıçraDönüş hareketi boşa
LOOK / C-LOOKSCAN/C-SCAN, ama son isteğe kadarPratikte kullanılan biçimler

Örnekler Silberschatz’ın kuyruğunu kullanır: kafa 53, istekler 98, 183, 37, 122, 14, 124, 65, 67. Silindirler 0–199.

Disk Çizelgeleme · Adım adım

FCFS

İlk gelen ilk hizmet alır: istekler geliş sırasıyla.

0143753656798122124183199toplam: 0 silindirhizmet verildibekliyor

Kafa 53’te. Kuyruk: 98, 183, 37, 122, 14, 124, 65, 67 (silindir 0–199). Kırmızı: bekleyen, yeşil: hizmet verilmiş.

0143753656798122124183199toplam: 45 silindirhizmet verildibekliyor

53 → 98: 45 silindir · toplam 45

0143753656798122124183199toplam: 130 silindirhizmet verildibekliyor

98 → 183: 85 silindir · toplam 130

0143753656798122124183199toplam: 276 silindirhizmet verildibekliyor

183 → 37: 146 silindir · toplam 276

0143753656798122124183199toplam: 361 silindirhizmet verildibekliyor

37 → 122: 85 silindir · toplam 361

0143753656798122124183199toplam: 469 silindirhizmet verildibekliyor

122 → 14: 108 silindir · toplam 469

0143753656798122124183199toplam: 579 silindirhizmet verildibekliyor

14 → 124: 110 silindir · toplam 579

0143753656798122124183199toplam: 638 silindirhizmet verildibekliyor

124 → 65: 59 silindir · toplam 638

0143753656798122124183199toplam: 640 silindirhizmet verildibekliyor

65 → 67: 2 silindir · toplam 640

Toplam 640 silindir. Adil ve açlıksız, ama 122 → 14 → 124 gibi gidip gelmeler çok pahalı.

Disk Çizelgeleme · Adım adım

SSTF

En kısa arama süresi önce: her adımda kafaya en yakın istek.

0143753656798122124183199toplam: 0 silindirhizmet verildibekliyor

Kafa 53’te. Kuyruk: 98, 183, 37, 122, 14, 124, 65, 67 (silindir 0–199). Kırmızı: bekleyen, yeşil: hizmet verilmiş.

0143753656798122124183199toplam: 12 silindirhizmet verildibekliyor

53 → 65: 12 silindir · toplam 12

0143753656798122124183199toplam: 14 silindirhizmet verildibekliyor

65 → 67: 2 silindir · toplam 14

0143753656798122124183199toplam: 44 silindirhizmet verildibekliyor

67 → 37: 30 silindir · toplam 44

0143753656798122124183199toplam: 67 silindirhizmet verildibekliyor

37 → 14: 23 silindir · toplam 67

0143753656798122124183199toplam: 151 silindirhizmet verildibekliyor

14 → 98: 84 silindir · toplam 151

0143753656798122124183199toplam: 175 silindirhizmet verildibekliyor

98 → 122: 24 silindir · toplam 175

0143753656798122124183199toplam: 177 silindirhizmet verildibekliyor

122 → 124: 2 silindir · toplam 177

0143753656798122124183199toplam: 236 silindirhizmet verildibekliyor

124 → 183: 59 silindir · toplam 236

Toplam 236 (FCFS’nin %37’si). Açgözlüdür ve en iyi sonucu garanti etmez: 53 → 37 → 14 → 65 … daha kısa (208). Yoğun yükte merkezdeki istekler uçtakileri aç bırakabilir.

Disk Çizelgeleme · Kodu adım adım çalıştır

SSTF: Kod İzleme

int sstf(int bas, int q[], int n) {
  int top = 0;
  for (int k = 0; k < n; k++) {
    int en = -1;
    for (int i = 0; i < n; i++)
      if (!bitti[i] && (en < 0 ||
        abs(q[i]-bas) < abs(q[en]-bas)))
        en = i;            /* en yakın */
    top += abs(q[en] - bas);
    bas = q[en];
    bitti[en] = 1;
  }
  return top;
}
05010015019950toplam = 0 silindir

Kafa silindir 50’de; kuyruk (geliş sırası): 82, 170, 43, 140, 24, 16, 190. Her turda iç döngü bekleyen isteklerin hepsine bakar.

0501001501995043toplam = 7 silindir

k = 0: kafa 50, en yakın bekleyen 43 (uzaklık 7; sonraki aday 24, uzaklık 26). top = 7.

050100150199504324toplam = 26 silindir

k = 1: kafa 43, en yakın bekleyen 24 (uzaklık 19; sonraki aday 16, uzaklık 27). top = 26.

05010015019950432416toplam = 34 silindir

k = 2: kafa 24, en yakın bekleyen 16 (uzaklık 8; sonraki aday 82, uzaklık 58). top = 34.

0501001501995043241682toplam = 100 silindir

k = 3: kafa 16, en yakın bekleyen 82 (uzaklık 66; sonraki aday 140, uzaklık 124). top = 100. Aşağıdaki istekler bitti, kol uzun bir yolu geri döner.

0501001501995043241682140toplam = 158 silindir

k = 4: kafa 82, en yakın bekleyen 140 (uzaklık 58; sonraki aday 170, uzaklık 88). top = 158.

0501001501995043241682140170toplam = 188 silindir

k = 5: kafa 140, en yakın bekleyen 170 (uzaklık 30; sonraki aday 190, uzaklık 50). top = 188.

0501001501995043241682140170190toplam = 208 silindir

k = 6: kafa 170, en yakın bekleyen 190 (uzaklık 20). top = 208.

0501001501995043241682140170190toplam = 208 silindir

Toplam 208 silindir (FCFS bu kuyrukta 642). Açgözlü seçim her adımda en kısa hareketi alır; ortadaki istekler sürekli gelirse uçtakiler bekleyebilir.

Disk Çizelgeleme · Adım adım

SCAN (Asansör)

SCAN: kafa bir yönde (burada 0’a doğru) uca kadar gider, sonra döner; asansör gibi.

0143753656798122124183199toplam: 0 silindirhizmet verildibekliyor

Kafa 53’te. Kuyruk: 98, 183, 37, 122, 14, 124, 65, 67 (silindir 0–199). Kırmızı: bekleyen, yeşil: hizmet verilmiş.

0143753656798122124183199toplam: 16 silindirhizmet verildibekliyor

53 → 37: 16 silindir · toplam 16

0143753656798122124183199toplam: 39 silindirhizmet verildibekliyor

37 → 14: 23 silindir · toplam 39

0143753656798122124183199toplam: 53 silindirhizmet verildibekliyor

14 → 0: 14 silindir · toplam 53 (istek yok, diskin ucuna kadar gidilir)

0143753656798122124183199toplam: 118 silindirhizmet verildibekliyor

0 → 65: 65 silindir · toplam 118

0143753656798122124183199toplam: 120 silindirhizmet verildibekliyor

65 → 67: 2 silindir · toplam 120

0143753656798122124183199toplam: 151 silindirhizmet verildibekliyor

67 → 98: 31 silindir · toplam 151

0143753656798122124183199toplam: 175 silindirhizmet verildibekliyor

98 → 122: 24 silindir · toplam 175

0143753656798122124183199toplam: 177 silindirhizmet verildibekliyor

122 → 124: 2 silindir · toplam 177

0143753656798122124183199toplam: 236 silindirhizmet verildibekliyor

124 → 183: 59 silindir · toplam 236

Toplam 236. “Açgözlü, kafa bir bölgede sıkışabilir” özelliği SSTF’ye aittir; SCAN açlığı önler. Uca kadar gidip dönmek (14 → 0 → 14) boşa harcanan 28 silindir demektir.

Disk Çizelgeleme · Adım adım

C-SCAN

Dairesel SCAN: yalnız yukarı yönde hizmet; uca varınca hizmet vermeden başa döner.

0143753656798122124183199toplam: 0 silindirhizmet verildibekliyor

Kafa 53’te. Kuyruk: 98, 183, 37, 122, 14, 124, 65, 67 (silindir 0–199). Kırmızı: bekleyen, yeşil: hizmet verilmiş.

0143753656798122124183199toplam: 12 silindirhizmet verildibekliyor

53 → 65: 12 silindir · toplam 12

0143753656798122124183199toplam: 14 silindirhizmet verildibekliyor

65 → 67: 2 silindir · toplam 14

0143753656798122124183199toplam: 45 silindirhizmet verildibekliyor

67 → 98: 31 silindir · toplam 45

0143753656798122124183199toplam: 69 silindirhizmet verildibekliyor

98 → 122: 24 silindir · toplam 69

0143753656798122124183199toplam: 71 silindirhizmet verildibekliyor

122 → 124: 2 silindir · toplam 71

0143753656798122124183199toplam: 130 silindirhizmet verildibekliyor

124 → 183: 59 silindir · toplam 130

0143753656798122124183199toplam: 146 silindirhizmet verildibekliyor

183 → 199: 16 silindir · toplam 146 (istek yok, diskin ucuna kadar gidilir)

0143753656798122124183199toplam: 345 silindirhizmet verildibekliyor

199 → 0: geri dönüş (sıçrama, 199 silindir), istek hizmeti yok. Burada sayılıyor · toplam 345

0143753656798122124183199toplam: 359 silindirhizmet verildibekliyor

0 → 14: 14 silindir · toplam 359

0143753656798122124183199toplam: 382 silindirhizmet verildibekliyor

14 → 37: 23 silindir · toplam 382

Toplam 382 (dönüş sayılmazsa 183). Disk bir halka gibi görülür; bekleme süreleri SCAN’e göre daha eşittir.

Disk Çizelgeleme · Adım adım

LOOK ve C-LOOK

0143753656798122124183199toplam: 0 silindirhizmet verildibekliyor

LOOK (aşağı yönde): SCAN gibi, ama uca kadar gitmez; o yöndeki son istekte döner.

0143753656798122124183199toplam: 39 silindirhizmet verildibekliyor

53 → 37 → 14: aşağıdaki istekler bitti, 0’a gidilmez. Toplam 39.

0143753656798122124183199toplam: 208 silindirhizmet verildibekliyor

14 → 65 … 183: yön değişir. Toplam 208 (SCAN’e göre 28 az). Uygulamada “asansör” denen davranış çoğunlukla bu LOOK’tur.

0143753656798122124183199toplam: 130 silindirhizmet verildibekliyor

C-LOOK (yukarı yönde): 53 → 65 … 183 yukarıdaki son istek. Toplam 130.

0143753656798122124183199toplam: 299 silindirhizmet verildibekliyor

183 → 14: en küçük bekleyen isteğe sıçrar (169 silindir), 199 ve 0’a gidilmez.

0143753656798122124183199toplam: 322 silindirhizmet verildibekliyor

14 → 37: toplam 322 (sıçrama sayılmazsa 153). Tek yönlü tarama bekleme sürelerini eşitler.

Linux’un eski deadline ve CFQ çizelgeleyicileri ile günümüzdeki mq-deadline LBA’ya göre sıralı gönderir; bu C-LOOK’a benzer bir davranıştır.

Disk Çizelgeleme · Kodu adım adım çalıştır

LOOK: Kod İzleme

/* s[] sıralı; önce yukarı, sonra aşağı */
int look(int bas, int s[], int n) {
  int i = 0, top = 0;
  while (i < n && s[i] < bas) i++;
  for (int j = i; j < n; j++) {
    top += s[j] - bas; bas = s[j];
  }
  for (int j = i - 1; j >= 0; j--) {
    top += bas - s[j]; bas = s[j];
  }
  return top;
}
05010015019950toplam = 0 silindir

Aynı kuyruk sıralanmış: s = 16, 24, 43, 82, 140, 170, 190. Kafa 50’de ve yukarı yönde hareket ediyor.

05010015019950toplam = 0 silindir

i, 50’den büyük ilk isteğin indisi: s[3] = 82. Altındaki 16, 24, 43 dönüşte alınacak.

0501001501995082toplam = 32 silindir

j = 3: 82 (+32), top = 32.

0501001501995082140toplam = 90 silindir

j = 4: 140 (+58), top = 90.

0501001501995082140170toplam = 120 silindir

j = 5: 170 (+30), top = 120.

0501001501995082140170190toplam = 140 silindir

j = 6: 190 (+20), top = 140. Yukarıdaki son istek: kol 199’a gitmeden döner (SCAN’den farkı).

050100150199508214017019043toplam = 287 silindir

Yön değişti, j = 2: 190 → 43 (+147), top = 287. Dönüşte en uzun hareket.

05010015019950821401701904324toplam = 306 silindir

j = 1: 24 (+19), top = 306.

0501001501995082140170190432416toplam = 314 silindir

j = 0: 16 (+8), top = 314.

0501001501995082140170190432416toplam = 314 silindir

Toplam 314: aynı kuyrukta SSTF 208. Kafa aşağı yönde olsaydı LOOK da 34 + 174 = 208 yapardı; yön seçimi sonucu belirler ama hiçbir istek aç kalmaz.

Disk Çizelgeleme

Algoritmaların Karşılaştırması

FCFS640SSTF236SCAN236C-SCAN382 (sıçramasız 183)LOOK208C-LOOK322 (sıçramasız 153)
Tanenbaum örneği: kafa 11; 1, 36, 16, 34, 9, 12Hareket
FCFS: 10 + 35 + 20 + 18 + 25 + 3111
SSTF: 12, 9, 16, 1, 34, 36 → 1 + 3 + 7 + 15 + 33 + 261
Asansör (yukarı): 12, 16, 34, 36, 9, 1 → 1 + 4 + 18 + 2 + 27 + 860
Etkileşimli simülatör: Disk Kolu Çizelgeleme Simülatörü: farklı istek kuyrukları ve başlangıç yönleriyle altı algoritmanın karşılaştırması.

Grafikteki kuyrukta SCAN yukarı yönde başlasaydı 331 olurdu: yön seçimi sonucu değiştirir. Tanenbaum’un asansörü uca gitmediği için aslında LOOK’tur.

Disk Çizelgeleme · Adım adım

SPTF: Dönme Gecikmesini de Saymak

dönüşkafa: iz 10A (iz 11)B (iz 30)7200 rpm: 1 tur = 8,33 ms, 1 ms’de disk 43,2° dönerA: arama 1 ms, sektör kafaya 30° sonra gelirB: arama 3 ms, sektör kafaya 150° sonra gelir0246810ms

Kafa iz 10’da, iki istek bekliyor. Yalnız iz farkına bakan SSTF için A açık ara yakın: 1 iz ötede. Ama süreyi arama değil arama + dönme belirler.

dönüşkafa: iz 10A (iz 11)B (iz 30)7200 rpm: 1 tur = 8,33 ms, 1 ms’de disk 43,2° dönerA: arama 1 ms, sektör kafaya 30° sonra gelirB: arama 3 ms, sektör kafaya 150° sonra gelir0246810msSSTF → A9,03 msaramadönme bekleme

SSTF A’yı seçer: 1 ms aramada disk 43,2° döner, kafaya 30° kalan sektör arama bitince kafayı 13,2° geçmiş olur. Neredeyse bir tur beklenir: 1 + 8,03 = 9,03 ms.

dönüşkafa: iz 10A (iz 11)B (iz 30)7200 rpm: 1 tur = 8,33 ms, 1 ms’de disk 43,2° dönerA: arama 1 ms, sektör kafaya 30° sonra gelirB: arama 3 ms, sektör kafaya 150° sonra gelir0246810msSSTF → A9,03 msSPTF → B3,47 msaramadönme bekleme

SPTF B’yi seçer: 3 ms aramada disk 129,6° döner, B’ye 20,4° kalır: 3 + 0,47 = 3,47 ms. Uzak iz, yakın izden 2,6 kat çabuk sonuç verdi.

SPTF (shortest positioning time first) konumlandırma süresini en aza indirir, ama İS sektörlerin açısını bilmez; bu yüzden diskin içinde NCQ ile uygulanır. Açlığa karşı F-SCAN: tarama başlarken kuyruk dondurulur, yeni istekler bir sonraki taramayı bekler.

Disk Çizelgeleme · Adım adım

Denetleyici Önbelleği ve Bozuk Sektörler

Denetleyici önbelleği

Disk kendi DRAM’inde (≈ 256 MB) iz önbelleği tutar: kafanın altından geçen, istenmemiş blokları da okur. İşletim sistemi önbelleğinden ayrıdır.

Yazma önbelleği ve NCQ

Yazma önbellekte bekleyebilir: kalıcılık için FLUSH/FUA gerekir. NCQ 32 isteği dönme konumuna göre sıralar.

(a) iz: sektör 7 bozuk, iki yedek01234567 ✗89101112131415Y1Y2

Üretimde ya da kullanımda bozulan sektör: yazılan veri geri okunamaz. Denetleyici fabrika listesini ve kullanımda bulduklarını izler (SMART: Reallocated Sectors).

(b) bozuk sektör yedekle eşlenir01234567 ✗891011121314157Y2denetleyici yönlendirir

Yöntem 1: bozuk sektör bir yedekle eşlenir. Basit ama sektör 7’ye giden ardışık okuma ize bir tur daha ödeyebilir.

(c) sektörler kaydırılır, bozuk atlanır0123456✗789101112131415Y28 … 15 numaralı sektörler bir kaydı, bir yedek kullanıldı; sıralı okuma bozulmaz

Yöntem 2: sektörler kaydırılır; tüm iz yeniden yazılmalıdır ama sıra korunur. İşletim sistemi de bozuk blok listesi tutabilir (badblocks, dosya sistemi).

SSD ve NVMe

SSD: NAND Flash

SSD denetleyicisiFTLECC (LDPC)DRAM önbelleğikalıpkalıpkalıpkalıpkalıpkalıpkalıpkalıpkalıpkalıpkalıpkalıp4–8 kanal × kalıp: paralellikblok (≈ 10–40 MiB) = silme birimisayfa (≈ 16 KiB) = okuma/yazma birimi
HücreBit/hücreTipik P/E döngüsüKullanım
SLC1≈ 50–100 binönbellek bölgesi, endüstriyel
MLC2≈ 3–10 bineski kurumsal
TLC3≈ 1–3 binçoğu tüketici ve sunucu SSD’si
QLC4≈ 0,1–1 binyüksek kapasite, okuma ağırlıklı
  • Hareketli parça yok: arama ve dönme gecikmesi yok, rastgele erişim ≈ ardışık erişim.
  • Yerinde güncelleme yok: sil, sonra yaz; her hücrenin silme ömrü sınırlıdır. 3D NAND 200–300+ katman.
  • Fiyat/GB farkı azaldı; HDD yine de arşivde ve kapasitede ucuzdur.

SSD ve NVMe · Adım adım

FTL, Çöp Toplama, TRIM, Aşınma Dengeleme

eşleme tablosu (FTL)LBA 0B0.s0LBA 1B0.s1LBA 2B0.s2LBA 3—blok B0 (silme: 0)s0geçerli: LBA 0s1geçerli: LBA 1s2geçerli: LBA 2s3boşblok B1 (silme: 0)s0boşs1boşs2boşs3boşLBA 0, 1, 2 yazıldıyalnız silinmiş (boş) sayfaya yazılabilir; silme blok düzeyinde

Üç mantıksal blok yazılır; FTL onları B0’ın boş sayfalarına koyar ve tabloya kaydeder.

eşleme tablosu (FTL)LBA 0B0.s0LBA 1B0.s3LBA 2B0.s2LBA 3—blok B0 (silme: 0)s0geçerli: LBA 0s1geçersiz (eski LBA 1)s2geçerli: LBA 2s3geçerli: LBA 1blok B1 (silme: 0)s0boşs1boşs2boşs3boşLBA 1 güncellendi: yerinde değilyalnız silinmiş (boş) sayfaya yazılabilir; silme blok düzeyinde

LBA 1 yeniden yazılır: eski sayfanın üzerine yazılamaz. Yeni veri boş sayfaya gider, eskisi geçersiz olur (yer dışı güncelleme).

eşleme tablosu (FTL)LBA 0B0.s0LBA 1B0.s3LBA 2—LBA 3—blok B0 (silme: 0)s0geçerli: LBA 0s1geçersiz (eski LBA 1)s2geçersiz (eski LBA 2)s3geçerli: LBA 1blok B1 (silme: 0)s0boşs1boşs2boşs3boşTRIM: LBA 2 artık kullanılmıyoryalnız silinmiş (boş) sayfaya yazılabilir; silme blok düzeyinde

Dosya silinince dosya sistemi TRIM (NVMe: Deallocate) gönderir; SSD sayfanın gereksiz olduğunu öğrenir. TRIM olmasa bu veri çöp toplamada boşuna kopyalanırdı.

eşleme tablosu (FTL)LBA 0B0.s0LBA 1B0.s3LBA 2—LBA 3B1.s0blok B0 (silme: 0)s0geçerli: LBA 0s1geçersiz (eski LBA 1)s2geçersiz (eski LBA 2)s3geçerli: LBA 1blok B1 (silme: 0)s0geçerli: LBA 3s1boşs2boşs3boşB0 doldu, LBA 3 B1’eyalnız silinmiş (boş) sayfaya yazılabilir; silme blok düzeyinde

B0’da boş sayfa kalmadı; yeni yazmalar B1’e gider. B0’da yarısı geçersiz.

eşleme tablosu (FTL)LBA 0B1.s1LBA 1B1.s2LBA 2—LBA 3B1.s0blok B0 (silme: 1)s0boşs1boşs2boşs3boşblok B1 (silme: 0)s0geçerli: LBA 3s1geçerli: LBA 0s2geçerli: LBA 1s3boşçöp toplama: 2 geçerli sayfa taşındı, B0 silindiyalnız silinmiş (boş) sayfaya yazılabilir; silme blok düzeyinde

Çöp toplama: B0’daki geçerli sayfalar (LBA 0, 1) B1’e kopyalanır, B0 silinir. Ek 2 sayfa yazması = yazma büyütmesi.

eşleme tablosu (FTL)LBA 0B1.s1LBA 1B1.s2LBA 2—LBA 3B1.s0blok B0 (silme: 1)s0boşs1boşs2boşs3boşblok B1 (silme: 0)s0geçerli: LBA 3s1geçerli: LBA 0s2geçerli: LBA 1s3boşaşınma dengeleme: az silinen bloklar da kullanılıryalnız silinmiş (boş) sayfaya yazılabilir; silme blok düzeyinde

Aşınma dengeleme: FTL silme sayılarını dengeler; uzun süre değişmeyen (soğuk) veriyi de taşıyarak tüm blokları eşit yaşlandırır. Yedek alan (over-provisioning) çöp toplamayı kolaylaştırır.

Windows “İyileştir” komutu SSD’de birleştirme yapmaz, TRIM gönderir; SSD’yi birleştirmek yalnızca yazma ve aşınma ekler. Bölümleri 1 MiB sınırına hizalamak, mantıksal blokların flaş sayfalarına bölünmeden oturmasını sağlar.

SSD ve NVMe

NVMe ve Çoklu Kuyruk

Çekirdek 0SQCQÇekirdek 1SQCQÇekirdek 2SQCQÇekirdek 3SQCQNVMe denetleyicisi (PCIe x4)AHCI (SATA)tek kuyruk · 32 komut · kilitNVMe65.535 kuyruk × 65.536 komutçekirdek başına kuyruk: kilitsiz gönderim
  • NVMe, PCIe üzerindeki flash için tasarlanmış protokoldür; M.2 ise bir form faktörüdür (M.2 kart SATA da olabilir). U.2/U.3 ve E1.S/E3.S kablolu/yuvalı sunucu biçimleridir.
  • Kuyruk kapasitesi: 64 K kuyruk × kuyruk başına 64 K komut. Sürücü desteği 2013’ten beri tüm işletim sistemlerinde yerleşiktir; AHCI ile uyumsuzluk yalnız protokol düzeyindedir.
  • Gecikme ≈ 10–100 µs; PCIe 5.0 x4 sürücüler ≈ 14 GB/s ve > 2 milyon IOPS. NVMe-oF ile ağ üzerinden, ZNS ile bölgeli ad alanları.

SSD ve NVMe

Linux blk-mq ve G/Ç Çizelgeleyicileri

CPU 0yazılım k.CPU 1yazılım k.CPU 2yazılım k.CPU 3yazılım k.çizelgeleyici (isteğe bağlı)dk 0dk 1dk 2dk 3donanım gönderim kuyruklarıNVMe
ÇizelgeleyiciFikirUygun
noneSıralama yok, doğrudan gönderNVMe (varsayılan), hızlı SSD
mq-deadlineLBA’ya göre sıralı + okuma/yazma son tarihiSATA HDD/SSD (çoğu dağıtımda varsayılan)
bfqSüreç başına bütçe, adil paylaşımMasaüstü, yavaş aygıtlarda etkileşim
kyberOkuma/yazma gecikme hedefleriyle sınırlamaHızlı çok kuyruklu aygıtlar
$ cat /sys/block/nvme0n1/queue/scheduler
[none] mq-deadline kyber bfq
$ echo bfq | sudo tee /sys/block/sda/queue/scheduler

CPU başına yazılım kuyrukları, milyonlarca IOPS’de tek kuyruk kilidinin çekişmesini önler; Linux 5.0’da tek kuyruklu eski blok katmanı (noop, deadline, CFQ) kaldırıldı. SSD’de arama olmadığından çizelgeleyicinin işi sıralamak değil, adaleti ve gecikmeyi korumaktır.

RAID ve Kararlı Depolama

RAID: Diskleri Birleştirmek

  • RAID (Patterson, Gibson, Katz, 1988): birçok diski işletim sistemine tek disk gibi gösterir; şeritleme paralellik, aynalama ve eşlik artıklık sağlar. Karşıtı SLED: tek, büyük, pahalı disk.
  • Açılımı bugün Redundant Array of Independent Disks. SCSI diskler pahalıydı; bugün SAS genişleticiler yüzlerce disk bağlar, standart düzeyler 0–6’dır.
  • Donanım RAID kartı ya da yazılım RAID (Linux mdadm, ZFS RAID-Z, Btrfs, Windows Depolama Alanları). RAID yedek değildir: silinen dosya her diskte silinir.
RAID 0: şeritlemedisk 0A0A2A4A6disk 1A1A3A5A7RAID 1: aynalamadisk 0A0A1A2A3disk 1A0A1A2A3paralel, artıklık yokher blok iki kez
4 × 4 TB diskKullanılabilirDayanırKüçük rastgele yazma maliyeti
RAID 0 (şeritleme)16 TB0 disk1 G/Ç
RAID 1 (4 kopya ayna)4 TB3 disk4 G/Ç (her kopyaya)
RAID 10 (ayna + şerit)8 TB1 (çiftler farklıysa 2)2 G/Ç
RAID 5 (dağıtılmış eşlik)12 TB1 disk4 G/Ç (2 oku + 2 yaz)
RAID 6 (çift eşlik)8 TB2 disk6 G/Ç (3 oku + 3 yaz)

RAID ve Kararlı Depolama · Adım adım

RAID Düzenleri

RAID 0: şeritleme, artıklık yokdisk 0ş0ş4ş8ş12disk 1ş1ş5ş9ş13disk 2ş2ş6ş10ş14disk 3ş3ş7ş11ş15

RAID 0: ardışık şeritler farklı disklere; büyük isteklerde n kat bant genişliği. Bir disk bozulursa her şey kaybolur.

RAID 1: aynalamadisk 0ş0ş1ş2ş3disk 1ş0ş1ş2ş3

RAID 1: her yazma iki kez yapılır; okuma iki diskten birinden (yük dağıtılır). Kapasitenin yarısı artıklık.

RAID 10: ayna çiftleri üzerinde şeritdisk 0ş0ş2ş4ş6disk 1ş0ş2ş4ş6disk 2ş1ş3ş5ş7disk 3ş1ş3ş5ş7

RAID 10: önce aynala, sonra şeritle. Veritabanlarında yaygın: hızlı yazma ve hızlı yeniden kurma.

RAID 2/3: bit/bayt şeritleme + eşlik diskidisk 0b0b4b8b12disk 1b1b5b9b13disk 2b2b6b10b14disk 3b3b7b11b15disk 4P0P1P2P3

RAID 2 sözcük + Hamming kodu, RAID 3 bayt + tek eşlik diski kullanır; disklerin eş zamanlı dönmesi gerekir. Bugün kullanılmaz (disk zaten ECC yapar).

RAID 4: blok şeritleme + ayrı eşlik diskidisk 0ş0ş4ş8ş12disk 1ş1ş5ş9ş13disk 2ş2ş6ş10ş14disk 3ş3ş7ş11ş15disk 4P0P1P2P3

RAID 4: blok şeritleri + ayrı eşlik diski. Her küçük yazma eşlik diskini günceller: eşlik diski darboğaz.

RAID 5: eşlik disklere dağıtılırdisk 0ş0ş4ş8ş12disk 1ş1ş5ş9P3disk 2ş2ş6P2ş13disk 3ş3P1ş10ş14disk 4P0ş7ş11ş15

RAID 5: eşlik blokları disklere sırayla dağıtılır; darboğaz kalkar. n − 1 disk kapasitesi, bir disk kaybına dayanır.

RAID 6: P ve Q eşliği dağıtılırdisk 0Q0ş3ş6ş9disk 1ş0ş4ş7P3disk 2ş1ş5P2Q3disk 3ş2P1Q2ş10disk 4P0Q1ş8ş11

RAID 6: P (XOR) + Q (Reed–Solomon, GF(2⁸)) eşliği; iki disk kaybına dayanır. Büyük disklerde yeniden kurma saatler sürdüğü için tercih edilir.

RAID ve Kararlı Depolama · Adım adım

Eşlik ve XOR: Örnek

D0 (disk 0)1011 0010D1 (disk 1)0101 1100D2 (disk 2)1110 0111P (disk 3)0000 0000

Bir şeritte üç veri bloğu (burada 8 bitlik örnek). Eşlik bloğu henüz hesaplanmadı.

D0 (disk 0)1011 0010D1 (disk 1)0101 1100D2 (disk 2)1110 0111P (disk 3)0000 1001P = D0 ⊕ D1 ⊕ D2 = 0000 1001

Eşlik bit bit XOR’dur: her bit konumunda 1’lerin sayısı çift olacak biçimde tamamlanır.

D0 (disk 0)1011 0010D1 (disk 1)✗ bozulduD2 (disk 2)1110 0111P (disk 3)0000 1001D1 = D0 ⊕ D2 ⊕ P = ?

Disk 1 bozuldu. XOR’un özelliği: x ⊕ x = 0, dolayısıyla kayıp blok kalanların XOR’udur.

D0 (disk 0)1011 0010D1 (disk 1)0101 1100D2 (disk 2)1110 0111P (disk 3)0000 1001D1 = 1011 0010 ⊕ 1110 0111 ⊕ 0000 1001 = 0101 1100

Kurtarılan değer 0101 1100: özgün D1 ile aynı. Yeni diske tüm şeritler böyle yeniden yazılır (yeniden kurma).

D0 (disk 0)1011 0010D1 (disk 1)0000 1111D2 (disk 2)1110 0111P (disk 3)0101 1010P' = P ⊕ D1 ⊕ D1' = 0101 1010

Küçük yazma: D1' = 0000 1111. Eski D1 ve P okunur, P' hesaplanır, D1' ve P' yazılır: 4 G/Ç (oku-değiştir-yaz).

Yeniden kurma riski: tüketici diskte düzeltilemeyen okuma hatası (URE) ≈ 1014 bitte 1. 12 TB’lık yeniden kurmada beklenen hata 12×1012×8 / 1014 ≈ 0,96; en az bir hata olasılığı ≈ %62: RAID 5’te yeniden kurma büyük olasılıkla takılır, bu yüzden büyük dizilerde RAID 6 seçilir.

RAID ve Kararlı Depolama · Kodu adım adım çalıştır

RAID 5 Küçük Yazma ve Kurtarma: Kod İzleme

void kucuk_yaz(int d, uint8_t yeni) {
  uint8_t eski = oku(d);   /* G/Ç 1 */
  uint8_t p = oku(P);      /* G/Ç 2 */
  p = p ^ eski ^ yeni;
  yaz(d, yeni);            /* G/Ç 3 */
  yaz(P, p);               /* G/Ç 4 */
}
uint8_t kur(int bozuk) {
  uint8_t x = 0;
  for (int d = 0; d <= P; d++)
    if (d != bozuk)
      x ^= oku(d);         /* P dahil */
  return x;
}
disk 0D01011 0010disk 1D10110 1001disk 2D21100 0101disk 3P0001 1110disk G/Ç: 0

Şeritte P = D0 ⊕ D1 ⊕ D2 = 0001 1110. D1 yerine 0011 0011 yazılacak: kucuk_yaz(1, ...).

disk 0D01011 0010disk 1D10110 1001disk 2D21100 0101disk 3P0001 1110disk G/Ç: 1

Eski D1 okunur. Diğer veri diskleri (D0, D2) okunmaz: şeritte 3 değil yalnız 1 veri diski değişiyor.

disk 0D01011 0010disk 1D10110 1001disk 2D21100 0101disk 3P0001 1110disk G/Ç: 2

Eski eşlik okunur: p = 0001 1110.

disk 0D01011 0010disk 1D10110 1001disk 2D21100 0101disk 3P0001 11100001 1110 ⊕ 0110 1001 ⊕ 0011 0011 = 0100 0100disk G/Ç: 2

p ⊕ eski, eski D1’in etkisini eşlikten çıkarır (x ⊕ x = 0); ⊕ yeni, yeni değeri ekler. p = 0100 0100.

disk 0D01011 0010disk 1D10011 0011disk 2D21100 0101disk 3P0001 1110disk G/Ç: 3

Yeni D1 yazılır.

disk 0D01011 0010disk 1D10011 0011disk 2D21100 0101disk 3P0100 0100disk G/Ç: 4

Yeni P yazılır: 4 G/Ç (2 okuma + 2 yazma). Bu iki yazma arasında çökme olursa şerit tutarsız kalır (“yazma deliği”).

disk 0D01011 0010disk 1D10011 0011disk 2D2????disk 3P0100 0100disk G/Ç: 0

Disk 2 bozuldu: D2 okunamıyor. kur(2) onu kalanların XOR’u olarak hesaplar.

disk 0D01011 0010disk 1D10011 0011disk 2D2????disk 3P0100 0100x = 1011 0010disk G/Ç: 1

d = 0: x ^= D0 → x = 1011 0010.

disk 0D01011 0010disk 1D10011 0011disk 2D2????disk 3P0100 0100x = 1000 0001disk G/Ç: 2

d = 1: x ^= D1 → x = 1000 0001.

disk 0D01011 0010disk 1D10011 0011disk 2D2????disk 3P0100 0100x = 1100 0101disk G/Ç: 3

d = 3: x ^= P → x = 1100 0101. (d = 2 atlandı.)

disk 0D01011 0010disk 1D10011 0011disk 2D2????disk 3P0100 0100D2 = 1100 0101disk G/Ç: 3

x = 1100 0101, kaybolan D2 ile aynı. Yeni diske her şerit için 3 okuma ile yeniden kurulur; bu sürede dizi korumasızdır.

RAID ve Kararlı Depolama · Hesap

RAID Performansı: Örnek

Tek disk (7200 rpm, 8 ms arama, 200 MB/s): rastgele 4 KiB = 12,19 ms → R ≈ 82 IOPS (0,34 MB/s); ardışık 10 MiB parça = 8 + 4,17 + 52,43 = 64,6 ms → S ≈ 162 MB/s. Dizi: N = 4 disk.
DüzenKapasiteArdışık okuma/yazmaRastgele okumaRastgele yazmaYazma gecikmesi
RAID 0N = 4N·S ≈ 649 MB/sN·R ≈ 328N·R ≈ 328D
RAID 1 (ikili ayna)N/2 = 2(N/2)·S ≈ 325 MB/sN·R ≈ 328(N/2)·R ≈ 164D (yavaş kopya)
RAID 4N − 1 = 3(N−1)·S ≈ 487 MB/s(N−1)·R ≈ 246R/2 ≈ 412D
RAID 5N − 1 = 3(N−1)·S ≈ 487 MB/sN·R ≈ 328(N/4)·R ≈ 822D
  • Aynada ardışık okuma yalnız (N/2)·S: iki kopya blokları paylaşır, ama her disk atladığı blokların da altından dönerek geçer.
  • RAID 4: her küçük yazma eşlik diskinde 1 okuma + 1 yazma ister; dizi tek diskin yarı hızına iner ve disk eklemek işe yaramaz.
  • RAID 5: aynı 4 G/Ç tüm disklere yayılır, N·R/4 disk sayısıyla büyür. Tam şerit yazmada eski veri okunmaz: (N−1)·S.
rastgele 4 KiB yazma (IOPS), N = 4RAID 0328RAID 1164RAID 441RAID 582

RAID ve Kararlı Depolama · Adım adım

Kararlı Depolama

  • Kararlı depolama: bir yazma ya doğru biçimde tamamlanır ya da eski veri yerinde kalır. Varsayımlar: iki diskte aynı bloğun birden bozulma olasılığı ihmal edilir; hatalı veri ECC ile fark edilir; CPU çökerse süren yazma durur.
  • Kararlı yazma: disk 1’e yaz, geri oku, doğrula (n kez dene, gerekirse yedek sektör); sonra aynısını disk 2’ye yap. Kararlı okuma: disk 1’den geçerli ECC ile okunamazsa disk 2’den oku.
disk 1eskidisk 2eskikurtarma:bir şey yapma (eski kalır)

(a) Çökme disk 1’e yazmadan önce: iki kopya da eski. Yazma hiç olmamış sayılır.

disk 1ECC hatasıdisk 2eskikurtarma:disk 2 → disk 1 kopyala

(b) Çökme disk 1’e yazarken: disk 1 bozuk (ECC). Eski değer disk 2’den geri getirilir.

disk 1yenidisk 2eskikurtarma:disk 1 → disk 2 kopyala

(c) Disk 1 yazıldı, disk 2 yazılmadan çöktü: yeni değer tamamlanır.

disk 1yenidisk 2ECC hatasıkurtarma:disk 1 → disk 2 kopyala

(d) Disk 2’ye yazarken çöktü: disk 2 bozuk, yeni değer disk 1’den kopyalanır.

disk 1yenidisk 2yenikurtarma:bir şey yapma

(e) İki kopya da yeni: yazma tamamlanmış. Her durumda sonuç ya tamamen eski ya tamamen yenidir.

RAID bozulan sektörlere karşı korur, yazma sırasında çökmeye karşı korumaz. Bugün aynı fikir günlükleme (journaling), yazma bariyerleri/FUA ve kurumsal SSD’lerdeki güç kaybı koruma kapasitörleriyle uygulanır.

Özet

Özet

KonuAna fikirBugün
Donanım erişimiDenetleyici yazmaçları; kapı ya da bellek eşlemeliPCIe BAR ile MMIO
AktarımYoklama → kesme → DMAMSI-X, bus-master DMA, IOMMU
Yazılım katmanlarıKullanıcı / bağımsız / sürücü / kesmeVFS + sayfa önbelleği + blk-mq
ArayüzBloke eden, bloke etmeyen, eş zamansızepoll, io_uring
TamponlamaHız/boyut farkı, çift ve dairesel tamponNIC/NVMe halkaları, sıfır kopya
HDDArama + dönme + aktarım; çizelgelemeNCQ, mq-deadline, BFQ
SSDArama yok; FTL, çöp toplama, TRIMNVMe, çok kuyruk, none
GüvenilirlikRAID 0/1/5/6/10, kararlı depolamamdadm, ZFS, günlükleme

G/Ç tasarımının özü: yavaş ve çeşitli aygıtları hızlı CPU’dan ayırmak (tampon, kesme, DMA), farkları tek tip arayüzün arkasına gizlemek (sürücü, VFS) ve sırayı akıllıca seçmek (çizelgeleme, toplu gönderim).

Özet

Kontrol Soruları

  1. Kapı eşlemeli ve bellek eşlemeli G/Ç’de aygıt yazmacına hangi komutla erişilir? MMIO’da önbellek sorunu nasıl çözülür?
  2. 4096 karakter, saniyede 1000 karakter basan yazıcıya kesme güdümlü G/Ç ile gönderilecek; kesme başına 2 µs. CPU maliyeti nedir?
  3. Döngü çalma nedir? DMA hangi durumlarda kendini geri ödemez?
  4. 7200 rpm, ortalama arama 8 ms, ortam hızı 200 MB/s olan diskte 4 KiB rastgele okuma kaç ms sürer?
  5. Kafa 53, kuyruk 98, 183, 37, 122, 14, 124, 65, 67 (0–199). SSTF ve C-LOOK (yukarı) toplam hareketi nedir?
  6. Kafa 11, istekler 1, 36, 16, 34, 9, 12. FCFS, SSTF ve asansör (yukarı) kaç silindir hareket eder?
  7. RAID 5’te D0 = 1011 0010, D2 = 1110 0111, P = 0000 1001. Bozulan D1 nedir? Tek disk 100 IOPS ise 6 diskli RAID 5 ve RAID 4 rastgele küçük yazmada kaç IOPS verir?
  8. SSD’de TRIM neden gerekir? Linux NVMe aygıtlarında varsayılan G/Ç çizelgeleyicisi hangisidir, neden?
  9. epoll ile io_uring arasındaki temel model farkı nedir?
Cevaplar
  1. Kapı: IN/OUT; MMIO: sıradan MOV. Yazmaç sayfaları önbelleklenemez işaretlenir (PAT/MTRR, ioremap).
  2. 4096 × 2 µs = 8,19 ms (yoklamada 4,096 s).
  3. DMA her sözcük için yolu kısa süre alır, CPU bellek erişiminde bekler. Küçük aktarım, yavaş DMA denetleyicisi ya da CPU’nun yapacak başka işi yoksa.
  4. 8 + 4,17 + 0,02 = 12,19 ms (≈ 82 IOPS).
  5. SSTF 236; C-LOOK 322 (sıçrama sayılmazsa 153).
  6. 111, 61, 60.
  7. D0 ⊕ D2 ⊕ P = 0101 1100. RAID 5: 6 × 100 / 4 = 150; RAID 4: eşlik diski darboğaz, 100 / 2 = 50.
  8. SSD hangi sayfaların artık geçersiz olduğunu öğrenir; çöp toplama onları kopyalamaz, yazma büyütmesi azalır. none: arama yok, çok kuyruk zaten paralel; sıralama CPU harcar.
  9. epoll hazır olmayı bildirir (sonra read çağrılır); io_uring işin tamamlandığını bildirir ve istekleri paylaşılan halkalarla toplu gönderir.

Özet

Kaynaklar

  • A. Silberschatz, P. B. Galvin, G. Gagne, Operating System Concepts, 10. baskı, Wiley, 2018 — Bölüm 11: Mass-Storage Structure; Bölüm 12: I/O Systems.
  • A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı (2014) / 5. baskı (2023), Pearson — Bölüm 5: Input/Output.
  • R. H. Arpaci-Dusseau, A. C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces (OSTEP), ostep.org — “I/O Devices”, “Hard Disk Drives”, “RAID”, “Flash-based SSDs”.
  • D. A. Patterson, G. Gibson, R. H. Katz, “A Case for Redundant Arrays of Inexpensive Disks (RAID)”, SIGMOD 1988.
  • NVM Express Base Specification 2.x; PCI-SIG PCIe 5.0/6.0; USB4 Specification; UEFI Specification (GPT).
  • Linux çekirdek belgeleri: “Multi-Queue Block IO Queueing Mechanism (blk-mq)”, “NO_HZ: Reducing Scheduling-Clock Ticks”, io_uring (J. Axboe, “Efficient IO with io_uring”), “Linux Device Drivers” (Corbet, Rubini, Kroah-Hartman, 3. baskı).

Son

Bölüm 11: Giriş/Çıkış
Sonraki bölüm: Çok İşlemcili Sistemler · Terim sözlüğü
1 / 1