IAli
Tüm Yazılar
Linux 6.6 EEVDF Zamanlayıcısı: Lag Kavramı ve Sanal Bitiş Seçimi

Linux 6.6 EEVDF Zamanlayıcısı: Lag Kavramı ve Sanal Bitiş Seçimi

Linux 6.6 ile CFS yerine gelen EEVDF zamanlayıcısı, lag metriği, sanal bitiş süresi seçimi ve ses veya oyun gecikmelerini düşürme mekanizmasının analizi.

Linux 6.6 sürümüyle birlikte çekirdek dünyasında son 16 yılın en büyük zamanlayıcı devrimi gerçekleşti. Linux 2.6.23'ten beri çekirdeğin kalbinde yer alan Completely Fair Scheduler (CFS), çekirdek geliştiricisi Peter Zijlstra'nın sunduğu yamalarla yerini Earliest Eligible Virtual Deadline First (EEVDF) algoritmasına bıraktı.

Linux Kernel Mailing List (LKML) tartışmalarında ve r/kernel forumlarında aylarca konuşulan bu değişimin temel motivasyonu, CFS'in modern çok çekirdekli sistemlerde ses duraksamaları (audio buffer underrun), oyun kare gecikmeleri (frame pacing jitter) ve interaktif iş yüklerinde yarattığı yapısal gecikmelerdi. Bu yazıda Peter Hoon Stoica'nın 1995 tarihli akademik makalesine dayanan EEVDF mimarisini, "lag" (gecikme/avans) kavramını ve Linux CFS Zamanlayıcı modelinden temel farklarını inceliyoruz.

TEXT
EEVDF İki Aşamalı Karar Mekanizması:

Tüm Çalışmaya Hazır Görevler
            │
            ▼
┌───────────────────────────────────────────────────────────────┐
│ 1. AŞAMA: UYGUNLUK FİLTRESİ (ELIGIBILITY FILTER)              │
│ Kural: lag_i >= 0 (vruntime_i <= V)                           │
│ Hak ettiğinden az CPU kullanan süreçler belirlenir            │
└───────────────────────────────┬───────────────────────────────┘
                                │ Uygun Görevler Kümesi (Eligible)
                                ▼
┌───────────────────────────────────────────────────────────────┐
│ 2. AŞAMA: EN ERKEN TERMİN SEÇİMİ (EARLIEST DEADLINE)          │
│ Kural: min(deadline_i)                                        │
│ d_i = e_i + (q_i / w_i)                                       │
│ Sanal bitiş süresi en erken olan süreç CPU'ya atanır          │
└───────────────────────────────────────────────────────────────┘

1. CFS Neden Yetmedi? Verim (Throughput) vs Gecikme (Latency)

CFS, adaleti sağlamak için tek bir metrik kullanıyordu: vruntime.

Ancak bilgisayar dünyasında iki zıt gereksinim çatışır:

  1. Verim Odaklı İş Yükleri (Batch / Throughput): Video işleme veya veritabanı sorguları büyük zaman dilimlerinde uzun süre kesintisiz çalışmak ister. Sık sık CPU'dan indirilmek önbellek kaybı ve bağlam değişimi maliyeti yaratır.
  2. Gecikme Odaklı İş Yükleri (Latency-Sensitive): Ses sunucusu (PipeWire, JACK), oyun döngüsü veya kullanıcı arayüzü yalnızca 0.2 milisaniye CPU kullanmak ister, ancak ihtiyaç duyduğu anda GECİKMEDEN hemen CPU almalıdır.

CFS bu iki iş yükünü tek bir nice değeriyle dengelemeye çalışıyordu. Bir ses sürecinin nice değerini -20 yapsanız bile, eğer arkada uzun süredir uyuyan bir hesaplama süreci aniden uyanırsa, CFS her iki sürecin vruntime farkını kapatmak için interaktif süreci kuyrukta bekleterek ses kartının tamponunun boşalmasına (audio glitch) neden olabiliyordu.

EEVDF'in getirdiği temel yenilik, "Bir sürecin ne kadar CPU alacağı" (verim/ağırlık) ile "Bu CPU'yu ne kadar acil alacağı" (gecikme/deadline) kavramlarını birbirinden tamamen ayırmasıdır.

2. Temel Kavram: Lag (Sanal Avans ve Borç)

EEVDF'in matematiksel temelinde "lag" (gecikme veya sapma) kavramı yer alır.

Sistemde $V$ ortalama sanal zamanı temsil ederken, bir $i$ sürecinin anlık sanal çalışma süresi $vruntime_i$ olsun. Lag şu şekilde tanımlanır:

$$\text{lag}_i = V - \text{vruntime}_i$$

