Giriş

Öğrenme Çıktıları

Temel Kavramlar

Çizelgeleme Nedir?

Temel Kavramlar

CPU–G/Ç Patlama Döngüsü

Belirleyici olan G/Ç beklemesinin uzunluğu değil, CPU patlamasının kısalığıdır. Hazır olan G/Ç'ye bağlı süreç hemen çalıştırılırsa diski ve ağı meşgul tutar.

Temel Kavramlar

Çizelgeleme Kararları Ne Zaman Alınır?

Temel Kavramlar

Kesmeli ve Kesmesiz Çizelgeleme

• Çekirdek içi kesme: Linux 2.6'dan beri çekirdek kodu da kesilebilir; kesme yalnızca kilit tutulmadığında yapılır (preempt_count = 0).
• PREEMPT_RT yamaları 20 yıllık geliştirmeden sonra Linux 6.12 (2024) ile ana çekirdeğe girdi: kesme işleyicileri iş parçacığı olarak çalışır, gecikme mikrosaniyeler düzeyine iner.
• Toplu işlerde kesmesiz ya da uzun dilimli kesmeli algoritmalar yeterlidir; etkileşimli ve sunucu sistemlerinde kesme zorunludur.

Temel Kavramlar

Görev Dağıtıcı ve Bağlam Değiştirme

Temel Kavramlar

Ortama Göre Çizelgeleme Hedefleri

Temel Kavramlar

Çizelgeleme Ölçütleri

Çizelgeleyici yalnızca hazır kuyruğundaki bekleme süresini etkiler; CPU ve G/Ç süresi programa aittir. Etkileşimli sistemde ortalamadan çok yanıt süresinin varyansını küçültmek önemlidir. Ağırlıklı dönüş = dönüş / CPU süresi.

Temel Algoritmalar

Ortak Süreç Kümesi

Temel Algoritmalar

FCFS Adım Adım

İlk gelen ilk hizmet alır (first-come, first-served): hazır kuyruğu FIFO; CPU'yu alan süreç bitene ya da bloke olana kadar bırakmaz. Gerçeklemesi en basit algoritmadır.

Temel Algoritmalar

FCFS: Konvoy Etkisi

Düzeltme: CPU'yu sonlanana kadar tutan G/Ç'ye bağlı değil, CPU'ya bağlı süreçtir. FCFS kesmesizdir; açlık yoktur ama etkileşimli sistemler için uygun değildir.

Temel Algoritmalar · Kodu adım adım çalıştır

FCFS Bekleme Süresini Hesaplamak

/* p[] geliş sırasına göre sıralı */
void fcfs(Surec p[], int n) {
  int t = 0, top = 0;
  for (int i = 0; i < n; i++) {
    if (t < p[i].gelis) t = p[i].gelis;
    int bekleme = t - p[i].gelis;
    t += p[i].sure;          /* bitiş */
    top += bekleme;
    printf("%s: %d\n", p[i].ad, bekleme);
  }
  printf("ort = %.2f\n", (double) top / n);
}

Düzeltme: sunumdaki ilk sürüm waitingTime'ı yazdırmadan önce artırdığı için bekleme yerine bitiş zamanını basıyor, geliş zamanlarını da yok sayıyordu.

Temel Algoritmalar

SJF: En Kısa İş Önce

Düzeltme: SJF CPU kullanımını değil, ortalama bekleme ve dönüş süresini en aza indirir; CPU her algoritmada iş olduğu sürece meşguldür.

Temel Algoritmalar

SJF: Hepsi Aynı Anda Hazır

Klasik örnek: dört süreç t = 0'da hazır; CPU süreleri P1 = 6, P2 = 8, P3 = 7, P4 = 3 ms. Aynı küme FCFS ile çalışsaydı ortalama bekleme (0 + 6 + 14 + 21) / 4 = 10,25 ms olurdu.

Temel Algoritmalar

SJF Ortak Kümede

Ortak kümede kesmesiz SJF: t = 0'da yalnızca P1 vardır ve kesilemez; sonraki her seçimde hazır süreçlerin en kısası alınır.

Temel Algoritmalar

FCFS ve SJF Karşılaştırması

