Bölüm 3: Süreçler

İşletim Sistemleri
Süreç kavramıBellek yerleşimiOluşturma: fork / exec / wait Sonlandırma, zombi, yetimSüreç durumlarıPCB Çizelgeleme kuyruklarıBağlam değiştirmePaylaşımlı bellek İleti geçirmeBorular ve soketlerMobil sistemlerde çoklu görev
Sercan KÜLCÜ · Giresun Üniversitesi · Bilgisayar Mühendisliği

Giriş

Öğrenme Çıktıları

Süreç modeli

Program ile süreç arasındaki farkı ve bir sürecin bellek yerleşimini açıklamak.

Yaşam döngüsü

Süreç durumlarını, geçişleri ve PCB’nin içeriğini tanımlamak.

UNIX API

fork(), exec(), wait(), exit() ve pipe() kullanan küçük programları izlemek.

Çizelgeleme altyapısı

Hazır/bekleme kuyruklarını ve bağlam değiştirmenin maliyetini açıklamak.

IPC

Paylaşımlı bellek, ileti geçirme, boru ve soketleri karşılaştırmak.

Mobil çoklu görev

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.
a.outprogram (diskte)pasif · dosyaçalıştırçalıştırsüreç · PID 4021metinveriheapyığınaktif · bellekte · kendi PCB’sisüreç · PID 4022metinveriheapyığınaktif · bellekte · kendi PCB’siaynı programdaniki ayrı süreç:ayrı adres alanı,ayrı durum ve kaynaklar

Süreç Kavramı

Bellekte Süreç Yerleşimi

çekirdek alanıher sürece eşlenir; kullanıcı modunda erişilemezyığın (stack)yerel değişkenler, parametreler, dönüş adresleriboş alanheapmalloc() / new ile çalışma anında ayrılan bellekBSSilk değer verilmemiş global / static (sıfırlanır)veri (data)ilk değer verilmiş global / static değişkenlermetin (text)programın makine kodu (salt okunur, paylaşılabilir)büyürbüyüryüksek adresadres 0’a yakın
Yığın (stack) yüksek adreslerden aşağı, heap yukarı doğru büyür. Program sayacı bellekte değil, işlemcide bir yazmaçtır; sürecin “şu anki konumu”nu gösterir. Gerçek düzende ASLR adresleri her çalıştırmada rastgele kaydırır.

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.

çekirdek alanıyığın (stack)↓ boş ↑heapBSSveri (data)metin (text)main()malloc(), free()(makine kodu)

Metin: main fonksiyonunun derlenmiş komutları; salt okunur ve aynı programın süreçleri arasında paylaşılabilir.

çekirdek alanıyığın (stack)↓ boş ↑heapBSSveri (data)metin (text)sayac = 5

Veri: ilk değeri verilmiş global sayac; değeri çalıştırılabilir dosyada saklanır.

çekirdek alanıyığın (stack)↓ boş ↑heapBSSveri (data)metin (text)tablo[1000]adet (static)

BSS: ilk değeri verilmemiş global ve static değişkenler; yükleyici sıfırla doldurur, dosyada yer kaplamaz.

çekirdek alanıyığın (stack)↓ boş ↑heapBSSveri (data)metin (text)argc, argvyerel = 3p (işaretçinin kendisi)dönüş adresi

Yığın: main çağrı çerçevesi: parametreler, yerel değişkenler ve işaretçi p’nin kendisi.

çekirdek alanıyığın (stack)↓ boş ↑heapBSSveri (data)metin (text)*p → 16 bayt(malloc ile)

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

(a) tek program sayacıABCDsüreçdeğişimi(b) dört bağımsız süreçABCDher birinin mantıksal PC’si var(c) bir anda yalnız biri çalışırzamanDCBA
  • 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

Eş zamanlılık(1 çekirdek)ABCABCABParalellik(2 çekirdek)AAABBBAACCCCAACCçekirdek 0çekirdek 1zaman
Eş zamanlılık (concurrency)

Birden çok iş aynı zaman aralığında ilerler; tek çekirdekte iç içe geçerek (interleaving).

Paralellik (parallelism)

Birden çok iş aynı anda yürütülür; birden çok çekirdek ya da işlemci gerekir.

2026 itibarıyla telefonlar bile 6–10 çekirdeklidir; yine de çalışan süreç sayısı (yüzlerce) çekirdek sayısından çok fazladır, bu yüzden çoklu programlama ve geçişler her sistemde vardır.

Süreç Kavramı

Örnek: Chrome’un Çok Süreçli Mimarisi

Tarayıcı süreciarayüz, sekmeler, izinler, diskOluşturucusite AOluşturucusite BGPU süreciçizimAğ hizmetiHTTP, önbellekEklenti / yardımcıuzantı, ses...IPC (Mojo)oluşturucular korumalı alanda (sandbox) çalışır;bir sekme çökse de tarayıcı ve diğer sekmeler yaşar
TarayıcıArayüzü, sekmeleri, disk ve izinleri yönetir; ayrıcalıklı tek süreç.
Oluşturucu (renderer)HTML, CSS, JavaScript işler; site yalıtımı ile site başına ayrı süreç.
GPU / ağ / yardımcıÇizim, ağ, uzantılar ayrı süreçlerde. Eski eklenti desteği kaldırıldı: NPAPI 2015’te, Flash 2020 sonunda.

Süreç Oluşturma

Süreç Oluşturma

Süreç oluşturan olaylar

  1. Sistem açılışı (init/systemd, arka plan hizmetleri: daemon).
  2. Çalışan bir sürecin süreç oluşturan sistem çağrısı yapması.
  3. Kullanıcının bir komut ya da uygulama başlatması.
  4. 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 / Linuxfork() + exec(); ayrıca posix_spawn(), Linux’ta clone()
