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

11.1G/Ç sistemine genel bakış

11.1.1İşletim sistemi aygıtlarla ne yapar?

Bir programın dosya okuması, ekrana yazı basması ya da ağdan paket alması, sonunda bir aygıtla konuşmayı gerektirir. Bu konuşmayı programın kendisi yapmaz. İşletim sistemi aygıtlara komut verir, durumlarını okur, işin bittiğini haber veren kesmeleri yakalar ve hataları ele alır. Uygulamaya ise aygıttan bağımsız, katmanlı ve tek tip bir arayüz sunar. Aynı read() çağrısı bir SSD'den, bir USB bellekten ya da bir seri porttan okuyabilir.

İşin büyüklüğünü bir sayı iyi anlatır. Linux kaynak kodunun yaklaşık %60–70'i drivers/ dizinindedir. Çekirdeğin en büyük parçası süreç yönetimi ya da bellek yönetimi değil, binlerce farklı aygıtın sürücüleridir. Her yeni ağ kartı, ekran kartı ya da sensör, çekirdeğe yeni bir sürücü ekler.

Şekil 11.1 bugünkü bir masaüstü bilgisayarın G/Ç düzenini gösterir. Her aygıt iki parçadan oluşur: bir denetleyici ve onun sürdüğü asıl aygıt. İşletim sistemi yalnız denetleyiciyle konuşur. Denetleyiciler de çeşitli veri yollarıyla işlemciye bağlanır.

11.1.2Veri yolları: PCIe, USB4, SATA

Paylaşılan paralel yolda aynı anda yalnız bir aygıt konuşabilir. Yol genişledikçe teller arasındaki zamanlama farkı da sorun olur. Seri hatlar bu iki sorunu birlikte çözer. Her bağlantı yalnız iki uç arasındadır ve veri tek bir hat çifti üzerinde çok yüksek frekansla akar. PCIe'de bir hat (lane) tam çift yönlüdür; bağlantı x1, x4, x8 ya da x16 hattı birleştirir. Bant genişliği her yönde ayrı ayrıdır: x4 bir NVMe disk okurken de yazarken de aynı hızı kullanabilir.

Aynı hesap PCIe 5.0 için 32 × 128 / 130 / 8 ≈ 3,94 GB/s verir; x16 bağlantıda bu 63 GB/s eder. PCIe 6.0 kodlamayı tamamen değiştirir: PAM4 sinyali her darbede iki bit taşır ve veri, hata düzeltme kodu (FEC) içeren 256 baytlık FLIT paketlerinde gider. Bir FLIT'in 242 baytı yararlı yüktür. Böylece 64 × 242 / 256 / 8 ≈ 7,6 GB/s bulunur.

Tablodaki bazı satırlar da tarihseldir. FireWire, 56K modem ve 10/100 Mb/s Ethernet artık ders kitabı örneği olarak kalmıştır. Pentium döneminin “kuzey köprüsü” de ortadan kalktı. Bellek denetleyicisi işlemcinin içine taşındı (AMD 2003, Intel 2008). Bugün hızlı aygıtlar PCIe ile doğrudan işlemciye, yavaş aygıtlar ise yonga setine bağlanır.

11.1.3Aygıt veri hızları

Aygıtları ayıran ilk özellik hızlarıdır. Şekil 11.2 tipik üst sınırları logaritmik bir eksende gösterir. Eksendeki her çizgi bir öncekinin 1000 katıdır.

Klavye ile PCIe 5.0 x16 arasında 63 × 10⁹ / 10 ≈ 6 × 10⁹ kat fark vardır. Aynı işletim sistemi hem saniyede birkaç tuşu hem de saniyede milyonlarca NVMe isteğini yönetmek zorundadır. Bu yüzden tek bir aktarım yöntemi her aygıta uymaz. Yavaş aygıtta CPU'nun her baytla tek tek ilgilenmesi sorun yaratmaz. Hızlı aygıtta ise CPU'nun veri yoluna hiç girmemesi gerekir. Şekildeki değerler tipik üst sınırlardır. Gerçek hız sinyal kalitesine, protokol yüküne ve aygıtın kendisine bağlıdır.

11.1.4Aygıt sınıfları: blok, karakter, ağ

Hızdan sonra ikinci ayrım, verinin nasıl adreslendiğidir. Unix geleneği aygıtları üç sınıfa ayırır.

Linux'ta blok ve karakter aygıtları /dev altında özel dosyalar olarak görünür. ls -l çıktısının ilk harfi sınıfı söyler:

$ 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

b blok, c karakter aygıtıdır. Dosya boyutunun bulunacağı yerdeki iki sayı ana ve yan numaradır. Ana numara (259) çekirdeğe hangi sürücünün çağrılacağını, yan numara (0) o sürücünün hangi birimi kastedildiğini söyler. Dosya sistemleri yalnız blok aygıtlarının üzerine kurulabilir, çünkü bir dosyanın herhangi bir bloğuna numarasıyla gitmek gerekir.

11.2G/Ç donanımı

11.2.1Aygıt denetleyicileri

Denetleyicinin işi, aygıtın ham sinyallerini işletim sisteminin anlayacağı birimlere çevirmektir. Şekil 11.3'teki disk denetleyicisini düşünelim. Okuma kafasının altından bir bit akışı geçer. Akış bir öncülle (preamble) başlar. Öncül, denetleyicinin saatini akışa eşleyen bir desen ile silindir ve sektör numarasını taşır. Ardından 512 bayt (4096 bit) ya da 4 KiB veri, en sonda da hata düzeltme kodu (ECC) gelir. Denetleyici bit akışını bloğa çevirir, ECC ile hataları düzeltir ve bloğu kendi tamponuna koyar. Blok ancak bundan sonra belleğe aktarılır.

Denetleyicinin standart bir arayüzü olması işletim sistemi için büyük kolaylıktır. SATA ya da NVMe arayüzü sayesinde tek bir sürücü, birçok üreticinin diskini sürebilir. İşletim sistemi açılışta ve bir aygıt sıcak takıldığında yolları tarar. PCIe yapılandırma alanını ve USB tanımlayıcılarını okur, aygıtın kimliğini öğrenir ve uygun sürücüyü yükler. Bu düzene tak-çalıştır denir.

Disklerin sektör boyutu da değişti. Modern diskler 4 KiB fiziksel sektör kullanır (Advanced Format). Eski yazılımla uyum için dışarıya 512 B sektör gösterenlere 512e denir. Böyle bir diske 512 baytlık hizasız bir yazma geldiğinde denetleyici önce 4 KiB'lık sektörün tamamını okur, değişen kısmı yerleştirir ve sektörü geri yazar.

11.2.2Aygıt yazmaçları: durum, komut, veri

Denetleyici, işletim sistemiyle yazmaçları üzerinden konuşur. Bir denetleyicinin genellikle dört yazmacı vardır.

• Durum yazmacı (status): CPU okur. Aygıtın meşgul olup olmadığını, sonucun hazır olup olmadığını, hata oluşup oluşmadığını bildirir.
• Komut yazmacı (command): CPU yazar. Denetleyiciye ne yapacağını söyler: okuma mı, yazma mı, hangi kipte.
• Veri çıkış yazmacı (data-out): CPU'dan aygıta giden veri buraya konur.
• Veri giriş yazmacı (data-in): aygıttan gelen veri CPU'nun okuması için burada bekler.

Kural basittir: yazmaca yazmak komut vermek, yazmacı okumak durum öğrenmektir. Bazı denetleyicilerde yazmaçlara ek olarak büyük veri tamponları da bulunur. Ekran kartının çerçeve tamponu ya da ağ kartının (NIC) gönderme ve alma halkaları buna örnektir. Yazmaçların düzeni aygıta özgüdür ve bu ayrıntıyı yalnız sürücü bilir. Şekil 11.4'teki bit adları da örnek amaçlıdır; gerçek bir SATA ya da NVMe denetleyicisinin yazmaç düzeni farklıdır.

11.2.3Kapı eşlemeli ve bellek eşlemeli G/Ç

CPU'nun bir aygıt yazmacına nasıl eriştiği sorusunun iki klasik cevabı vardır.

x86 ailesi iki yöntemi birlikte taşır. IBM PC'den kalma birçok aygıt hâlâ sabit kapı numaralarındadır (Tablo 11.3). Şekil 11.5'teki hibrit düzenin klasik örneği eski PC'nin VGA kartıdır: denetim yazmaçları kapılarda, ekran belleği ise bellek adreslerindeydi.

İki erişim biçimi makine kodunda şöyle görünür:

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

İlk satır 0x60 kapısından, yani klavye denetleyicisinin veri yazmacından bir bayt okur. Bunun için ayrı bir komut (in) gerekir. İkinci satır sıradan bir bellek yüklemesidir. rbx bir aygıtın eşlendiği adresi gösteriyorsa bu komut o aygıtın 0x14 konumundaki yazmacını okur; CPU açısından bellekten okumaktan farkı yoktur. Linux çekirdeğinde kapılara inb()/outb() ile, bellek eşlemeli yazmaçlara ise önce ioremap() ile eşleyip sonra readl()/writel() ile erişilir. Hangi kapıların ve hangi fiziksel adres aralıklarının hangi aygıta ait olduğu /proc/ioports ve /proc/iomem dosyalarında görülür.

Bugün ağırlık açıkça bellek eşlemeli G/Ç'dedir. ARM ve RISC-V işlemcilerinde kapı komutları hiç yoktur; yalnız MMIO kullanılır. PCIe aygıtları da x86'da bile yazmaçlarını BAR (base address register) denen adres pencereleriyle bellek eşlemeli olarak sunar.

11.2.4Bellek eşlemeli G/Ç: artılar ve eksiler

Bellek eşlemeli G/Ç'nin yaygınlaşmasının üç nedeni vardır. Birincisi, özel komut gerekmez. Sürücü tamamen C ile yazılabilir; yazmaç bir volatile işaretçi üzerinden okunup yazılır. İkincisi, koruma sayfa tablosuyla gelir. Yazmaçların bulunduğu sayfa kullanıcı uzayına eşlenmezse hiçbir kullanıcı programı aygıta dokunamaz. İstenirse bu sayfa tek bir sürece verilebilir; VFIO ve DPDK gibi kullanıcı alanı sürücüleri bu yolla çalışır. Üçüncüsü, belleğe erişen her komut yazmaçla da çalışır: TEST ya da AND gibi komutlar doğrudan yazmacın üzerinde işlem yapabilir.

Yöntemin bedelleri de vardır.

• Önbellek. Durum yazmacı önbelleğe alınırsa CPU sonraki okumalarda yazmacın kendisine değil, önbellekteki eski kopyaya bakar. Aygıt hazır olsa bile program bunu göremez. Bu yüzden yazmaç sayfaları önbelleklenemez olarak işaretlenir (x86'da PAT/MTRR; Linux'ta ioremap bunu yapar).
• Birden çok yol. Bellek ayrı ve hızlı bir yoldaysa G/Ç aygıtları o yoldaki adresleri göremez (Şekil 11.6). Hangi adres aralığının belleğe, hangisinin aygıtlara gideceğine köprü ya da kök kompleks karar verir.
• Derleyici ve işlemci sıralaması. Derleyici, değeri değişmiyor gibi görünen bir okumayı döngü dışına alabilir ya da iki yazmayı yer değiştirebilir. Yazmaç işaretçisi volatile olmalı, sıranın önemli olduğu yerlere bellek bariyerleri konmalıdır.

11.3Programlanmış G/Ç

11.3.1Yoklama ve el sıkışma

CPU ile denetleyicinin bir baytı nasıl devrettiğini en yalın biçimiyle inceleyelim. İki taraf, durum ve komut yazmaçlarındaki birkaç bit üzerinden anlaşır. Bu anlaşmaya el sıkışma (handshaking) denir.

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 */

Kodun üst yarısını sürücü, alt yarısındaki yorumlarla anlatılan adımları denetleyici yürütür. Bir baytın, 'A' karakterinin (0x41) yazılması sekiz adımda biter:

1. Bekleme. Sürücü durum yazmacını okur. Denetleyici önceki işi bitirmediği için BUSY = 1'dir ve while döngüsü döner. CPU bu sırada başka iş yapamaz.
2. Çıkış. BUSY 0 olunca döngüden çıkılır. Bu bekleme birkaç döngüden milisaniyelere kadar sürebilir; süre aygıta bağlıdır.
3. Komut. Komut yazmacına WRITE biti yazılır: yapılacak iş yazmadır.
4. Veri. Gönderilecek bayt (0x41) veri çıkış yazmacına konur.
5. Komut hazır. CMDRDY = 1 yapılır. Bu bit denetleyiciye işin başlayabileceğini söyler. Sıra önemlidir: CMDRDY, komut ve veri yerine konduktan sonra kurulmalıdır.
6. Denetleyici meşgul. Denetleyici CMDRDY'yi görür ve BUSY = 1 yapar. Böylece ana makineye meşgul olduğunu bildirir.
7. İş. Denetleyici komut yazmacını okur (WRITE), veri çıkış yazmacındaki baytı alır ve aygıta gönderir.
8. Bitiş. CMDRDY, ERR ve BUSY temizlenir. ERR = 0, işin başarıyla bittiğini gösterir. Sonraki bayt için döngü baştan başlar.

Programlanmış G/Ç basittir ve ek donanım istemez. Ama CPU bekleme boyunca boşa döner. Daha kötüsü, CPU başka bir sürece geçer ve bir baytı zamanında almazsa veri kaybolabilir. Denetleyicinin tamponu taşarsa yeni gelen baytın konacak yeri kalmaz.

11.3.2Yazıcı örneği

Tanenbaum'un klasik örneği, bir kullanıcı sürecinin “ABCD” dizisini yazıcıya göndermesidir. Sistem çağrısının çekirdekteki kısmı şöyledir:

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();

İlk satır kullanıcının dizisini çekirdek tamponuna kopyalar (copy_from_user). Çekirdek kullanıcı belleğini doğrudan kullanmaz, çünkü süreç o belleği başka bir iş parçacığıyla değiştirebilir ya da adres geçersiz olabilir. Ardından her karakter için iki iş yapılır. İç while döngüsü durum yazmacı READY olana kadar döner. Yazıcı hazır olunca karakter veri yazmacına yazılır; yazıcı karakteri basar ve yeniden meşgul olur. Dört karakterin dördü de basıldıktan sonra sürece dönülür.

Yine de PIO her zaman kötü değildir. Gömülü bir sistemde CPU'nun başka işi yoksa ya da aygıt çok hızlı yanıt veriyorsa yoklama en basit ve en hızlı çözümdür. Aşağıdaki örnek, yoklamanın ne zaman zararsız, ne zaman imkânsız olduğunu sayılarla gösterir.

11.4Kesmeler

11.4.1Kesme donanımı: hattan MSI'ya

Yoklamanın kusuru, CPU'nun aygıtı sürekli sorgulamasıdır. Daha iyi bir düzen, işi bitince aygıtın CPU'ya haber vermesidir.

Klasik düzende her aygıtın kesme denetleyicisine giden bir hattı (IRQ) vardır. Denetleyici CPU'nun tek kesme girişini aygıtlar arasında paylaştırır ve öncelik belirler. Bir disk okuması şu sırayla haber verilir:

1. Sinyal. Disk denetleyicisi işini bitirince kendi kesme hattına sinyal verir.
2. İletme. Kesme denetleyicisi o anda başka kesme işlenmiyorsa ya da yeni kesme daha öncelikliyse CPU'ya kesme iletir. Değilse istek bekletilir; CPU onaylayana kadar hat etkin kalır.
3. Vektör. CPU kesmeyi kabul eder ve denetleyici bir vektör numarası verir. CPU bu sayıyı kesme vektör tablosunda indis olarak kullanır ve işleyicinin adresini bulur.

Bu anlatım tarihsel PC düzenine dayanır: iki 8259 PIC ve 15 IRQ hattı. Denetleyicinin vektörü “adres yoluna koyması” da yalnız o düzen için geçerlidir. Bugün x86'da bir I/O APIC ve her çekirdekte bir yerel APIC (x2APIC) bulunur; ARM'da bu görevi GIC üstlenir.

MSI'nın iki üstünlüğü vardır. Hat paylaşımı ortadan kalkar, çünkü her aygıt istediği kadar ayrı vektör alabilir. Kesme ayrıca istenen çekirdeğe yönlendirilebilir. MSI-X bir PCIe işlevine 2048 vektöre kadar izin verir. NVMe diskler ve ağ kartları her kuyruk için ayrı vektör alır ve o kuyruğun kesmesini kuyruğu kullanan çekirdeğe gönderir.

11.4.2Vektörler, öncelik, NMI ve istisnalar

Vektörlerin bir kısmı aygıtlara değil, işlemcinin kendisine aittir. x86'da 0–31 arası işlemci istisnalarına ayrılmıştır (Tablo 11.4).

Kesmelerin de kendi aralarında farkları vardır. Maskelenebilir kesmeler kritik bir bölgede ertelenebilir; x86'da cli komutu kesmeleri kapatır, sti yeniden açar. NMI (non-maskable interrupt) ise ertelenemez. Donanım hataları, bellek ECC hataları ve izleme köpeği (watchdog) bu yolu kullanır, çünkü bu olaylar beklemeye tahammül etmez. Öncelik de önemlidir. APIC kesmeleri vektör sınıfına göre sıralar; yüksek öncelikli bir kesme, düşük öncelikli bir işleyiciyi kesebilir.

Aygıt sayısı vektör sayısından fazla olduğunda bir vektör birden çok aygıta düşebilir. Bu durumda tablonun girdisi tek bir işleyiciyi değil, bir işleyici listesini gösterir. Kesme geldiğinde listedeki işleyiciler sırayla “bu kesme benim mi?” diye kendi aygıtına bakar. Bu düzene kesme zinciri ya da paylaşılan IRQ denir. Linux'ta hangi vektörün hangi çekirdekte kaç kez geldiği /proc/interrupts dosyasında görülür; irqbalance hizmeti kesmeleri çekirdeklere dağıtır.

11.4.3Kesme işleme adım adım

Bir kesmenin baştan sona nasıl işlendiğini somut bir durumda izleyelim. Süreç A çalışıyor; süreç B ise bir disk okumasının bitmesini bekliyor. Disk okuması biter ve denetleyici kesme ister.

1. Kabul. CPU o anki komutu bitirir, sonra kesmeyi kabul eder. Kesme ancak komut sınırında alınır.
2. Donanımın kaydı. Donanım program sayacını (x86-64'te RIP), durum sözcüğünü (PSW, RFLAGS) ve yığın işaretçisini çekirdek yığınına iter. Çekirdek moduna geçer ve kesmeleri maskeler.
3. İşleyiciyi bulma. Vektör numarası IDT'de indis olur ve işleyicinin adresi bulunur. Giriş kodu (assembly) donanımın kaydetmediği yazmaçları da kaydeder. Artık C ile yazılmış kesme hizmet yordamı (ISR) için bağlam ve yığın hazırdır.
4. ISR. İşleyici aygıtın durumunu okur, veriyi alır ve kesme denetleyicisine onay (EOI, end of interrupt) gönderir. Bundan sonra yeni kesmeler gelebilir. Uzun sürecek iş daha sonraya, alt yarıya ertelenir.
5. Uyandırma. Bekleyen süreç B, bloke durumundan hazır kuyruğuna alınır.
6. Çizelgeleme. Çizelgeleyici sıradaki süreci seçer; burada B'yi seçtiğini varsayalım. B'nin sayfa tablosu MMU'ya yüklenir (x86'da CR3 yazmacı), yazmaçları süreç tablosundan ya da yığından geri alınır.
7. Dönüş. iret komutu kaydedilen PC ve PSW'yi geri yükler, kullanıcı moduna döner ve kesmeleri açar. B, kaldığı komuttan devam eder.

Bu sıra Tanenbaum'un kesme işleyicisi adımlarını izler. Çizelgeleyici A'yı da seçebilirdi; bu seçim politikaya bağlıdır. Kesme, bekleyen bir süreci hazır yapmak dışında çizelgeleme kararını kendiliğinden değiştirmez.

11.4.4Kesin ve kesin olmayan kesmeler

Kesmeden sonra programın kaldığı yerden devam edebilmesi için “kaldığı yer”in iyi tanımlanmış olması gerekir. Boru hattıyla çalışan işlemcide bu kendiliğinden sağlanmaz.

Boru hattında aynı anda birçok komut farklı aşamalardadır. Üstün ölçekli bir işlemcide komutlar sıra dışı da tamamlanabilir. Şekil 11.12'nin (b) kısmındaki durumda tek bir PC değeri programın nerede kaldığını anlatmaz. Yeniden başlamak için ya donanım yarım işleri geri almalı ya da işletim sistemi çok miktarda iç durumu kaydedip çözümlemelidir. İkincisi işleyiciyi hem yavaşlatır hem karmaşıklaştırır.

Modern x86, ARM ve RISC-V işlemcileri kesin kesme sağlar. Bunu yeniden sıralama arabelleği (ROB, reorder buffer) ile yapar. Komutlar sıra dışı yürütülse de ROB onları program sırasıyla “emekliye ayırır”, yani sonuçlarını kalıcı hâle getirir. Kesme geldiğinde henüz emekliye ayrılmamış komutların etkileri atılır. Bedeli yonga alanı ve tasarım karmaşıklığıdır, ama işletim sistemi bu sayede sade kalır.

11.4.5Kesme güdümlü G/Ç: yazıcı örneği

Kesmelerle yazıcı örneği baştan yazılabilir. Amaç, CPU'nun yazıcıyı beklerken boşa dönmemesidir.