Düzeltme: sunumdaki tabloda C için ağırlıklı dönüş 3,1 yazıyordu; doğrusu 16 / 5 = 3,2, SJF ortalaması da 2,12'dir.

Temel Algoritmalar

Sonraki CPU Patlamasını Tahmin: Üstel Ortalama

Temel Algoritmalar · Kodu adım adım çalıştır

Üstel Ortalamayı Hesaplamak

double tau = 10.0;      /* τ0 */
const double a = 0.5;  /* α */
int t[] = { 6, 4, 6, 4, 13, 13, 13 };
for (int n = 0; n < 7; n++) {
  printf("%.1f %d\n", tau, t[n]);
  tau = a * t[n] + (1 - a) * tau;
}
printf("sonraki: %.1f\n", tau);

Temel Algoritmalar

SRTF Adım Adım

En kısa kalan süre önce (SRTF / SRTN): SJF'nin kesmeli sürümü. Yeni süreç gelince süresi, çalışanın kalan süresiyle karşılaştırılır.

Düzeltme: sunumda “başlama süresi P1 = 10” deniyordu; P1 t = 0'da başlar, 1'de kesilir, 10'da kaldığı yerden devam eder. Ortalama bekleme 6,5 ms doğrudur.

Temel Algoritmalar

Öncelik Çizelgeleme