WindowsCreateProcess(): oluşturma ve program yüklemeyi tek çağrıda yapar
Ebeveyn (parent) süreç çocuk (child) süreç oluşturur; çocuklar da kendi çocuklarını oluşturarak bir süreç ağacı oluşur. Her süreç tekil bir PID taşır.

Süreç Oluşturma

Süreç Ağacı

systemdPID 1kthreaddPID 2journaldPID 312sshdPID 890gdmPID 1003kworker/0:1PID 57sshd (oturum)PID 2101gnome-shellPID 1520bashPID 2105firefoxPID 2310vimPID 2230psPID 2241çekirdek işparçacıkları$ pstree -p$ ps -ef --forest

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

Kaynak paylaşımı

Ç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.

Yürütme

Ebeveyn ve çocuk eş zamanlı çalışabilir ya da ebeveyn wait() ile çocuğun bitmesini bekleyebilir.

Adres alanı

UNIX fork(): çocuk ebeveynin adres alanının kopyasını alır (paylaşmaz). Ardından exec() ile yeni bir program yükleyebilir.

Kimlikler

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 */ }
ebeveyn (PID 1234)sayfa tablosufiziksel bellek (çerçeveler)sayfa Asayfa Bsayfa C

Başlangıç: ebeveyn sürecin sayfa tablosu fiziksel A, B, C sayfalarını gösteriyor.

ebeveyn (PID 1234)sayfa tablosuçocuk (PID 1235)sayfa tablosufiziksel bellek (çerçeveler)sayfa Asayfa Bsayfa Cyazmaya karşıkorumalı paylaşım(salt okunur)

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.

ebeveyn (PID 1234)sayfa tablosuçocuk (PID 1235)sayfa tablosufiziksel bellek (çerçeveler)sayfa Asayfa Bsayfa Csayfa C′kopyalayazmaya karşıkorumalı paylaşım(salt okunur)çocuk C’ye yazdı →sayfa hatası →çekirdek kopyaladı

Ç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;
}
ebeveyn · 1234çalışıyor

Tek süreç var: ebeveyn (PID 1234), x = 10.

ebeveyn · 1234fork() → 1235çocuk · 1235fork() → 0

fork() çocuk 1235’i oluşturur. Ebeveynde pid = 1235, çocukta pid = 0; iki ayrı x var.

ebeveyn · 1234wait() → bekliyorçocuk · 1235hazır

Ebeveynde pid ≠ 0: if atlanır, wait(NULL) çocuk bitene kadar ebeveyni bekliyor durumuna sokar.

ebeveyn · 1234bekliyorçocuk · 1235çalışıyor

Çocukta pid == 0 doğru: çocuk dalına girer. (Çocuk önce çalışmış olsaydı da sonuç aynı olurdu.)

ebeveyn · 1234bekliyorçocuk · 1235çalışıyor

Çocuk kendi kopyasını değiştirir: x = 15. Ebeveynin x’i 10 kalır.

ebeveyn · 1234bekliyorçocuk · 1235çalışıyor

Çocuk yazdırır.

ebeveyn · 1234uyandı (SIGCHLD)çocuk · 1235zombi

Çocuk return 0 ile çıkar (exit(0)); kısa süre zombi olur, çekirdek ebeveyni uyandırır.

ebeveyn · 1234çalışıyorçocuk · 1235biçildi

wait 1235 döndürür; çocuğun girdisi süreç tablosundan silinir.

ebeveyn · 1234çalışıyorçocuk · 1235biçildi

Ebeveyn yazdırır: kendi x’i hâlâ 10.

ebeveyn · 1234sonlandıçocuk · 1235biçildi

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");
Çizelge 1fork()ebeveyn: printfçocuk: printfebeveynçocukÇizelge 2fork()çocuk: printfebeveyn: printfçocukebeveynzaman (tek çekirdek)
fork sonrası hangi sürecin önce çalışacağını çizelgeleyici belirler; çok çekirdekte ikisi aynı anda bile çalışabilir. Programın doğruluğu bu sıraya bağlıysa wait() (ya da başka bir senkronizasyon) kullanılmalıdır.

Süreç Oluşturma

exec() Ailesi

exec öncesiexeclp("ls", ...) sonrasıPID 1235 · PPID 1234metin: a.out koduveri / BSSheapyığınaçık dosyalar 0,1,2cwd, kimliklerPID 1235 · PPID 1234metin: ls koduyeni veri / BSSyeni (boş) heapyeni yığın: argvaçık dosyalar 0,1,2cwd, kimlikleradres alanı tümüyleyeniden yüklenirkorunan: PID, PPID,açık dosya tanımlayıcıları
ÇağrıArgümanlarPATH aramasıOrtam
execl / execvliste / dizihayırdevralınır
execlp / execvpliste / dizievetdevralınır
execle / execveliste / dizihayıraçı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?

1. Dosyayı aç; izni ve biçimi (ELF başlığı ya da #! satırı) denetle.

Dosya yoksa ya da çalıştırılamıyorsa exec −1 döner ve eski program kaldığı yerden sürer.

2. Eski adres alanını bırak.

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.

3. close-on-exec fd’leri kapat, sinyal işleyicilerini sıfırla.

Yakalanan sinyaller varsayılan eyleme döner, çünkü işleyici kodu artık bellekte değildir; yok sayılanlar yok sayılmaya devam eder.

4. Kod ve veri bölümlerini dosyadan eşle.

Kopyalama yapılmaz: bir sayfa ilk kez kullanıldığında sayfa hatası olur ve o sayfa diskten getirilir (tembel yükleme).

5. bss, heap ve yığın için sıfırlı bellek ayır.

Yığının tepesine argv ve envp dizgileri, bunları gösteren işaretçi dizileri ve argc yerleştirilir.

6. PC = giriş noktası; kullanıcı moduna dön.

_start C çalışma zamanını kurar ve main(argc, argv, envp)’yi çağırır. PID hiç değişmemiştir.

eski kod, veri, heap,yığın: silinirkorunur:PID ve ebeveynaçık fd’ler (cloexec hariç)çalışma dizini, kullanıcısinyal maskesiprog (ELF)başlık.text.datayığınargc, argv, envpboşheap (boş)bss (sıfırlı)verimetin (kod)PC = giriş (_start)eşleme tembeldir: sayfa ilk erişimde okunur

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;
}
ebeveyn · 1234fork() → 1235çocuk · 1235fork() → 0