Lag değerinin işareti sürecin adalet terazisindeki konumunu gösterir:

  • $\text{lag}_i > 0$: Süreç hak ettiğinden daha az CPU kullanmıştır (alacaklıdır).
  • $\text{lag}_i < 0$: Süreç hakkından fazlasını tüketmiştir (sisteme borçludur).
  • $\text{lag}_i = 0$: Süreç tam olarak adil payını almıştır.

Bir sürecin CPU'ya seçilebilmesi için birinci kural, sürecin uygun (eligible) olmasıdır. Bir süreç ancak $\text{lag}_i \ge 0$ ise (yani sisteme borçlu değilse) CPU yarışına katılabilir. Borçlu süreçler sistemin sanal zamanı $V$ ilerleyip onları yakalayana kadar bekletilir.

3. Sanal Bitiş Süresi (Virtual Deadline) Hesabı

Uygunluk filtresinden geçen süreçler arasından hangisinin CPU'ya atanacağına sanal bitiş süresi (virtual deadline - $d_i$) karar verir.

Bir sürecin sanal bitiş süresi şu formülle hesaplanır:

$$d_i = e_i + \frac{q_i}{w_i}$$

Burada:

  • $e_i$: Sürecin çalışmaya uygun hale geldiği sanal an (eligible time).
  • $q_i$: Sürecin talep ettiği zaman dilimi (time slice / quantum).
  • $w_i$: Sürecin nice önceliğinden gelen ağırlığı.

Bu formülün mühendislik anlamı şudur: Küçük bir dilim ($q_i$) talep eden gecikme duyarlı bir sürecin bitiş süresi ($d_i$) çok daha küçük çıkar. EEVDF çalışma kuyruğundaki uygun süreçler arasından en küçük $d_i$ değerine sahip olanı seçer.

Böylece 0.5 milisaniyelik küçük bir ses paketi işlemek isteyen süreç, kuyrukta 10 milisaniyelik devasa dilimler talep eden derleme süreçlerinin önüne doğrudan geçer.

4. LKML Tartışmaları ve Eski CFS Yamalarının Kaldırılması

Peter Zijlstra EEVDF yama setini sunduğunda çekirdek kod tabanından binlerce satırlık karmaşık sezgisel mantık temizlendi:

  1. Latency Sensitivity Heuristics Çöpe Atıldı: CFS'te sonradan eklenen latency_prio ve karmaşık uyku tahmin edicileri tamamen kaldırıldı.
  2. Kırmızı-Siyah Ağaç İkili Yapıya Geçti: EEVDF iki kriter izler: Süreçlerin uygunluğu (vruntime) ve termin süreleri (deadline). Çekirdek augmented red-black tree kullanarak en erken deadline değerine sahip uygun süreci logaritmik zamanda bulur.

Ses ve Oyun Performansındaki Pratik Etki

CS:GO / Counter-Strike 2 ve Cyberpunk 2077 gibi oyunlarda Linux altında yaşanan mikro takılmalar (stuttering) çoğunlukla arka plan I/O işlemlerinin uyandığı anda oyunun ana render thread'ini birkaç milisaniye geciktirmesinden kaynaklanıyordu. EEVDF ile birlikte render iş parçacığı küçük zaman dilimleri istediği için anında CPU alır, kare üretim süresi (frametime) grafiği düzleşir.

5. EEVDF Ayarları ve sched_setattr Arayüzü

Linux 6.6+ çekirdeklerinde bir sürecin zaman dilimini (slice) özelleştirmek için sched_setattr sistem çağrısı veya kullanıcı aracı olan chrt kullanılır.

Sistem genelindeki temel zaman dilimini görmek ve değiştirmek için:

Bash
# Temel zaman dilimini kontrol et (varsayılan genelde 3000000 ns = 3 ms)
cat /sys/kernel/debug/sched/base_slice_ns

Belirli bir uygulamanın (örneğin PipeWire ses sunucusunun) gecikme duyarlılığını artırmak için sched_slice süresini düşürmek mümkündür:

C
#include <sched.h>
#include <sys/syscall.h>
#include <unistd.h>

struct sched_attr {
    uint32_t size;
    uint32_t sched_policy;
    uint64_t sched_flags;
    int32_t  sched_nice;
    uint32_t sched_priority;
    uint64_t sched_runtime;
    uint64_t sched_deadline;
    uint64_t sched_period;
};

/* Gecikme duyarlı iş parçacığı dilimini 1 ms seviyesine ayarla */

Bu mekanizma, gereksiz İşlemci Bağlam Değişimi maliyeti yaratmadan, interaktif süreçlerin ihtiyaç duydukları anda kesintisiz çalışabilmesini sağlar.

Yazıyı Değerlendir

0 tepki

Fikirlerinizi tek tıkla paylaşarak geri bildirim bırakın.

Bu teknik notu çevrenizle paylaşın

Ali Purtaş

@alipurtas • Hey, This is Ali!

İletişime Geç

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

İç Bağlantılı Mimari
Yorumlar yükleniyor...