/* 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();

Kod iki parçadan oluşur. Üst kısım sistem çağrısıdır. Diziyi çekirdek tamponuna kopyalar, yazıcının kesmelerini açar, yazıcı hazır olunca yalnız ilk karakteri yazar, sayaçları günceller ve çizelgeleyiciyi çağırır. Süreç bloke olur ve CPU başka bir süreci çalıştırır. Alt kısım kesme hizmet yordamıdır. Yazıcı her karakteri bastığında bir kesme gelir. Yordam count'a bakar: sıfırsa bütün karakterler basılmıştır ve kullanıcı süreci uyandırılır. Değilse sıradaki karakter yazılır, count bir azalır, i bir artar. Her iki durumda kesme onaylanır ve kesilen sürece dönülür.

Tablo 11.5 bir ayrıntıyı ortaya koyar: üç karakter için üç kesme gelir, ama üçüncü kesme yeni bir karakter yazmaz. Yalnız işin bittiğini bildirir. Sistem çağrısı ilk karakteri yazdığı için kesmelerin sayısı karakter sayısına eşittir. Yöntemin bedeli kesme başına bağlam kaydı ve işleyici süresidir; bu da tipik olarak 1–2 µs'dir. Yazıcı beklerken CPU başka süreçleri çalıştırır; bu kazanç, birkaç mikrosaniyelik kesme maliyetinden çok büyüktür.

11.4.6Üst yarı, alt yarı ve hibrit yoklama

Kesme işleyicisi çalışırken en azından aynı hattaki kesmeler kapalıdır. İşleyici uzun sürerse başka aygıtların kesmeleri gecikir, hatta kaybolur. Bu yüzden işletim sistemleri işleyiciyi ikiye böler.

Kesme sayısını azaltmanın başka yolları da vardır.

• Kesme birleştirme (interrupt coalescing). Ağ kartları ve NVMe diskler birkaç tamamlanmayı tek bir kesmede bildirir. Kesme sayısı azalır, gecikme biraz artar.
• NAPI: kesme ile yoklamanın birleşimi. Yoğun ağ trafiğinde Linux sürücüsü kesmeyi kapatır ve kuyruğu yoklar. Trafik azalınca kesmeye döner. Seyrek olayda kesme, sık olayda yoklama verimlidir; hibrit yöntem ikisinin iyi yanını alır.
• Saf yoklama. Olay hızı çok yüksek ve gecikme kritikse kesme hiç kullanılmaz. DPDK ve SPDK, NVMe yoklamalı kuyrukları ve io_uring'in IOPOLL kipi bu yolu seçer. Bir çekirdek tamamen yoklamaya ayrılır.

Kesmelerin bir de arıza durumu vardır. Hatalı bir aygıt sürekli kesme üretirse işlemci yalnız işleyiciyi çalıştırır ve sistem kilitlenir. Buna kesme fırtınası denir. Linux, hiçbir işleyicinin sahiplenmediği kesmeler çok sayıda gelirse “nobody cared” iletisiyle hattı kapatır; kesme hızını sınırlayan mekanizmalar da vardır.

11.5Doğrudan bellek erişimi (DMA)

11.5.1DMA denetleyicisi

Kesme güdümlü G/Ç beklemeyi ortadan kaldırır, ama her bayt ya da sözcük için hâlâ bir kesme gelir. 4 KiB'lık bir disk bloğunu sözcük sözcük taşımak binlerce kesme demektir. Çözüm, taşıma işini CPU'dan tamamen almaktır.

Bir DMA denetleyicisinin yazmaçları aktarımı tarif eder: bellek adresi, bayt sayısı ve denetim yazmacı. Denetim yazmacı G/Ç kapısını, yönü (okuma mı, yazma mı), aktarım birimini (bayt mı, sözcük mü) ve bir seferde kaç birim taşınacağını (patlama boyutu) belirler. Çok kanallı bir denetleyici her kanal için ayrı bir yazmaç takımı tutar ve aynı anda birçok aktarımı yönetir.

Anakartta tek bir DMA denetleyicisinin bütün aygıtlara hizmet ettiği düzen yalnız tarihsel 8237 yongası için geçerlidir (Şekil 11.14 (a)). Bugün aygıtların çoğunda kendi DMA motoru vardır ve bu aygıtlar belleğe doğrudan PCIe yazması yapar. Kavram aynı kalır: aktarımı kuran CPU'dur, taşıyan aygıttır.

11.5.2DMA aktarımı adım adım

Bir disk sektörünün DMA ile belleğe okunmasını izleyelim. Sektör 4096 bayttır ve bellekte 0x7A000 adresine yazılacaktır.

1. Kurulum. CPU, DMA denetleyicisini (adres = 0x7A000, sayaç = 4096, yön = okuma) ve disk denetleyicisini (“sektörü oku”) programlar, sonra başka işe döner.
2. Tampon. Disk denetleyicisi sektörü kendi tamponuna okur ve ECC ile doğrular. Tampon sayesinde yol o an meşgulse veri kaybolmaz.
3. İstek. DMA denetleyicisi yolu ister, bellek adresini yola koyar ve disk denetleyicisine okuma isteği gönderir.
4. Yazma. Disk denetleyicisi sözcüğü doğrudan belleğe yazar. CPU bu aktarımın içinde değildir.
5. Onay. Disk denetleyicisi onay gönderir; DMA denetleyicisi adresi artırır, sayacı azaltır. Sayaç 0 olana kadar istek, yazma ve onay adımları tekrarlanır.
6. Kesme. Sayaç 0'a inince DMA denetleyicisi CPU'yu kesmeyle uyarır. İşletim sistemi kesmeyi işlediğinde veri zaten bellektedir.

DMA'nın veri yolunu nasıl kullandığı da önemlidir. Döngü çalma (cycle stealing) kipinde denetleyici her sözcük için yolu birkaç turluğuna CPU'dan alır. CPU tamamen durmaz, yalnız belleğe erişmek istediği anlarda biraz bekler. Patlama (burst) kipinde yol bir blok boyunca tutulur; aktarım hızlanır ama CPU daha uzun bekleyebilir. Bir ayrım daha vardır. Geçişsiz (fly-by) kipte veri aygıttan belleğe doğrudan gider. Öteki kipte DMA denetleyicisi sözcüğü önce kendisi okur, sonra hedefe yazar; bu iki yol döngüsü harcar ama bellekten belleğe kopyalamaya da izin verir.

11.5.3Dağıt-topla ve IOMMU

Sanal bellek kullanan bir sistemde bir sürecin 12 KiB'lık tamponu sanal adreslerde bitişiktir, ama fiziksel bellekte üç ayrı sayfaya dağılmış olabilir. Basit bir DMA denetleyicisi yalnız tek bir bitişik bölgeye yazabilir. Bu durumda çekirdek ya veriyi bitişik bir tampona alıp sonra kopyalamalı ya da üç ayrı aktarım yapmalıdır.

Dağıt-topla, Linux'ta readv/writev çağrılarının, parçalı ağ paketlerinin ve NVMe'deki PRP ve SGL listelerinin temelidir. Ek kopya gerekmez. IOMMU'nun ise üç görevi vardır. Birincisi korumadır: aygıt yalnız kendisine eşlenmiş sayfalara erişebilir. Thunderbolt gibi dışarıdan takılan bir aygıtın bütün belleği okumaya çalıştığı DMA saldırıları bu sayede engellenir. İkincisi sanallaştırmadır: bir aygıt doğrudan bir sanal makineye atanabilir (VFIO); konuk işletim sistemi kendi “fiziksel” adreslerini verir, IOMMU bunları gerçek adreslere çevirir. Üçüncüsü, yalnız 32 bit adresleyebilen eski aygıtların 4 GiB'nin üstündeki belleği kullanabilmesidir. Intel'de bu birimin adı VT-d, AMD'de AMD-Vi, ARM'da SMMU'dur.

11.5.4DMA ile yazıcı örneği

Yazıcı örneğinin üçüncü sürümü DMA kullanır:

/* 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();

Sistem çağrısı veriyi çekirdek tamponuna kopyalar, DMA denetleyicisini programlar (tampon adresi, sayaç = 3, hedef olarak yazıcı kapısı) ve süreci bloke eder. DMA denetleyicisi karakterleri CPU'suz olarak yazıcıya iletir. Bu sırada CPU'ya hiç kesme gelmez. Bütün karakterler aktarılınca DMA tek bir kesme üretir. Kesme hizmet yordamı yalnız iki iş yapar: kesmeyi onaylar ve kullanıcı sürecini uyandırır. Karakter başına değil, tampon başına bir kesme gelir.

DMA her zaman kazandırmaz. DMA denetleyicisi genellikle CPU'dan yavaştır. Aygıt çok yavaşsa ya da CPU'nun yapacak başka bir işi yoksa, kesme güdümlü G/Ç ya da PIO daha basit ve yeterli olabilir. Tanenbaum bu noktayı özellikle vurgular: DMA'nın kazancı, CPU'nun boşalan zamanda yararlı iş yapabilmesine bağlıdır.

11.5.5Üç yöntemin maliyeti

Üç yöntemi aynı iş üzerinde sayılarla karşılaştıralım.

Bu iki örnek kuralı açık eder. Aktarım büyüdükçe DMA'nın sabit maliyeti önemsizleşir ve CPU yükü aktarım boyundan bağımsız hâle gelir. Aktarım küçüldükçe, aygıt yavaşladıkça ya da CPU boşta bekledikçe DMA'nın kazancı kaybolur. Kesme, DMA ve G/Ç Akışı Simülatörü üç yöntemi aynı aktarımla çalıştırır ve CPU kullanımlarını yan yana gösterir.

11.6G/Ç yazılımı

11.6.1G/Ç yazılımının hedefleri

Donanımın bu kadar çeşitli olması, yazılımın düzenli olmasını zorunlu kılar. G/Ç yazılımı tasarlanırken altı hedef gözetilir.

• Aygıt bağımsızlığı. Program hangi aygıtla çalıştığını bilmeden çalışabilmelidir. sort < girdi komutu, girdi dosyası SSD'de de, USB bellekte de dursa aynı biçimde çalışır.
• Tek tip adlandırma. Bir dosyanın ya da aygıtın adı aygıt türüne bağlı olmamalıdır. /dev/nvme0n1 ve /mnt/usb/rapor.txt aynı ağacın parçalarıdır; farklı aygıtlar bağlama (mount) ile tek bir ağaca eklenir.
• Hata ele alma. Hata donanıma olabildiğince yakın çözülmelidir. Denetleyici bit hatasını ECC ile düzeltir, sürücü başarısız işlemi yeniden dener. Üst katman ancak gerektiğinde hatadan haberdar olur.
• Eş zamanlı ve eş zamansız aktarım. Donanım düzeyinde aktarımların çoğu eş zamansızdır: CPU işi başlatır ve kesmeyi bekler. Kullanıcıya ise bloke eden bir arayüz sunmak programlamayı kolaylaştırır. İşletim sistemi bu ikisi arasında köprü kurar.
• Tamponlama. Ağdan gelen bir paket, nereye gideceği belli olmadan önce bir yere konmalıdır. Ses gibi gerçek zamanlı aygıtlar da tampona dayanır.
• Paylaşılan ve adanmış aygıtlar. Bir disk aynı anda birçok kullanıcıya hizmet verebilir. Yazıcı ya da tarayıcı ise belli bir anda tek bir kullanıcıya adanır. Adanmış aygıtlar kilitlenme riski doğurur: iki süreç birbirinin tuttuğu aygıtı bekleyebilir.

11.6.2G/Ç yazılım katmanları

Bu hedeflere ulaşmanın yolu katmanlı bir yapıdır. Her katmanın iyi tanımlı bir görevi ve üst katmana sunduğu bir 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 ve kesme işleyicileri. Linux'ta “aygıttan bağımsız” kısım kendi içinde birkaç parçaya ayrılır: VFS (sanal dosya sistemi), sayfa önbelleği, dosya sistemi ve blok katmanı (Şekil 11.19). Aşağıdaki örnek, bir isteğin bu katmanlardan nasıl geçtiğini gösterir.

11.6.3Bir read() çağrısının yolu

Aynı veri ikinci kez okunursa üçüncü adımda sayfa önbellekte bulunur. Aygıta hiç gidilmez; işlem mikrosaniyeler içinde biter. Bu fark, işletim sisteminin boş belleği neden önbelleğe ayırdığını da açıklar.

11.6.4Aygıt sürücüleri

Bir sürücü, üst katmandan gelen her istek için benzer bir iş sırası izler. Önce parametreleri doğrular. Sonra isteği aygıtın anlayacağı bir komuta çevirir; bir disk için bu, LBA ve kuyruk girdisi demektir. Gerekirse aygıtı başlatır, yazmaçlara yazar ve kesmeyi bekler, yani bloke olur. İş bitince hatayı denetler ve sonucu üst katmana döndürür.

Sürücü yazmanın iki zorluğu vardır. Birincisi, sürücü yeniden girilebilir (reentrant) olmalıdır: bir isteği işlerken yeni bir istek ya da bir kesme gelebilir. İkincisi, sıcak takılabilen bir aygıt çalışırken ortadan kaybolabilir; sürücü bunu çökmeden karşılamalıdır.

Linux'ta sürücülerin çoğu çekirdek kaynak ağacının içindedir; bazıları üreticiden ayrıca gelir. Sürücüler genellikle yüklenebilir modüllerdir: modprobe modülü yükler, lsmod yüklü modülleri listeler. Ama çekirdekte çalışan hatalı bir sürücü bütün sistemi çökertebilir. Bu riski azaltmak için sürücüleri kullanıcı alanına taşıyan tasarımlar vardır. MINIX 3'te bütün sürücüler kullanıcı alanındadır. Linux'ta FUSE, VFIO/UIO, DPDK ve SPDK, Windows'ta UMDF bu amaçla kullanılır.

11.6.5Aygıttan bağımsız G/Ç yazılımı

Sürücünün üstündeki katman, bütün sürücüler için ortak olan işleri üstlenir. Bunların başında tek tip arayüz gelir. Her aygıt sınıfı aynı işlevleri sunar ve çekirdek sürücüyü bir işlev işaretçisi tablosu üzerinden çağırır:

struct file_operations nvme_fops = {
  .open           = nvme_open,
  .release        = nvme_release,
  .read_iter      = nvme_read,
  .unlocked_ioctl = nvme_ioctl,
  .poll           = nvme_poll,
};

Bu tablo C'de nesne yönelimli programlamanın karşılığıdır. VFS bir dosyada read istendiğinde hangi aygıt olduğunu sormaz; dosyaya bağlı tablodaki read_iter işaretçisini çağırır. NVMe için bu nvme_read'dir, bir seri port için başka bir işlevdir. Yeni bir aygıt eklemek, çekirdeğin geri kalanına dokunmadan yeni bir tablo yazmak demektir.

Aynı katman başka işleri de yapar. Adlandırma: /dev/nvme0n1 gibi bir ad, ana numara (sürücü) ve yan numara (birim) çiftine çevrilir. Koruma: aygıt dosyasının izinleri, kimin aygıta erişebileceğini belirler. Ayrıca aygıttan bağımsız bir blok boyutu sunar, tamponlamayı ve hata raporlamayı yönetir, adanmış aygıtların ayrılmasını ve bırakılmasını düzenler.

11.6.6Ara belleğe alma (tamponlama)

Silberschatz tamponlamanın üç nedenini sayar. Birincisi, üretici ile tüketici arasındaki hız farkıdır: modemden gelen yavaş akış diske tek tek yazılmaz, bir tamponda biriktirilir. İkincisi, aktarım boyutu farkıdır: ağdaki küçük paketler alıcı tarafta birleştirilir. Üçüncüsü kopya anlamıdır: write döndükten sonra uygulama kendi tamponunu değiştirebilmelidir; diske yazılacak veri o anki hâliyle çekirdekte kopyalanmış olmalıdır.

Bir modemden ya da seri porttan karakter okuyan bir süreci düşünelim. Tamponlamanın beş farklı düzeyi vardır (Şekil 11.23).

1. Tamponsuz. Her karakter için bir kesme gelir ve süreç uyandırılır. Çok sayıda bağlam değiştirme olur; verimsizdir.
2. Kullanıcı tamponu. Kesme işleyicisi karakterleri doğrudan süreçteki bir tampona yazar; süreç ancak tampon dolunca uyandırılır. Ama tampon sayfası o sırada diske atılmışsa işleyici nereye yazacak? Sayfa bellekte kilitlenmelidir. Çok sayıda süreç sayfa kilitlerse kullanılabilir bellek azalır.
3. Çekirdek tamponu. Karakterler önce çekirdekteki bir tamponda birikir; tampon dolunca tek seferde kullanıcıya kopyalanır. Peki kopyalama sürerken gelen karakter nereye konacak?
4. Çift tampon. Çekirdekte iki tampon vardır: biri dolarken öteki kullanıcıya kopyalanır, sonra roller değişir. Bu düzenin genel biçimi dairesel tampondur.
5. Ağda kopyalar. Bir paket ağ üzerinden giderken beş kez kopyalanabilir: gönderen kullanıcıdan çekirdeğe, çekirdekten ağ kartına, kablo üzerinden alıcının ağ kartına, oradan çekirdeğe ve en sonda kullanıcıya. Her kopya bellek bant genişliği ve gecikme demektir. Bu yüzden sendfile, splice, MSG_ZEROCOPY ve io_uring gibi sıfır kopya teknikleri geliştirilmiştir.

11.6.7Dairesel tampon

Dolu tamponda üretici iki şey yapabilir: tüketicinin yer açmasını bekler ya da veriyi düşürür. Ağ kartında ikincisi olur ve paket kaybolur. Bir yuvanın hep boş bırakılmasının nedeni basittir. Bütün yuvalar dolabilseydi dolu tamponda da baş = kuyruk olurdu ve boş ile dolu ayırt edilemezdi. Bunun bedeli, N yuvalı tamponun en çok N − 1 bayt tutmasıdır.

Dairesel tamponlar G/Ç'nin her yerindedir: klavye ve seri port sürücüleri, ağ kartlarının alma ve gönderme halkaları, NVMe'nin gönderim ve tamamlanma kuyrukları, io_uring. Tek üretici ve tek tüketici varsa kilit gerekmez. Üretici yalnız kuyruğu, tüketici yalnız başı değiştirir; doğru sırayı korumak için yalnız bellek bariyerleri gerekir.

11.6.8Kod izleme: dairesel tampon

Aşağıdaki iki işlev dairesel tamponu C ile gerçekler. koy kesme işleyicisinde, al süreçte çalışır.

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;
}

koy önce kuyruğun bir sonraki değerini s'de hesaplar. s başa eşitse yazmak tamponu “boş” görünür hâle getirirdi; bu yüzden tampon dolu sayılır ve -1 döner. Değilse bayt buf[kuy]'a yazılır ve kuyruk ilerler. Burada sıra önemlidir: önce veri yazılır, sonra indis güncellenir. Tersi olsaydı tüketici henüz yazılmamış bir yuvayı okuyabilirdi. al ise başın kuyruğa eşit olup olmadığına bakar; eşitse tampon boştur. Değilse buf[bas] okunur ve baş ilerler. Her iki işlev O(1) zamanda çalışır. Tamponun alanı N yuvadır ve hiç değişmez.

'f' reddedildiğinde tamponda dört bayt vardır ('b', 'c', 'd', 'e'): N − 1 = 4. Bir okuma yapılınca yer açılır ve bir sonraki koy başarılı olur.

11.6.9Önbellek, biriktirme ve hata ele alma

Önbellek ve tampon farklı şeylerdir. Tampon, verinin tek kopyasını geçici olarak tutar. Önbellek (cache) ise başka bir yerde duran verinin hızlı erişilen bir kopyasıdır. Linux'un sayfa önbelleği ikisini birleştirir: diske yazılacak veri orada tamponlanır, diskten okunan veri orada önbelleklenir. Boşta kalan RAM önbelleğe gider; free -h çıktısındaki buff/cache sütunu bunu gösterir.

Yazıcı biriktirmenin klasik örneğidir. Kullanıcı yazdırılacak dosyayı biriktirme dizinine koyar; tek bir arka plan süreci (Linux'ta CUPS, dizin /var/spool/cups) dosyaları sırayla yazdırır. Hiçbir kullanıcı süreci yazıcıyı kilitlemez; bu yüzden yazıcı yüzünden kilitlenme de oluşmaz.

Hata ele alma iki tür hatayı ayırır. Programlama hatalarında, örneğin geçersiz bir dosya tanımlayıcısında, çağrı bir hata kodu döndürür (EBADF, EINVAL). Gerçek bir G/Ç hatasında sürücü işlemi yeniden dener; hata kalıcıysa çağrı EIO döndürür ve olay çekirdek günlüğüne yazılır (dmesg).

Ayırma ve koruma. Adanmış bir aygıt open ile ayrılır. Aygıt meşgulse istek kuyruğa alınır ya da çağrı EBUSY döndürür. G/Ç komutlarının hepsi ayrıcalıklıdır; kullanıcı süreci G/Ç'yi yalnız sistem çağrısıyla yapabilir.

En üstte kullanıcı alanındaki G/Ç yazılımı durur. printf ve scanf gibi kütüphane yordamları biçimlendirme yapar ve kendi tamponlarını tutar. stdio terminale satır satır, dosyaya ise blok blok yazar. Tampon dolunca ya da satır bitince write sistem çağrısı yapılır. Böylece her printf bir sistem çağrısına dönüşmez.

11.7G/Ç arayüzleri

11.7.1Bloke eden, bloke etmeyen ve eş zamansız G/Ç

Bir uygulama G/Ç istediğinde çağrının ne zaman döneceği, programın bütün yapısını belirler. Üç model vardır.

Bloke eden model en kolay programlanandır ve çoğu programın kullandığı modeldir. Ama bir süreç aynı anda binlerce ağ bağlantısına hizmet edecekse her bağlantı için bir iş parçacığı açmak pahalıdır. Tek bir iş parçacığının birçok tanımlayıcıyı izleyebilmesi için çekirdek “hangi tanımlayıcı hazır?” sorusuna cevap veren arayüzler sunar (Tablo 11.7).

11.7.2Olay 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);
  }
}

Kod tipik bir sunucunun olay döngüsüdür. epoll_create1 çekirdekte bir epoll nesnesi oluşturur. Bu nesne iki liste tutar: izlenen tanımlayıcıların ilgi listesi ve o an hazır olanların hazır listesi. Ardından soketler bloke etmeyen kipte (O_NONBLOCK) ilgi listesine eklenir. Bu işlem bir kez yapılır; select'teki gibi her turda listenin yeniden verilmesi gerekmez.

Sonsuz döngüde epoll_wait hiçbir soket hazır değilken süreci bloke eder; CPU boşa dönmez. Diyelim ki soket 7'ye bir paket geldi. Ağ kartı kesme üretir, ağ yığını paketi işler ve fd 7'yi hazır listesine ekler; süreç uyanır ve n = 1 döner. İç döngü yalnız hazır tanımlayıcıyı işler: 512 bayt okunur ve handle çağrılır. Maliyet hazır tanımlayıcı sayısıyla orantılıdır, toplam tanımlayıcı sayısıyla değil. Bir sonraki read EAGAIN döndürürse okunacak veri kalmamıştır ve döngü yeniden epoll_wait'e gider.

Bu düzenle tek bir iş parçacığı on binlerce bağlantıyı yönetebilir. nginx, Node.js ve Redis böyle çalışır. epoll'un bir sınırı da vardır. epoll yalnız “okuyabilirsin” der; işi yine read yapar ve kopyalama sürecin zamanından gider. Disk dosyaları ise her zaman “hazır” görünür, çünkü çekirdek bir disk okumasını hiçbir zaman EAGAIN ile reddetmez; bloke ederek tamamlar. Bu yüzden disk için gerçek eş zamansızlık io_uring ile gelir.

11.7.3io_uring: paylaşılan halkalar

1. Halkalar. Uygulama ile çekirdek iki halkayı mmap ile paylaşımlı bellekte görür. İstekler ve sonuçlar kopyalanmaz.
2. Gönderim kayıtları. Uygulama üç SQE yazar: iki okuma ve bir yazma. Her kayıt işlem kodunu, dosya tanımlayıcısını, tampon adresini ve ofseti taşır.
3. Toplu gönderim. Tek bir io_uring_enter çağrısı üç isteği birden gönderir. SQPOLL kipinde bir çekirdek iş parçacığı halkayı sürekli yoklar ve hiç sistem çağrısı gerekmez.
4. Tamamlanma. Aygıtlar işleri bitirdikçe çekirdek CQE'leri halkaya ekler. Her CQE'nin sonuç alanı aktarılan bayt sayısını ya da negatif hata kodunu (−errno) taşır.
5. Toplama. Uygulama CQE'leri doğrudan bellekten okur ve halkanın başını ilerletir. Toplu gönderim ve toplu toplama sayesinde bağlam değiştirme çok azalır.

io_uring bir tamamlanma modelidir: çekirdek “işin bitti” der, Windows'taki IOCP gibi. epoll ise bir hazır olma modelidir: “artık okuyabilirsin” der. io_uring ağ, dosya, accept, zamanlayıcı dahil yüzlerce işlem türünü destekler. Karmaşık bir arayüz olduğu için çok sayıda güvenlik açığı çıkmıştır; bu yüzden Android ve bazı konteyner ortamları gibi yerlerde kapalıdır.

11.8Saatler ve diğer aygıtlar

11.8.1Saat donanımı

Saatler ne blok ne karakter aygıtıdır, ama işletim sisteminin en çok kullandığı aygıtlardandır. Zaman dilimlerini, günün saatini ve bütün zamanlayıcıları onlar yürütür.

8254 bugün yalnız uyumluluk için durur. Modern x86 işlemcilerinde TSC (zaman damgası sayacı), HPET ve her çekirdekteki yerel APIC zamanlayıcısı kullanılır. APIC zamanlayıcısının TSC-deadline kipinde işletim sistemi doğrudan “TSC şu değere ulaşınca kesme üret” der. ARM işlemcilerinde bu görevi genel zamanlayıcı (generic timer) üstlenir. Pil destekli gerçek zaman saati (RTC) ise bilgisayar kapalıyken tarihi tutar; açılışta günün saati ondan okunur.

Saat yazılımının görevleri şunlardır: günün saatini tutmak, süreçlerin zaman dilimi tükenince çizelgeleyiciyi çağırmak, CPU kullanım muhasebesi yapmak, süreçlerin istediği alarmları ve zamanlayıcıları çalıştırmak, izleme köpeği zamanlayıcılarını beslemek ve profil çıkarmak için örnek almak.

11.8.2Tik ve tiksiz çekirdek

Klasik çekirdek saati periyodik kipte kullanır. Zamanlayıcı her 1/HZ saniyede bir kesme üretir. Linux'ta HZ yapılandırma sırasında seçilir: 100, 250 ya da 1000; tik aralığı sırasıyla 10, 4 ve 1 ms'dir. Her tikte işleyici zamanı ilerletir, çalışan sürecin kalan zaman dilimini azaltır ve süresi dolan zamanlayıcıları çalıştırır.

Periyodik tikin sorunu, CPU'nun boştayken de uyanmasıdır. Her uyanma CPU'yu derin uyku durumundan çıkarır ve enerji harcar. Tiksiz çekirdek (Linux'ta NO_HZ_IDLE, 2007) CPU boşken tiki durdurur ve saati bir sonraki olayın zamanına tek atımla kurar. nohz_full seçeneği bir adım daha ileri gider. Tek bir sürecin çalıştığı çekirdekte, süreç çalışırken bile tiki kaldırır. Bu, yüksek başarımlı hesaplama ve gerçek zamanlı iş yükleri için önemlidir. Tiksiz çalışma dizüstü bilgisayarlarda pil, sanal makinelerde ise işlemci zamanı kazandırır. Mikrosaniye düzeyindeki kısa beklemeler için yumuşak zamanlayıcılar ve yoklama birlikte kullanılır. Linux'un yüksek çözünürlüklü zamanlayıcıları (hrtimer) nanosaniye çözünürlüklüdür ve kırmızı-siyah ağaçta sıralı tutulur.

11.8.3Zamanlayıcı listesi

Birçok süreç “şu kadar tik sonra bana haber ver” diye alarm kurabilir. Saat yazılımı bu alarmları her tikte hepsine bakmadan nasıl izleyebilir? Tanenbaum'un cevabı fark listesidir.

Bu düzenin üstünlüğü tik işleyicisindedir: her tikte yalnız baştaki sayaç bir azaltılır. Baştaki fark 0'a inince olay tetiklenir ve düğüm listeden çıkar. Listede kaç zamanlayıcı olursa olsun tik başına iş O(1)'dir. Bedel eklemededir: yeni zamanlayıcının yeri bulunurken liste gezilir ve bu O(n) sürer.

11.8.4Kod izleme: ekle ve tik

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 */
}