fork(): iki süreç aynı a.out görüntüsünü çalıştırıyor.

ebeveyn · 1234waitpid → bekliyorçocuk · 1235hazır

Ebeveyn çocuk dalını atlar ve waitpid(1235, ...) ile bloke olur.

ebeveyn · 1234bekliyorçocuk · 1235exec: ls

Çocuk execlp çağırır: PATH içinde ls bulunur, adres alanı /usr/bin/ls ile değiştirilir. PID hâlâ 1235.

ebeveyn · 1234bekliyorçocuk · 1235ls çalışıyor

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.

ebeveyn · 1234uyandıçocuk · 1235çıktı: 0

ls exit(0) ile biter; waitpid döner ve st çıkış durumunu taşır.

ebeveyn · 1234çalışıyorçocuk · 1235biçildi

WEXITSTATUS(st) = 0 yazdırılır.

Süreç Oluşturma

Kabuk Döngüsü: fork → exec → wait

bashPID 2105$ ls → komutu okur

Kabuk istemi gösterir ve ls komutunu okur.

bashPID 2105bash (kopya)PID 2300fork()waitpid(2300)→ bekliyor

fork(): kabuğun bir kopyası (PID 2300) oluşur; ebeveyn waitpid ile beklemeye geçer.

bashPID 2105lsPID 2300fork()execvp("ls")görüntü ls ile değişirwaitpid(2300)→ bekliyor

Çocuk execvp("ls", argv) çağırır; görüntüsü ls ile değişir.

bashPID 2105lsPID 2300fork()execvp("ls")görüntü ls ile değişirwaitpid(2300)→ bekliyorlsçalışırstdout’a yazar

ls çalışır, miras aldığı terminal stdout’una yazar.

bashPID 2105lsPID 2300fork()execvp("ls")görüntü ls ile değişirwaitpid(2300)→ bekliyorlsçalışırstdout’a yazarexit(0) → SIGCHLDçocuk biçilir (reap)

ls çıkar; çekirdek ebeveyni SIGCHLD ile bilgilendirir, waitpid çocuğu biçer.

bashPID 2105lsPID 2300fork()execvp("ls")görüntü ls ile değişirwaitpid(2300)→ bekliyorlsçalışırstdout’a yazarexit(0) → SIGCHLDçocuk biçilir (reap)$ yeni istem (prompt)

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;
}
çocuğun fd tablosu (ebeveynin kopyası)0 → tty1 → tty2 → ttyebeveyn: 0, 1, 2 → terminal (değişmez)

fork(): çocuk ebeveynin fd tablosunu kopyalar; 0, 1, 2 terminaldir.

çocuğun fd tablosu0 → tty1 → tty2 → ttyebeveyn: 0, 1, 2 → terminal (değişmez)

Ebeveyn waitpid ile bekler; sonraki adımlar yalnız çocuğun tablosunu değiştirir.

çocuğun fd tablosu0 → tty1 → (boş)2 → ttyebeveyn: 0, 1, 2 → terminal (değişmez)

close(1): çocuğun 1 numaralı girişi boşalır. Ebeveynin stdout’u hâlâ terminaldir.

çocuğun fd tablosu0 → tty1 → sayim.txt2 → ttyebeveyn: 0, 1, 2 → terminal (değişmez)

open her zaman en küçük boş numarayı verir: 1. Artık çocuğun stdout’u dosyadır.

çocuk = wc · fd tablosu korundu0 → tty1 → sayim.txt2 → ttyebeveyn: 0, 1, 2 → terminal (değişmez)

exec kodu ve veriyi değiştirir, fd tablosunu korur: habersiz wc fd 1’e, yani dosyaya yazar.

çocuk bitti; dosyada: 42 notlar.txt0 → tty1 → sayim.txt2 → tty$ cat sayim.txt → 42 notlar.txt

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

NedenTü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 hataistemsizgeçersiz bellek erişimi (SIGSEGV), sıfıra bölme (SIGFPE)
Başka süreç tarafındanistemsizkill(pid, SIGTERM), Windows’ta TerminateProcess()
  • exit(durum): C kütüphanesi tamponları boşaltır, atexit işleyicilerini çalıştırır, sonra _exit sistem ç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çin kill() 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

HataSinyal
Geçersiz/izinsiz bellek erişimiSIGSEGV
Tam sayı sıfıra bölmeSIGFPE
Geçersiz komutSIGILL
Hizalama / veri yolu hatasıSIGBUS
Kapalı boruya yazmaSIGPIPE
  • İş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 core ile hatanın nedeni incelenir (crash dump analizi).
Bellek sızıntısı ve kaynakları serbest bırakmamak kendi başına ölümcül hata değildir; süreç çalışmayı sürdürür. Bellek tükenirse Linux OOM killer süreci SIGKILL ile sonlandırabilir.
p = NULL; *p = 5MMU: sayfa hatasıçekirdek: geçersiz adresSIGSEGV gönderilirsonlan + coreişleyici yoksa

Süreç Sonlandırma

Sinyallerle Sonlandırma: kill, pkill, killall

