Bölüm 3: Süreçler
Giriş
Öğrenme Çıktıları
Program ile süreç arasındaki farkı ve bir sürecin bellek yerleşimini açıklamak.
Süreç durumlarını, geçişleri ve PCB’nin içeriğini tanımlamak.
fork(), exec(), wait(), exit() ve pipe() kullanan küçük programları izlemek.
Hazır/bekleme kuyruklarını ve bağlam değiştirmenin maliyetini açıklamak.
Paylaşımlı bellek, ileti geçirme, boru ve soketleri karşılaştırmak.
iOS ve Android’in arka plan süreçlerini neden ve nasıl sınırladığını açıklamak.
Süreç Kavramı
Süreç Nedir?
- Süreç (process): yürütülmekte olan bir program örneği.
- Program pasiftir (diskte duran çalıştırılabilir dosya); süreç aktiftir (program sayacı, yazmaçlar, bellek, açık dosyalar). Program belleğe yüklenince süreç olur.
- Aynı programdan birden çok süreç oluşabilir (iki terminalde
vim); her biri ayrı adres alanı ve kaynaklara sahiptir, metin bölümü paylaşılabilir. - Tek iş parçacıklı bir süreç komutlarını sıralı yürütür; çok iş parçacıklı bir süreç çok çekirdekte paralel ilerleyebilir.
Süreç Kavramı
Bellekte Süreç Yerleşimi
Süreç Kavramı
Değişkenler Nereye Yerleşir?
#include <stdlib.h> int sayac = 5; /* data */ int tablo[1000]; /* bss */ int main(int argc, char *argv[]) { int yerel = 3; static int adet; int *p = malloc(4 * sizeof *p); p[0] = yerel + sayac; free(p); return 0; }
Linux’ta size a.out metin/veri/BSS boyutlarını, cat /proc/PID/maps çalışan sürecin bölgelerini gösterir.
Metin: main fonksiyonunun derlenmiş komutları; salt okunur ve aynı programın süreçleri arasında paylaşılabilir.
Veri: ilk değeri verilmiş global sayac; değeri çalıştırılabilir dosyada saklanır.
BSS: ilk değeri verilmemiş global ve static değişkenler; yükleyici sıfırla doldurur, dosyada yer kaplamaz.
Yığın: main çağrı çerçevesi: parametreler, yerel değişkenler ve işaretçi p’nin kendisi.
Heap: malloc ile ayrılan 16 bayt; p yığında durur ama gösterdiği alan heap’tedir. free ile geri verilir.
Süreç Kavramı
Sözde Paralellik ve Çoklu Programlama
- Tek çekirdekte herhangi bir anda yalnızca bir süreç yürütülür; çizelgeleyici süreçler arasında hızla geçiş yaparak sözde paralellik yaratır.
- Geçişler tipik olarak birkaç milisaniyelik zaman dilimleriyle olur (Linux EEVDF’de taban dilim ~3 ms; eski CFS’de hedef gecikme 6–24 ms); kullanıcıya tüm süreçler aynı anda çalışıyor gibi görünür.
- Kullanıcı için faydalıdır; ancak yönetimi zordur: süreçlerin ne zaman kesileceği öngörülemez, zaman varsayımı yapılmamalıdır.
Süreç Kavramı
Eş Zamanlılık ve Paralellik
Birden çok iş aynı zaman aralığında ilerler; tek çekirdekte iç içe geçerek (interleaving).
Birden çok iş aynı anda yürütülür; birden çok çekirdek ya da işlemci gerekir.
Süreç Kavramı
Örnek: Chrome’un Çok Süreçli Mimarisi
Süreç Oluşturma
Süreç Oluşturma
Süreç oluşturan olaylar
- Sistem açılışı (init/systemd, arka plan hizmetleri: daemon).
- Çalışan bir sürecin süreç oluşturan sistem çağrısı yapması.
- Kullanıcının bir komut ya da uygulama başlatması.
- Toplu (batch) bir işin başlatılması.
Her durumda teknik olarak aynı şey olur: var olan bir süreç, yeni süreç oluşturan bir sistem çağrısı yürütür.
Sistem çağrıları
| Sistem | Çağrı |
|---|---|
| UNIX / Linux | fork() + exec(); ayrıca posix_spawn(), Linux’ta clone() |
| Windows | CreateProcess(): oluşturma ve program yüklemeyi tek çağrıda yapar |
Süreç Oluşturma
Süreç Ağacı
Linux açılışta PID 1 olarak systemd (ya da başka bir init) çalıştırır; PID 2 kthreadd çekirdek iş parçacıklarının ebeveynidir. PID değerleri örnektir.
Süreç Oluşturma
Ebeveyn ve Çocuk İlişkisi
Çocuk ebeveyn kaynaklarının tümünü ya da bir kısmını paylaşabilir ya da hiçbirini paylaşmayabilir. UNIX’te çocuk açık dosya tanımlayıcılarını miras alır.
Ebeveyn ve çocuk eş zamanlı çalışabilir ya da ebeveyn wait() ile çocuğun bitmesini bekleyebilir.
UNIX fork(): çocuk ebeveynin adres alanının kopyasını alır (paylaşmaz). Ardından exec() ile yeni bir program yükleyebilir.
getpid() kendi PID’ini, getppid() ebeveynin PID’ini döndürür.
fork() sonrası çocuğun adres alanı ebeveyninkinden ayrıdır; verimlilik için yalnızca fiziksel sayfalar yazılana kadar ortak tutulur (copy-on-write).Süreç Oluşturma
fork(): Bir Çağrı, İki Dönüş
pid_t pid = fork(); if (pid < 0) { perror("fork"); exit(1); } else if (pid == 0) { /* çocuk: fork 0 döndürdü */ } else { /* ebeveyn: pid = çocuğun PID'i */ }
Başlangıç: ebeveyn sürecin sayfa tablosu fiziksel A, B, C sayfalarını gösteriyor.
fork(): çekirdek PCB’yi ve sayfa tablosunu kopyalar; sayfalar kopyalanmaz, ikisine de salt okunur eşlenir. Ebeveyn çocuğun PID’ini, çocuk 0 alır; hata olursa çocuk oluşmaz ve yalnız ebeveyne −1 döner.
Çocuk C sayfasına yazınca sayfa hatası oluşur; çekirdek yalnızca o sayfayı kopyalar (C′). Bu yazınca kopyala (COW) tekniğidir.
Süreç Oluşturma · Kodu adım adım çalıştır
Kod İzleme: fork() + wait()
#include <stdio.h> #include <unistd.h> #include <sys/wait.h> int main(void) { int x = 10; pid_t pid = fork(); if (pid == 0) { x = x + 5; printf("çocuk: x=%d\n", x); return 0; } wait(NULL); printf("ebeveyn: x=%d\n", x); return 0; }
Tek süreç var: ebeveyn (PID 1234), x = 10.
fork() çocuk 1235’i oluşturur. Ebeveynde pid = 1235, çocukta pid = 0; iki ayrı x var.
Ebeveynde pid ≠ 0: if atlanır, wait(NULL) çocuk bitene kadar ebeveyni bekliyor durumuna sokar.
Çocukta pid == 0 doğru: çocuk dalına girer. (Çocuk önce çalışmış olsaydı da sonuç aynı olurdu.)
Çocuk kendi kopyasını değiştirir: x = 15. Ebeveynin x’i 10 kalır.
Çocuk yazdırır.
Çocuk return 0 ile çıkar (exit(0)); kısa süre zombi olur, çekirdek ebeveyni uyandırır.
wait 1235 döndürür; çocuğun girdisi süreç tablosundan silinir.
Ebeveyn yazdırır: kendi x’i hâlâ 10.
Ebeveyn de sonlanır. wait() sayesinde çıktı sırası her çalıştırmada aynıdır.
Süreç Oluşturma
wait() Olmadan Çıktı Sırası Belirsizdir
pid_t pid = fork(); if (pid == 0) printf("çocuk\n"); else printf("ebeveyn\n");
wait() (ya da başka bir senkronizasyon) kullanılmalıdır.Süreç Oluşturma
exec() Ailesi
| Çağrı | Argümanlar | PATH araması | Ortam |
|---|---|---|---|
execl / execv | liste / dizi | hayır | devralınır |
execlp / execvp | liste / dizi | evet | devralınır |
execle / execve | liste / dizi | hayır | açıkça verilir |
Hepsi execve() sistem çağrısına varır. Başarılı exec geri dönmez; dönüyorsa hata vardır.
Süreç Oluşturma
exec Çekirdekte Ne Yapar?
#! satırı) denetle.Dosya yoksa ya da çalıştırılamıyorsa exec −1 döner ve eski program kaldığı yerden sürer.
Kod, veri, heap ve yığın eşlemeleri silinir; süreçteki diğer iş parçacıkları sonlandırılır. Bu noktadan sonra geri dönülecek program yoktur.
Yakalanan sinyaller varsayılan eyleme döner, çünkü işleyici kodu artık bellekte değildir; yok sayılanlar yok sayılmaya devam eder.
Kopyalama yapılmaz: bir sayfa ilk kez kullanıldığında sayfa hatası olur ve o sayfa diskten getirilir (tembel yükleme).
Yığının tepesine argv ve envp dizgileri, bunları gösteren işaretçi dizileri ve argc yerleştirilir.
_start C çalışma zamanını kurar ve main(argc, argv, envp)’yi çağırır. PID hiç değişmemiştir.
Diskteki program pasif bir dosyadır; exec onu çalışan bir sürecin adres alanına dönüştürür. Linux’ta tüm exec ailesi sonunda execve()’ye iner.
Süreç Oluşturma · Kodu adım adım çalıştır
Kod İzleme: fork + exec + waitpid
#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> int main(void) { pid_t pid = fork(); if (pid == 0) { execlp("ls", "ls", "-l", NULL); perror("execlp"); /* hata */ exit(1); } int st; waitpid(pid, &st, 0); printf("bitti: %d\n", WEXITSTATUS(st)); return 0; }
fork(): iki süreç aynı a.out görüntüsünü çalıştırıyor.
Ebeveyn çocuk dalını atlar ve waitpid(1235, ...) ile bloke olur.
Çocuk execlp çağırır: PATH içinde ls bulunur, adres alanı /usr/bin/ls ile değiştirilir. PID hâlâ 1235.
Artık çocuk ls programıdır; 10–11. satırlar hiç çalışmaz (exec başarılı). Miras alınan stdout’a listeyi yazar.
ls exit(0) ile biter; waitpid döner ve st çıkış durumunu taşır.
WEXITSTATUS(st) = 0 yazdırılır.
Süreç Oluşturma
Kabuk Döngüsü: fork → exec → wait
Kabuk istemi gösterir ve ls komutunu okur.
fork(): kabuğun bir kopyası (PID 2300) oluşur; ebeveyn waitpid ile beklemeye geçer.
Çocuk execvp("ls", argv) çağırır; görüntüsü ls ile değişir.
ls çalışır, miras aldığı terminal stdout’una yazar.
ls çıkar; çekirdek ebeveyni SIGCHLD ile bilgilendirir, waitpid çocuğu biçer.
Kabuk yeni istemi gösterir. Komut sonuna & eklenirse kabuk beklemeden devam eder (arka plan işi).
Süreç Oluşturma · Kodu adım adım çalıştır
Neden fork ve exec Ayrı? Çıktı Yönlendirme
int main(void) { pid_t pid = fork(); if (pid == 0) { /* çocuk */ close(1); /* stdout boşalır */ int fd = open("sayim.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644); /* en küçük boş numara: fd == 1 */ execlp("wc", "wc", "-l", "notlar.txt", NULL); perror("execlp"); exit(1); } waitpid(pid, NULL, 0); printf("bitti\n"); return 0; }
fork(): çocuk ebeveynin fd tablosunu kopyalar; 0, 1, 2 terminaldir.
Ebeveyn waitpid ile bekler; sonraki adımlar yalnız çocuğun tablosunu değiştirir.
close(1): çocuğun 1 numaralı girişi boşalır. Ebeveynin stdout’u hâlâ terminaldir.
open her zaman en küçük boş numarayı verir: 1. Artık çocuğun stdout’u dosyadır.
exec kodu ve veriyi değiştirir, fd tablosunu korur: habersiz wc fd 1’e, yani dosyaya yazar.
wc biter, waitpid döner; ebeveyn terminale yazar: ekranda yalnız bitti.
Kabuk > sayim.txt’i böyle yapar: çocuk fork ile exec arasında ortamını (fd, dizin, öncelik) hazırlar. Windows’un CreateProcess’i bunları parametre ister.
Süreç Sonlandırma
Süreç Sonlandırma
| Neden | Tür | Örnek |
|---|---|---|
| Normal çıkış | gönüllü | return 0, exit(0); derleyici işi bitti |
| Hata sonrası çıkış | gönüllü | dosya bulunamadı → exit(1) |
| Ölümcül hata | istemsiz | geçersiz bellek erişimi (SIGSEGV), sıfıra bölme (SIGFPE) |
| Başka süreç tarafından | istemsiz | kill(pid, SIGTERM), Windows’ta TerminateProcess() |
exit(durum): C kütüphanesi tamponları boşaltır,atexitişleyicilerini çalıştırır, sonra_exitsistem çağrısı.abort(): çağıran süreç kendine SIGABRT gönderir, anormal biter (çekirdek dökümü oluşabilir). Başka süreci sonlandırmak içinkill()kullanılır.- Çekirdek sürecin belleğini, açık dosyalarını ve diğer kaynaklarını geri alır; çıkış durumu ebeveyn
wait()çağırana kadar saklanır. - Bazı sistemlerde ebeveyn sonlanınca çocuklar da sonlandırılır (basamaklı sonlandırma); UNIX’te ise çocuklar yaşamaya devam eder.
Süreç Sonlandırma
Ölümcül Hatalar
| Hata | Sinyal |
|---|---|
| Geçersiz/izinsiz bellek erişimi | SIGSEGV |
| Tam sayı sıfıra bölme | SIGFPE |
| Geçersiz komut | SIGILL |
| Hizalama / veri yolu hatası | SIGBUS |
| Kapalı boruya yazma | SIGPIPE |
- İşletim sistemi donanım istisnasını yakalar, sürece ilgili sinyali gönderir; işlenmezse süreç sonlanır.
- Süreç bellekten temizlenir, kaynakları serbest bırakılır.
- Çekirdek dökümü (core dump) alınabilir:
coredumpctl,gdb a.out coreile hatanın nedeni incelenir (crash dump analizi).
Süreç Sonlandırma
Sinyallerle Sonlandırma: kill, pkill, killall
| Sinyal | No | Anlamı |
|---|---|---|
| SIGTERM | 15 | kibarca bitir; süreç yakalayıp temizlik yapabilir (kill’in varsayılanı) |
| SIGKILL | 9 | zorla bitir; yakalanamaz, yok sayılamaz, temizlik yapılamaz |
| SIGINT | 2 | terminalde Ctrl+C |
| SIGTSTP | 20 | terminalde Ctrl+Z (duraklat); fg/bg sürdürür |
| SIGSTOP / SIGCONT | 19 / 18 | durdur (yakalanamaz) / sürdür |
Numaralar x86/ARM Linux içindir; taşınabilir kod numaraları değil adları kullanır.
$ ps -e | grep yaz 1234 ? 00:00:03 yaz $ kill 1234 # SIGTERM $ kill -9 1234 # SIGKILL $ pkill yaz # ada göre $ killall yaz
- Önce SIGTERM, yanıt yoksa SIGKILL.
- Sinyal göndermek için aynı kullanıcı ya da yetkili (root) olmak gerekir.
Süreç Sonlandırma
Zombi ve Yetim Süreçler
Ebeveyn (100) ve çocuk (101) çalışıyor.
Çocuk exit() ile bitti ama ebeveyn henüz wait() çağırmadı: çocuk zombidir. Belleği serbest; süreç tablosunda PID ve çıkış durumu bekler (ps’te Z / <defunct>).
Ebeveyn wait() çağırır, çıkış durumunu alır; çekirdek girdiyi siler (biçme, reaping). Zombi kalmaz.
Senaryo 2: ebeveyn (100) çocuktan önce sonlandı. Çocuk (101) hâlâ çalışıyor: yetim süreç.
Çekirdek yetimi init/systemd’ye (PID 1) ya da tanımlı bir alt-biçici (subreaper) sürece bağlar; getppid() artık 1 döndürür.
Yetim bitince yeni ebeveyni onu wait() ile biçer; böylece zombi birikmez.
Zombi kaynak harcamaz ama PID tüketir; wait çağırmayan uzun ömürlü bir sunucu binlerce zombi biriktirip PID’leri tüketebilir. Çözüm: wait/waitpid ya da SIGCHLD işleyicisi.
Durumlar ve PCB
Süreç Durumları (Beş Durum Modeli)
Bir çekirdekte aynı anda yalnız bir süreç çalışıyor olabilir; pek çoğu hazır ya da bekliyor durumundadır.
Durumlar ve PCB
Durum Geçişleri Adım Adım
Kullanıcı programı başlattı: PCB oluşturuluyor, bellek ayrılıyor → Yeni.
Çekirdek süreci kabul etti ve hazır kuyruğuna koydu → Hazır.
Çizelgeleyici bu süreci seçti, bağlamı yüklendi → Çalışıyor.
Süreç diskten read() istedi; veri gelene kadar CPU’yu bırakır → Bekliyor.
Disk kesmesi: veri hazır. Süreç doğrudan çalışmaz, hazır kuyruğuna döner → Hazır.
Yeniden seçildi → Çalışıyor.
Zamanlayıcı kesmesi: zaman dilimi doldu (kesmeli çizelgeleme) → Hazır.
Tekrar seçildi → Çalışıyor.
exit() çağırdı → Sonlandı; ebeveyn wait() edene kadar zombi.
Bekliyor → Çalışıyor geçişi yoktur: olay tamamlanan süreç önce hazır kuyruğuna girer.
Durumlar ve PCB
Linux’ta Süreç Durumları
| ps STAT | Anlam | Modeldeki karşılığı |
|---|---|---|
R | çalışıyor ya da çalışmaya hazır | Çalışıyor + Hazır |
S | kesilebilir uyku (olay bekliyor) | Bekliyor |
D | kesilemez uyku (genelde disk G/Ç) | Bekliyor |
T | durdurulmuş (SIGSTOP, hata ayıklayıcı) | askıya alınmış |
Z | zombi | Sonlandı (biçilmedi) |
I | boşta çekirdek iş parçacığı | — |
$ ps -eo pid,stat,comm
PID STAT COMMAND
1 Ss systemd
890 Ss sshd
2105 Ss bash
2241 R+ ps
2307 Z yaz <defunct>Ek harfler: s oturum lideri, + ön plan grubu. Linux hazır ile çalışıyor durumunu ayırmaz; ikisi de R.
Durumlar ve PCB
Süreç Kontrol Bloğu (PCB)
- Çekirdek her süreç için bir PCB (process control block) tutar; sürece dair bilinmesi gereken her şey buradadır.
- Tüm PCB’lerin oluşturduğu yapıya süreç tablosu denir (Tanenbaum’un tablosu bu girdilerin alanlarını listeler).
- Süreç CPU’dan ayrıldığında program sayacı ve yazmaçlar PCB’ye kaydedilir; geri döndüğünde buradan yüklenir. Bu bilgiye bağlam denir.
- PCB’ler çekirdek belleğinde durur; kullanıcı süreçleri doğrudan erişemez.
Durumlar ve PCB
PCB Alanları (Tanenbaum’a göre)
| Süreç yönetimi | Bellek yönetimi | Dosya yönetimi |
|---|---|---|
| yazmaçlar · program sayacı · program durum sözcüğü (PSW) · yığın işaretçisi · süreç durumu · öncelik · çizelgeleme parametreleri · PID · ebeveyn süreç · süreç grubu · sinyaller · başlama zamanı · kullanılan CPU zamanı · çocukların CPU zamanı · sonraki alarm zamanı | metin, veri ve yığın bölümlerinin (segment) işaretçileri; günümüzde sayfa tablosu işaretçisi ve bellek bölgeleri listesi | kök dizin · çalışma dizini · dosya tanımlayıcıları · kullanıcı kimliği (UID) · grup kimliği (GID) |
Durum bayrakları (sıfır, taşma...), çalışma modu (kullanıcı/çekirdek), kesme izinleri.
Birlikte yönetilen süreçler: kabuktaki bir boru hattı tek grup olur, Ctrl+C hepsine gider.
alarm() ile istenen SIGALRM’nin teslim zamanı.
Durumlar ve PCB
Linux’ta PCB: task_struct
struct task_struct { /* <linux/sched.h> */ pid_t pid; /* süreç kimliği */ unsigned int __state; /* süreç durumu */ int prio; /* öncelik */ struct sched_entity se; /* CFS/EEVDF bilgisi */ struct task_struct *parent; /* ebeveyn süreç */ struct list_head children; /* çocuklar */ struct files_struct *files; /* açık dosyalar */ struct mm_struct *mm; /* adres uzayı */ /* ... yüzlerce alan daha ... */ };
- Tüm görevler çift yönlü bağlı listededir;
currento çekirdekte çalışan görevi gösterir. - Eski çekirdeklerdeki
long state/time_slicealanları güncel çekirdeklerde__statevesched_entityiçine taşınmıştır.
Çizelgeleme
Hazır ve Bekleme Kuyrukları
- Çizelgeleyici (scheduler) hazır süreçler arasından CPU’ya geçecek olanı seçer; amaç CPU’yu meşgul tutmak ve kullanıcıya hızlı yanıt vermektir.
- Hazır kuyruğu: bellekte olup yürütülmeyi bekleyen süreçler. Bekleme kuyrukları: belirli bir olayı (G/Ç bitişi, çocuğun sonlanması...) bekleyenler; her olay türü için ayrı kuyruk vardır.
- Linux her çekirdeğe ayrı bir çalışma kuyruğu (runqueue) atar; CFS/EEVDF bunu kırmızı-siyah ağaçla tutar.
Çizelgeleme
Kuyruk Diyagramı: Bir Sürecin Yolculuğu
Yeni süreç hazır kuyruğunun sonuna eklenir ve sırasını bekler.
Çizelgeleyici onu seçer (dispatch): süreç CPU’da çalışır.
G/Ç isteği yaptı: G/Ç bekleme kuyruğuna geçer; G/Ç bitince hazır kuyruğuna döner.
Zaman dilimi doldu: zamanlayıcı kesmesiyle CPU’dan alınır, doğrudan hazır kuyruğuna döner.
Çocuk oluşturup wait() çağırdı: çocuk bitene kadar bekler.
Bir kesmeyi/olayı bekliyor (örn. sleep(), ağ paketi).
İşi bitti: exit() ile sistemden çıkar; PCB’si ebeveyn wait edince silinir.
Çizelgeleme
CPU’ya Bağlı ve G/Ç’ye Bağlı Süreçler
Uzun hesaplama patlamaları, seyrek G/Ç: derleme, video kodlama, bilimsel hesap.
Kısa CPU patlamaları, sık bekleme: editör, web sunucusu, veritabanı istemcisi.
- CPU’lar disklerden çok daha hızlı geliştiği için süreçler giderek G/Ç’ye bağlı hâle gelir.
- G/Ç’ye bağlı süreç hazır olunca hemen CPU almalı (hızlı bağlam değiştirme); iki tür dengeli karıştırılmalıdır.
Çizelgeleme
Çoklu Programlamanın Modellenmesi
Bir süreç zamanının p kesrini G/Ç bekleyerek geçirsin. Bellekte n bağımsız süreç varsa hepsinin aynı anda beklemesi olasılığı pⁿ’dir:
CPU kullanımı = 1 − pⁿ
Örn. p = 0,8: n = 1 → %20, n = 4 → %59, n = 10 → %89.
Kaba bir model: süreçlerin bağımsız olduğu varsayılır.
Çizelgeleme · Kodu adım adım çalıştır
Kod İzleme: CPU Kullanımı 1 − pⁿ
double p = 0.8; /* G/Ç oranı */ double pn = 1.0; for (int n = 1; n <= 5; n++) { pn = pn * p; /* hepsi bekler */ double kul = 1 - pn; printf("n=%d %%%.0f\n", n, kul * 100); }
Her süreç zamanının %80’ini G/Ç bekleyerek geçiriyor. CPU yalnızca bellekteki süreçlerin hepsi aynı anda beklerken boştur.
n = 1: tek süreç; CPU’nun boş kalma olasılığı pⁿ = 0,8.
kul = 1 − 0,8 = %20: tek programlı sistemde CPU zamanın beşte dördünde boş.
n = 2: hepsinin birden beklemesi olasılığı 0,82 = 0,64.
kul = %36.
n = 3: hepsinin birden beklemesi olasılığı 0,83 = 0,512.
kul = %48,8.
n = 4: hepsinin birden beklemesi olasılığı 0,84 = 0,4096.
kul = %59,04.
n = 5: hepsinin birden beklemesi olasılığı 0,85 = 0,32768.
kul = %67,23. Her yeni süreç bir öncekinden daha az kazandırıyor: artış 8 puan.
Çizelgeleme
Bağlam Değiştirme (Context Switch)
P₀ çalışıyor (kalın çizgi); P₁ hazır kuyruğunda bekliyor.
Kesme ya da sistem çağrısı: CPU çekirdek moduna geçer, P₀’ın program sayacı ve yazmaçları PCB₀’a kaydedilir.
Çizelgeleyici P₁’i seçer; P₁’in bağlamı PCB₁’den yüklenir (adres alanı da değişir).
P₁ çalışıyor; P₀ boşta (hazır ya da bekliyor).
Yeni kesme: P₁’in durumu PCB₁’e kaydedilir.
PCB₀’dan geri yüklenir; P₀ kaldığı yerden devam eder. Aradaki gri bölümlerde hiçbir kullanıcı işi yapılmaz: ek yük.
Çizelgeleme · Kodu adım adım çalıştır
Kod İzleme: Bağlam Değiştirme
struct pcb { int pc, sp, r1; char durum; }; struct pcb P[2]; /* süreç tablosu */ int pc, sp, r1; /* CPU yazmaçları */ void baglam_degistir(int e, int y) { P[e].pc = pc; P[e].sp = sp; /* kaydet */ P[e].r1 = r1; P[e].durum = 'H'; pc = P[y].pc; sp = P[y].sp; /* yükle */ r1 = P[y].r1; P[y].durum = 'C'; } /* kesme */ baglam_degistir(0, 1); /* ... P1 çalışır ... */ /* kesme */ baglam_degistir(1, 0);
P₀ çalışıyor: yazmaçlar P₀’ın değerlerini taşıyor. P₁’in son durumu PCB₁’de saklı. Zamanlayıcı kesmesi gelir; çekirdek P₁’e geçmeye karar verir.
Kaydet: P₀’ın pc ve sp değerleri PCB₀’a yazılır. Bunlar kaybolursa P₀ kaldığı yere dönemez.
Genel yazmaç da kaydedilir; P₀ artık hazır (H).
Yükle: P₁’in pc ve sp değerleri CPU’ya. Bu andan sonra CPU P₁’in koduna ve yığınına bakar.
r1 = 2 yüklenir, P₁ çalışıyor (C). Bu arada hiçbir kullanıcı işi yapılmadı: bağlam değiştirme saf ek yüktür.
P₁ birkaç komut çalıştırdı: pc 340 → 352, r1 = 5, sp = 492. PCB₁ bu sırada güncel değil; güncel değerler yalnızca CPU’da.
Yeni kesme: çekirdek P₀’a dönmeye karar verir.
P₁’in pc ve sp değerleri PCB₁’e kaydedilir.
r1 de kaydedilir; P₁ hazır.
PCB₀’daki değerler geri yüklenir: pc = 104, sp = 896.
r1 = 8: P₀ tam olarak kesildiği durumdan, pc = 104’ten sürer; kesildiğini fark etmez. Gerçekte yazmaç sayısı onlarcadır ve adres alanı da değişir.
Çizelgeleme
Sınırlı Doğrudan Yürütme
Program CPU’da doğrudan çalışır; ayrıcalıklı işler çekirdekte, CPU’yu İS zorla geri alır.
Açılışta, çekirdek modunda: İS hangi olayda hangi kodun çalışacağını (tuzak/kesme tablosu) donanıma bildirir ve zamanlayıcıyı kurar. İkisi de ayrıcalıklı komuttur.
A kullanıcı modunda doğrudan CPU’da çalışır: arada yorumlayıcı yok, tam hız. Ayrıcalıklı bir iş için sistem çağrısıyla tuzağa düşmek zorundadır.
A sonsuz döngüde olsa bile kesme gelir. Donanım A’nın yazmaçlarını kaydeder, çekirdek moduna geçer ve İS’nin işleyicisine atlar: denetim İS’de.
İS, A’nın dilimi dolduğu için B’ye geçmeye karar verir. switch() A’nın bağlamını PCB(A)’ya yazar, B’ninkini yükler ve B’nin çekirdek yığınına geçer.
Tuzaktan dönüş, B sanki kesildiği yerden dönüyormuş gibi yazmaçlarını yükler ve kullanıcı moduna geçer: artık B çalışır.
Kesme olmasaydı (işbirlikçi çok görevlilik, Windows 3.x) sonsuz döngü makineyi kilitlerdi.
Çizelgeleme
Bağlam Değiştirmenin Maliyeti
- CPU başka sürece geçerken eski sürecin durumunu kaydetmeli, yenisininkini yüklemelidir.
- Bu süre saf ek yüktür (overhead): bu sırada sistem yararlı iş yapmaz.
- PCB ve işletim sistemi ne kadar karmaşıksa bağlam değiştirme o kadar uzun sürer.
Yazmaçların kaydı/yüklenmesi, çekirdek kodu: güncel Linux’ta tipik olarak birkaç mikrosaniye.
Önbellek ve TLB’nin “soğuması”: yeni süreç ilk anlarda daha çok önbellek ıskası yaşar; çoğu zaman doğrudan maliyetten büyüktür.
Birden çok yazmaç kümesi, TLB’de adres alanı etiketi (ASID / PCID) ile boşaltmadan kaçınma.
Çizelgeleme
Kesmenin Ele Alınması
Bir G/Ç kesmesi geldiğinde işletim sisteminin en alt katmanında olanlar (Tanenbaum):
Kesme isteği komut sınırında kabul edilir; CPU çekirdek moduna geçer.
Vektör, her kesme türü için işleyicinin adresini tutan tablodur.
Yazmaçlar o anki sürecin PCB’sine (ya da çekirdek yığınına) yazılır.
Kesme işleyicisi çekirdek yığınında çalışır.
Genelde girdiyi okur/tamponlar; bekleyen süreci hazır yapar.
Uyanan süreç daha öncelikliyse kesilen süreç yerine o seçilebilir.
Kalan iş, seçilen sürecin bağlamının yüklenmesidir.
Yazmaçlar ve bellek eşlemesi yüklenir, kullanıcı moduna dönülür.
Süreçler Arası İletişim
Süreçler Arası İletişim
- Süreçler bağımsız (başkasını etkilemez) ya da işbirlikçi (veri paylaşır) olabilir.
- İşbirliği nedenleri: bilgi paylaşımı, hızlanma (işi parçalamak), modülerlik, güvenlik ve yalıtım (Chrome).
- İşbirlikçi süreçler bir IPC (interprocess communication) mekanizmasına ihtiyaç duyar.
Üç temel soru
- Bir süreç diğerine bilgiyi nasıl iletir?
- Süreçler birbirinin yoluna çıkmasın: aynı koltuğa iki rezervasyon nasıl önlenir?
- Bağımlılıklarda doğru sıra nasıl sağlanır? (Nişan almadan ateş edilmemeli; üretilmeden tüketilmemeli.)
Süreçler Arası İletişim
Paylaşımlı Bellek ve İleti Geçirme
Paylaşımlı bellek: çekirdek bir bölge oluşturur ve iki sürecin adres alanına eşler (yalnızca kurulumda sistem çağrısı).
A bölgeye doğrudan yazar: çekirdek devrede değildir, bu yüzden çok hızlıdır.
B aynı veriyi okur. Ancak senkronizasyonu (kim ne zaman yazar?) süreçler kendileri sağlamalıdır.
İleti geçirme: A send(m₃) der; çekirdek iletiyi kendi kuyruğuna kopyalar.
B receive() ile sıradaki iletiyi alır. Her iletide sistem çağrısı ve kopyalama vardır; ama senkronizasyon çekirdekçe sağlanır, ağ üzerinden de çalışır.
Süreçler Arası İletişim
POSIX Paylaşımlı Bellek
/* üretici */ int fd = shm_open("/os03", O_CREAT|O_RDWR, 0600); ftruncate(fd, 4096); char *p = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); strcpy(p, "merhaba"); /* doğrudan yaz */ /* tüketici (başka süreç) */ int fd = shm_open("/os03", O_RDONLY, 0); char *p = mmap(NULL, 4096, PROT_READ, MAP_SHARED, fd, 0); printf("%s\n", p); shm_unlink("/os03"); /* sil */
shm_openadlı bir nesne oluşturur (Linux’ta/dev/shmaltında).ftruncateboyutu belirler,mmapadres alanına eşler.- Sonrası sıradan bellek erişimidir.
- Tüketici üreticiden önce okursa boş görür: gerçek kodda semafor gibi bir senkronizasyon gerekir.
- Eski System V API:
shmget/shmat.
Süreçler Arası İletişim
İleti Geçirme Tasarımı
İki temel işlem: send(mesaj) ve receive(mesaj). Önce bir iletişim bağı kurulmalıdır.
| Boyut | Seçenekler |
|---|---|
| Fiziksel bağ | paylaşımlı bellek, donanım veri yolu, ağ |
| Adlandırma | doğrudan (sürecin adı) · dolaylı (posta kutusu / port) |
| Eş zamanlı / eş zamansız | bloklayan (senkron): gönderen alınana kadar, alıcı ileti gelene kadar bekler · bloklamayan (eş zamansız): hemen döner |
| Tamponlama | sıfır kapasite (gönderen bekler: buluşma/rendezvous) · sınırlı (kuyruk doluysa bekler) · sınırsız (hiç beklemez) |
mq_send/mq_receive, Mach portları, Windows ALPC.Süreçler Arası İletişim
Doğrudan ve Dolaylı İletişim
send(P, m): P’ye gönder;receive(Q, m): Q’dan al.- Bağlantı otomatik kurulur, tam olarak bir çift sürece aittir.
- Her çift arasında tek bağlantı; genelde çift yönlü.
send(A, m)/receive(A, m): A kutusu üzerinden.- Her posta kutusunun tekil kimliği vardır; aynı kutuyu paylaşanlar haberleşir.
- Bir bağlantı çok sürece, bir çift çok bağlantıya sahip olabilir; tek ya da çift yönlü.
Süreçler Arası İletişim
Borular (Pipes)
Tasarım soruları
- Tek yönlü mü (simplex), çift yönlü mü?
- Çift yönlüyse yarı mı (half), tam mı (full duplex)?
- Süreçler arasında ebeveyn-çocuk ilişkisi gerekli mi?
- Ağ üzerinden kullanılabilir mi?
| Sıradan (adsız) | Adlandırılmış (FIFO) | |
|---|---|---|
| Erişim | yalnız oluşturan ve çocukları | dosya adı bilen her süreç |
| Yön | tek yönlü | UNIX: yarı çift yönlü; Windows: tam çift yönlü |
| Ömür | süreçler kapatınca biter | mkfifo; dosya sisteminde kalır |
| Ağ | hayır | UNIX hayır; Windows evet |
Süreçler Arası İletişim · Kodu adım adım çalıştır
Kod İzleme: pipe() + fork()
int main(void) { int fd[2]; char buf[32]; pipe(fd); pid_t pid = fork(); if (pid == 0) { /* çocuk: okur */ close(fd[1]); ssize_t n = read(fd[0], buf, sizeof buf - 1); buf[n] = '\0'; printf("çocuk aldı: %s\n", buf); close(fd[0]); return 0; } close(fd[0]); /* ebeveyn: yazar */ write(fd[1], "merhaba", 7); close(fd[1]); wait(NULL); return 0; }
pipe(fd): çekirdek boş bir tampon açar; okuma ucu fd[0]=3, yazma ucu fd[1]=4 (0–2 stdin/stdout/stderr).
fork(): çocuk tanımlayıcıları miras alır; şimdi her iki uç da iki süreçte açık.
Çocuk kullanmayacağı yazma ucunu kapatır.
Boru boş: read çocuğu bloke eder.
Ebeveyn okuma ucunu kapatır.
Ebeveyn 7 bayt yazar; ≤ PIPE_BUF yazımlar bölünmez (atomik). Bekleyen okuyucu uyanır.
Ebeveyn yazma ucunu kapatır (okuyucu ileride EOF görebilsin) ve wait ile bekler.
read 7 döndürür; veri tampondan çocuğun buf dizisine kopyalanır.
Sonlandırıcı '\0' eklenir ve yazdırılır.
Çocuk okuma ucunu kapatıp çıkar; ebeveyn wait’ten döner ve biter. Yalnız çocuk yazdığı için çıktı belirlenimlidir.
Süreçler Arası İletişim
Kabukta Boru Hattı: ls | wc -l
int fd[2]; pipe(fd); if (fork() == 0) { dup2(fd[1], 1); close(fd[0]); close(fd[1]); execlp("ls", "ls", NULL); } if (fork() == 0) { dup2(fd[0], 0); close(fd[0]); close(fd[1]); execlp("wc", "wc", "-l", NULL); } close(fd[0]); close(fd[1]); wait(NULL); wait(NULL);
Hata denetimleri kısalık için çıkarıldı. dup2(eski, yeni) yeni tanımlayıcıyı eskinin kopyası yapar; programlar stdin/stdout ile çalıştığı için boruyu fark etmez.
Süreçler Arası İletişim
Soketler
- Soket: iletişimin uç noktası; IP adresi + port ile tanımlanır (
161.25.19.8:80). - İletişim bir çift soket arasında olur; port, makinedeki hizmeti ayırt eder.
- 1024’ün altındaki portlar iyi bilinen hizmetlere ayrılmıştır (SSH 22, HTTP 80, HTTPS 443); sunucu olarak bu portları açmak (bind) yetki gerektirir.
127.0.0.1(IPv6:::1) geri döngü adresidir: aynı makinedeki süreçler.- TCP bağlantılı, sıralı, güvenilir bayt akışı; UDP bağlantısız datagram.
- Aynı makinede UNIX alan soketleri (
AF_UNIX) daha hızlıdır; Docker, systemd, X/Wayland bunları kullanır.
Mobil Sistemler
Mobil Sistemlerde Çoklu Görev
- İlk sürümler (2007) yalnız tek kullanıcı uygulamasına izin veriyordu; iOS 4 (2010) sınırlı çoklu görev getirdi.
- Arka planda yalnız izin verilen işler: ses çalma, konum, VoIP,
BGTaskSchedulergörevleri; diğerleri askıya alınır.
- Arka plan süreçlerine izin verir; uzun işler hizmet (service) bileşeniyle, arayüz askıdayken bile sürer.
- Android 8’den beri arka plan kısıtları: uzun iş için bildirimli ön plan hizmeti ya da
WorkManager.
Kısıtların nedeni sınırlı bellek ve pil. Eski belgelerdeki “arka plan” ve “boş” süreçler bugün önbellekteki (cached) grupta toplanır; bellek azalınca lmkd alttan başlayarak sonlandırır.
Özet
Özet
Yürütülen program: metin, veri, heap, yığın + CPU bağlamı + kaynaklar. Çekirdek onu PCB ile izler.
Yeni → Hazır ⇄ Çalışıyor → Bekliyor → Hazır … → Sonlandı. Çıkış durumu wait ile alınır.
fork kopyalar (COW), exec görüntüyü değiştirir, wait bekler ve biçer, exit bitirir.
Hazır/bekleme kuyrukları; bağlam değiştirme saf ek yüktür.
Paylaşımlı bellek hızlı ama senkronizasyon ister; ileti geçirme, boru ve soketler çekirdek aracılığıyla çalışır.
Sınırlı bellek ve pil yüzünden arka plandaki süreçler askıya alınır, gerekirse sonlandırılır.
Özet
Kontrol Soruları
fork(); fork();çalıştıran program toplam kaç süreçle biter? Yafor (i = 0; i < 3; i++) fork();?printf("A"); fork(); printf("B\n");stdout bir dosyaya yönlendirildiğinde çıktı nedir? Neden?- Bir süreç Bekliyor durumundan doğrudan Çalışıyor durumuna geçebilir mi?
- Zombi ile yetim süreç arasındaki fark nedir? Hangisi sistem için daha çok sorun çıkarır?
execbaşarılı olursa ardından gelen satır ne zaman çalışır?- p = 0,5 ve n = 3 için CPU kullanımı nedir?
- Boru örneğinde ebeveyn
close(fd[1])yapmasaydı ve çocuk EOF’a kadar okusaydı ne olurdu?
Cevapları göster
- 4 süreç (1 → 2 → 4). Döngüde 2³ = 8 süreç (7 yeni).
ABiki kez: dosyaya yazarken stdout tam tamponludur; "A" fork anında tamponda olduğu için çocuğa da kopyalanır.- Hayır; önce Hazır’a geçer, sonra çizelgeleyici seçer.
- Zombi bitmiş ama biçilmemiş; yetim çalışıyor ama ebeveyni yok (init evlat edinir). Biriken zombiler PID tüketir.
- Hiçbir zaman; satır yalnız exec başarısız olursa çalışır.
- 1 − 0,5³ = 0,875 → %87,5.
- Yazma ucu ebeveynde açık kaldığı için
readasla 0 döndürmez; çocuk sonsuza dek bekler, ebeveyn dewait’te bekler.
Özet
Kaynaklar
- A. Silberschatz, P. B. Galvin, G. Gagne, Operating System Concepts, 10. baskı, Wiley, 2018 — Bölüm 3: Processes.
- A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı (5. baskı 2023), Pearson — Bölüm 2: Processes and Threads.
- R. H. Arpaci-Dusseau, A. C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces (OSTEP), pages.cs.wisc.edu/~remzi/OSTEP — Processes, Process API.
- Linux kılavuz sayfaları:
fork(2),execve(2),wait(2),pipe(7),signal(7),shm_overview(7). - Chromium Projects, “Multi-process Architecture” ve “Site Isolation” belgeleri; Android Developers, “Processes and app lifecycle”.