ekle yeni zamanlayıcıyı listeye t tik sonrası için ekler. p bir işaretçinin işaretçisidir: önce liste başını (&bas), sonra her adımda bir önceki düğümün sonraki alanını gösterir. Böylece başa ekleme ile araya ekleme ayrı ayrı yazılmaz. Döngü, geçilen her düğümün farkını t'den çıkarır; t artık “o düğümden sonra kaç tik” anlamına gelir. Farkı t'den büyük bir düğüme gelince döngü durur. Yeni düğüm oraya girer ve arkasındaki düğümün farkı t kadar azaltılır; böylece arkadaki düğümün mutlak zamanı değişmez. tik ise yalnız baştaki farkı azaltır ve farkı 0 olan bütün düğümleri sırayla çalıştırıp çıkarır. Aynı anda dolan iki zamanlayıcıdan ikincisinin farkı 0'dır; while döngüsü bu yüzden vardır.

11.8.5Terminaller, giriş aygıtları ve güç yönetimi

Terminaller. Unix'te terminal sürücüsü (tty) ile uygulama arasında bir satır disiplini bulunur. Kanonik kipte satır disiplini satırı düzenler: geri silme ve satır silme orada işlenir, satır ancak Enter'a basılınca uygulamaya teslim edilir. Ham kipte her tuş hemen uygulamaya gider; metin düzenleyiciler bu kipi kullanır (stty -icanon). Terminal öykünücüleri ve ssh oturumları sözde terminal (pty) kullanır. Ekran denetimi, imleci taşıyan ya da rengi değiştiren ANSI kaçış dizileriyle yapılır.