SinyalNoAnlamı
SIGTERM15kibarca bitir; süreç yakalayıp temizlik yapabilir (kill’in varsayılanı)
SIGKILL9zorla bitir; yakalanamaz, yok sayılamaz, temizlik yapılamaz
SIGINT2terminalde Ctrl+C
SIGTSTP20terminalde Ctrl+Z (duraklat); fg/bg sürdürür
SIGSTOP / SIGCONT19 / 18durdur (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

Senaryo 1: çocuk önce biterebeveyn · PID 100çalışıyorçocuk · PID 101çalışıyor

Ebeveyn (100) ve çocuk (101) çalışıyor.

Senaryo 1: çocuk önce biterebeveyn · PID 100çalışıyorçocuk · PID 101ZOMBİ (Z) · çıkış kodu saklı

Ç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>).

Senaryo 1: çocuk önce biterebeveyn · PID 100wait() çağırırPID 101 süreç tablosundan silindidurum=0 alındı

Ebeveyn wait() çağırır, çıkış durumunu alır; çekirdek girdiyi siler (biçme, reaping). Zombi kalmaz.

Senaryo 2: ebeveyn önce bitersystemd · PID 1init / subreaperebeveyn (100) sonlandıçocuk · PID 101YETİM · PPID artık yok

Senaryo 2: ebeveyn (100) çocuktan önce sonlandı. Çocuk (101) hâlâ çalışıyor: yetim süreç.

Senaryo 2: ebeveyn önce bitersystemd · PID 1init / subreaperçocuk · PID 101evlat edinildi · PPID = 1

Ç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.

Senaryo 2: ebeveyn önce bitersystemd · PID 1init / subreaperçocuk · PID 101bitti → systemd wait() ile biçer

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)

Yeninew: oluşturuluyor
Hazırready: CPU’yu bekliyor
Çalışıyorrunning: komutlar yürütülüyor
Bekliyorwaiting/blocked: bir olayı bekliyor
Sonlandıterminated: yürütme bitti
kabul (admitted)çizelgeleyici seçti (dispatch)kesme / zaman dilimi dolduG/Ç ya da olay bekleG/Ç ya da olay tamamlandıçıkış (exit)YeninewHazırreadyÇalışıyorrunningBekliyorwaitingSonlandıterminated

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

kabul (admitted)çizelgeleyici seçti (dispatch)kesme / zaman dilimi dolduG/Ç ya da olay bekleG/Ç ya da olay tamamlandıçıkış (exit)YeninewHazırreadyÇalışıyorrunningBekliyorwaitingSonlandıterminated

Kullanıcı programı başlattı: PCB oluşturuluyor, bellek ayrılıyor → Yeni.

kabul (admitted)çizelgeleyici seçti (dispatch)kesme / zaman dilimi dolduG/Ç ya da olay bekleG/Ç ya da olay tamamlandıçıkış (exit)YeninewHazırreadyÇalışıyorrunningBekliyorwaitingSonlandıterminated

Çekirdek süreci kabul etti ve hazır kuyruğuna koydu → Hazır.

kabul (admitted)çizelgeleyici seçti (dispatch)kesme / zaman dilimi dolduG/Ç ya da olay bekleG/Ç ya da olay tamamlandıçıkış (exit)YeninewHazırreadyÇalışıyorrunningBekliyorwaitingSonlandıterminated

Çizelgeleyici bu süreci seçti, bağlamı yüklendi → Çalışıyor.

kabul (admitted)çizelgeleyici seçti (dispatch)kesme / zaman dilimi dolduG/Ç ya da olay bekleG/Ç ya da olay tamamlandıçıkış (exit)YeninewHazırreadyÇalışıyorrunningBekliyorwaitingSonlandıterminated

Süreç diskten read() istedi; veri gelene kadar CPU’yu bırakır → Bekliyor.

kabul (admitted)çizelgeleyici seçti (dispatch)kesme / zaman dilimi dolduG/Ç ya da olay bekleG/Ç ya da olay tamamlandıçıkış (exit)YeninewHazırreadyÇalışıyorrunningBekliyorwaitingSonlandıterminated

Disk kesmesi: veri hazır. Süreç doğrudan çalışmaz, hazır kuyruğuna döner → Hazır.

kabul (admitted)çizelgeleyici seçti (dispatch)kesme / zaman dilimi dolduG/Ç ya da olay bekleG/Ç ya da olay tamamlandıçıkış (exit)YeninewHazırreadyÇalışıyorrunningBekliyorwaitingSonlandıterminated

Yeniden seçildi → Çalışıyor.

kabul (admitted)çizelgeleyici seçti (dispatch)kesme / zaman dilimi dolduG/Ç ya da olay bekleG/Ç ya da olay tamamlandıçıkış (exit)YeninewHazırreadyÇalışıyorrunningBekliyorwaitingSonlandıterminated

Zamanlayıcı kesmesi: zaman dilimi doldu (kesmeli çizelgeleme) → Hazır.

kabul (admitted)çizelgeleyici seçti (dispatch)kesme / zaman dilimi dolduG/Ç ya da olay bekleG/Ç ya da olay tamamlandıçıkış (exit)YeninewHazırreadyÇalışıyorrunningBekliyorwaitingSonlandıterminated

Tekrar seçildi → Çalışıyor.

kabul (admitted)çizelgeleyici seçti (dispatch)kesme / zaman dilimi dolduG/Ç ya da olay bekleG/Ç ya da olay tamamlandıçıkış (exit)YeninewHazırreadyÇalışıyorrunningBekliyorwaitingSonlandıterminated

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 STATAnlamModeldeki karşılığı
Rçalışıyor ya da çalışmaya hazırÇalışıyor + Hazır
Skesilebilir uyku (olay bekliyor)Bekliyor
Dkesilemez uyku (genelde disk G/Ç)Bekliyor
Tdurdurulmuş (SIGSTOP, hata ayıklayıcı)askıya alınmış
ZzombiSonlandı (biçilmedi)
Iboş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)

