
Linux io_uring ve epoll: Asenkron G/Ç Mimarisi ve Performans
Linux sistem çağrısı ek yükü, submission ve completion halkaları, kayıtlı tamponlar ve modern yüksek eşzamanlı sunucularda sıfır kopyalama mimarisi.
Modern Linux sunucularında ağ ve depolama donanımları saniyede yüz binlerce hatta milyonlarca girdi/çıktı (G/Ç) işlemini kaldırabilecek düzeye ulaşmıştır. 100 GbE ağ kartları ve mikro-saniye altında erişim sunan NVMe sürücüler, donanım darboğazını işletim sistemi çekirdeğinin yazılım katmanına taşımıştır. Uzun süredir yüksek eşzamanlı ağ mimarilerinin omurgasını oluşturan epoll mekanizması, bu yeni donanım hızlarında sistem çağrısı ek yükü ve mimari kısıtları nedeniyle sınırlarına çarpmaktadır.
Jens Axboe tarafından tasarlanan ve Linux 5.1 ile ana hat çekirdeğe dahil edilen io_uring alt sistemi, Linux tarafında asenkron G/Ç mimarisini kökten değiştiren bir yaklaşım sunmaktadır. Bu yazıda epoll mekanizmasının yapısal sınırlarını ve io_uring'in paylaşımlı halka kuyrukları üzerindeki çalışma prensiplerini inceliyoruz.
1. Linux G/Ç Evrimi ve Sistem Çağrısı Maliyeti
Linux çekirdeğinde çoklu G/Ç izleme süreci select ve poll ile başlamıştır. Bu eski arayüzler, her çağrıda kullanıcı alanındaki dosya tanıtıcı listesinin tamamını çekirdeğe kopyalayıp doğrusal olarak O(N) karmaşıklıkla taradığı için bağlantı sayısı arttıkça tıkanıyordu. 2002 yılında Linux 2.5.44 ile tanıtılan epoll, dosya tanıtıcılarını çekirdek belleğinde bir kırmızı-siyah ağaç (red-black tree) içinde tutarak ve olay bildirimlerini O(1) karmaşıklıkta hazır listesine bağlayarak C10K problemini çözdü.
Ancak epoll mekanizmasının çözemediği temel bir maliyet vardır: Sistem çağrısı (syscall) geçişi.
Kullanıcı alanından (user space) çekirdek alanına (kernel space) geçmek donanım düzeyinde CPU kip değişimi, kayıtların saklanması ve çekirdek yığınına geçilmesini gerektirir. Üstelik işlemci güvenlik açıkları (Spectre ve Meltdown) sonrası çekirdeğe eklenen KPTI (Kernel Page Table Isolation) mekanizması nedeniyle her sistem çağrısında sayfa tablolarının değiştirilmesi ek bir CPU maliyeti getirmiştir. Milyonlarca küçük paketin veya disk bloğunun işlendiği modern sunucularda CPU döngülerinin önemli bir bölümü iş mantığına değil, salt bu bağlam geçişlerine harcanır.
2. epoll Modelinin Yapısal Kısıtları
epoll mekanizmasının modern yüksek verimli sistemlerde karşılaştığı üç temel kısıt bulunmaktadır:
Hazır Olma (Readiness) ve Tamamlanma (Completion) Ayrımı
epoll bir hazır olma (readiness) modelidir. epoll_wait çağrısı uygulamaya bir soketin okunmaya veya yazılmaya hazır olduğunu söyler fakat veriyi taşımaz.
Tipik bir HTTP isteği döngüsünde şu adımlar gerçekleşir:
- Uygulama epoll_wait çağırır (1 sistem çağrısı, bağlam geçişi).
- Çekirdek soketin okunabilir olduğunu bildirir.
- Uygulama veriyi kullanıcı alanına almak için read veya recv çağırır (2. sistem çağrısı, bağlam geçişi ve çekirdek tamponundan bellek kopyalama).
- Uygulama cevabı hazırladıktan sonra sokete yazmak için write veya send çağırır (3. sistem çağrısı).
- Soket tamponu doluysa uygulama tekrar epoll_ctl ile soketi yazma izlemesine alır.
Tek bir G/Ç işlemi için en az 2 veya 3 ayrı sistem çağrısı yapılması gerekir.
Çekirdek Kilit Çekişmeleri
Çok çekirdekli sistemlerde birden fazla iş parçacığı aynı epoll dosya tanıtıcısını paylaştığında ya da soket olaylarını dinlediğinde, çekirdek içindeki ep->lock spinlock mekanizması ve bekleme kuyruğu kilitleri üzerinde çekişme yaşanır. Olaylar hazır listesine eklenip çıkarılırken çekirdek kilitleri CPU önbellek satırlarının çekirdekler arasında sürekli geçiş yapmasına (cache bouncing) neden olur.
Düzenli Disk Dosyalarında Asenkron Destek Eksikliği
epoll yalnızca soketler, borular (pipes) ve eventfd gibi hazır olma durumu bildirebilen dosya tanıtıcılarıyla çalışır. Linux VFS katmanında düzenli disk dosyaları yapısal olarak hazır kabul edilir. Bir dosya tanıtıcısı epoll kümesine eklense bile epoll_wait dosya için hemen döner. Ancak uygulamanın yapacağı read çağrısı sayfa önbelleğinde (page cache) veriyi bulamazsa doğrudan disk denetleyicisine gider ve çağıran iş parçacığını bloklar. Bu nedenle epoll tabanlı ağ sunucuları dosya işlemlerini ayrı iş parçacığı havuzlarına devretmek zorunda kalır.
3. io_uring Mimarisi: Paylaşımlı Halka Kuyrukları
io_uring, hazır olma modeli yerine tamamlanma (completion) modelini benimser. Uygulama çekirdeğe bir işlemin yapılmasını söyler (örneğin "şu soketten 4 KB oku ve şu tampona yaz"). Çekirdek işlemi arka planda yürütür ve tamamlandığında sonucu bildirir.
Bu modelin merkezinde bellek haritalama (mmap) ile hem kullanıcı alanına hem de çekirdek alanına açılan iki dairesel halka kuyruğu (ring buffer) yer alır:
- Submission Queue (SQ): Uygulamanın isteklerini yazdığı, çekirdeğin ise bu istekleri tükettiği halka kuyruğudur. Kuyruktaki her eleman 64 baytlık io_uring_sqe (submission queue entry) yapısıdır.
- Completion Queue (CQ): Çekirdeğin tamamlanan G/Ç sonuçlarını yazdığı, uygulamanın ise okuduğu halka kuyruğudur. Kuyruktaki her eleman 16 baytlık io_uring_cqe (completion queue entry) yapısıdır.
io_uring Paylaşımlı Halka Kuyruğu Mimarisi:
+-------------------------------------------------------------------+
| KULLANICI ALANI (USER SPACE) |
+-------------------------------------------------------------------+
│ ▲
│ SQE Yazar (tail++) │ CQE Okur (head++)
▼ │
+──────────────────────────────+ +───────────────────────────────+
| Submission Queue (SQ) | | Completion Queue (CQ) |
| [SQE-0] [SQE-1] [SQE-2]... | | [CQE-0] [CQE-1] [CQE-2]... |
| head (Kernel Okur) | | head (User Okur) |
| tail (User Yazar) | | tail (Kernel Yazar) |
+──────────────────────────────+ +───────────────────────────────+
│ ▲
==========│============== mmap PAYLAŞIMLI BELLEK ========│==========
▼ │
+───────────────────────────────────────────────────────────────────+
| ÇEKİRDEK ALANI (KERNEL SPACE) |
| |
| io_uring Motoru (İstekleri İşler ve Tamamlar) |
| ├── Blok Katmanı (NVMe / SSD Asenkron İstekler) |
| └── Ağ Katmanı (TCP Soketleri / DMA Aktarımları) |
+───────────────────────────────────────────────────────────────────+
Kilit Gerektirmeyen (Lock-Free) Eşzamanlılık
Halka kuyrukları üzerinde baş (head) ve kuyruk (tail) işaretçileri bulunur:
- SQ halkasında tail kullanıcının kontrolündedir, head çekirdeğin kontrolündedir.
- CQ halkasında tail çekirdeğin kontrolündedir, head kullanıcının kontrolündedir.
Kullanıcı ve çekirdek ortak bir işaretçi üzerinde yarış durumuna girmez. Bu ayrım sayesinde işaretçi güncellemeleri kilit gerektirmeyen atomik bellek işlemleri ve bellek bariyerleri ile yönetilir.
Standart modda uygulama birden fazla SQE girdisini SQ halkasına yazar ve ardından tek bir io_uring_enter sistem çağrısı yaparak çekirdeğe kuyruktaki N adet isteği işlemesini söyler. Tek bir sistem çağrısı ile onlarca hatta yüzlerce G/Ç işlemi toplu olarak başlatılabilir.
4. Sistem Çağrısı Maliyetini Düşüren İleri Modlar
io_uring mimarisi sistem çağrısı yükünü azaltmakla kalmaz, belirli çalışma modlarında bu geçişleri en aza indirir.
Çekirdek İş Parçacığı Yoklama Modu (IORING_SETUP_SQPOLL)
io_uring_setup sırasında IORING_SETUP_SQPOLL bayrağı verildiğinde, çekirdek arka planda özel bir çekirdek iş parçacığı (io_uring-sq) başlatır:
- Kullanıcı uygulaması SQ halkasına yeni bir io_uring_sqe ekler ve atomik olarak tail işaretçisini günceller.
- Çekirdek iş parçacığı bu kuyruğu sürekli tarar ve yeni isteği yakalayıp işleme alır.
- Uygulama hiçbir io_uring_enter sistem çağrısı yapmaz. G/Ç gönderim yolundaki sistem çağrısı sayısı en aza iner.
Bu modun operasyonel kuralı sq_thread_idle parametresidir. Eğer kuyruğa yapılandırılan süre boyunca yeni istek gelmezse çekirdek iş parçacığı uyku moduna geçer. İş parçacığı uykuya daldığında uygulama bir sonraki istek için tek seferlik io_uring_enter çağırarak iş parçacığını yeniden uyandırır.
Kayıtlı Tamponlar (IORING_REGISTER_BUFFERS)
Geleneksel bir read veya write çağrısında çekirdek şu adımları işletir:
- Kullanıcı alanından gelen bellek adresini doğrular.
- get_user_pages fonksiyonunu çağırarak sanal bellek sayfalarını fiziksel RAM sayfalarıyla eşler ve sayfaların disk takas alanına atılmasını engellemek için sayfaları sabitler.
- G/Ç işlemi bittiğinde sayfaların sabitlemesini kaldırır.
Yüksek IOPS seviyelerinde her istekte sayfa sabitlemek belirgin bir CPU ek yüküdür. io_uring IORING_REGISTER_BUFFERS sistem çağrısı ile uygulamanın kullanacağı bellek tamponlarının önceden bir defa çekirdeğe kaydedilmesini sağlar. Çekirdek fiziksel sayfaları baştan sabitler. Sonraki G/Ç isteklerinde bellek eşleme ve sabitleme adımları atlanır.
Kayıtlı Dosya Tanıtıcıları (IORING_REGISTER_FILES)
Normal şartlarda her dosya tanıtıcısı işleminde çekirdek dosya tablosuna erişir ve dosyanın kapatılmadığından emin olmak için atomik fget ve fput referans sayaçlarını günceller. IORING_REGISTER_FILES ile dosya tanıtıcıları çekirdeğe bir dizi olarak kaydedilir. io_uring doğrudan bu dizideki sabit indeks üzerinden dosyaya erişir ve atomik referans sayacı çekişmesini önler.
Bellek Kopyalamasız Ağ İletimi: IORING_OP_SEND_ZC
Linux 6.0 ile birlikte io_uring ağına bellek kopyalamasız iletim (zero-copy send) yeteneği olarak IORING_OP_SEND_ZC eklenmiştir.
Geleneksel ağ gönderiminde kullanıcı belleğindeki veri çekirdeğin soket ara belleğine kopyalanır ve oradan ağ kartına DMA ile iletilir. Bellek kopyalama işlemi özellikle büyük paketlerde CPU önbelleklerini kirletir ve bellek bant genişliğini tüketir.
IORING_OP_SEND_ZC mekanizmasında:
- Kullanıcı belleğindeki veri çekirdek tamponuna kopyalanmaz.
- Ağ kartı doğrudan kullanıcı belleğindeki sayfalardan veriyi DMA ile okur.
- Çekirdek, ağ kartı veriyi göndermeyi tamamlayana kadar kullanıcı sayfalarının serbest bırakılmasını engeller.
- Aktarım bittiğinde çekirdek CQ halkasına bildirim bırakır ve uygulama tamponu yeniden kullanabileceğini anlar.
Bu mekanizma CPU kopyalama maliyetini düşürür fakat küçük paketlerde (örneğin 1 KB altı) sayfa yönetim maliyeti kopyalama maliyetinden yüksek olabileceği için genellikle 4 KB ve üzeri paket boyutlarında net kazanç sağlar.
5. Ölçüm ve Yöntem Bağlamı: Performans Karakteristiği
Farklı G/Ç mimarilerinin davranışını anlamak için test koşullarının ve donanım sınırlarının net tanımlanması gerekir.
Linux çekirdek belgelerinde ve Jens Axboe'nun ölçümlerinde belirtildiği üzere, tek bir NVMe aygıtı üzerinde doğrudan G/Ç (O_DIRECT) ile 512 bayt ve 4 KB rastgele okuma testlerinde:
- Standart senkron read çağrısı CPU bağlam geçişleri nedeniyle çekirdek başına sınırlı IOPS üretir.
- io_uring standart toplu modda (batching) tek sistem çağrısıyla birden fazla isteği göndererek sistem çağrısı ek yükünü amorti eder.
- IORING_SETUP_SQPOLL modu devreye girdiğinde ve çekirdek iş parçacığı özel bir CPU çekirdeğine bağlandığında (CPU affinity), sistem çağrısı geçişi tamamen aradan çıktığı için donanım sınırlarına yaklaşan IOPS değerlerine ulaşılır.
Buna karşılık küçük paketli (64 bayt - 256 bayt) ağ iş yüklerinde epoll ile io_uring arasındaki fark, disk G/Ç senaryolarındaki kadar dramatik değildir. Çünkü ağ yığınında paket işleme ve kilit protokolleri CPU zamanının büyük kısmını almaya devam eder.
6. epoll ve io_uring Karşılaştırma Matrisi
İki alt sistemin yapısal özellikleri şu tabloda özetlenmiştir:
| Özellik | epoll | io_uring |
|---|---|---|
| G/Ç Paradigması | Hazır olma (Readiness) | Tamamlanma (Completion) |
| G/Ç Başına Sistem Çağrısı | En az 2 (epoll_wait + read/write) | Toplu modda paylaştırılmış, SQPOLL ile 0 |
| Düzenli Dosya Desteği | Yok (bloklar, iş parçacığı havuzu gerekir) | Tam asenkron (NVMe, sayfa önbelleği, doğrudan G/Ç) |
| Çekirdek Bellek Paylaşımı | Yok (olaylar kopyalanır) | mmap tabanlı dairesel halka kuyrukları |
| Tampon Sabitleme | Yok (her çağrıda get_user_pages) | IORING_REGISTER_BUFFERS ile önceden sabitleme |
| Ağ Kopyalama Modeli | Soket tamponuna kopyalama | IORING_OP_SEND_ZC ile doğrudan DMA aktarımı |
| Boşta CPU Tüketimi | Düşük (epoll_wait uyur) | Standart modda düşük, SQPOLL modunda 1 çekirdek meşgul |
| Olgunluk ve Güvenlik | 20 yılı aşkın kararlılık, dar saldırı yüzeyi | Yeni çekirdek mimarisi, geçmişte seccomp kısıtlamaları |
7. Mimari Karar Kriterleri
Yeni bir sistem tasarlanırken epoll ile io_uring arasında seçim yaparken şu kriterler dikkate alınmalıdır:
-
epoll Tercih Edilmesi Gereken Senaryolar:
- Ağ gecikmesinin baskın olduğu ve CPU'nun sistem çağrısı sınırına takılmadığı standart web servisleri.
- Düşük kaynaklı ortamlar ve CPU tüketiminin her an asgari düzeyde tutulması gereken mikro servisler.
- Geniş dağıtım desteği gereken ve eski Linux çekirdeklerinde (5.1 öncesi) çalışması zorunlu uygulamalar.
- Konteyner ortamlarında io_uring sistem çağrılarının varsayılan seccomp profilleriyle engellendiği güvenli platformlar.
-
io_uring Tercih Edilmesi Gereken Senaryolar:
- Hem disk hem ağ işlemlerini tek bir asenkron olay döngüsünde birleştiren yüksek verimli depolama motorları.
- NVMe sürücüler üzerinde doğrudan G/Ç (O_DIRECT) çalıştıran veritabanı motorları.
- 10 GbE ve 100 GbE üzerinde çalışan yüksek eşzamanlı vekil sunucuları ve ağ yönlendiricileri.
- İş parçacığı bağlam geçişlerinin p99 gecikmesini bozduğu gecikmeye duyarlı sistemler.
8. Operasyonel ve Güvenlik Tavsiyeleri
Üretim ortamında io_uring devreye alınırken şu teknik detaylar göz önünde bulundurulmalıdır:
- Çekirdek Sürümü Seçimi: io_uring erken sürümlerinde (5.1 - 5.10) çeşitli hata düzeltmelerinden geçmiştir. Üretim sistemlerinde en az Linux 6.1 LTS veya Linux 6.6 LTS sürümleri tercih edilmelidir.
- Yetki Kısıtları: IORING_SETUP_SQPOLL modu geçmişte root yetkisi gerektiriyordu. Linux 5.11 sonrasında bu mod CAP_SYS_NICE yetkisiyle de çalışabilmektedir.
- Kütüphane Katmanı: io_uring doğrudan ham sistem çağrılarıyla değil, Jens Axboe tarafından geliştirilen resmi liburing kütüphanesi üzerinden kullanılmalıdır. liburing bellek bariyerlerini, doğru işaretçi aritmetiğini ve çekirdek sürüm farklılıklarını kullanıcı adına yönetir.
- Güvenlik İzolasyonu: io_uring geçmişte çekirdek ayrıcalık yükseltme açıklarına konu olmuştur. Bu nedenle çok kiracılı ortamlarda konteyner profillerinin io_uring_setup, io_uring_enter ve io_uring_register çağrılarına erişimi sıkı denetlenmelidir.
Yazıyı Değerlendir
0 tepkiFikirlerinizi tek tıkla paylaşarak geri bildirim bırakın.
Ali Purtaş
@alipurtas • Hey, This is Ali!
Kendi halinde yazılım geliştiren bir öğrenci. Sistemler kuruyor, deniyor, bozuyor ve öğrendiği gerçek çözümleri burada belgeliyor.
Konu Kümesi & Önerilen Yazılar
copy_file_range ile Blok Katmanında Reflink Tabanlı Dosya Klonlama
copy_file_range sistem çağrısı, Btrfs ve XFS reflink mekanizması, blok seviyesinde anlık dosya klonlama ve gigabaytlarca veriyi kopyalamadan çoğaltma rehberi.
Linux sendfile ve splice Çağrılarıyla Çekirdek İçi Veri Aktarımı
Geleneksel G/Ç kopyalama maliyetleri, sendfile ve splice sistem çağrıları, boru tamponları üzerinden kullanıcı alanına inmeden sokete veri aktarma mimarisi.
Bellek Bariyerleri: x86 TSO ile ARM Zayıf Bellek Düzeni Farkları
x86 TSO modeli ile ARM gevşek bellek mimarisi karşılaştırması, hafıza bariyeri komutları ve lock-free kodların Graviton işlemcilerde çökme nedenleri analizi.
Tartışma & Yorumlar
0Tartışmaya katılmak ve soru sormak için oturum açmalısınız.
Giriş Yap