Klavye ve giriş aygıtları. Klavye karakter değil, tarama kodu gönderir: her tuşun basılması ve bırakılması ayrı bir koddur. Sürücü tuş eşlemesini kullanarak bunları karaktere çevirir. Shift tuşu bu yüzden ayrı bir olaydır. USB klavye ve fareler (HID aygıtları) kesme üretmez; ana makine onları saniyede 125–1000 kez yoklar. Linux'ta giriş olayları input alt sisteminden /dev/input/event* (evdev) dosyalarına, oradan libinput'a ve Wayland birleştiricisine, en sonda pencereye ulaşır.

Güç yönetimi. ACPI sistem için uyku durumları tanımlar: S0 çalışır durumdur (S0ix modern bekleme), S3 RAM'e askıya alma, S4 diske hazırda bekleme, S5 kapalıdır. İşlemcide iki ayrı ayar vardır. C durumları boşta ne kadar derin uyunacağını, P durumları çalışırken hangi frekans ve gerilimin kullanılacağını belirler; Linux'ta P durumlarını schedutil yöneticisi seçer. Aygıtların da D0 (açık) ile D3 (kapalı) arasında durumları vardır. Çalışma zamanı güç yönetimi, kullanılmayan aygıtı sistem çalışırken uyutur: NVMe'de APST, PCIe'de ASPM, Wi-Fi güç tasarrufu ve ekranın kararması buna örnektir. İşletim sistemi aygıtları doğru sırayla uyutup uyandırmalı ve hangi aygıtların (klavye, ağ, saat) sistemi uyandırabileceğini belirlemelidir. Bir dizüstü bilgisayarın pil ömrü, büyük ölçüde boşta geçen sürede ne kadar az güç harcandığına bağlıdır.

11.9Diskler

11.9.1Manyetik disk geometrisi

Plakalar masaüstü disklerde 5400–7200 rpm, sunucu disklerinde 10 000–15 000 rpm hızla döner. Dış izler daha uzun olduğu için dış bölgelerde iz başına daha çok sektör vardır. Buna bölgeli kayıt (zoned bit recording) denir; disk dış izlerde daha hızlı aktarım yapar.

İşletim sistemi bu geometriyi bugün görmez. Eskiden diskler silindir-kafa-sektör (CHS) üçlüsüyle adreslenirdi. Bugün işletim sistemi yalnız LBA (logical block address), yani 0'dan N − 1'e kadar numaralı bloklar görür. Disk içindeki denetleyici LBA'yı gerçek geometriye, yedek sektörlere ve kendi önbelleğine kendisi çevirir. Eski CHS arayüzünün sınırı 1024 silindir × 255 kafa × 63 sektör × 512 B ≈ 8,4 GB idi.

11.9.2Erişim süresi

Sonuç açıktır: süre neredeyse tamamen mekanik hareketlerde geçer. CPU bu 12 ms'de on milyonlarca komut çalıştırabilir; işletim sistemi beklemez, başka bir süreç çalıştırır. Aynı disk erişim düzenine göre çok farklı hızlar verir:

• Rastgele 4 KiB. Saniyede 1000 / 12,19 ≈ 82 istek (IOPS) yapılabilir. Bu, 82 × 4096 B ≈ 0,34 MB/s eder.
• Ardışık 1 MiB. Aktarım 1 048 576 / (200 × 10⁶) = 5,24 ms; toplam 8 + 4,17 + 5,24 = 17,41 ms. Hız 1 048 576 B / 17,41 ms ≈ 60 MB/s olur.

Aynı disk, büyük ardışık okumada küçük rastgele okumaya göre yaklaşık 180 kat hızlıdır. Dosya sistemlerinin blokları yakın yerleştirmeye çalışması ve disk kolu çizelgelemenin önemi bu farktan gelir. Karşılaştırma için: bir NVMe SSD'de 4 KiB rastgele okuma 50–100 µs sürer ve paralel kuyruklarla saniyede bir milyonun üzerinde istek yapılabilir.

11.9.3Biçimlendirme ve silindir eğriliği

Bir diskin kullanılabilmesi için iki düzeyde biçimlendirilmesi gerekir. Düşük düzey format fabrikada yapılır. İzler ve sektörler yüzeye yazılır; her sektöre öncül, veri alanı ve ECC konur, yedek sektörler ayrılır. Bu yüzden biçimlendirilmiş kapasite ham kapasiteden azdır. Üst düzey format ise bir bölüme boş bir dosya sistemi yazar: önyükleme bloğu, boş alan yönetimi yapıları ve kök dizin.

Eskiden yavaş denetleyiciler için bir de serpiştirme (interleaving) yapılırdı: denetleyici bir sektörü belleğe aktarırken sonraki sektör kafanın altından geçip kaçmasın diye ardışık sektörler izde aralıklı dizilirdi. Bugün denetleyici bütün izi kendi tamponuna okuduğu için serpiştirme gereksizdir.

11.9.4Optik diskler

Optik disklerde veri, manyetik diskteki eş merkezli izler yerine içten dışa uzanan tek bir sarmal iz boyunca durur. İzde çukurlar (pit) ve düzlükler (land) vardır; çukur ile düzlük arasındaki her geçiş 1 bitini, geçiş olmaması 0'ı gösterir. Basılı disklerde çukurlar polikarbonata kalıpla basılır, lazerle yakılmaz. Kaydedilebilir CD-R ve DVD-R disklerinde ise lazer organik bir boya katmanını ısıtarak yansıtıcılığını değiştirir.

Kuşaklar arasındaki kapasite artışı, Tablo 11.8'deki gibi lazer dalga boyunun kısalmasından gelir: daha kısa dalga boyu daha küçük bir noktaya odaklanır, çukurlar ve iz aralığı küçülür. CD-ROM'un kodlaması ayrıca ilginçtir. Her bayt, EFM (eight-to-fourteen modulation) ile 14 bitlik bir kanal sembolüne çevrilir. Bu bir modülasyon kodudur, hata düzeltme kodu değildir; hata düzeltme CIRC ile yapılır. 98 çerçevenin her biri 24 veri baytı taşır ve 98 × 24 = 2352 B'lık bir sektör oluşur. Mod 1'de bunun 2048 B'ı kullanıcı verisidir; geri kalanı eşzamanlama, başlık ve ek ECC/EDC alanıdır.

DVD'nin iki katmanlı türlerinde üst katman yarı saydamdır; lazer odağını değiştirerek alttaki katmanı okur. Optik ortam bugün çoğunlukla arşiv ve dağıtım için kullanılır; yoğunlukta manyetik ve flaş ortamın gerisindedir.

11.10Disk kolu çizelgeleme

11.10.1Amaç ve ölçüt

Erişim süresi örneği, bir disk isteğinin süresinin büyük kısmının arama ve dönmede geçtiğini gösterdi. Diskte aynı anda birçok istek bekliyorsa bunların hangi sırayla karşılanacağı, kolun ne kadar yol alacağını belirler.

Bu modelin bir basitleştirme olduğunu baştan söylemek gerekir. Bugün LBA'nın fiziksel konuma eşlenmesi diskin içindedir; işletim sistemi silindirleri bilmez. Disk ayrıca NCQ (native command queuing) ile 32 isteği dönme konumuna göre kendisi yeniden sıralar. İşletim sistemi bu yüzden yaklaşık olarak “LBA yakınlığı” ile çizelgeler: numaraları yakın blokların diskte de yakın olduğunu varsayar.

Algoritmaları karşılaştırmak için hepsine aynı kuyruğu vereceğiz. Silberschatz'ın klasik örneğinde silindirler 0–199 arasıdır, kafa 53'tedir ve istekler geliş sırasıyla 98, 183, 37, 122, 14, 124, 65, 67'dir (Şekil 11.38). Tablo 11.9 algoritmaların özünü önceden özetler.

11.10.2FCFS