süreç durumusüreç kimliği (PID)program sayacıyazmaçlarçizelgeleme bilgisibellek yönetim bilgisiaçık dosyalar listesimuhasebe bilgisi (CPU süresi)• • •bağlam(context)
  • Ç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önetimiBellek yönetimiDosya 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 listesikök dizin · çalışma dizini · dosya tanımlayıcıları · kullanıcı kimliği (UID) · grup kimliği (GID)
PSW

Durum bayrakları (sıfır, taşma...), çalışma modu (kullanıcı/çekirdek), kesme izinleri.

Süreç grubu

Birlikte yönetilen süreçler: kabuktaki bir boru hattı tek grup olur, Ctrl+C hepsine gider.

Sonraki alarm

alarm() ile istenen SIGALRM’nin teslim zamanı.

süreç tablosu141210331034…PID ile indislenen dizi ya da listesüreç: durum, yazmaçlar, öncelikbellek: sayfa tablosu işaretçisidosya: açık dosyalar, çalışma diziniPCB (PID 1033)

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 ... */
};
task_structPID 1task_structPID 2105task_structPID 2241currenttasks: çift yönlü bağlı liste
  • Tüm görevler çift yönlü bağlı listededir; current o çekirdekte çalışan görevi gösterir.
  • Eski çekirdeklerdeki long state / time_slice alanları güncel çekirdeklerde __state ve sched_entity içine taşınmıştır.

Çizelgeleme

Hazır ve Bekleme Kuyrukları

hazır kuyruğubaş · sonPCB 7PCB 2PCB 9disk G/Ç beklemebaş · sonPCB 3PCB 14ağ / klavye beklemebaş · sonPCB 6CPUPCB 5 çalışıyorkuyruklar PCB’lere bağlı listeler olarak tutulur
  • Ç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

hazır kuyruğuCPUsonlan (exit)G/Ç bekleme kuyruğuG/Ç isteğizaman dilimi dolduçocuğun bitmesini bekleçocuk oluştur (fork)kesme bekleme kuyruğukesme bekle

Yeni süreç hazır kuyruğunun sonuna eklenir ve sırasını bekler.

hazır kuyruğuCPUsonlan (exit)G/Ç bekleme kuyruğuG/Ç isteğizaman dilimi dolduçocuğun bitmesini bekleçocuk oluştur (fork)kesme bekleme kuyruğukesme bekle

Çizelgeleyici onu seçer (dispatch): süreç CPU’da çalışır.

hazır kuyruğuCPUsonlan (exit)G/Ç bekleme kuyruğuG/Ç isteğizaman dilimi dolduçocuğun bitmesini bekleçocuk oluştur (fork)kesme bekleme kuyruğukesme bekle

G/Ç isteği yaptı: G/Ç bekleme kuyruğuna geçer; G/Ç bitince hazır kuyruğuna döner.

hazır kuyruğuCPUsonlan (exit)G/Ç bekleme kuyruğuG/Ç isteğizaman dilimi dolduçocuğun bitmesini bekleçocuk oluştur (fork)kesme bekleme kuyruğukesme bekle

Zaman dilimi doldu: zamanlayıcı kesmesiyle CPU’dan alınır, doğrudan hazır kuyruğuna döner.

hazır kuyruğuCPUsonlan (exit)G/Ç bekleme kuyruğuG/Ç isteğizaman dilimi dolduçocuğun bitmesini bekleçocuk oluştur (fork)kesme bekleme kuyruğukesme bekle

Çocuk oluşturup wait() çağırdı: çocuk bitene kadar bekler.

hazır kuyruğuCPUsonlan (exit)G/Ç bekleme kuyruğuG/Ç isteğizaman dilimi dolduçocuğun bitmesini bekleçocuk oluştur (fork)kesme bekleme kuyruğukesme bekle

Bir kesmeyi/olayı bekliyor (örn. sleep(), ağ paketi).

hazır kuyruğuCPUsonlan (exit)G/Ç bekleme kuyruğuG/Ç isteğizaman dilimi dolduçocuğun bitmesini bekleçocuk oluştur (fork)kesme bekleme kuyruğukesme bekle

İş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

(a) CPU’ya bağlı(b) G/Ç’ye bağlıCPU patlaması (burst)G/Ç beklemezaman
CPU’ya bağlı (CPU-bound)

Uzun hesaplama patlamaları, seyrek G/Ç: derleme, video kodlama, bilimsel hesap.

G/Ç’ye bağlı (I/O-bound)

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

204060801000246810bellekteki süreç sayısı (çoklu programlama derecesi) nCPU %%20 G/Ç bekleme%50 G/Ç bekleme%80 G/Ç bekleme

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);
}
%0%50%100n=1n=2n=3n=4n=5boş olasılığı pⁿ = —

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.

%0%50%100n=1n=2n=3n=4n=5boş olasılığı pⁿ = 0,8

n = 1: tek süreç; CPU’nun boş kalma olasılığı pⁿ = 0,8.

%0%50%100n=1%20boşn=2n=3n=4n=5boş olasılığı pⁿ = 0,8

kul = 1 − 0,8 = %20: tek programlı sistemde CPU zamanın beşte dördünde boş.

%0%50%100n=1%20n=2n=3n=4n=5boş olasılığı pⁿ = 0,64

n = 2: hepsinin birden beklemesi olasılığı 0,82 = 0,64.

%0%50%100n=1%20n=2%36boşn=3n=4n=5boş olasılığı pⁿ = 0,64

kul = %36.

%0%50%100n=1%20n=2%36n=3n=4n=5boş olasılığı pⁿ = 0,512

n = 3: hepsinin birden beklemesi olasılığı 0,83 = 0,512.

%0%50%100n=1%20n=2%36n=3%49boşn=4n=5boş olasılığı pⁿ = 0,512