• Her sürece bir öncelik sayısı verilir; en yüksek öncelikli hazır süreç çalışır. Bu derste küçük sayı = yüksek öncelik (Linux ve Windows'ta yönler farklıdır, dikkat).
• Öncelik iç (bellek, açık dosya, ölçülen G/Ç/CPU oranı) ya da dış (önem, ücret, politika) etkenlerden gelir. SJF, önceliği “tahmini sonraki patlama” olan özel bir durumdur; tüm öncelikler eşitse algoritma FCFS'ye döner.
• Kesmeli ya da kesmesiz olabilir; aynı öncelik düzeyindekiler arasında RR uygulanabilir (b).

Temel Algoritmalar

Kesmeli Öncelik Ortak Kümede

Kesmeli öncelik, ortak küme (P1 ö 2, P2 ö 3, P3 ö 1, P4 ö 4). Yeni gelen süreç çalışandan daha yüksek öncelikliyse onu keser.

Temel Algoritmalar

Açlık ve Yaşlanma

Açlık (starvation): yüksek öncelikli işler sürekli gelirse düşük öncelikli iş hiç çalışamaz. Yaşlanma (aging): beklerken önceliği adım adım artırılır. Kural: hazırda geçen her 4 ms için öncelik sayısı 1 azalır. L (3 ms, ö 7) t = 0'da gelir; her 4 ms'de bir yeni H (4 ms, ö 2) gelir. Kesmesiz öncelik.

Round Robin

Round Robin (RR)

Round Robin

RR Adım Adım: q = 2

Ortak küme, q = 2 ms. Küçük dilim: süreçler sık sık yer değiştirir; herkes kısa sürede ilk kez CPU'ya çıkar.

Round Robin

RR Adım Adım: q = 5

Ortak küme, q = 5 ms. Daha büyük dilim: geçiş sayısı azalır, ama ilk yanıtı bekleme süresi uzar.

Round Robin

Kuantum Seçimi: Ödünleşim

• q küçüldükçe yanıt iyileşir (q = 2'de 2 ms) ama bağlam değiştirme artar (12 geçiş); her geçiş gerçek sistemde CPU zamanı yer.
• Ortalama bekleme ve dönüş, q ile tekdüze değişmez (q = 3, q = 2'den kötü). q ≥ 9 (en uzun patlama) olunca RR tam olarak FCFS olur.

Round Robin

Kuantum ve Bağlam Değiştirme

• Kayıp oranı = s / (q + s): q = 4 ms, geçiş s = 1 ms ise CPU'nun %20'si boşa gider; q = 100 ms'de ≈ %1 ama sistem ağır yanıt verir.
• Bugün geçiş birkaç µs, tipik dilim 1–100 ms (Linux EEVDF temel dilimi 0,75 ms × (1 + log₂ CPU), 8+ çekirdekte 3 ms; Windows istemcide ≈ 2 saat tıkı). Kural: CPU patlamalarının ≈ %80'i q'dan kısa olmalı.
• Dönüş süresi q ile tekdüze iyileşmez (sağda). q = 4 ile P1 24, P2 3, P3 3 kümesinde ortalama bekleme 17 / 3 ≈ 5,67 ms (FCFS'de 17).

Çok Düzeyli Kuyruklar

Çok Düzeyli Kuyruk (MLQ)

Düzeltme: sunum MLQ ile MLFQ'yu tek başlıkta birleştiriyordu. Sabit atamalı olan MLQ'dur; süreçlerin davranışına göre kuyruk değiştirdiği yapı geri beslemeli MLFQ'dur (sonraki slayt).

Çok Düzeyli Kuyruklar

Çok Düzeyli Geri Beslemeli Kuyruk (MLFQ)

Parametreler: kuyruk sayısı, her kuyruğun algoritması ve dilimi, alt/üst kuyruğa geçiş kuralı, yeni işin giriş kuyruğu. Kurallar OSTEP (Bölüm 8) düzenlemesidir; kısa işler üstte biter, uzun CPU işleri aşağı süzülür.

Çok Düzeyli Kuyruklar

MLFQ Adım Adım

Üç kuyruk: Q0 (q = 8), Q1 (q = 16), Q2 (FCFS). İşler: A (0, 30), B (2, 6), C (4, 20), D (25, 4). Kesilen iş kuyruğunun başına döner ve dilimini tamamlar.

Çok Düzeyli Kuyruklar

MLFQ Uygulamada

Orantılı Pay ve Öncelik Sorunları

Garantili ve Adil Paylaşım

Düzeltme: sunumda garantili çizelgeleme “önceden belirlenmiş programa göre, gerçek zamanlı sistemler için” diye tanımlanıyordu; Tanenbaum'daki anlamı yukarıdaki pay garantisidir. Katı/yumuşak gerçek zaman konusu Gerçek Zamanlı bölümüne taşındı.

Orantılı Pay ve Öncelik Sorunları

Piyango Çizelgeleme

Düzeltme: sunum piyangoyu “uygulaması karmaşık, önceliği dikkate almaz” diye özetliyordu; aksine en basit algoritmalardandır ve öncelik bilet sayısıyla ifade edilir.

Orantılı Pay ve Öncelik Sorunları

Stride Çizelgeleme Adım Adım

Adım = büyük sayı / bilet (10 000 / bilet): A 100, B 200, C 40. Her dilimde en küçük pass değerli süreç çalışır, pass değerine adımını ekler; eşitlikte A, B, C sırası.

Stride, piyangonun deterministik hali (Waldspurger, 1995). Dezavantajı küresel durum: yeni gelen sürecin pass değeri 0 olursa CPU'yu tekeline alır; bu yüzden mevcut en küçük pass ile başlatılır. Linux CFS'in vruntime fikri buna çok yakındır.

Orantılı Pay ve Öncelik Sorunları

Öncelik Ters Çevirme

Sunumdaki adlandırma: P1 = L, PRT3 = M, PRT2 = H. Gerçek örnek: Mars Pathfinder (1997) bu yüzden sürekli yeniden başladı; VxWorks'te öncelik kalıtımı açılarak düzeltildi. POSIX: PTHREAD_PRIO_INHERIT; Linux rt_mutex ve futex PI kilitleri. Diğer çözüm: öncelik tavanı (priority ceiling).

Çok İşlemcili Çizelgeleme

İş Parçacığı Çizelgeleme: PCS ve SCS

pthread_attr_t attr;
int scope;
pthread_attr_init(&attr);
pthread_attr_getscope(&attr, &scope);
if (scope == PTHREAD_SCOPE_PROCESS)
  printf("PCS\n");
/* Linux ve macOS yalnızca SYSTEM */
pthread_attr_setscope(&attr,
                      PTHREAD_SCOPE_SYSTEM);
pthread_create(&tid, &attr, runner, NULL);

Çok İşlemcili Çizelgeleme

Çok İşlemcili Çizelgeleme Yaklaşımları

Çok İşlemcili Çizelgeleme

Çok Çekirdek ve Donanım İş Parçacıkları

• Bellek beklemesi (memory stall): önbellek ıskalarında çekirdek zamanın %50'ye varan kısmını veri beklerken geçirebilir.
• SMT (Intel Hyper-Threading, AMD SMT): bir çekirdekte 2 donanım iş parçacığı; biri beklerken diğeri yürür. İşletim sistemi her donanım iş parçacığını ayrı bir mantıksal CPU olarak görür.
• İki düzeyli çizelgeleme: işletim sistemi hangi yazılım iş parçacığının hangi mantıksal CPU'da çalışacağını, çekirdek donanımı hangi donanım iş parçacığının o an yürüyeceğini seçer.
• Kardeş mantıksal CPU'lar yürütme birimlerini paylaşır: boş fiziksel çekirdek varken iki yoğun işi aynı çekirdeğe koymak kötü bir karardır.

Çok İşlemcili Çizelgeleme

Yük Dengeleme

Çok İşlemcili Çizelgeleme

İşlemci Yakınlığı, NUMA ve Heterojen Çekirdekler

Gerçek Zamanlı Çizelgeleme

Gerçek Zamanlı Sistemler ve Gecikme

• Çakışmalar: çekirdekte çalışan herhangi bir işin kesilmesi ve düşük öncelikli sürecin tuttuğu kaynağın bırakılması. Bu yüzden kesmeli, öncelik tabanlı çekirdek gerekir; katı garanti için ayrıca kabul denetimi (admission control).
• Algoritmalar statik (öncelikler önceden hesaplanır, ör. RM) ya da dinamik (kararlar çalışma anında, ör. EDF) olabilir.

Gerçek Zamanlı Çizelgeleme

Periyodik Görevler ve Hız Monoton (RM)

Örnek: U = 20/50 + 35/100 = 0,40 + 0,35 = 0,75 ≤ 0,828 → RM ile çizelgelenebilir. Silberschatz Şekil 5.21'den yeniden hesaplanmıştır.

Gerçek Zamanlı Çizelgeleme

RM ve EDF Adım Adım

Orantılı pay (proportional share) çizelgeleme: toplam T pay dağıtılır; N pay alan uygulama CPU'nun N/T'sini alır, kabul denetimi toplamı aşan isteği reddeder. Linux SCHED_DEADLINE (3.14+) EDF ile CBS bant genişliği korumasını birleştirir.

Gerçek Zamanlı Çizelgeleme

POSIX Gerçek Zamanlı Çizelgeleme

pthread_attr_t attr;
struct sched_param sp;
int policy;
pthread_attr_init(&attr);
pthread_attr_getschedpolicy(&attr, &policy);
/* kalıtım kapatılmazsa politika yok sayılır */
pthread_attr_setinheritsched(&attr,
                      PTHREAD_EXPLICIT_SCHED);
pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
sp.sched_priority = 50;          /* 1..99 */
pthread_attr_setschedparam(&attr, &sp);
pthread_create(&tid, &attr, runner, NULL);

• POSIX.1b uzantısı; ayrıcalık ister (CAP_SYS_NICE), kabukta chrt -f 50 ./prog. Linux RT işlere saniyenin en fazla 0,95 s'sini verir (sched_rt_runtime_us).

Düzeltme: sunumdaki pthread_attr_getsched_policy / setsched_policy adları yanlıştı; doğrusu pthread_attr_getschedpolicy ve pthread_attr_setschedpolicy.

İşletim Sistemi Örnekleri

Linux: Çizelgeleme Sınıfları

Düzeltme: sunumda “iki çizelgeleme sınıfı (varsayılan, gerçek zamanlı)” yazıyordu; bugünkü çekirdekte yukarıdaki sınıflar vardır. Tarihçe: O(n) (2.4) → O(1) (2.6.0, 2003) → CFS (2.6.23, 2007) → EEVDF (6.6, 2023).

İşletim Sistemi Örnekleri

Linux CFS: Sanal Çalışma Süresi

İşletim Sistemi Örnekleri

EEVDF: CFS'in Halefi

EEVDF (Earliest Eligible Virtual Deadline First, Stoica 1995; Linux 6.6+): görev, payından geride ya da tam payındaysa (gecikme lag ≥ 0, yani v ≤ V) uygundur; sanal son tarih vd = v + dilim / ağırlık. Uygunlar içinde vd en erken olan çalışır. Üç eşit ağırlıklı görev:

CFS'teki gecikme sezgileri yerine iki net ölçüt (uygunluk ve son tarih) gelir; gecikmeye duyarlı görev sched_setattr() ile kısa dilim isteyebilir (6.12+). Ağırlıklar nice ile CFS'tekiyle aynıdır.

İşletim Sistemi Örnekleri

Windows Çizelgeleme ve Öncelikleri

• Kesmeli, öncelik tabanlı: en yüksek öncelikli hazır iş parçacığı çalışır; bloke olana, dilimi bitene ya da daha yüksek öncelikli biri gelene kadar. 32 düzey: 1–15 değişken, 16–31 gerçek zamanlı, 0 sayfa sıfırlama (zero-page) iş parçacığı. Her düzey için bir kuyruk; iş yoksa boşta (idle) iş parçacığı.
• Değişken sınıfta dinamik artırma: G/Ç tamamlanınca (klavye/fare için daha çok), ön plan penceresi ve GUI uyanmalarında öncelik geçici yükselir, her dilimde 1 azalır, 15'i aşmaz; ≈ 4 saniye aç kalan iş parçacığı bir dilimlik 15'e çıkarılır. Dilim istemcide ≈ 2, sunucuda 12 saat tıkı.

Değerlendirme ve Özet

Algoritmaları Değerlendirme

Değerlendirme ve Özet

Ortak Kümede Karşılaştırma

• SRTF ortalama beklemede en iyisidir (6,5) ama sürelerin bilinmesini ister; RR q = 2 yanıtta en iyisidir (2) ama en çok geçişi yapar.
• Öncelik bekleme süresini değil önemi optimize eder. Tek bir “en iyi” algoritma yoktur: seçim, hedefe (yanıt, verim, adalet, son tarih) bağlıdır.

Değerlendirme ve Özet

Kontrol Soruları

1. Kesmesiz bir çizelgeleyici hangi durum geçişlerinde karar verir?
2. P1 = 5, P2 = 2, P3 = 1 ms, hepsi t = 0'da ve bu sırayla geliyor. FCFS ve SJF için ortalama bekleme nedir?
3. α = 0,5 ve τ₀ = 8. Ölçülen patlamalar 4 ve 12 ms ise sonraki tahmin kaçtır?
4. RR'de kuantum çok büyük ya da çok küçük seçilirse ne olur? q = 4 ms, geçiş 1 ms ise kayıp oranı nedir?
5. Ortak kümede SRTF, P1'i neden t = 1'de keser?
6. Öncelik ters çevirme nedir, öncelik kalıtımı onu nasıl çözer?
7. P1 (p = 40, t = 10) ve P2 (p = 60, t = 30) RM ile çizelgelenebilir mi?
8. CFS'de nice 0 ve nice 5 olan iki CPU'ya bağlı görev CPU'yu nasıl paylaşır? EEVDF'de “uygun” görev ne demektir?

Değerlendirme ve Özet

Kaynaklar

• A. Silberschatz, P. B. Galvin, G. Gagne, Operating System Concepts, 10. baskı, Wiley, 2018 — Bölüm 5: CPU Scheduling.
• A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı (2014) / 5. baskı (2022), Pearson — Bölüm 2.4: Scheduling.
• R. H. Arpaci-Dusseau, A. C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces (OSTEP), ostep.org — Bölüm 7–10: Scheduling, MLFQ, Lottery, Multiprocessor.
• P. Yosifovich, A. Ionescu, M. Russinovich, D. Solomon, Windows Internals, 7. baskı, Kısım 1, 2017 — Bölüm 4: Thread scheduling.
• Linux çekirdek belgeleri: sched-eevdf.rst, sched-design-CFS.rst, sched-deadline.rst, sched-ext.rst; sched(7) kılavuz sayfası.
• I. Stoica, H. Abdel-Wahab, “Earliest Eligible Virtual Deadline First”, 1995; C. L. Liu, J. W. Layland, “Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment”, JACM, 1973; C. A. Waldspurger, W. E. Weihl, “Lottery Scheduling”, OSDI 1994.