FCFS adildir ve açlık yaratmaz: her istek, önündekiler bitince mutlaka karşılanır. Ama 122 → 14 → 124 gibi gidip gelmeler çok pahalıdır. Kol diskin bir ucundan öbürüne iki kez gidip gelir; 14 ile 124'e giden iki istek yalnız 218 silindir tüketir.

11.10.3SSTF

236, FCFS'nin 640'ının yaklaşık %37'sidir. Ama SSTF açgözlüdür ve en iyi sonucu garanti etmez. Kafa önce aşağı inseydi sıra 53 → 37 → 14 → 65 → 67 → 98 → 122 → 124 → 183 olurdu. Toplam 16 + 23 + 51 + 2 + 31 + 24 + 2 + 59 = 208 çıkar. SSTF'de üçüncü adımdaki 30 silindirlik kısa adım, sonra 84 silindirlik bir geri dönüşe yol açmıştır.

11.10.4Kod izleme: sstf()

SSTF'nin C ile yazılmış bir sürümü aşağıdadır. bitti[] dizisi hangi isteklerin karşılandığını tutar.

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;
}

Dış döngü her turda bir istek karşılar ve n tur sürer. İç döngü bekleyen isteklerin hepsine bakar; en, şu ana kadar bulunan en yakın isteğin indisidir. Koşuldaki en < 0 || parçası ilk bekleyen isteği aday yapar; sonraki istekler ancak kesin olarak daha yakınsa adayın yerini alır. Bu yüzden eşit uzaklıkta iki istek varsa geliş sırasında önce olan seçilir. Tur sonunda uzaklık top'a eklenir, kafa o isteğe taşınır ve istek bitti işaretlenir. Her turda n istek tarandığı için algoritma O(n²) zaman ve bitti[] için O(n) ek alan kullanır.

Bu kuyrukta FCFS 642 silindir harcardı; SSTF 208 ile üçte birin altına iner. k = 3 satırı SSTF'nin zayıf noktasını gösterir: aşağıdaki istekler bitince kol 66 silindirlik uzun bir yolu geri döner. Ortadaki istekler sürekli gelseydi uçtakiler bekleyebilirdi.

11.10.5SCAN (asansör)

SCAN bu kuyrukta SSTF ile aynı toplamı verir, ama açlığı önler: kafa yolundaki her isteği bir tarama içinde karşılar. Yeni gelen istekler kafanın önündeyse aynı taramada, arkasındaysa dönüşte karşılanır. Uca kadar gitmenin (14 → 0) bedeli boşa harcanan 14 silindirdir. Yön seçimi de sonucu değiştirir: aynı kuyrukta kafa yukarı yönde başlasaydı 53 → 199 (146) ve 199 → 14 (185) ile toplam 331 olurdu.

SCAN'in bir adalet kusuru vardır. Kafa bir uca varıp döndüğünde, hemen arkasındaki bölgeye yeni hizmet vermiştir; orada bekleyen istek azdır. İsteklerin en yoğun olduğu yer diskin öbür ucudur ve o istekler en uzun bekleyenlerdir. Kafa ortadaki silindirlerden her gidiş-dönüşte eşit aralıklarla iki kez geçer. Uçtaki silindirlerden ise kısa arayla iki kez geçer, ardından uzun bir boşluk gelir. Bu yüzden uçlara düşen istekler ortalamada daha uzun bekler.

11.10.6C-SCAN

Dönüş hareketi sayılmazsa toplam 382 − 199 = 183 olur. Kaynaklar bu konuda farklı davranır; bir sınav sorusunda dönüşün sayılıp sayılmadığı mutlaka belirtilmelidir. Dönüş gerçekte de hızlıdır: kol hiçbir sektörde durmadan tek hamlede geri gelir. C-SCAN'in kazancı toplam hareketten değil, adaletten gelir. Her istek, kafanın yukarı taramasında bir kez karşılanır; uçtaki ve ortadaki istekler yaklaşık eşit bekler.

11.10.7LOOK ve C-LOOK

Uygulamada “asansör” denen davranış çoğunlukla LOOK'tur; hiçbir gerçek sürücü istek yokken kolu diskin ucuna götürmez. Linux'un eski deadline ve CFQ çizelgeleyicileri ile bugünkü mq-deadline istekleri LBA'ya göre artan sırada gönderir ve en yüksek LBA'dan sonra baştan başlar. Bu, C-LOOK'a benzer bir davranıştır.

11.10.8Kod izleme: look()

LOOK'un yukarı yönde başlayan sürümü, sıralı bir dizi üzerinde iki döngüyle yazılabilir:

/* 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;
}

İlk while döngüsü kafadan büyük ya da kafaya eşit ilk isteğin indisini (i) bulur. Birinci for döngüsü i'den sona kadar yukarı yönde ilerler ve her adımın uzaklığını (s[j] - bas) toplar. İkinci for döngüsü i - 1'den 0'a kadar aşağı iner; bu kez uzaklık bas - s[j]'dir. Kafa yukarıdaki son istekten sonra uca gitmeden döndüğü için kod LOOK'tur, SCAN değildir. Fonksiyon dizi sıralı verildiğinde O(n) çalışır; sıralama O(n log n) sürer.

Aynı kuyrukta SSTF 208 yapmıştı; LOOK 314 yaptı. Fark yön seçiminden gelir. Kafa aşağı yönde başlasaydı LOOK önce 50 → 16 (34 silindir), sonra 16 → 190 (174 silindir) giderdi: 34 + 174 = 208. Yön seçimi sonucu belirler, ama yön ne olursa olsun hiçbir istek aç kalmaz.

11.10.9Algoritmaların karşılaştırması

Şekil 11.46 ortak kuyruktaki sonuçları bir arada gösterir. Toplam hareket tek başına bir algoritmayı seçmeye yetmez. SSTF ve LOOK en az hareketi verir, ama SSTF açlık yaratabilir. C-SCAN ve C-LOOK daha uzun yol alır, buna karşılık bekleme sürelerini daha eşit dağıtır. Yük hafifken bütün algoritmalar FCFS'ye benzer davranır, çünkü kuyrukta aynı anda genellikle tek istek vardır.

Disk Kolu Çizelgeleme Simülatörü, farklı istek kuyrukları ve başlangıç yönleriyle bu altı algoritmayı yan yana çalıştırır ve kafanın yolunu canlandırır.

11.10.10SPTF: dönme gecikmesini de saymak

Buraya kadarki bütün algoritmalar yalnız silindir uzaklığına baktı. Oysa bir isteğin süresini arama ve dönme birlikte belirler. Yakındaki bir sektör kafanın altından yeni geçmişse, onun için neredeyse bir tur beklemek gerekir.

SPTF konumlanma süresini en aza indirir, ama işletim sistemi sektörlerin açısal konumunu bilmez. Bu yüzden SPTF diskin içinde, NCQ ile uygulanır. SPTF de SSTF gibi açlığa açıktır. Açlığa karşı kullanılan bir yöntem F-SCAN'dir: tarama başlarken kuyruk dondurulur; tarama sırasında gelen yeni istekler bir sonraki taramayı bekler. Böylece kafanın önüne sürekli yeni istek dökülerek eski istekler geride bırakılamaz.

11.10.11Denetleyici önbelleği ve bozuk sektörler

Denetleyici önbelleği. Disk kendi DRAM'inde (yaklaşık 256 MB) bir iz önbelleği tutar. Kafanın altından geçen ve henüz istenmemiş blokları da okur; sonraki ardışık istek doğrudan önbellekten karşılanır. Bu önbellek işletim sisteminin sayfa önbelleğinden ayrıdır.

Yazma önbelleği ve NCQ. Disk bir yazmayı önbelleğine alıp hemen “tamam” diyebilir. Veri henüz plakaya ulaşmamıştır; güç kesilirse kaybolur. Kalıcılık gerektiğinde işletim sistemi FLUSH komutu ya da FUA (force unit access) bayraklı yazma kullanır. NCQ ise kuyruktaki 32 isteği dönme konumuna göre sıralar; bu, donanımın içindeki bir SPTF'dir.

Bozuk sektörler. Üretimde ya da kullanımda bozulan bir sektöre yazılan veri geri okunamaz. Denetleyici fabrikada bulunan bozuk sektörlerin listesini ve kullanımda bulduklarını izler. SMART verilerindeki “Reallocated Sectors” sayısı bu listenin büyüklüğünü gösterir. Bozuk bir sektörün iki çözümü vardır (Şekil 11.48).

1. Yedekle eşleme. Bozuk sektör izin sonundaki bir yedek sektörle eşlenir. Basittir, ama sektör 6, 7, 8'i okuyan ardışık bir istek 7 için izin sonuna gidip gelmek zorunda kalır ve bir tur daha ödeyebilir.
2. Kaydırma. Bozuk sektörden sonraki bütün sektörler bir kaydırılır. İzin tamamı yeniden yazılmalıdır, ama sıra korunur.

İşletim sistemi de bozuk blok listesi tutabilir: Linux'ta badblocks aracı ve dosya sistemlerinin bozuk blok listeleri bu amaçla vardır. Bugünkü disklerde yeniden eşleme tamamen disk içinde yapıldığı için bu liste çoğu zaman boş kalır.

11.11SSD ve NVMe

11.11.1NAND flaş

SSD'nin sabit diskten iki temel farkı vardır. Birincisi, hareketli parça olmadığı için arama ve dönme gecikmesi yoktur. Rastgele erişim ardışık erişimle hemen hemen aynı hızdadır. İkincisi, flaşta yerinde güncelleme yoktur. Bir sayfa ancak silinmiş durumdayken yazılabilir ve silme yalnız blok düzeyinde yapılır. Ayrıca her hücrenin dayanabileceği silme sayısı sınırlıdır. Bu sayıya P/E (program/erase) döngüsü denir ve bir hücrede kaç bit tutulduğuna bağlıdır (Tablo 11.12).

Hücre başına bit arttıkça hücrenin ayırt etmesi gereken gerilim düzeyi sayısı 2, 4, 8, 16 diye artar. Düzeyler sıklaştıkça okuma yavaşlar ve hücre daha çabuk yıpranır. Kapasiteyi artırmanın öteki yolu dikey yığmadır: bugünkü 3D NAND yongalarında 200–300'ün üzerinde katman bulunur. SSD ile HDD arasındaki GB başına fiyat farkı azalmıştır; yine de büyük kapasite ve arşiv için HDD hâlâ daha ucuzdur.

11.11.2FTL, çöp toplama, TRIM ve aşınma dengeleme

Yerinde güncelleme yapılamıyorsa işletim sisteminin “LBA 1'in üzerine yaz” isteği nasıl karşılanır? Cevap, SSD denetleyicisindeki bir çeviri katmanıdır.

TRIM olmasaydı SSD, silinmiş dosyanın sayfalarını hâlâ geçerli sanır ve çöp toplamada onları da boşuna kopyalardı. Yazma büyütmesi artar, hem performans hem ömür düşerdi.

Aşınma dengeleme olmasaydı sık güncellenen birkaç blok kısa sürede ömrünü doldurur, geri kalanlar ise neredeyse hiç kullanılmamış kalırdı. SSD'ler ayrıca kullanıcıya gösterilmeyen bir yedek alan (over-provisioning) ayırır. Yedek alan, çöp toplamanın her zaman boş blok bulmasını kolaylaştırır ve yazma büyütmesini azaltır.

11.11.3NVMe ve çoklu kuyruk

SATA ve onun AHCI arayüzü dönen diskler için tasarlanmıştı. Tek bir kuyruğu ve en çok 32 komutu vardır; bu sınır bir sabit disk için yeterliydi, çünkü disk zaten aynı anda tek bir isteği yerine getirir. Flaş ise kanallar ve kalıplar boyunca yüzlerce işi paralel yürütebilir. NVMe bu paralelliği açığa çıkarır: 64 K kuyruk ve kuyruk başına 64 K komut tanımlar. Her çekirdek kendi kuyruğuna yazdığı için çekirdekler arasında kilit çekişmesi olmaz; tamamlanma kesmesi de MSI-X ile aynı çekirdeğe gelir.

Birkaç terim sık karıştırılır. NVMe bir protokoldür; M.2 ise bir kart biçimidir (form faktörü). M.2 bir kart SATA da olabilir. U.2/U.3 ve E1.S/E3.S sunucularda kullanılan kablolu ya da yuvalı biçimlerdir. NVMe sürücü desteği 2013'ten beri bütün yaygın işletim sistemlerinde yerleşiktir; AHCI ile uyumsuzluk yalnız protokol düzeyindedir. NVMe disklerde gecikme 10–100 µs arasındadır; PCIe 5.0 x4 diskler yaklaşık 14 GB/s ve saniyede 2 milyonun üzerinde istek sunar. NVMe-oF aynı protokolü ağ üzerinden taşır; ZNS (bölgeli ad alanları) ise flaşın blok yapısını doğrudan yazılıma açar.

11.11.4Linux blk-mq ve G/Ç çizelgeleyicileri

Linux'un blok katmanı NVMe'nin çoklu kuyruk modelini izler. blk-mq (multi-queue block layer) her CPU'ya bir yazılım kuyruğu verir ve bunları aygıtın donanım kuyruklarına bağlar. Tek kuyruklu eski tasarımda milyonlarca IOPS'de bütün çekirdekler aynı kuyruk kilidini beklerdi; blk-mq bu çekişmeyi ortadan kaldırır. Linux 5.0'da tek kuyruklu eski blok katmanı ve onun çizelgeleyicileri (noop, deadline, CFQ) tamamen kaldırıldı. Bugünkü G/Ç çizelgeleyicileri (I/O scheduler) Tablo 11.13'te özetlenmiştir.

Bir aygıtın çizelgeleyicisi sysfs üzerinden okunur ve değiştirilir:

$ cat /sys/block/nvme0n1/queue/scheduler
[none] mq-deadline kyber bfq
$ echo bfq | sudo tee /sys/block/sda/queue/scheduler

Köşeli parantez içindeki ad etkin çizelgeleyicidir; NVMe diskte bu none'dır. İkinci komut bir SATA diskin çizelgeleyicisini bfq yapar. sudo tee kullanılır, çünkü yönlendirme (>) sudo'nun dışında, kullanıcının yetkisiyle yapılırdı.

NVMe'de neden hiç sıralama yapılmaz? Kol çizelgelemenin varlık nedeni arama süresini azaltmaktır. SSD'de arama yoktur ve erişim süresi konumdan neredeyse bağımsızdır. Çoklu donanım kuyrukları zaten her çekirdeğe paralel bir yol verir. Sıralama yalnız CPU harcar ve gecikme ekler. SSD'de çizelgeleyicinin işi sıralamak değil, gerektiğinde adaleti ve gecikme hedeflerini korumaktır; bunun için mq-deadline, bfq ya da kyber seçilebilir.

11.12RAID ve kararlı depolama

11.12.1RAID: diskleri birleştirmek

RAID fikri Patterson, Gibson ve Katz'ın 1988 tarihli makalesine dayanır. Makale, pahalı tek büyük disk (SLED, single large expensive disk) yerine ucuz disklerden bir dizi kurmayı önerdi. Açılımdaki “I” bu yüzden ilk başta inexpensive idi. Bugün “bağımsız” (independent) olarak okunur. Standart düzeyler 0–6 arasıdır. RAID bir donanım kartıyla ya da yazılımla kurulabilir: Linux'ta mdadm, ZFS'te RAID-Z, Btrfs ve Windows Depolama Alanları yazılım RAID örnekleridir.

11.12.2RAID düzenleri

• RAID 0. Ardışık şeritler farklı disklere gider. Büyük isteklerde n disk n kat bant genişliği verir. Artıklık yoktur: bir disk bozulursa dizideki her şey kaybolur.
• RAID 1. Her yazma iki kez yapılır. Okuma iki diskten birinden yapılabilir; yük diskler arasında dağıtılır. Kapasitenin yarısı artıklığa gider.
• RAID 10. Önce aynalanır, sonra şeritlenir. Yazma hızlıdır ve bozulan disk yalnız aynasından kopyalanarak hızla yeniden kurulur. Veritabanlarında yaygındır.
• RAID 2 ve 3. RAID 2 sözcük düzeyinde Hamming kodu, RAID 3 bayt düzeyinde tek bir eşlik diski kullanır. Her iki düzende de bütün kolların eş zamanlı dönmesi gerekir. Diskler zaten kendi içlerinde ECC yaptığı için bugün kullanılmazlar.
• RAID 4. Blok düzeyinde şeritleme ve ayrı bir eşlik diski. Her küçük yazma eşlik diskini de günceller; eşlik diski darboğaz olur.
• RAID 5. Eşlik blokları disklere sırayla dağıtılır ve darboğaz kalkar. n diskin n − 1'inin kapasitesi kullanılır; bir disk kaybına dayanır.
• RAID 6. İki eşlik tutar: P (XOR) ve Q (GF(2⁸) cisminde Reed–Solomon kodu). İki disk kaybına dayanır. Büyük disklerde yeniden kurma saatler sürdüğü için, bu sürede ikinci bir arıza riskine karşı tercih edilir.

11.12.3Eşlik ve XOR

Eşliğin temeli XOR (⊕) işlemidir. İki bit farklıysa XOR 1, aynıysa 0 verir. Bit dizileri üzerinde XOR, her bit konumunda ayrı ayrı uygulanır. İşlemin üç özelliği RAID'in bütün hesaplarını taşır: x ⊕ x = 0, x ⊕ 0 = x, ve işlem değişme ve birleşme özelliklidir.

Kanıt kısadır. P'nin tanımında D_k dışındaki blokları her iki yana XOR'layalım. Her D_i (i ≠ k) sağ tarafta iki kez geçer ve x ⊕ x = 0 olduğu için yok olur; geriye D_k kalır. Tek bir eşliğin yetmesinin nedeni, hangi diskin bozulduğunun bilinmesidir: disk ya hiç yanıt vermez ya da ECC hatası bildirir. Eşlik bozuk bloğu bulmaz, yalnız yerini bildiğimiz bloğu yeniden hesaplar.

Yeniden kurmanın bir riski de vardır. Tüketici sınıfı disklerde düzeltilemeyen okuma hatası (URE, unrecoverable read error) oranı yaklaşık 10¹⁴ bitte 1'dir. Bozulan diski kurmak için kalan disklerin tamamı okunmalıdır.

11.12.4Kod izleme: küçük yazma ve kurtarma

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;
}

Kodda diskler 0'dan numaralanır; P, eşlik diskinin numarasıdır (burada 3). oku ve yaz birer disk G/Ç'sidir. kucuk_yaz d diskindeki bloğu yeni ile değiştirir. Önce eski veri ve eski eşlik okunur (2 G/Ç). p ^ eski eski verinin etkisini eşlikten çıkarır, çünkü x ⊕ x = 0'dır; ^ yeni yeni değeri ekler. Sonra yeni veri ve yeni eşlik yazılır (2 G/Ç). Şeridin öteki veri diskleri hiç okunmaz. kur ise bozuk disk dışındaki bütün diskleri, eşlik dahil, XOR'layarak kaybolan bloğu hesaplar.

Kurtarılan değer özgün D2 ile aynıdır. Yeni diske her şerit için 3 okuma yapılarak yeniden kurulur ve bu süre boyunca dizi korumasızdır. Küçük yazmanın da bir zayıf noktası vardır: 4. ve 5. adımdaki iki yazma arasında sistem çökerse veri yeni, eşlik eski kalır ve şerit tutarsız olur. Buna yazma deliği (write hole) denir. Ardından bir disk bozulursa yanlış eşlikten yanlış veri hesaplanır. Donanım RAID kartları bunu pil destekli önbellekle, ZFS ise şeritleri hiçbir zaman yerinde güncellemeyerek önler.

11.12.5RAID performansı

Bir RAID düzeninin hızı, tek bir diskin iki ölçüsüyle kolayca ifade edilir. Bunlar rastgele küçük isteklerdeki hız R (IOPS) ve büyük ardışık aktarımdaki hız S (MB/s)'dir. Arpaci-Dusseau'ların modeli bu iki sayıdan yola çıkar.

Tablonun üç satırı açıklama ister. Aynada ardışık okuma neden yalnız (N/2)·S'dir? İki kopya blokları paylaşabilir: bir disk çift numaralı blokları, öteki tek numaralıları okur. Ama her disk atladığı blokların da altından dönerek geçmek zorundadır; atlanan bloklar zaman kazandırmaz. RAID 4'te küçük yazma her seferinde eşlik diskinde bir okuma ve bir yazma ister. Dizinin hızı tek diskin yarısına iner ve disk eklemek hiç işe yaramaz. RAID 5 aynı 4 G/Ç'yi bütün disklere yaydığı için küçük yazma hızı N·R/4 olur ve disk sayısıyla büyür. Tam bir şerit yazıldığında ise eski veri okunmaz; eşlik yeni verilerden hesaplanır ve hız (N − 1)·S olur.

11.12.6Kararlı depolama

RAID bozulan sektörlere ve disklere karşı korur, ama yazma sırasında bir çökme olursa ne olacağına cevap vermez. Aynalı iki diske aynı anda yazılırken güç kesilirse iki kopya da yarım kalabilir.

Düzen iki diskle ve üç işlemle kurulur. Kararlı yazma: blok önce disk 1'e yazılır, geri okunur ve doğrulanır; gerekirse n kez yeniden denenir, olmazsa yedek sektöre yazılır. Disk 1 başarıyla yazılınca aynı işlem disk 2'ye yapılır. Kararlı okuma: blok disk 1'den okunur; geçerli ECC ile okunamazsa disk 2'den okunur. Kurtarma: çökmeden sonra iki diskteki bloklar karşılaştırılır ve tutarsızlık giderilir.

Her durumda sonuç ya tamamen eski ya tamamen yenidir. Bunu sağlayan yazma sırasının sabit olmasıdır. Herhangi bir anda en az bir kopya ya tamamen eski ya tamamen yeni ve geçerlidir; kurtarma o kopyayı ötekine yayar. RAID 1 bunu tek başına sağlamaz, çünkü iki diske aynı anda yazar ve hangisinin “doğru” olduğuna dair bir sıra tutmaz.

Aynı fikir bugün başka biçimlerde yaşar. Dosya sistemleri değişiklikleri önce bir günlüğe yazar (journaling) ve ancak günlük kalıcı olunca asıl yerlerine işler. Yazma bariyerleri ve FUA, belirli yazmaların diskte kalıcı olduğundan emin olmayı sağlar. Kurumsal SSD'lerde güç kaybı koruma kapasitörleri, elektrik kesildiğinde önbellekteki veriyi flaşa yazmaya yetecek enerjiyi saklar.

11.13Özet

• İşletim sistemi aygıtla değil, aygıt denetleyicisiyle konuşur. Denetleyicinin durum, komut, veri giriş ve veri çıkış yazmaçları vardır: yazmaca yazmak komut vermek, okumak durum öğrenmektir.
• Yazmaçlara kapı eşlemeli G/Ç'de özel IN/OUT komutlarıyla, bellek eşlemeli G/Ç'de sıradan yükleme ve saklama komutlarıyla erişilir. MMIO'da yazmaç sayfası önbelleklenemez eşlenmeli, işaretçi volatile olmalıdır. Bugün PCIe aygıtları BAR'larla MMIO kullanır.
• Üç aktarım yöntemi vardır. Yoklamada CPU durum yazmacını döngüyle bekler; kesme güdümlü G/Ç'de her birim için bir kesme gelir; DMA'da CPU yalnız kurulumu ve bitiş kesmesini işler. 4096 karakterlik örnekte CPU maliyetleri 4,096 s, 8,19 ms ve yaklaşık 7 µs'dir.
• Kesme geldiğinde CPU komut sınırında durur, donanım PC ve PSW'yi kaydeder, vektör IDT'de indis olur, işleyici aygıtı onaylar ve bekleyeni uyandırır, çizelgeleyici seçer, iret ile dönülür. Modern aygıtlar kesmeyi MSI-X ile bellek yazması olarak gönderir. İşleyici üst yarı ve alt yarı olarak ikiye bölünür.
• Dağıt-topla bitişik olmayan sayfalara tek DMA işlemiyle yazar; IOMMU aygıt adreslerini çevirir ve aygıtları birbirinden yalıtır.
• G/Ç yazılımı katmanlıdır: kullanıcı kütüphanesi, aygıttan bağımsız yazılım (Linux'ta VFS, sayfa önbelleği, dosya sistemi, blok katmanı), aygıt sürücüsü ve kesme işleyicisi. Sürücüler ortak bir işlev tablosu (file_operations) sunar.
• Tamponlama hız farkını, boyut farkını ve kopya anlamını karşılar. Dairesel tampon N yuvada en çok N − 1 bayt tutar: baş = kuyruk boş, (kuyruk + 1) mod N = baş dolu demektir. Tek üretici ve tek tüketicide kilit gerekmez.
• Bloke eden çağrı veri gelene kadar dönmez; bloke etmeyen çağrı ne varsa onu ya da EAGAIN döndürür; eş zamansız çağrı işi başlatır ve sonra haber verir. epoll hazır olmayı, io_uring tamamlanmayı bildirir.
• Saat donanımı her darbede bir sayacı azaltır ve sıfırda kesme üretir. Tiksiz çekirdek boşta tiki durdurur. Bekleyen zamanlayıcılar fark listesinde tutulur: tik başına iş O(1), ekleme O(n)'dir.
• Disk erişim süresi = arama + dönme gecikmesi + aktarım. 7200 rpm, 8 ms arama ve 200 MB/s ile rastgele 4 KiB okuma 12,19 ms (≈ 82 IOPS), ardışık 1 MiB okuma 17,41 ms (≈ 60 MB/s) sürer.
• Disk kolu çizelgelemede ortak kuyruğun (kafa 53) toplam hareketleri: FCFS 640, SSTF 236, SCAN 236, C-SCAN 382 (dönüşsüz 183), LOOK 208, C-LOOK 322 (sıçramasız 153). SSTF açlık yaratabilir; tarama algoritmaları yaratmaz. SPTF dönme gecikmesini de hesaba katar ve diskin içinde NCQ ile uygulanır.
• SSD'de arama yoktur ve yerinde güncelleme yapılamaz. FTL yer dışı güncelleme, çöp toplama ve aşınma dengeleme yapar; TRIM yazma büyütmesini azaltır. NVMe çekirdek başına kuyruk sunar; Linux blk-mq bu modeli izler ve NVMe'de varsayılan çizelgeleyici none'dır.
• RAID şeritleme, aynalama ve eşlikle diskleri birleştirir. Eşlik XOR'dur; kaybolan blok kalanların XOR'udur. RAID 5'te küçük yazma 4 G/Ç, RAID 6'da 6 G/Ç ister. RAID 4'te eşlik diski darboğazdır. RAID yedek değildir.
• Kararlı depolama iki diske sırayla yazarak her çökmeden sonra ya tamamen eski ya tamamen yeni veriyi garanti eder. Bugün aynı fikri günlükleme, FUA ve güç kaybı koruması sürdürür.

11.14Kavram listesi

• veri yolu bus
• aygıt denetleyicisi device controller
• blok / karakter aygıtı block / character device
• bellek eşlemeli G/Ç memory-mapped I/O
• yoklama polling
• meşgul bekleme busy waiting
• programlanmış G/Ç programmed I/O
• kesme interrupt
• kesme vektörü interrupt vector
• kesme işleyicisi interrupt handler
• istisna exception
• tuzak trap
• boru hattı pipeline
• kesme güdümlü G/Ç interrupt-driven I/O
• doğrudan bellek erişimi (DMA) direct memory access
• aygıt sürücüsü device driver
• tampon / tamponlama buffer / buffering
• sayfa önbelleği page cache
• biriktirme spooling
• bloke eden / bloke etmeyen / eş zamansız G/Ç blocking / nonblocking / asynchronous I/O
• zamanlayıcı timer
• sabit disk (HDD) hard disk drive
• arama süresi / dönme gecikmesi seek time / rotational latency
• disk kolu çizelgeleme disk scheduling
• SSD solid-state drive
• aşınma dengeleme wear leveling
• G/Ç çizelgeleyicisi I/O scheduler
• RAID
• eşlik parity
• günlükleme journaling

11.15Kendini Dene

1. Silindirler 0–199; kafa 100'de ve yukarı yönde gidiyor. İstekler geliş sırasıyla 55, 58, 39, 18, 90, 160, 150, 38, 184. FCFS, SSTF, LOOK ve C-LOOK (sıçrama sayılsın) toplam hareketi nedir?

   Cevap

   FCFS: 45 + 3 + 19 + 21 + 72 + 70 + 10 + 112 + 146 = 498. SSTF: 90, 58, 55, 39, 38, 18, 150, 160, 184 sırasıyla 10 + 32 + 3 + 16 + 1 + 20 + 132 + 10 + 24 = 248. LOOK: 100 → 184 (84), 184 → 18 (166): 250. C-LOOK: 100 → 184 (84), sıçrama 184 → 18 (166), 18 → 90 (72): 322.

2. 5400 rpm dönen bir diskin ortalama arama süresi 10 ms, ortam hızı 100 MB/s (1 MB = 10⁶ B). 8 KiB'lık rastgele bir okuma ortalama ne kadar sürer? Disk saniyede yaklaşık kaç rastgele okuma yapabilir?

   Cevap

   Bir tur 60 000 / 5400 ≈ 11,11 ms; ortalama dönme gecikmesi 5,56 ms. Aktarım 8192 / 10⁸ s ≈ 0,08 ms. Toplam 10 + 5,56 + 0,08 ≈ 15,64 ms; saniyede 1000 / 15,64 ≈ 64 okuma.

3. N = 4 yuvalı dairesel tampon boş. Çağrılar sırayla: koy x, koy y, al, koy z, koy w, koy v, al, koy u. Hangi çağrı başarısız olur? Sonunda baş ve kuyruk nedir?

   Cevap

   x yuva 0'a, y yuva 1'e yazılır (kuyruk 2). al x'i okur (baş 1). z yuva 2'ye, w yuva 3'e yazılır; kuyruk başa sarar (0). koy v'de (0 + 1) mod 4 = 1 = baş: tampon dolu, −1 döner. al y'yi okur (baş 2). u yuva 0'a yazılır (kuyruk 1). Sonuç: baş = 2, kuyruk = 1; tamponda z, w, u vardır.

4. Fark listesi A 5, B 2, C 6. 9 tik sonra dolacak X eklenirse liste ne olur? ekle kaç düğüm geçer?

   Cevap

   A'nın farkı 5 ≤ 9 → t = 4; B'nin farkı 2 ≤ 4 → t = 2; C'nin farkı 6 > 2, döngü durur. X 2 farkıyla C'den önce girer, C'nin farkı 6 − 2 = 4 olur. Liste A 5, B 2, X 2, C 4. İki düğüm geçilir. C'nin mutlak zamanı 13 tik sonrası olarak kalır.

5. RAID 5 şeridinde D0 = 0110 1101, D2 = 1001 0011, P = 1010 0110. D1'in diski bozuldu. D1 nedir?

   Cevap

   D1 = D0 ⊕ D2 ⊕ P. D0 ⊕ D2 = 1111 1110; ⊕ P = 0101 1000. D1 = 0101 1000.

6. Bir ağ kartı 2000 paketlik bir patlama alıyor. Kesme güdümlü yöntemde her paket için 3 µs'lik bir kesme, DMA'lı halkada ise 10 µs kurulum ve patlama sonunda tek bir 3 µs'lik kesme gerekiyor. CPU maliyetleri nedir? Tek paketlik trafikte hangisi daha ucuzdur?

   Cevap

   Kesme güdümlü: 2000 × 3 = 6000 µs = 6 ms. DMA: 10 + 3 = 13 µs; yaklaşık 460 kat az. Tek pakette kesme güdümlü 3 µs, DMA 13 µs harcar: sabit kurulum maliyeti küçük aktarımda kendini geri ödemez.

7. Bir program diskteki bir dosyayı epoll ile izleyip “hazır” olduğunda okumak istiyor. Bu neden eş zamansız okuma sağlamaz? Hangi arayüz sağlar?

   Cevap

   epoll yalnız hazır olmayı bildirir. Disk dosyaları her zaman hazır görünür, çünkü çekirdek bir disk okumasını EAGAIN ile reddetmez, bloke ederek tamamlar. Okuma yine read içinde beklenir. İşi başlatıp tamamlanmayı sonra bildiren io_uring (ya da Windows'ta IOCP) gerçek eş zamansızlık sağlar.

8. Bir SSD'de dosya sistemi TRIM göndermiyor. Kullanıcı büyük bir dosyayı sildikten sonra disk yeniden doldukça neden yavaşlar ve neden daha çabuk yıpranır?

   Cevap

   SSD silinen dosyanın sayfalarını hâlâ geçerli sanır. Çöp toplama bir bloğu temizlerken bu sayfaları da başka bloğa kopyalar. Kopyalanan her sayfa ek bir yazmadır: yazma büyütmesi artar, yazmalar çöp toplamayı bekler ve hücreler gereksiz yere silinip yazılır.

9. Bir sürücü durum yazmacını int *durum işaretçisiyle okuyan bir bekleme döngüsü içeriyor. Optimizasyon açılınca döngü hiç bitmiyor. Neden? İki düzeltme nedir?

   Cevap

   Derleyici *durum'un döngüde değişmediğini varsayar ve okumayı bir kez yapar. İşaretçi volatile int * yapılmalıdır. Ayrıca yazmaç sayfası önbelleklenemez eşlenmelidir (Linux'ta ioremap); yoksa CPU önbellekteki eski değeri okur.

10. Kararlı depolamada iki kopyanın ikisi de geçerli ECC veriyor ama değerleri farklı. Kurtarma ne yapar? Bu durum hangi anda çökme olduğunu gösterir?

    Cevap

    Disk 1 kazanır; değeri disk 2'ye kopyalanır ve yazma tamamlanır. Bu durum, disk 1'e yazmanın bitip doğrulandığını, disk 2'ye yazmanın ise henüz başlamadığını gösterir. Disk 2'ye yazarken çökülseydi disk 2'deki blok ECC hatası verirdi.

11.16İleri okuma

• R. H. Arpaci-Dusseau ve A. C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces, “I/O Devices”, “Hard Disk Drives”, “Redundant Arrays of Inexpensive Disks” ve “Flash-based SSDs” bölümleri: disk zamanlamasını, RAID başarım modelini ve FTL'yi kısa ve hesaplı anlatır; ostep.org'da ücretsizdir.
• D. A. Patterson, G. Gibson ve R. H. Katz, “A Case for Redundant Arrays of Inexpensive Disks (RAID)”, SIGMOD 1988: RAID düzeylerini ilk kez tanımlayan, bugün de okunabilir kısa makaledir.
• J. Axboe, “Efficient IO with io_uring” (kernel.dk): io_uring'in tasarımcısının arayüzü, halkaları ve SQPOLL kipini anlattığı belgedir.
• J. Corbet, A. Rubini ve G. Kroah-Hartman, Linux Device Drivers, 3. baskı, O'Reilly, 2005: karakter sürücüleri, kesme işleme ve DMA üzerine örnekli klasik kaynaktır; çekirdek arayüzlerinin bir kısmı eskimiştir ama kavramlar geçerlidir.

11.17Kaynaklar

1. 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.
2. A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı (2014) / 5. baskı (2023), Pearson — Bölüm 5: Input/Output.
3. 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”.
4. D. A. Patterson, G. Gibson, R. H. Katz, “A Case for Redundant Arrays of Inexpensive Disks (RAID)”, SIGMOD 1988.
5. NVM Express Base Specification 2.x; PCI-SIG PCIe 5.0/6.0; USB4 Specification; UEFI Specification (GPT).
6. 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”); J. Corbet, A. Rubini, G. Kroah-Hartman, Linux Device Drivers, 3. baskı.