kul = %48,8.

%0%50%100n=1%20n=2%36n=3%49n=4n=5boş olasılığı pⁿ = 0,4096

n = 4: hepsinin birden beklemesi olasılığı 0,84 = 0,4096.

%0%50%100n=1%20n=2%36n=3%49n=4%59boşn=5boş olasılığı pⁿ = 0,4096

kul = %59,04.

%0%50%100n=1%20n=2%36n=3%49n=4%59n=5boş olasılığı pⁿ = 0,3277

n = 5: hepsinin birden beklemesi olasılığı 0,85 = 0,32768.

%0%50%100n=1%20n=2%36n=3%49n=4%59n=5%67boşboş olasılığı pⁿ = 0,3277

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)

süreç P₀işletim sistemisüreç P₁zaman

P₀ çalışıyor (kalın çizgi); P₁ hazır kuyruğunda bekliyor.

süreç P₀işletim sistemisüreç P₁kesme ya da sistem çağrısıdurumu PCB₀’a kaydetzaman

Kesme ya da sistem çağrısı: CPU çekirdek moduna geçer, P₀’ın program sayacı ve yazmaçları PCB₀’a kaydedilir.

süreç P₀işletim sistemisüreç P₁kesme ya da sistem çağrısıdurumu PCB₀’a kaydetdurumu PCB₁’den yüklezaman

Çizelgeleyici P₁’i seçer; P₁’in bağlamı PCB₁’den yüklenir (adres alanı da değişir).

süreç P₀işletim sistemisüreç P₁kesme ya da sistem çağrısıdurumu PCB₀’a kaydetdurumu PCB₁’den yükleboşta (idle)zaman

P₁ çalışıyor; P₀ boşta (hazır ya da bekliyor).

süreç P₀işletim sistemisüreç P₁kesme ya da sistem çağrısıdurumu PCB₀’a kaydetdurumu PCB₁’den yükledurumu PCB₁’e kaydetzaman

Yeni kesme: P₁’in durumu PCB₁’e kaydedilir.

süreç P₀işletim sistemisüreç P₁kesme ya da sistem çağrısıdurumu PCB₀’a kaydetdurumu PCB₁’den yükledurumu PCB₁’e kaydetdurumu PCB₀’dan yüklezaman

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);
CPU (P₀)pc104sp896r18PCB₀ çalışıyorpc—sp—r1—PCB₁ hazırpc340sp500r12

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.

CPU (P₀)pc104sp896r18PCB₀ çalışıyorpc104sp896r1—PCB₁ hazırpc340sp500r12kaydet

Kaydet: P₀’ın pc ve sp değerleri PCB₀’a yazılır. Bunlar kaybolursa P₀ kaldığı yere dönemez.

CPU (P₀)pc104sp896r18PCB₀ hazırpc104sp896r18PCB₁ hazırpc340sp500r12kaydet

Genel yazmaç da kaydedilir; P₀ artık hazır (H).

CPU (P₁)pc340sp500r18PCB₀ hazırpc104sp896r18PCB₁ hazırpc340sp500r12yükle

Yükle: P₁’in pc ve sp değerleri CPU’ya. Bu andan sonra CPU P₁’in koduna ve yığınına bakar.

CPU (P₁)pc340sp500r12PCB₀ hazırpc104sp896r18PCB₁ çalışıyorpc340sp500r12yükle

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.

CPU (P₁)pc352sp492r15PCB₀ hazırpc104sp896r18PCB₁ çalışıyorpc340sp500r12

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.

CPU (P₁)pc352sp492r15PCB₀ hazırpc104sp896r18PCB₁ çalışıyorpc340sp500r12

Yeni kesme: çekirdek P₀’a dönmeye karar verir.

CPU (P₁)pc352sp492r15PCB₀ hazırpc104sp896r18PCB₁ çalışıyorpc352sp492r12kaydet

P₁’in pc ve sp değerleri PCB₁’e kaydedilir.

CPU (P₁)pc352sp492r15PCB₀ hazırpc104sp896r18PCB₁ hazırpc352sp492r15kaydet

r1 de kaydedilir; P₁ hazır.

CPU (P₀)pc104sp896r15PCB₀ hazırpc104sp896r18PCB₁ hazırpc352sp492r15

PCB₀’daki değerler geri yüklenir: pc = 104, sp = 896.

CPU (P₀)pc104sp896r18PCB₀ çalışıyorpc104sp896r18PCB₁ hazırpc352sp492r15

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.

İS (çekirdek modu)DonanımProgram (kullanıcı modu)açılışçalışmatuzak tablosunu kurişleyici adreslerini saklazamanlayıcıyı başlatbirkaç ms’de bir kesme üret

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.

İS (çekirdek modu)DonanımProgram (kullanıcı modu)açılışçalışmatuzak tablosunu kurişleyici adreslerini saklazamanlayıcıyı başlatbirkaç ms’de bir kesme üretA çalışıyor (doğrudan CPU’da)

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.

İS (çekirdek modu)DonanımProgram (kullanıcı modu)açılışçalışmatuzak tablosunu kurişleyici adreslerini saklazamanlayıcıyı başlatbirkaç ms’de bir kesme üretA çalışıyor (doğrudan CPU’da)zamanlayıcı kesmesiyazmaçlar(A) → çekirdek yığını

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 (çekirdek modu)DonanımProgram (kullanıcı modu)açılışçalışmatuzak tablosunu kurişleyici adreslerini saklazamanlayıcıyı başlatbirkaç ms’de bir kesme üretA çalışıyor (doğrudan CPU’da)zamanlayıcı kesmesiyazmaçlar(A) → çekirdek yığınıçizelgeleyici B’yi seçerswitch(): A → PCB(A), B’yi yükle

İ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.

İS (çekirdek modu)DonanımProgram (kullanıcı modu)açılışçalışmatuzak tablosunu kurişleyici adreslerini saklazamanlayıcıyı başlatbirkaç ms’de bir kesme üretA çalışıyor (doğrudan CPU’da)zamanlayıcı kesmesiyazmaçlar(A) → çekirdek yığınıçizelgeleyici B’yi seçerswitch(): A → PCB(A), B’yi yüklereturn-from-trapyazmaçlar(B), kullanıcı moduB çalışıyor

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.
Doğrudan maliyet

Yazmaçların kaydı/yüklenmesi, çekirdek kodu: güncel Linux’ta tipik olarak birkaç mikrosaniye.

Dolaylı maliyet

Ö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.

Donanım desteği

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):

1. Donanım program sayacı, PSW vb. değerleri yığına kaydeder.

Kesme isteği komut sınırında kabul edilir; CPU çekirdek moduna geçer.

2. Donanım kesme vektöründen yeni program sayacını yükler.

Vektör, her kesme türü için işleyicinin adresini tutan tablodur.

3. Assembly yordamı yazmaçları kaydeder.

Yazmaçlar o anki sürecin PCB’sine (ya da çekirdek yığınına) yazılır.

4. Assembly yordamı yeni bir yığın hazırlar.

Kesme işleyicisi çekirdek yığınında çalışır.

5. C kesme hizmet yordamı çalışır.

Genelde girdiyi okur/tamponlar; bekleyen süreci hazır yapar.

6. Çizelgeleyici sıradaki süreci seçer.

Uyanan süreç daha öncelikliyse kesilen süreç yerine o seçilebilir.

7. C yordamı assembly koduna döner.

Kalan iş, seçilen sürecin bağlamının yüklenmesidir.

8. Assembly yordamı yeni süreci başlatır.

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

  1. Bir süreç diğerine bilgiyi nasıl iletir?
  2. Süreçler birbirinin yoluna çıkmasın: aynı koltuğa iki rezervasyon nasıl önlenir?
  3. Bağımlılıklarda doğru sıra nasıl sağlanır? (Nişan almadan ateş edilmemeli; üretilmeden tüketilmemeli.)
İki temel model: paylaşımlı bellek ve ileti geçirme. Son iki soru eşgüdüm (senkronizasyon) gerektirir: paylaşılan veriye denetimsiz erişim, sonucu yürütme sırasına bağlı kılar (yarış durumu). Aynı sorular iş parçacıkları için de geçerlidir.

Süreçler Arası İletişim

Paylaşımlı Bellek ve İleti Geçirme

(a) paylaşımlı bellek(b) ileti geçirmesüreç Apaylaşımlı bölgeiki adres alanına da eşlenirsüreç Bçekirdekshm_open + mmapsüreç Asüreç Bçekirdek: ileti kuyruğum₀m₁m₂

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) paylaşımlı bellek(b) ileti geçirmesüreç Apaylaşımlı bölgeiki adres alanına da eşlenirsüreç Bçekirdekyazsüreç Asüreç Bçekirdek: ileti kuyruğum₀m₁m₂

A bölgeye doğrudan yazar: çekirdek devrede değildir, bu yüzden çok hızlıdır.

(a) paylaşımlı bellek(b) ileti geçirmesüreç Apaylaşımlı bölgeiki adres alanına da eşlenirsüreç Bçekirdekokusüreç Asüreç Bçekirdek: ileti kuyruğum₀m₁m₂

B aynı veriyi okur. Ancak senkronizasyonu (kim ne zaman yazar?) süreçler kendileri sağlamalıdır.

(a) paylaşımlı bellek(b) ileti geçirmesüreç Apaylaşımlı bölgeiki adres alanına da eşlenirsüreç Bçekirdeksüreç Asüreç Bçekirdek: ileti kuyruğum₀m₁m₂m₃send(m₃)

İleti geçirme: A send(m₃) der; çekirdek iletiyi kendi kuyruğuna kopyalar.

(a) paylaşımlı bellek(b) ileti geçirmesüreç Apaylaşımlı bölgeiki adres alanına da eşlenirsüreç Bçekirdeksüreç Asüreç Bçekirdek: ileti kuyruğum₁m₂m₃receive() → m₀

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_open adlı bir nesne oluşturur (Linux’ta /dev/shm altında).
  • ftruncate boyutu belirler, mmap adres 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.
üretici süreçkodverip = 0x7f3a…yığıntüketici süreçkodverip = 0x7f91…yığın/os03 (4096 B)"merhaba"fiziksel bellek (/dev/shm)mmapmmap

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.

BoyutSeçenekler
Fiziksel bağpaylaşımlı bellek, donanım veri yolu, ağ
Adlandırmadoğrudan (sürecin adı) · dolaylı (posta kutusu / port)
Eş zamanlı / eş zamansızbloklayan (senkron): gönderen alınana kadar, alıcı ileti gelene kadar bekler · bloklamayan (eş zamansız): hemen döner
Tamponlamasıfır kapasite (gönderen bekler: buluşma/rendezvous) · sınırlı (kuyruk doluysa bekler) · sınırsız (hiç beklemez)
Bloklayan send + bloklayan receive = buluşma (rendezvous): üretici–tüketici problemi kendiliğinden çözülür. Örnekler: POSIX mq_send/mq_receive, Mach portları, Windows ALPC.

Süreçler Arası İletişim

Doğrudan ve Dolaylı İletişim

doğrudan: send(Q, m)PQtek bağlantı · bir çift süreçdolaylı: send(A, m)posta kutusu Aport / kuyrukPQRçok süreç · çok bağlantı
Doğrudan
  • 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ü.
Dolaylı (posta kutusu)
  • 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)

ebeveynfd[0] kapalı · fd[1] yazarçocukfd[0] okur · fd[1] kapalıboru: çekirdekte FIFO tamponwrite(fd[1])read(fd[0])yazma ucu → okuma ucu (tek yönlü)

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şimyalnız oluşturan ve çocuklarıdosya adı bilen her süreç
Yöntek yönlüUNIX: yarı çift yönlü; Windows: tam çift yönlü
Ömürsüreçler kapatınca bitermkfifo; dosya sisteminde kalır
AğhayırUNIX 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;
}
ebeveyn 1234çalışıyor(boş)4 (w)3 (r)

pipe(fd): çekirdek boş bir tampon açar; okuma ucu fd[0]=3, yazma ucu fd[1]=4 (0–2 stdin/stdout/stderr).

ebeveyn 1234çalışıyorçocuk 1235çalışıyor(boş)4 (w)3 (r)4 (w)3 (r)

fork(): çocuk tanımlayıcıları miras alır; şimdi her iki uç da iki süreçte açık.

ebeveyn 1234çalışıyorçocuk 1235çalışıyor(boş)4 (w)3 (r)3 (r)

Çocuk kullanmayacağı yazma ucunu kapatır.

ebeveyn 1234çalışıyorçocuk 1235read → bekliyor(boş)4 (w)3 (r)3 (r)

Boru boş: read çocuğu bloke eder.

ebeveyn 1234çalışıyorçocuk 1235bekliyor(boş)4 (w)3 (r)

Ebeveyn okuma ucunu kapatır.

ebeveyn 1234çalışıyorçocuk 1235uyandımerhaba4 (w)3 (r)

Ebeveyn 7 bayt yazar; ≤ PIPE_BUF yazımlar bölünmez (atomik). Bekleyen okuyucu uyanır.

ebeveyn 1234wait → bekliyorçocuk 1235hazırmerhaba3 (r)

Ebeveyn yazma ucunu kapatır (okuyucu ileride EOF görebilsin) ve wait ile bekler.

ebeveyn 1234bekliyorçocuk 1235çalışıyor(boş)3 (r)

read 7 döndürür; veri tampondan çocuğun buf dizisine kopyalanır.

ebeveyn 1234bekliyorçocuk 1235çalışıyor(boş)3 (r)

Sonlandırıcı '\0' eklenir ve yazdırılır.

ebeveyn 1234çalışıyorçocuk 1235bitti(boş)

Ç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

bashpipe(), 2 × fork(), waitlsdup2(fd[1], 1) → stdoutwc -ldup2(fd[0], 0) → stdinboru (64 KiB tampon)her iki süreç de kullanmadığı uçları kapatmalı; aksi hâlde wc EOF göremez
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

istemci 146.86.5.20soket146.86.5.20:1625web sunucusu 161.25.19.8soket161.25.19.8:80TCP bağlantısıgeçici port ↔ iyi bilinen port
  • 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

iOS / iPadOS
  • İ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, BGTaskScheduler görevleri; diğerleri askıya alınır.
Android
  • 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.
ön plan (foreground)kullanıcının etkileşimde olduğu etkinlikgörünür (visible)ekranda ama odakta değilhizmet (service)örn. arka planda senkronizasyonönbellekteki (cached)arka plan + boş süreçlerbellek azalınca önce alttakiler sonlandırılır (lmkd)

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

Süreç

Yürütülen program: metin, veri, heap, yığın + CPU bağlamı + kaynaklar. Çekirdek onu PCB ile izler.

Yaşam döngüsü

Yeni → Hazır ⇄ Çalışıyor → Bekliyor → Hazır … → Sonlandı. Çıkış durumu wait ile alınır.

UNIX API

fork kopyalar (COW), exec görüntüyü değiştirir, wait bekler ve biçer, exit bitirir.

Çizelgeleme altyapısı

Hazır/bekleme kuyrukları; bağlam değiştirme saf ek yüktür.

IPC

Paylaşımlı bellek hızlı ama senkronizasyon ister; ileti geçirme, boru ve soketler çekirdek aracılığıyla çalışır.

Mobil çoklu görev

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ı

  1. fork(); fork(); çalıştıran program toplam kaç süreçle biter? Ya for (i = 0; i < 3; i++) fork();?
  2. printf("A"); fork(); printf("B\n"); stdout bir dosyaya yönlendirildiğinde çıktı nedir? Neden?
  3. Bir süreç Bekliyor durumundan doğrudan Çalışıyor durumuna geçebilir mi?
  4. Zombi ile yetim süreç arasındaki fark nedir? Hangisi sistem için daha çok sorun çıkarır?
  5. exec başarılı olursa ardından gelen satır ne zaman çalışır?
  6. p = 0,5 ve n = 3 için CPU kullanımı nedir?
  7. Boru örneğinde ebeveyn close(fd[1]) yapmasaydı ve çocuk EOF’a kadar okusaydı ne olurdu?
Cevapları göster
  1. 4 süreç (1 → 2 → 4). Döngüde 2³ = 8 süreç (7 yeni).
  2. AB iki kez: dosyaya yazarken stdout tam tamponludur; "A" fork anında tamponda olduğu için çocuğa da kopyalanır.
  3. Hayır; önce Hazır’a geçer, sonra çizelgeleyici seçer.
  4. Zombi bitmiş ama biçilmemiş; yetim çalışıyor ama ebeveyni yok (init evlat edinir). Biriken zombiler PID tüketir.
  5. Hiçbir zaman; satır yalnız exec başarısız olursa çalışır.
  6. 1 − 0,5³ = 0,875 → %87,5.
  7. Yazma ucu ebeveynde açık kaldığı için read asla 0 döndürmez; çocuk sonsuza dek bekler, ebeveyn de wait’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”.

Son

Bölüm 3: Süreçler
Sonraki bölüm: İş Parçacıkları · Terim sözlüğü
1 / 1