İşletim Sistemleri Vize Notları
Bu not, ABM-313 dersinin ilk 4 haftalık slaytlarını (Silberschatz, Operating System Concepts 10. baskı) sınav için teorik olarak özetler; kod yok, kavram ve mantık var. Her haftanın sonunda "sınavda sorulabilecekler" kutusu, en altta sözlük bulunur.
Hafta 1 — İşletim Sistemlerine Giriş
1.1 İşletim sistemi ne iş yapar?
İşletim sistemi (OS), donanımı yöneten ve kullanıcı ile donanım arasında aracılık yapan programdır. Donanım tek başına kullanılması çok zor bir şeydir; OS bu zorluğu gizler ve kaynakları (CPU zamanı, bellek, disk, I/O cihazları) programlar arasında paylaştırır.
Bir bilgisayar sistemi 4 bileşenden oluşur:
Donanım — CPU, bellek, I/O cihazları; temel kaynakları sağlar.
İşletim sistemi — kaynakların kullanımını koordine eder.
Uygulama programları — kelime işlemci, derleyici, tarayıcı; kaynakların kullanıcı problemine nasıl uygulanacağını belirler.
Kullanıcılar — insanlar, makineler veya başka bilgisayarlar.
OS'e iki açıdan bakılır:
Kullanıcı açısından: Kişisel bilgisayarda OS kolay kullanım için tasarlanır; kaynak paylaşımı ikinci plandadır. Çok kullanıcının bağlandığı ana bilgisayarda ise amaç kaynak kullanım oranını maksimize etmektir. Sunucuda verimlilik, mobil/istemcide kullanılabilirlik öne çıkar.
Sistem açısından: OS bir kaynak yöneticisi (resource allocator) ve kontrol programıdır — kaynakları planlar, programları ve I/O cihazlarını denetler, hatalı kullanımı önler.
Tanım: Yaygın tanıma göre OS, bilgisayarda sürekli çalışan programdır ve buna kernel (çekirdek) denir. Mobil OS'ler (iOS, Android) kernel'a ek olarak middleware içerir: uygulama geliştiricilere veritabanı, multimedya, grafik gibi hazır servisler sunan framework katmanı.
1.2 Bilgisayar sistemi organizasyonu
Genel yapı: Bir veya daha fazla CPU ve cihaz denetleyicileri (device controller) ortak bir bus üzerinden paylaşılmış belleğe bağlıdır. CPU ve denetleyiciler eş zamanlı çalışır ve belleğe aynı anda erişmek isteyebilir; bunu bellek denetleyicisi düzenler.
Açılış (boot) süreci:
Bilgisayar açılınca bootstrap programı çalışır. Basit bir programdır, ROM veya EEPROM'da saklanır; bu tür programlara firmware denir.
Bootstrap, CPU register'larını, cihaz denetleyicilerini ve bellek içeriğini başlatır.
Kernel'ın diskteki yerini bulur ve kernel'ı belleğe yükler.
Kernel dışındaki bazı servisleri sistem programları / daemon'lar sağlar. UNIX'te ilk süreç init'tir; birçok daemon'ı başlatır. Bundan sonra sistem tamamen açılmıştır.
OS artık bir olay (event) olmasını bekler.
Interrupt (kesme): Olaylar OS'e interrupt ile bildirilir.
Donanım CPU'ya bir sinyal göndererek interrupt üretir (ör. klavyeye basıldı, disk okuması bitti).
Yazılım bir system call çalıştırarak interrupt üretir (buna trap da denir).
CPU interrupt alınca: o anki işini keser → interrupt'a karşılık gelen interrupt service routine (ISR)'nin başlangıç adresine atlar → rutin bitince kaldığı yere döner. ISR adresleri, belleğin en başında (0–100 arası adresler) tutulan interrupt vector adlı bir pointer tablosunda saklanır; her cihazın kendi girişi vardır. Kesilen işe geri dönebilmek için o anki komut adresi ve register değerleri stack'e kaydedilir (slaytta bu kaydetme işi "context switch" olarak geçer).
Depolama yapısı: CPU komutları yalnızca bellekten okuyabilir; bu yüzden çalışacak program önce ana belleğe (RAM) yüklenmelidir. RAM yarı iletken DRAM ile yapılır.
von Neumann döngüsü: Komut bellekten fetch edilir ve instruction register'a alınır → çözümlenir (decode) → çalıştırılır (execute) → sonuç varsa register'a veya belleğe yazılır.
Tüm programlar RAM'de tutulamaz, çünkü (1) RAM'in kapasitesi sınırlıdır, (2) RAM volatile'dır: elektrik gidince veri silinir. Bu yüzden kalıcı ikincil depolama (secondary storage) — en yaygın olarak manyetik disk (HDD) — kullanılır.
Depolama hiyerarşisi (yukarıdan aşağı): register → cache → ana bellek → SSD → manyetik disk → optik disk → manyetik teyp. Hiyerarşide yukarı çıktıkça:
erişim hızı artar,
bit başına maliyet artar,
toplam kapasite azalır,
CPU tarafından kullanılma sıklığı artar.
Register, cache ve ana bellek volatile (geçici); SSD, disk, optik disk ve teyp nonvolatile (kalıcı). NVRAM, DRAM'i bataryayla destekleyerek kalıcı hale getirir.
I/O yapısı: OS kodunun büyük kısmı I/O yönetimidir. Her cihaz denetleyicisinin bir device driver'ı vardır. Klasik I/O akışı:
Driver, denetleyicinin register'larına uygun değerleri yazar.
Denetleyici işi yapar, bitince driver'a interrupt gönderir.
Bu yöntemde her küçük veri parçası için interrupt gerekir; overhead yüksek ve yavaştır. Çözüm DMA (Direct Memory Access): denetleyici, bir veri bloğunu CPU'ya uğramadan doğrudan bellekle cihaz arasında taşır; blok başına tek bir interrupt üretilir. Bu sırada CPU başka işler yapabilir.
1.3 Bilgisayar sistemi mimarisi
Tek işlemcili sistem: Genel amaçlı tek bir CPU vardır. Disk denetleyicisi gibi cihazlara özel işlemciler olabilir ama bunlar kullanıcı süreci çalıştırmaz; sistem yine "tek işlemcili" sayılır.
Çok işlemcili sistem (multiprocessor / parallel / multicore): İki veya daha fazla CPU; bus, saat (clock), bellek ve çevre birimlerini paylaşır. Önce sunucularda, sonra PC'lerde, şimdi mobilde yaygın. Üç avantajı:
| Avantaj | Açıklama |
|---|---|
| Yüksek throughput | Daha kısa sürede daha çok iş yapılır. Dikkat: N işlemci N kat hız vermez (senkronizasyon ve paylaşım maliyeti). |
| Ölçek ekonomisi | Çevre birimi, depolama ve güç kaynağı paylaşıldığı için aynı sayıda ayrı tek işlemcili makineden ucuzdur. |
| Yüksek güvenilirlik | Bir işlemci bozulunca sistem durmaz, sadece yavaşlar (graceful degradation). |
AMP vs SMP:
AMP (asimetrik): Her işlemciye belirli bir iş atanır; bir ana (master) işlemci diğerlerini yönetir (master–slave).
SMP (simetrik): Her işlemci OS'in her işini yapabilir; hepsi eş düzeydir (peer). Her CPU'nun kendi register'ları ve yerel cache'i vardır ama bellek ortaktır. Windows, macOS, Linux SMP destekler.
UMA vs NUMA: Belleğe erişim süresi tüm CPU'lar için aynıysa UMA, CPU'nun belleğe yakınlığına göre farklıysa NUMA'dır. OS, süreçleri kendi verisine yakın CPU'da çalıştırarak NUMA'nın gecikme dezavantajını azaltabilir.
Multicore: Tek bir çip üzerinde birden fazla çekirdek. Çipler arası iletişim gerekmediği için çok çipli sistemlerden daha hızlı ve daha az enerji tüketir. Her çekirdeğin kendi register ve cache'i vardır, bellek ortaktır.
Blade sunucu: İşlemci, I/O ve ağ kartları aynı kasada; her blade ayrı boot olur ve kendi OS'ini çalıştırır.
Kümelenmiş (clustered) sistemler: Bağımsız iki veya daha fazla bilgisayar, depolamayı paylaşır ve LAN üzerinden haberleşir; bu yüzden gevşek bağlı (loosely coupled) denir. Multiprocessor sistemler ise sıkı bağlıdır (tek makine içinde bellek paylaşılır).
Amaç genelde high availability: her düğüm (node) diğerlerini izler, biri çökerse işini üstlenir.
Asimetrik kümeleme: Bir makine aktif çalışır, diğeri hot-standby modunda onu izler; hata olursa devreye girer.
Simetrik kümeleme: Tüm makineler aktif olarak uygulama çalıştırır ve birbirini izler (donanımı daha verimli kullanır).
Paralelleştirme: Program parçalara bölünüp düğümlerde eş zamanlı çalıştırılır, sonuçlar birleştirilir.
Paylaşılan veride çakışmayı önlemek için DLM (distributed lock manager) kullanılır.
1.4 İşletim sistemi yapısı: multiprogramming ve multitasking
Multiprogramming: Bellekte aynı anda birden fazla iş tutulur (işler diskteki job pool'dan gelir). Çalışan iş I/O gibi bir şey için beklemeye girince CPU başka işe geçer. Amaç: CPU hiç boş kalmasın.
Multitasking (time sharing): Multiprogramming'in mantıksal uzantısı. CPU işler arasında çok sık geçer; geçiş için işin beklemeye girmesi gerekmez. Kullanıcı her programla etkileşimli çalışabilir, bu yüzden tepki süresi (response time) çok kısa olmalıdır.
Bellekte yüklü ve çalışan programa process denir.
Job scheduling: Bellekte yer yetmiyorsa, diskteki işlerden hangisinin belleğe alınacağına karar vermek.
CPU scheduling: Bellekte birden çok iş hazırsa, CPU'yu önce hangisine vereceğine karar vermek.
1.5 İşletim sistemi işlemleri
Modern OS'ler interrupt-driven'dır: yapılacak iş yoksa OS boşta bekler, her şey bir interrupt ile tetiklenir. Trap / exception, yazılımın ürettiği interrupt'tır — ya bir hata (sıfıra bölme, geçersiz bellek erişimi) ya da bir system call isteği. İyi bir OS, hatalı veya kötü niyetli bir programın diğer programları ve OS'i bozmasını engeller.
Dual mode (çift mod): OS kodunu kullanıcı kodundan ayırmak için donanımda bir mode bit vardır:
| Mod | Mode bit | Ne yapabilir? |
|---|---|---|
| Kernel mode (supervisor / system / privileged) | 0 | Ayrıcalıklı (privileged) komutlar dahil her şeyi |
| User mode | 1 | Sadece sıradan komutları; ayrıcalıklı işler için system call yapmalı |
Sistem açılırken kernel moddadır; kullanıcı programına geçilirken user moda geçilir. Bir interrupt, trap veya system call olunca donanım kernel moda geçer, OS işini bitirince tekrar user moda döner. Birden fazla bit ile multimode (ör. sanallaştırma için ayrı mod) yapılabilir.
Timer: Bir program sonsuz döngüye girerse ya da hiç system call yapmazsa kontrol asla OS'e dönmez. Bunu önlemek için timer kullanılır: programa geçmeden önce kurulur, geri sayar, 0'a ulaşınca interrupt üretir ve kontrol OS'e geçer. Timer'ı ayarlamak ayrıcalıklı bir komuttur.
1.6 OS'in yönetim görevleri
Process yönetimi. Program pasif bir varlıktır (diskte duran dosya); process aktif bir varlıktır (çalışmakta olan program). Process'in CPU, bellek, dosya, I/O gibi kaynaklara ihtiyacı vardır; bitince OS bunları geri alır. Program counter (PC) bir sonraki komutun adresini tutar: single-threaded process'in bir PC'si, multithreaded process'in her thread için bir PC'si vardır. OS'in sorumlulukları:
process ve thread'lerin CPU üzerinde zamanlanması,
process oluşturma ve silme,
askıya alma (suspend) ve devam ettirme,
senkronizasyon mekanizmaları,
process'ler arası haberleşme.
Bellek (memory) yönetimi. CPU her programı bellekten çalıştırır. OS:
belleğin hangi kısmının kim tarafından kullanıldığını izler,
hangi process'in belleğe alınıp atılacağına karar verir,
bellek alanı tahsis eder ve serbest bırakır.
Depolama (storage) yönetimi.
Dosya sistemi: OS, depolama cihazlarının fiziksel farklılıklarını soyutlayarak mantıksal bir birim olan dosyayı (file) tanımlar. Görevleri: dosya/dizin oluşturma–silme, dosya ve dizin işlemleri, erişim denetimi (okuma, yazma, ekleme).
Kitle depolama (mass storage): Disk yönetimi — boş alan yönetimi, alan tahsisi, disk zamanlaması. Teyp, CD, DVD gibi üçüncül (tertiary) depolama: WORM (bir kez yaz, çok oku) veya RW (okunur-yazılır).
Cache: Bellekten hızlı, CPU'ya daha yakın küçük depolama. CPU bir veriyi bellekten alınca kopyasını cache'e koyar; tekrar istenirse cache'ten okunur. Kapasite küçük olduğundan neyin tutulup neyin atılacağını replacement algoritmaları belirler. Cache'e adresle, register'lara isimle erişilir. Çok işlemcili sistemlerde aynı verinin farklı CPU cache'lerindeki kopyaları tutarlı olmalıdır: cache coherence.
I/O alt sistemi: Donanım ayrıntılarını kullanıcıdan gizler; cihazın ayrıntısını sadece onun driver'ı bilir. Bileşenleri: bellek yönetim bileşeni (buffering, caching, spooling), genel device driver arayüzü ve cihaza özel driver'lar.
1.7 Koruma ve güvenlik
Koruma (protection): Kaynaklara (CPU, dosya, bellek segmentleri) yalnızca yetkili process ve kullanıcıların erişmesini sağlayan iç denetim mekanizmasıdır. Yetkili ve yetkisiz kullanımı ayırt eder, hataları erken yakalar.
Güvenlik (security): Sistemi içeriden ve dışarıdan saldırılara karşı savunmaktır (virüs, worm, DoS, kimlik hırsızlığı). Koruma yeterli olsa bile çalınan bir parola ile sisteme girilebilir; bu güvenliğin konusudur.
İkisi de kullanıcıları ayırt etmeyi gerektirir: user ID, group ID ve yönetici (admin) yetkileri.
1.8 Kernel veri yapıları
| Yapı | Mantığı | Erişim (en kötü) | OS'te kullanımı |
|---|---|---|---|
| Dizi (array) | Sabit boyutlu elemanlar, indeksle doğrudan erişim | O(1) | Basit tablolar |
| Bağlı liste (singly / doubly / circular) | Elemanlar birbirine pointer ile bağlı; farklı boyutlu elemanlara uygun | O(n) | Process listeleri |
| Stack (yığın) | LIFO — son giren ilk çıkar (push / pop) | — | Fonksiyon çağrıları ve interrupt'ta dönüş adresi, parametre, yerel değişken |
| Queue (kuyruk) | FIFO — ilk giren ilk çıkar | — | Yazıcı kuyruğu, CPU bekleyen görevler |
| Ağaç (tree) | Parent–child hiyerarşisi; binary tree'de en fazla 2 çocuk | BST: O(n), dengeli BST: O(log n) | Dizin yapısı, zamanlayıcılar |
| Hash | Anahtarı sayıya çeviren fonksiyon; hash map anahtar→değer eşler | O(1) | Hızlı arama tabloları |
| Bitmap | n bitlik dizi; her bit bir kaynağın boş(0)/dolu(1) durumunu tutar | O(1) | Disk bloklarının doluluk durumu |
1.9 Hesaplama ortamları
Geleneksel: Ağa bağlı ofis PC'leri; bugün Web portalları ve WAN ile sınırları genişledi. Ev ağları firewall ile korunur (IP, port, Web ve içerik filtreleme).
Mobil: Akıllı telefon ve tabletler; iOS ve Android baskın.
Dağıtık sistemler: Fiziksel olarak ayrı, heterojen bilgisayarların ağ üzerinden kaynak paylaşması. Ağ türleri kapsama alanına göre: PAN (kişisel) < LAN (yerel) < MAN (şehir) < WAN (geniş); WLAN ~300 m (IEEE 802.11, Bluetooth). En yaygın protokol TCP/IP. Ağ işletim sistemi, ağdaki kaynakları ve farklı makinelerdeki process'ler arası iletişimi yönetir.
İstemci–sunucu: Compute-server istemcinin isteği üzerine hesaplama yapar; file-server dosya oluşturma/okuma/silme sağlar.
Peer-to-peer (P2P): İstemci/sunucu ayrımı yoktur, her düğüm eşittir (Napster, Gnutella, Skype).
Sanallaştırma: Bir OS'in başka OS'leri misafir (guest) olarak çalıştırması. Yöneten yazılım VMM (virtual machine manager / hypervisor)'dır: VMware Workstation host OS üstünde çalışır; VMware ESXi ve Citrix XenServer doğrudan host olarak çalışır.
Emülasyon, sanallaştırmadan farklıdır: kaynak CPU ile hedef CPU farklı olduğunda komutlar çevrilir (Apple'ın Rosetta'sı IBM PowerPC kodunu Intel'de çalıştırır). Daha yavaştır.
Yorumlayıcı (interpreter) kodu makine koduna çevirmeden çalıştırır; derleyici (compiler) makine koduna çevirir. JVM bir yorumlama/emülasyon ortamıdır.
Bulut bilişim: Hesaplama, depolama ve uygulamanın ağ üzerinden hizmet olarak sunulması; sanallaştırmanın mantıksal uzantısı (ör. Amazon EC2, kullandığın kadar öde).
Dağıtım türü: public (herkese açık), private (bir firmaya ait), hybrid (ikisi birden).
Hizmet türü: SaaS (uygulama, ör. Office online), PaaS (yazılım yığını/platform, ör. veritabanı sunucusu), IaaS (sunucu ve depolama altyapısı).
Gerçek zamanlı gömülü sistemler: Araba motoru, robot, mikrodalga fırın, uçak gibi özel amaçlı cihazlar. Ya özel amaçlı bir OS çalıştırır ya da ASIC ile OS'siz çalışır (hardwired). Real-time OS'te zaman kısıtı katıdır: iş belirlenen sürede bitmezse sonuç hatalı sayılır (enjeksiyon, medikal, silah sistemleri).
1.10 Açık kaynak işletim sistemleri
Açık kaynak OS'te derlenmiş binary'nin yanında kaynak kod da açıktır (Linux, BSD UNIX, Solaris). Kapalı kaynak'ta sadece binary verilir (Windows); bunu anlamak için tersine mühendislik (reverse engineering) gerekir. macOS ve iOS hibrittir: açık kaynak Darwin kernel'ı + kapalı kaynak bileşenler. Slayttaki iddia: açık kaynak daha güvenlidir çünkü kodu daha çok kişi inceler.
Sınavda sorulabilecekler (Hafta 1): OS'in iki bakış açısı · boot süreci ve firmware · interrupt nasıl işlenir, interrupt vector · DMA neden gerekli · depolama hiyerarşisinin 4 kuralı · AMP/SMP, UMA/NUMA farkı · çok işlemcinin 3 avantajı ve graceful degradation · clustered (asimetrik/simetrik) · multiprogramming vs multitasking · job vs CPU scheduling · dual mode ve mode bit değerleri · timer neden var · program vs process · koruma vs güvenlik · veri yapılarının karmaşıklıkları · SaaS/PaaS/IaaS · sanallaştırma vs emülasyon.
Hafta 2 — İşletim Sistemi Yapıları
2.1 İşletim sistemi servisleri
OS, programların çalışması için bir ortam ve programcıların işini kolaylaştıran servisler sağlar. Servisler iki gruba ayrılır:
A) Kullanıcıya yardımcı olan servisler
Kullanıcı arayüzü: CLI (metin komutları), batch (komutlar bir dosyada hazır verilir), GUI (en yaygın ve esnek).
Program çalıştırma: Programı belleğe yükleme, çalıştırma, normal veya hatalı sonlandırma.
I/O işlemleri: Kullanıcı koruma ve verimlilik nedeniyle cihazlara doğrudan erişemez; I/O'yu OS yapar.
Dosya sistemi işlemleri: Dosya/dizin oluşturma, okuma, yazma, silme, izin yönetimi.
İletişim: Aynı makinedeki veya ağdaki process'ler arası veri alışverişi (paylaşılan bellek veya mesaj).
Hata denetimi: CPU, bellek, I/O ve programlardaki hataları sürekli izleme, raporlama, mümkünse düzeltme.
B) Sistemin verimli çalışmasını sağlayan servisler
Kaynak tahsisi: CPU zamanı, bellek, dosya ve I/O cihazlarını aynı anda çalışan işlere dağıtmak.
Hesap tutma (accounting): Kim ne kadar kaynak kullandı — ücretlendirme veya istatistik için.
Koruma ve güvenlik: Kaynak erişimini kullanıcı bazında denetlemek ve yetkilendirmek.
2.2 Kullanıcı–OS arayüzü
| Komut satırı (CLI / command interpreter) | Grafik arayüz (GUI) | |
|---|---|---|
| Kullanım | Kullanıcı komutu doğrudan yazar | Fare, menü, ikon, masaüstü (mobilde dokunmatik) |
| Öğrenme | Zor | Kolay |
| Tarihçe | — | İlk GUI: Xerox Alto (1973); ilk yaygın GUI: Apple Macintosh (1980'ler); Windows 1.0 = MS-DOS + GUI |
Command interpreter (shell): Bazı OS'lerde kernel'ın içindedir; Windows ve UNIX'te ayrı bir programdır. UNIX/Linux'ta kullanıcı farklı shell'ler seçebilir: Bourne Shell, C Shell, Korn Shell vb. Shell'in görevi komutu alıp yürütmektir (create, delete, list, copy, execute…). İki uygulama yöntemi vardır:
Komutların kodu shell'in içindedir — shell her yeni komutla büyür.
Her komut ayrı bir sistem programıdır (UNIX yaklaşımı) — shell sadece o dosyayı bulup çalıştırır; yeni komut eklemek kolaydır.
2.3 Sistem çağrıları (system calls)
System call, kullanıcı programının OS servisini istemek için kullandığı arayüzdür. User moddaki program ayrıcalıklı bir iş (dosya açmak, cihaza yazmak) yapamaz; system call ile kontrolü kernel'a devreder, kernel işi kernel modda yapar, sonra geri döner. System call'lar genelde C/C++ ile, donanıma yakın kısımları assembly ile yazılır.
Basit bir iş bile çok sayıda system call gerektirir: dosyayı açmak, okumak, kapatmak ayrı ayrı çağrılardır; "dosya bulunamadı" gibi hatalar da bu çağrılarla yönetilir.
Programcı genelde system call'u doğrudan çağırmaz; bir API (Application Programming Interface) kullanır: Windows API, POSIX API (UNIX/Linux/macOS), Java API. API fonksiyonu arka planda gerçek system call'u tetikler. Örnek: Windows'ta
CreateProcess()API fonksiyonu kernel'dakiNTCreateProcess()system call'unu çalıştırır.Neden API? Taşınabilirlik (aynı API'yi destekleyen her sistemde program çalışır) ve kolaylık (gerçek system call'lar daha ayrıntılı ve zordur).
System call'a parametre geçirmenin 3 yolu:
Register'lar — en hızlı, ama register sayısı sınırlı.
Bellekte blok/tablo — parametreler bellekte bir bloka konur, bloğun adresi register'la verilir (Linux bu yöntemi register'larla birlikte kullanır).
Stack — program parametreleri stack'e push eder, OS pop eder.
Blok ve stack yöntemleri parametre sayısını ve boyutunu sınırlamaz.
2.4 Sistem çağrı türleri (6 grup)
| Grup | Ne için? | Örnek çağrılar |
|---|---|---|
| Process control | Programı yükleme, çalıştırma, bitirme, bekleme, kilit | end, abort, load, execute, create/terminate process, wait, acquire/release lock |
| File management | Dosya işlemleri | create, delete, open, close, read, write, get/set file attributes |
| Device management | Cihaz (fiziksel veya sanal) kullanımı | request, release, read, write |
| Information maintenance | Sistemle bilgi alışverişi | time, date, sistem bilgisi, dump |
| Communications | Process'ler arası iletişim | open/close/accept connection, shared memory create/attach |
| Protection | Erişim izinleri | set/get permission, allow user, deny user |
Process control ayrıntıları:
Program normal (end) veya anormal (abort) bitebilir. Anormal bitimde hata mesajı üretilir ve belleğin dökümü (memory dump) diske yazılır; debugger bu dökümü inceleyerek bug'ı bulmaya yardım eder.
Aynı veriyi paylaşan process'ler çakışmamak için veriyi kilitler: acquire lock / release lock.
Tek görevli (single-tasking) — MS-DOS: Bir program çalışırken başka process başlatılamaz. Program belleğe yüklenir (shell'in büyük kısmının üzerine yazılır), PC ilk komutu gösterir; program bitince shell yeniden yüklenir.
Çok görevli (multitasking) — FreeBSD: Shell, bir program çalışırken de çalışmaya devam eder ve yeni process'ler başlatabilir.
Örnek mantık: C'deki
printf()bir kütüphane fonksiyonudur; ekrana yazmak için arka plandawrite()system call'unu kullanır.
Device management: OS'in kontrol ettiği her kaynak bir cihaz gibi düşünülebilir — fiziksel (disk) veya sanal (dosya). Önce request, iş bitince release; aradaki kullanım read/write ile.
Information maintenance: time/date, kullanıcı sayısı, OS sürümü, boş bellek/disk gibi bilgileri taşır. dump debugging'e yardım eder. OS'ler timer interrupt'larıyla programları periyodik olarak izleyip durumlarını kaydedebilir.
Communication — iki model:
| Message passing | Shared memory | |
|---|---|---|
| Nasıl? | Process'ler mesajları doğrudan veya bir posta kutusu (mailbox) üzerinden gönderir | Process'ler ortak bir bellek alanı oluşturup oraya okur/yazar |
| Kimlik | Her process'in adı ve ID'si vardır; gönderen client, alan server | — |
| Çağrılar | open/close connection, accept connection | shared memory create, shared memory attach |
| OS'in rolü | Her mesaj kernel'dan geçer | Alanı kurar; verinin içeriğini kontrol etmez — tutarlılıktan process'ler sorumludur |
| Artı / eksi | Küçük veri ve ağ için kolay; daha yavaş | Daha hızlı; senkronizasyon sorunu doğurur |
Protection: Eskiden çok kullanıcılı sistemler için tasarlandı; bugün mobil dahil her cihazda gerekli.
2.5 Sistem programları
Katmanlar aşağıdan yukarı: donanım → işletim sistemi → sistem programları → uygulama programları. Sistem programları (system utilities), program geliştirme ve çalıştırma için uygun bir ortam sağlar. Kullanıcının OS'i nasıl gördüğü büyük ölçüde system call'lar değil, sistem programları tarafından belirlenir.
File management: create, delete, copy, rename, print, list.
Status information: Tarih, saat, boş bellek/disk, kullanıcı sayısı; daha gelişmişleri performans, log, debug bilgisi. Bazı sistemlerde yapılandırma registry'de tutulur.
File modification: Metin editörleri.
Programming-language support: Derleyici, assembler, debugger, yorumlayıcı.
Program loading / execution: Loader'lar, linker'lar, debug araçları.
Communications: Mesajlaşma, Web, e-posta, uzak bağlantı, dosya transferi.
Background services: Boot sırasında başlatılan, bazen sistem açık kaldıkça çalışan programlar; service, subsystem veya daemon denir (ağ bağlantısı, yazıcı kuyruğu, hata izleme).
2.6 OS tasarımı ve gerçekleştirimi
Tasarım hedefleri: Önce donanım ve sistem türü (tek/çok kullanıcılı, gerçek zamanlı, dağıtık, genel/özel amaçlı) belirlenir. Gereksinimler ikiye ayrılır:
Kullanıcı hedefleri (user goals): Kolay kullanım, kolay öğrenme, güvenilir, güvenli, hızlı.
Sistem hedefleri (system goals): Tasarımı, gerçekleştirimi ve bakımı kolay; esnek, güvenilir, hatasız, verimli.
Bu hedefler belirsizdir ve tek doğru çözüm yoktur; genel ilkeler yazılım mühendisliğinden gelir.
Policy vs mechanism (kural vs mekanizma) — sınavda çok sevilir:
Mekanizma = NASIL yapılacağı. Örnek: CPU'yu korumak için timer kullanmak.
Kural (policy) = NE yapılacağı. Örnek: timer'ın bir kullanıcı için kaç ms'ye ayarlanacağına karar vermek.
Neden ayrılır? Kurallar zamanla ve yere göre değişir. Mekanizma genel tasarlanırsa kural değiştiğinde sadece birkaç parametre değişir, sistem yeniden yazılmaz. Kaynak tahsisi kararlarında bu ayırım çok önemlidir.
Gerçekleştirim (implementation): İlk OS'ler assembly ile yazıldı. Bugün çoğu C/C++ ile yazılır: kernel'ın en alt kısmı assembly, üst seviye işlemler C, sistem programları C, C++, Perl, Python vb. Linux tüm bu dilleri içerir.
| Assembly ile yazılan OS | Yüksek seviyeli dille yazılan OS | |
|---|---|---|
| Örnek | MS-DOS (8088 assembly) → sadece Intel x86 | Linux (C) → x86, SPARC, PowerPC |
| Taşınabilirlik | Yok, tek işlemci ailesi | Kolay, başka işlemciye taşınabilir |
| Hız / boyut | Daha hızlı, daha küçük | Biraz daha yavaş ve büyük |
| Geliştirme | Zor, yavaş | Hızlı, okunur, hata ayıklaması kolay |
Hız dezavantajı bugün önemsizleşmiştir: derleyiciler optimizasyon yapar, işlemciler pipelining gibi tekniklerle performansı artırır.
2.7 İşletim sistemi yapıları
Bu bölümün özü: OS'i parçalara nasıl böleriz ve parçalar nasıl haberleşir? Beş yaklaşım vardır.
| Yapı | Fikir | Artı | Eksi | Örnek |
|---|---|---|---|---|
| Basit (simple / monolitik) | Küçük başlayıp plansız büyüyen, katmanları net ayrılmamış yapı | Hızlı, az overhead | Uygulama doğrudan donanıma erişebilir → kötü program tüm sistemi çökertebilir; bakımı zor | MS-DOS, ilk UNIX |
| Katmanlı (layered) | OS üst üste katmanlara bölünür: en alt (0) donanım, en üst (N) kullanıcı arayüzü; her katman sadece altındakini kullanır | Tasarımı ve hata ayıklaması kolay — her katman ayrı test edilir | Katmanları doğru tanımlamak zor; her istek katmanlardan geçtiği için performans düşer → katman sayısı az tutulmalı | — |
| Mikrokernel | Kernel'da sadece çekirdek işler kalır (process'ler arası iletişim, temel bellek ve process yönetimi); diğer her şey user modda sistem programı olarak çalışır; parçalar mesajla haberleşir | Genişletmesi ve taşıması kolay; bir servis çökse kernel etkilenmez → daha güvenli ve güvenilir | Mesajlaşma overhead'i → daha yavaş | Mach (Carnegie Mellon, 1980'ler); macOS kısmen; Windows NT 4.0 (XP ile monolitik yapıya geri dönüldü) |
| Modüler (loadable kernel modules) | Çekirdek küçük bir nüve; ek bileşenler boot sırasında veya çalışırken modül olarak yüklenir; modüller birbirini doğrudan çağırabilir | Katmanlıdan esnek (herhangi bir modül diğerini çağırabilir), mikrokernel'dan hızlı (mesaj gerekmez) — günümüzün en iyi yöntemi | — | Linux (sürücüler ve dosya sistemleri modül), UNIX, macOS, Windows |
| Hibrit | Birden fazla yapıyı birleştirerek performans, güvenlik ve kullanılabilirlik dengelenir | Pratik denge | Karmaşık | Linux/Solaris: monolitik + dinamik modül; Windows: monolitik + bazı mikrokernel özellikleri; macOS, iOS, Android |
Gerçek sistem örnekleri:
macOS (hibrit, katmanlı): En üstte Aqua kullanıcı arayüzü → uygulama ortamları ve servisler (Cocoa: Objective-C API'si) → kernel ortamı. Kernel = Mach (bellek yönetimi, process'ler arası iletişim, thread yönetimi, RPC) + BSD (komut satırı, ağ, dosya sistemleri, POSIX API) + I/O Kit (sürücüler) + kernel extensions (yüklenebilir modüller).
iOS: macOS üzerine kurulu, iPhone/iPad için. Katmanlar üstten alta: Cocoa Touch (Objective-C API, dokunmatik) → Media Services (grafik, ses, video) → Core Services (bulut, veritabanı) → Core OS (kernel işlevleri).
Android: Açık kaynak, çok platformda çalışır. En altta Linux kernel (bellek, process, sürücüler, güç yönetimi) → üstünde kütüphaneler (WebKit: tarayıcı, SQLite: veritabanı, media framework + OpenGL: multimedya/oyun, libc: standart C kütüphanesi, surface manager: ekran) ve Android runtime (Java kütüphaneleri + Dalvik sanal makinesi, Java uygulamalarını çalıştırır) → uygulama framework'ü → uygulamalar.
2.8 OS debugging
Debugging: Sistemdeki hataları (bug) bulup gidermek; buna performans ayarı (performance tuning) da dahildir.
Hata analizi: Bir process çökerse OS hatayı log dosyasına yazar ve belleğin o anki halini (core dump / memory dump) kaydedebilir. Kernel'daki çökmeye crash denir (o zaman kaydedilen döküm crash dump'tur). Slayt notu: debug etmek kodu yazmaktan çok daha zordur.
Performance tuning: Sistemdeki darboğazlar (bottleneck) izlenerek bulunur ve giderilir. Araç örneği: Windows Task Manager (Linux'ta top).
2.9 OS üretimi (system generation) ve boot
OS üretimi: OS'ler farklı makine ve yapılandırmalarda çalışacak şekilde tasarlanır; disk, CD/DVD veya ISO imajı olarak dağıtılır. Kurulum programı o makine için OS'i yapılandırırken şu bilgileri bilmelidir:
kullanılan CPU,
disk formatı ve bölümleri (partition),
bellek miktarı,
cihazların interrupt bilgileri (bugün çoğu sistem bunları kendi algılar),
hangi OS seçeneklerinin istendiği.
Sistem boot: Kernel'ı yükleyerek bilgisayarı başlatmaya booting denir.
Bilgisayar açılınca veya reset atılınca PC (program counter) önceden belirlenmiş bir adrese gider; orada bootstrap programı vardır.
Bootstrap ROM'dadır (firmware) ve kernel'ı bulup belleğe yükler.
Mobil/küçük cihazlarda OS'in tamamı EPROM'da (firmware) durur.
Büyük OS'lerde bootstrap ROM'da, OS diskte durur. OS'in boot kısmını taşıyan diske boot disk / system disk denir.
Sınavda sorulabilecekler (Hafta 2): Kullanıcıya yönelik ve sisteme yönelik servisler · system call nedir, API ile ilişkisi, neden API kullanılır · parametre geçirmenin 3 yolu · 6 system call türü ve örnekleri · message passing vs shared memory · MS-DOS (single-tasking) vs FreeBSD (multitasking) · policy vs mechanism (timer örneği) · assembly vs yüksek seviyeli dil · basit / katmanlı / mikrokernel / modüler / hibrit yapıların artı–eksileri · macOS, iOS, Android katmanları · crash, core dump, performance tuning · boot süreci.
Hafta 3 — Process Yönetimi
3.1 Process kavramı
Process = çalışmakta olan program. Modern OS'ler birçok programı aynı anda belleğe yükler; CPU aralarında hızla geçiş yaparak hepsini "eş zamanlı" ilerletir. Tek kullanıcılı bir PC'de bile Word, Excel ve tarayıcı birlikte çalışır; multitasking olmayan bir OS bile kendi iç işlerini process olarak yürütür. Batch sistemlerde "job", zaman paylaşımlı sistemlerde "task" denir; ikisi de process demektir.
Process'in bellekteki yapısı (adres alanının bölümleri):
| Bölüm | Ne tutar? |
|---|---|
| Text (kod) | Programın makine komutları |
| Data section | Global değişkenler |
| Heap | Çalışma anında (runtime) dinamik olarak ayrılan bellek |
| Stack | Fonksiyon parametreleri, dönüş (return) adresleri, yerel değişkenler |
Bunlara ek olarak process'in o anki aktivitesi vardır: program counter değeri ve CPU register'larının içeriği. Stack ve heap çalışma sırasında büyüyüp küçülür.
Program vs process: Program diskte duran pasif bir dosyadır (executable). Process ise aktiftir; PC bir sonraki komutu gösterir ve kaynakları vardır. Aynı program birden fazla process olabilir (ör. iki ayrı tarayıcı penceresi): kod aynıdır ama her birinin data, heap ve stack'i ayrıdır.
3.2 Process durumları (process state)
Process çalışırken durum değiştirir. Beş durum vardır:
| Durum | Anlamı |
|---|---|
| New | Process oluşturuluyor |
| Ready | Her şeyi hazır, sadece CPU'nun kendisine verilmesini bekliyor |
| Running | Komutları şu an CPU'da çalışıyor |
| Waiting | Bir olayı bekliyor (I/O'nun bitmesi, bir sinyal) — CPU verilse bile çalışamaz |
| Terminated | Çalışması bitti |
Kritik nokta: Bir çekirdekte aynı anda yalnızca bir process running olabilir; birçok process ready veya waiting olabilir. Ready ile waiting farkı sınavda sık sorulur: ready CPU bekler, waiting olay bekler.
Durum geçişleri:
Running'den çıkışın üç yolu vardır: süresi dolarsa veya interrupt gelirse ready'ye, I/O isterse waiting'e, bitince terminated'a gider. Waiting'deki process olay bitince doğrudan running'e değil, ready'ye döner.
3.3 Process Control Block (PCB)
OS her process'i bir PCB (task control block) ile temsil eder; process hakkında bilinmesi gereken her şey buradadır:
| PCB alanı | İçeriği |
|---|---|
| Process state | new, ready, running, waiting, terminated |
| Program counter | Sıradaki komutun adresi |
| CPU register'ları | Accumulator, index register, stack pointer, genel amaçlı register'lar, condition code'lar |
| CPU-scheduling bilgisi | Öncelik, kuyruk pointer'ları |
| Memory-management bilgisi | Base ve limit register'ları, sayfa/segment tabloları |
| Accounting bilgisi | Kullanılan CPU süresi, hesap bilgisi, process numarası |
| I/O status bilgisi | Process'e ayrılmış I/O cihazları, açık dosyalar listesi |
Process'ler arası geçiş (slayttaki P0–P1 şekli): P0 çalışırken interrupt veya system call gelir → OS, P0'ın durumunu PCB0'a kaydeder → PCB1'den P1'in durumunu yükler → P1 çalışır. Geri dönüşte tersi olur. Arada CPU kullanıcı işi yapmaz (bekleme süresi = overhead).
Thread'ler ve PCB: Tek thread'li process aynı anda tek bir iş yapabilir (kelime işlemcide yazarken aynı anda yazım denetimi yapılamaz). Modern OS'ler bir process'te birden fazla thread'e izin verir; özellikle multicore'da thread'ler paralel çalışır. Bu durumda PCB her thread'in bilgisini de tutar.
3.4 Process planlama (scheduling)
Amaç: Multiprogramming'de CPU kullanımını maksimuma çıkarmak, time sharing'de CPU'yu process'ler arasında o kadar sık değiştirmek ki kullanıcı her programla etkileşimde kalabilsin. Hangi process'in CPU'ya alacağını process scheduler seçer.
Zamanlama kuyrukları:
Job queue: Sisteme giren tüm process'ler.
Ready queue: Bellekte, hazır ve CPU bekleyen process'ler. Genelde bağlı liste ile tutulur; kuyruk başlığı ilk ve son PCB'yi gösterir, her PCB bir sonrakini gösterir.
Device queue / wait queue: Belirli bir I/O cihazını veya olayı bekleyen process'ler (her cihazın kendi kuyruğu vardır).
Kuyruk diyagramı (queueing diagram) mantığı: Yeni process ready queue'ya girer, seçilince CPU'da çalışır. CPU'dan şu dört yolla ayrılabilir:
I/O isteği yapar → I/O kuyruğuna gider, bitince ready queue'ya döner.
Child process oluşturur ve onun bitmesini bekler.
Zaman dilimi (time slice) dolar → ready queue'nun sonuna alınır.
Bir interrupt bekler → interrupt kuyruğuna alınır.
Process bitene kadar bu döngü sürer; bitince PCB ve kaynakları silinir.
3.5 Scheduler türleri
| Long-term (job scheduler) | Short-term (CPU scheduler) | Medium-term | |
|---|---|---|---|
| Görevi | Diskte biriken işlerden hangilerinin belleğe yükleneceğini seçer | Bellekteki hazır process'lerden hangisinin CPU'yu alacağını seçer | Process'leri bellekten diske (swap out) çıkarıp sonra geri alır (swap in) |
| Çalışma sıklığı | Seyrek (dakikalar) | Çok sık (< 100 ms) → çok hızlı olmalı | Gerektiğinde |
| Kontrol ettiği | Multiprogramming derecesi (bellekteki process sayısı) | CPU dağıtımı | Bellek baskısı ve process karışımı |
| Nerede? | Batch sistemler; Windows ve UNIX'te yok | Her sistemde | Bazı time-sharing sistemler |
Medium-term scheduler, uzun ve kısa vadeli scheduler'lar arasında köprüdür: bellek yetmediğinde veya process'in bellek ihtiyacı değiştiğinde swapping yapar; swap edilen process diskteki swap alanında bekler.
I/O-bound vs CPU-bound process:
| I/O-bound | CPU-bound | |
|---|---|---|
| Zamanını neğe harcar? | Çoğunlukla I/O bekleyerek (disk, ağ, dosya); CPU boşta kalır | Çoğunlukla hesaplama yaparak; CPU sürekli dolu |
| Örnek | Web sunucusu, veritabanı sorguları, sık dosya erişimi | Bilimsel hesaplama, makine öğrenmesi, şifreleme, grafik işleme |
| Hızlandırma | Daha hızlı disk (SSD)/ağ, I/O'yu paralelleştirme | Daha güçlü veya çok çekirdekli CPU, paralel işleme |
Neden dengeli karışım gerekir? Hepsi I/O-bound olursa ready queue neredeyse hep boş kalır, short-term scheduler'ın yapacak işi olmaz, CPU boşa geçer. Hepsi CPU-bound olursa I/O kuyruğu boş kalır, cihazlar kullanılmaz. Long-term scheduler'ın görevi iki türü dengeli karıştırmaktır.
3.6 Context switch
Interrupt geldiğinde CPU o anki işi bırakıp bir kernel rutinine geçer; iş bitince kaldığı yere dönebilmesi için o anki context (bağlam) saklanmalıdır. Process'in context'i PCB'de tutulur ve CPU register değerleri, process durumu ve bellek yönetim bilgisini içerir.
Context switch = CPU'nun bir process'ten diğerine geçmesi: eski process'in durumunu kaydet (state save) + yeni process'in kayıtlı durumunu yükle (state restore).
Context switch sırasında sistem faydalı iş yapmaz → saf overhead'dir.
Süresi donanıma bağlıdır (bellek hızı, kopyalanacak register sayısı); slayta göre genelde birkaç milisaniye.
Çok sık context switch performansı düşürür.
3.7 Process işlemleri: oluşturma ve sonlandırma
Oluşturma (creation):
Process'ler çalışırken dinamik olarak yeni process'ler oluşturabilir. Oluşturan parent, oluşan child'dır; sonuçta bir process ağacı oluşur.
UNIX, Linux ve Windows her process'e tekil (unique) bir pid (process identifier) verir; process'e bu numarayla erişilir.
Kaynak paylaşımı: Child'ın kaynakları ya parent'ın kaynaklarından paylaştırılır ya da OS tarafından yeni tahsis edilir. Parent'ın paylaştırması, çok fazla child açıp sistemi kilitlemeyi engeller.
Çalışma biçimi: Parent, child ile eş zamanlı çalışmaya devam edebilir ya da child bitene kadar bekleyebilir.
UNIX mantığı (kod yok, akış):
fork()system call'u parent'ın kopyası olan bir child yaratır. fork'un dönüş değeri ikisini ayırt eder: child'da 0, parent'ta child'ın pid'i (> 0), hata olursa negatif. Child geneldeexec()ile kendi belleğine başka bir program yükler (slayttaki örnekte dizin listeleyen program). Parentwait()ile child'ınexit()ile bitmesini bekler.Windows mantığı:
CreateProcess()hem yeni process'i yaratır hem de belirtilen programı (ör. mspaint.exe) yükler; pencere boyutu, giriş/çıkış gibi özellikler parametreyle verilir. ParentWaitForSingleObject()ile bekler. Yani UNIX'te iki adım (fork + exec), Windows'ta tek adımdır.
Sonlandırma (termination):
Process son komutunu bitirince exit() çağırır, OS'ten silinmeyi ister; parent'a bir durum değeri (integer) döndürebilir. OS tüm kaynakları (bellek, açık dosyalar, I/O tamponları) geri alır.
exit()doğrudan, main'denreturnise dolaylı sonlandırmadır.Parent, child'ı sonlandırabilir (Windows'ta
TerminateProcess()). Nedenleri:child kaynak kullanım sınırını aştı,
child'ın yaptığı işe artık gerek yok,
parent sonlanıyor ve OS, parent'ı bitmiş bir child'ın devam etmesine izin vermiyor → tüm child'lar da sonlandırılır (cascading termination).
3.8 Process'ler arası iletişim (IPC)
Independent process: Başka process'leri etkilemez, onlardan etkilenmez (veri paylaşmaz).
Cooperating process: Başka process'leri etkiler ve onlardan etkilenir (veri paylaşır).
Neden cooperating process'lere izin verilir? (4 neden)
Information sharing: Aynı bilgiye (ör. paylaşılan dosya) birden fazla kullanıcının erişmesi.
Computation speedup: İşi parçalara bölüp çok çekirdekte paralel yürütmek.
Modularity: Sistemi ayrı process/thread'lere bölerek modüler kurmak.
Convenience: Kullanıcının aynı anda müzik dinleyip yazı yazıp derleme yapabilmesi.
Cooperating process'ler iki modelle haberleşir:
| Shared memory | Message passing | |
|---|---|---|
| Mantık | Bellekte bir bölge process'ler arasında paylaştırılır, herkes oraya okur/yazar | Veri mesajlar halinde gönderilir: send(message), receive(message) |
| Hız | Daha hızlı — alan bir kez kurulunca kernel'a gerek kalmaz | Daha yavaş — her mesaj kernel'dan (system call) geçer |
| Uygun olduğu yer | Aynı makinede büyük veri | Dağıtık ortam (farklı makineler, ör. chat programı), küçük veri |
| Zorluk | Senkronizasyonu programcı sağlamalı | Çakışma riski az |
Producer–consumer problemi (shared memory örneği): Producer veri üretip paylaşılan buffer'a yazar, consumer buradan okuyup tüketir. (Slayt örneği: derleyici assembly kodu üretir → assembler onu tüketip object kod üretir → loader onu tüketir.) Buffer dairesel bir dizi olarak düşünülür:
in = bir sonraki boş yer, out = ilk dolu yer.
in == out → buffer boş; consumer beklemeli.
(in + 1) mod BUFFER_SIZE == out → buffer dolu; producer beklemeli. (Bu yöntemle buffer'ın en fazla BUFFER_SIZE − 1 elemanı kullanılabilir.)
Message passing'de adresleme: Process'ler birbirini doğrudan ismiyle adresleyebilir: send(P, mesaj) P'ye gönderir, receive(Q, mesaj) Q'dan alır. Mesajlar sabit veya değişken uzunlukta olabilir (sabit = OS için kolay, programcı için zor; değişken = tersi).
3.9 İstemci–sunucu sistemlerde iletişim: soketler
Soket (socket) = iletişimin uç noktasıdır. Ağ üzerinden haberleşen iki process'in her birinin bir soketi vardır; iletişim bir soket çifti üzerinden olur.
Soket = IP adresi + port numarası.
Sunucu belirli bir portu dinler; istek gelince kabul edip işlemi başlatır.
Bilinen servislerin sabit portları vardır: HTTP 80, FTP 21 (1024 altı "well-known" portlardır).
İstemcinin portunu OS atar ve her bağlantı tekil olmalıdır: bir host'taki her process'in port numarası farklıdır.
Slayt örneği: İstemci 146.86.5.20 adresinde, OS'in verdiği 1625 portunda; Web sunucusu 161.25.19.8 adresinde, 80 portunda. Soket çifti: (146.86.5.20:1625) ↔ (161.25.19.8:80).
127.0.0.1 = loopback: Makinenin kendisini gösterir; istemci ve sunucu aynı makinedeyse kullanılır. (Slayttaki Java örneğinde sunucu 6013 portunu dinler, bağlanan istemciye tarih ve saati gönderip bağlantıyı kapatır; istemci 127.0.0.1:6013'e bağlanıp gelen veriyi ekrana yazar.)
İki bağlantı türü:
| Connection-oriented | Connectionless | |
|---|---|---|
| Mantık | Veri göndermeden önce uçtan uca bağlantı kurulur | Bağlantı kurmadan paketler doğrudan gönderilir |
| Güvenilirlik | Reliable (sıralı, kayıpsız) | Unreliable (kayıp olabilir) |
| Protokol | TCP | UDP |
| Java sınıfı | Socket / ServerSocket | DatagramSocket |
Sınavda sorulabilecekler (Hafta 3): Process'in bellek bölümleri (stack/heap/data/text) · program vs process · 5 durum ve geçişler, ready vs waiting · PCB alanları · job / ready / device kuyrukları · long / short / medium-term scheduler farkı · I/O-bound vs CPU-bound ve neden dengeli karışım · context switch neden overhead · parent/child, pid, kaynak paylaşımı seçenekleri · fork dönüş değerleri · cascading termination · cooperating process'lerin 4 nedeni · shared memory vs message passing · producer–consumer'da boş/dolu koşulu · soket tanımı, soket çifti örneği · TCP vs UDP.
Hafta 4 — Thread'ler
4.1 Thread nedir?
Thread, CPU kullanımının temel birimidir; bir process'in içinde bağımsız yürüyen bir akıştır. Process'i bir ev, thread'leri o evde yaşayan kişiler gibi düşün: ev (bellek, dosyalar) ortak, ama herkes kendi işini yapar.
| Her thread'in kendine ait olanlar | Aynı process'teki thread'lerin ortak kullandıkları |
|---|---|
| Thread ID | Kod (text) bölümü |
| Program counter | Data bölümü (global değişkenler) |
| Register kümesi | Açık dosyalar ve diğer OS kaynakları |
| Stack | Heap |
Klasik (heavyweight) process tek thread'lidir; birden fazla thread'i olan process aynı anda birden fazla iş yapabilir.
Örnekler: Web tarayıcı bir thread'le veri indirirken diğeriyle ekranı çizer. Kelime işlemci bir thread'le klavyeyi okur, biriyle yazım denetimi yapar, biriyle ekranı günceller.
Multithreaded Web sunucusu: Her gelen istek için ayrı bir thread açar; ana thread portu dinlemeye devam eder. Her istek için yeni process açmak çok daha pahalı olurdu.
Çoğu OS kernel'ı da multithreaded'dir: cihaz yönetimi, bellek yönetimi ve interrupt işleme aynı anda yapılabilir.
4.2 Thread'lerin 4 faydası
| Fayda | Açıklama |
|---|---|
| Responsiveness (cevap verebilirlik) | Bir kısım bloklanır veya uzun iş yaparken kullanıcıyla etkileşen kısım çalışmaya devam eder; program donmuş görünmez. |
| Resource sharing (kaynak paylaşımı) | Process'ler kaynak paylaşmak için shared memory veya message passing kurmak zorundadır; thread'ler ise ait oldukları process'in belleğini ve kaynaklarını kendiliğinden paylaşır. |
| Economy (ekonomi) | Process oluşturmak (bellek ve kaynak tahsisi) pahalıdır; thread kaynakları paylaştığı için hem oluşturma hem context switch ucuzdur. Solaris'te thread oluşturma 30 kat, thread context switch'i 5 kat daha hızlıdır. |
| Scalability (ölçeklenebilirlik) | Çok çekirdekli sistemde thread'ler farklı çekirdeklerde paralel çalışır; tek thread'li process ise ne kadar çekirdek olursa olsun tek çekirdek kullanabilir. |
4.3 Multicore programlama
Tek çip üzerinde birden fazla çekirdek (multicore) bulunur; OS her çekirdeği ayrı bir işlemci olarak görür.
Concurrency vs parallelism — sınavın klasik sorusu:
Concurrency (eşzamanlılık): Birden fazla görev arasında kısa aralıklarla geçiş yapılarak hepsinin ilerlemesi sağlanır. Tek çekirdekte 4 thread varsa, thread'ler sırayla çalışır (T1, T2, T3, T4, T1…); aynı anda değil, iç içe ilerler.
Parallelism (paralellik): Birden fazla görev gerçekten aynı anda çalışır. Çok çekirdekte her çekirdeğe bir thread atanır.
Sonuç: Paralellik olmadan concurrency olabilir (tek çekirdek), ama paralellik için birden fazla çekirdek gerekir. Çekirdek sayısı arttıkça aynı anda yapılan iş sayısı artar.
Amdahl yasası: Bir uygulamanın bir kısmı mutlaka seri çalışmak zorundaysa, çekirdek eklemekle elde edilecek hızlanma sınırlıdır.
Hızlanma ≤ 1 / ( S + (1 − S) / N )
S = seri çalışmak zorunda olan kısmın oranı, N = çekirdek sayısı.
Örnek: %75 paralel, %25 seri (S = 0,25). N = 2 → 1 / (0,25 + 0,375) = 1,6 kat. N = 4 → 1 / (0,25 + 0,1875) ≈ 2,28 kat.
N sonsuza giderken hızlanma 1/S'ye yaklaşır → S = 0,25 ise en fazla 4 kat. Yani seri kısım, performansın tavanını belirler.
Donanım thread'leri: Intel CPU'lar çekirdek başına 2 thread (Hyper-Threading), Oracle T4 çekirdek başına 4 thread destekler. Yeni Intel hibrit mimarilerde P-core (performans) çekirdek başına 2 thread, E-core (verimlilik) 1 thread çalıştırır. Örnek Core i9-13900K: 8 P × 2 + 16 E × 1 = 32 thread.
4.4 Multicore programlamanın 5 zorluğu
Identifying tasks: Programda aynı anda çalışabilecek, birbirinden bağımsız görevleri bulmak.
Balance: Görevlere eşit iş yükü dağıtmak; az iş yapan bir görev için koca bir çekirdek ayırmak israftır.
Data splitting: Veriyi, farklı çekirdeklerdeki görevlerin ayrı ayrı işleyebileceği şekilde bölmek.
Data dependency: Görevlerin eriştiği veriler arasındaki bağımlılıkları incelemek; bir görev diğerinin sonucuna ihtiyaç duyuyorsa senkronizasyon gerekir.
Testing and debugging: Paralel programda olası yürütme sıraları çok fazladır; test ve hata ayıklama çok daha zordur.
4.5 Paralel çalışma türleri
| Data parallelism | Task parallelism | |
|---|---|---|
| Ne dağıtılır? | Veri parçaları çekirdeklere dağıtılır | Görevler (thread'ler) çekirdeklere dağıtılır |
| İşlem | Her çekirdek aynı işlemi kendi veri parçasında yapar | Her thread farklı bir işlem yapar; aynı veya farklı veri üzerinde |
| Slayt örneği | N elemanlı dizinin toplamı: [0 … N/2 − 1] 1. çekirdekte, [N/2 … N − 1] 2. çekirdekte toplanır | Aynı dizi üzerinde farklı istatistikler (ortalama, standart sapma…) farklı çekirdeklerde hesaplanır |
Gerçek uygulamalar çoğunlukla ikisinin karışımını kullanır.
4.6 User thread, kernel thread ve multithreading modelleri
User thread: Kullanıcı seviyesinde bir thread kütüphanesi tarafından yönetilir; kernel bu thread'lerden haberdar değildir.
Kernel thread: Doğrudan OS tarafından desteklenir ve zamanlanır. Windows, Linux, UNIX, macOS ve Solaris kernel thread destekler.
User thread'lerin çalışabilmesi için kernel thread'lerle eşleştirilmesi gerekir. Üç model vardır:
| Model | Eşleştirme | Bir thread bloklanırsa | Multicore'da paralellik | Kim kullanır? |
|---|---|---|---|---|
| Many-to-one | Çok sayıda user thread → tek kernel thread | Tüm process bloklanır | Yok — aynı anda sadece bir user thread kernel'a erişebilir | Solaris (green threads) |
| One-to-one | Her user thread → kendi kernel thread'i | Diğer thread'ler çalışmaya devam eder | Var | Linux, Windows |
| Many-to-many | Çok sayıda user thread → eşit veya daha az sayıda kernel thread | Kernel başka bir thread'i çalıştırır | Var | Solaris 9 öncesi, bazı UNIX'ler |
One-to-one'ın tek dezavantajı: Her user thread için bir kernel thread oluşturmak gerekir; çok fazla kernel thread sisteme yük bindirir, bu yüzden bazı sistemler thread sayısını sınırlar. Many-to-many iki dünyanın iyisini almaya çalışır: istediğin kadar user thread açılır, ama paralellik ve bloklanmama korunur.
4.7 Thread kütüphaneleri
Thread kütüphanesi, programcıya thread oluşturma ve yönetme API'si sağlar. İki uygulama yolu vardır:
Tamamen user alanında kütüphane: kernel desteği yoktur; kütüphane fonksiyonu çağırmak sıradan bir fonksiyon çağrısıdır (system call değil).
Kernel seviyesinde kütüphane: OS doğrudan destekler; kütüphane çağrısı genelde bir system call'a dönüşür.
İki threading stratejisi:
Asenkron threading: Parent, child thread'i oluşturduktan sonra kendi işine devam eder; ikisi bağımsız çalışır. Thread'ler arasında az veri paylaşımı varsa uygundur (ör. Web sunucusunda her istek için thread).
Senkron threading (fork–join): Parent, child'ları oluşturur ve hepsi bitene kadar bekler, sonra devam eder. Thread'ler arasında çok veri paylaşımı varsa uygundur (parent child'ların sonuçlarını birleştirir).
Üç temel kütüphane:
| Kütüphane | Seviye | Özellikler |
|---|---|---|
| POSIX Pthreads | User-level veya kernel-level | IEEE 1003.1c standardı. Bir tanımdır (specification), gerçekleştirim değil; her OS kendine göre uygular. Linux, UNIX, macOS, Solaris kullanır; Windows yerel olarak desteklemez. Thread'ler ayrı fonksiyonlar olarak yazılır, global veriyi paylaşır. |
| Windows threads | Kernel-level | Pthreads'e çok benzer: thread'ler ayrı fonksiyon, global veri ortak. |
| Java threads | User-level (JVM içinde; JVM altta host OS'in kütüphanesini kullanır) | JVM olan her yerde çalışır (Windows, Linux, UNIX, macOS, Android). Java'da global veri olmadığından paylaşım parametre geçirme ile yapılır. Oluşturmanın iki yolu: Thread sınıfından türetip run() metodunu override etmek veya Runnable arayüzünü uygulamak (daha yaygın). |
4.8 Dolaylı thread oluşturma (implicit threading)
Uygulamalar artık yüzlerce, binlerce thread içerebilir; bunları elle yönetmek zor ve hataya açıktır. Implicit threading: Thread oluşturma ve yönetme işini programcı yerine derleyiciye ve çalışma zamanı kütüphanelerine bırakmak. Programcı sadece paralel çalışabilecek görevleri belirtir.
Thread pool (thread havuzu):
Sorun: Her istek için yeni thread açan bir Web sunucusunda (1) her seferinde thread oluşturmak zaman alır, (2) istek sayısı çok artarsa sınırsız thread CPU ve belleği tüketir.
Çözüm: Başlangıçta belirli sayıda thread oluşturulup havuzda bekletilir. İstek gelince havuzdaki boş bir thread işi alır; boş thread yoksa istek bir thread serbest kalana kadar bekler. İşi biten thread havuza döner.
Faydaları: Var olan thread'i kullanmak yeni thread oluşturmaktan hızlıdır; aynı anda çalışan thread sayısı sınırlanır, sistem çökmez.
OpenMP:
C, C++ ve Fortran için bir grup derleyici direktifi ve API'dir; shared memory ortamlarında paralel programlama sağlar.
Programcı paralel çalışacak bölgeyi (parallel region) bir direktifle işaretler (
#pragma omp parallel); OpenMP o bölgeyi, sistemdeki çekirdek sayısı kadar thread oluşturarak paralel çalıştırır.Farklı yapılar (ör. döngüleri paralelleştirmek) için farklı direktifler vardır. Linux, Windows ve macOS'teki birçok açık kaynak ve ticari derleyicide desteklenir.
Grand Central Dispatch (GCD):
Apple'ın macOS ve iOS için implicit threading teknolojisidir.
Paralel çalışacak kod parçasına blok denir ve ^ sembolüyle işaretlenir.
GCD blokları bir dispatch queue'ya koyar; bir blok kuyruktan alınınca thread havuzundaki bir thread'e atanır.
İki tür kuyruk vardır:
Serial queue: FIFO; aynı anda sadece bir blok kuyruktan alınır, bir blok bitmeden diğeri başlamaz.
Concurrent queue: Yine FIFO sırayla alınır ama aynı anda birden fazla blok alınıp paralel çalışabilir. Sistem genelinde üç öncelikli concurrent kuyruk vardır: low, default, high (bloğun önem derecesini belirler).
4.9 Thread çalıştırma kuralları (threading issues)
fork() ve exec(): Multithreaded bir programda bir thread fork() çağırırsa yeni process tüm thread'leri mi kopyalar, yoksa sadece fork çağıran thread'i mi? Bazı UNIX sistemlerde bu yüzden iki farklı fork() vardır: biri tüm thread'leri, diğeri yalnızca çağıran thread'i çoğaltır. exec() ise çağrıldığında parametre olarak verilen program, tüm thread'leriyle birlikte process'in tamamının yerine geçer. Bu yüzden fork'tan hemen sonra exec çağrılacaksa tüm thread'leri kopyalamak gereksizdir; sadece çağıran thread kopyalanır. (Slayttaki "exec ile process duplicate yapılır" ifadesini bu şekilde anla: exec kopyalamaz, process'i yeni programla değiştirir.)
Signal handling (sinyal işleme): UNIX'te sinyal, process'e belirli bir olayın gerçekleştiğini bildirir. Akış: olay olur → sinyal üretilir → process'e iletilir → bir signal handler tarafından işlenir.
| Senkron sinyal | Asenkron sinyal | |
|---|---|---|
| Kimden gelir? | Sinyale neden olan işlemi yapan process'in kendisinden | Process'in dışından bir olaydan |
| Kime gider? | Sinyali oluşturan process'e / thread'e | Başka bir process'e |
| Örnek | Geçersiz bellek erişimi, sıfıra bölme | Ctrl+C ile programı sonlandırma, timer'ın dolması |
Multithreaded process'te sinyal nereye gidecek? Seçenekler:
Sinyalin ilgili olduğu tek thread'e (senkron sinyaller her zaman sadece onu oluşturan thread'e gider),
Process'teki tüm thread'lere (ör. Ctrl+C),
Process'teki bazı thread'lere,
Process'in tüm sinyallerini almakla görevli özel bir thread'e.
UNIX'te sinyal pid verilerek process'e (kill), Pthreads'te ise belirli bir thread'e (pthread_kill) gönderilir.
Thread iptali (thread cancellation): Bir thread'i işi bitmeden sonlandırmak. Örnekler: birden fazla thread bir veritabanında arama yapıyorsa biri sonucu bulunca diğerleri iptal edilir; tarayıcıda Stop düğmesine basılınca sayfayı yükleyen tüm thread'ler iptal edilir. İptal edilecek thread'e target thread denir.
Asenkron iptal: Bir thread hedef thread'i hemen, aniden sonlandırır. Tehlikelidir: hedef thread bir kaynağı yarım bırakabilir veya paylaşılan veriyi güncellerken kesilebilir.
Ertelenmiş (deferred) iptal: Hedef thread, sonlanması gerekip gerekmediğini kendisi periyodik olarak kontrol eder ve güvenli bir noktada kendini düzenli şekilde sonlandırır. Daha güvenlidir.
4.10 Windows ve Linux thread'leri
Windows:
Temel API: Windows API. Her uygulama ayrı bir process'tir, her process bir veya daha fazla thread içerir.
User thread ↔ kernel thread eşleştirmesi one-to-one'dır.
Bir thread'in register kümesi, stack'leri (user ve kernel stack) ve özel depolama alanı birlikte thread'in context'i olarak adlandırılır.
Windows bir thread için üç veri yapısı tutar:
| Yapı | Açılımı | Nerede? | İçeriği |
|---|---|---|---|
| ETHREAD | Executive thread block | Kernel alanı | Thread'in ait olduğu process'e pointer, thread'in başlangıç rutininin adresi, KTHREAD'e pointer |
| KTHREAD | Kernel thread block | Kernel alanı | Zamanlama ve senkronizasyon bilgisi, kernel stack, TEB'e pointer |
| TEB | Thread environment block | User alanı | Thread ID, user stack, thread'e özel veri (thread-local storage) |
Linux:
Linux, process ve thread arasında ayrım yapmaz; ikisine de task (görev) der.
fork()ile yeni task oluşturulunca parent'ın veri yapısının kopyası çıkarılır → klasik yeni process.clone()ile yeni task oluşturulurken bayrak (flag) bitleriyle parent ile child'ın neyi paylaşacağı belirtilir: dosya sistemi bilgisi, bellek alanı, sinyal işleyicileri, açık dosyalar. Hepsi paylaşılırsa sonuç bir thread gibi davranır; hiçbiri paylaşılmazsa fork() gibi davranır.Kernel'da her task bir struct task_struct ile temsil edilir; bu yapı açık dosyalar, sanal bellek ve sinyal bilgilerini içermek yerine bunları gösteren pointer'lar tutar. Paylaşım bu pointer'ların aynı yapıyı göstermesiyle sağlanır.
Sınavda sorulabilecekler (Hafta 4): Thread'in kendine ait ve paylaştığı kaynaklar · thread'lerin 4 faydası (Solaris 30 kat / 5 kat) · concurrency vs parallelism · Amdahl hesabı (S = 0,25 için N = 2 → 1,6; N = 4 → 2,28; sınır 1/S) · multicore'un 5 zorluğu · data vs task parallelism · user vs kernel thread · many-to-one / one-to-one / many-to-many karşılaştırması · asenkron vs senkron (fork–join) threading · Pthreads, Windows, Java kütüphaneleri · thread pool neden · OpenMP, GCD serial/concurrent queue · fork/exec sorunu · senkron vs asenkron sinyal · asenkron vs deferred cancellation · ETHREAD/KTHREAD/TEB · Linux clone() ve task kavramı.
Sözlük
Terimler alfabetik sıradadır; parantez içindeki sayı konunun geçtiği haftayı gösterir.
| Terim | Türkçesi | Kısa tanım |
|---|---|---|
| Accounting | Hesap tutma | Kullanıcı/process başına kaynak kullanımını kaydetme (2) |
| Amdahl yasası | — | Çekirdek ekleyince hızlanmanın seri kısımla sınırlı olduğunu söyleyen formül; tavan 1/S (4) |
| AMP | Asimetrik çoklu işlem | Bir ana işlemcinin diğerlerine iş dağıttığı yapı (1) |
| API | Uygulama programlama arayüzü | Programcının kullandığı, arka planda system call çağıran fonksiyon kümesi (Windows API, POSIX, Java) (2) |
| ASIC | Uygulamaya özel entegre devre | OS'siz, tek işe özel donanım (1) |
| Asynchronous cancellation | Asenkron iptal | Hedef thread'in anında sonlandırılması (4) |
| Batch | Toplu iş | Komutların bir dosyada hazır verildiği, etkileşimsiz çalışma (2) |
| Bitmap | Bit eşlem | Her bitin bir kaynağın boş/dolu durumunu tuttuğu dizi (1) |
| Blade server | Blade sunucu | Aynı kasadaki, her biri kendi OS'ini çalıştıran kartlar (1) |
| Boot / bootstrap | Açılış / önyükleyici | Bilgisayarı başlatıp kernel'ı belleğe yükleyen süreç / program (1, 2) |
| Buffer | Tampon | Veri aktarımında geçici saklama alanı (1, 3) |
| Bus | Veri yolu | CPU, bellek ve cihazları bağlayan ortak hat (1) |
| Cache | Önbellek | CPU'ya yakın, hızlı, küçük bellek (1) |
| Cache coherence | Önbellek tutarlılığı | Farklı CPU cache'lerindeki aynı verinin tutarlı tutulması (1) |
| Cascading termination | Zincirleme sonlandırma | Parent bitince tüm child'ların da sonlandırılması (3) |
| clone() | — | Linux'ta, paylaşımı bayraklarla belirlenen yeni task oluşturan çağrı (4) |
| CLI | Komut satırı arayüzü | Kullanıcının komutları yazarak verdiği arayüz (2) |
| Cloud computing | Bulut bilişim | Hesaplama, depolama ve uygulamaların ağ üzerinden hizmet olarak sunulması (1) |
| Clustered system | Kümelenmiş sistem | Depolamayı paylaşan, LAN ile bağlı bağımsız bilgisayarlar (1) |
| Concurrency | Eşzamanlılık | Görevler arasında hızlı geçişle hepsinin ilerlemesi (4) |
| Context | Bağlam | Process/thread'in register, durum ve bellek bilgisi (3, 4) |
| Context switch | Bağlam değişimi | CPU'nun bir process'ten diğerine geçmesi: kaydet + yükle; overhead'dir (3) |
| Cooperating process | İşbirlikçi process | Başka process'leri etkileyen ve onlardan etkilenen process (3) |
| CPU-bound | CPU'ya bağımlı | Zamanını çoğunlukla hesaplamaya harcayan process (3) |
| CPU scheduling | CPU zamanlaması | Hazır process'lerden CPU'yu alacak olanı seçmek (1, 3) |
| Crash / core dump | Çökme / bellek dökümü | Kernel hatası / hata anında belleğin diske yazılması (2) |
| Daemon | Arka plan servisi | Arka planda sürekli çalışan sistem programı (1, 2) |
| Data parallelism | Veri paralelliği | Veriyi bölüp her çekirdekte aynı işlemi yapmak (4) |
| Deferred cancellation | Ertelenmiş iptal | Hedef thread'in iptali kendisinin kontrol edip düzgünce bitmesi (4) |
| Device driver | Aygıt sürücüsü | Bir cihaz denetleyicisini yöneten OS yazılımı (1) |
| Device queue | Cihaz kuyruğu | Bir I/O cihazını bekleyen process'ler (3) |
| DLM | Dağıtık kilit yöneticisi | Kümede paylaşılan veriye erişimi kilitlerle düzenler (1) |
| DMA | Doğrudan bellek erişimi | Cihaz ile bellek arasında CPU'suz blok aktarımı (1) |
| Dual mode / mode bit | Çift mod / mod biti | User (1) ve kernel (0) modunu ayıran donanım biti (1) |
| Embedded system | Gömülü sistem | Özel amaçlı cihazdaki bilgisayar (1) |
| Emulator | Emülatör | Farklı bir CPU'nun komutlarını çevirerek çalıştıran yazılım (1) |
| ETHREAD / KTHREAD / TEB | — | Windows thread veri yapıları: executive blok, kernel blok (kernel alanı), ortam bloğu (user alanı) (4) |
| exec() | — | Process'in belleğini yeni bir programla değiştiren çağrı (3, 4) |
| exit() | — | Process'i sonlandıran çağrı; parent'a durum değeri döner (3) |
| Firmware | Bellenim | ROM/EEPROM'da duran kalıcı yazılım (1, 2) |
| fork() | — | UNIX'te parent'ın kopyası olan child yaratan çağrı; child'da 0, parent'ta pid döner (3) |
| Fork–join | Çatalla–birleş | Parent'ın child'ları oluşturup hepsinin bitmesini beklediği senkron model (4) |
| GCD | Grand Central Dispatch | Apple'ın blok ve dispatch queue tabanlı implicit threading teknolojisi (4) |
| Graceful degradation | Zarif bozulma | Parça bozulunca sistemin durmayıp yavaşlaması (1) |
| GUI | Grafik kullanıcı arayüzü | Fare/dokunmatik, ikon ve menülerle arayüz (2) |
| Hash function | Özet fonksiyonu | Veriyi sayıya çevirip O(1) erişim sağlayan fonksiyon (1) |
| Heap | Yığıt | Process'e çalışma anında dinamik ayrılan bellek (3) |
| Hot-standby | Sıcak yedek | Aktif makineyi izleyip hata anında devralan yedek makine (1) |
| I/O-bound | I/O'ya bağımlı | Zamanını çoğunlukla I/O bekleyerek geçiren process (3) |
| IaaS / PaaS / SaaS | Altyapı / platform / yazılım hizmeti | Bulutta sunucu-depolama / yazılım yığını / uygulama sunulması (1) |
| Implicit threading | Dolaylı thread oluşturma | Thread yönetimini derleyici ve kütüphaneye bırakma (4) |
| Independent process | Bağımsız process | Veri paylaşmayan, kimseyi etkilemeyen process (3) |
| init | — | UNIX'te boot sonrası ilk başlayan sistem process'i (1) |
| Interrupt | Kesme | Bir olayın CPU'ya bildirilmesi; CPU işini bırakıp ISR'ye geçer (1) |
| Interrupt vector | Kesme vektörü | ISR adreslerini tutan, belleğin başındaki tablo (1) |
| IPC | Process'ler arası iletişim | Shared memory veya message passing ile veri alışverişi (3) |
| Job queue | İş kuyruğu | Sisteme giren tüm process'ler (3) |
| Kernel | Çekirdek | OS'in sürekli çalışan çekirdeği (1) |
| Kernel thread | Çekirdek thread'i | OS'in doğrudan tanıyıp zamanladığı thread (4) |
| LAN / MAN / WAN / PAN | Yerel / şehir / geniş / kişisel alan ağı | Kapsama alanına göre ağ türleri (1) |
| Layered approach | Katmanlı yapı | Her katmanın sadece altındakini kullandığı OS yapısı (2) |
| LIFO / FIFO | Son giren ilk çıkar / ilk giren ilk çıkar | Stack ve queue'nun çalışma kuralı (1) |
| Loadable kernel module | Yüklenebilir kernel modülü | Çalışırken kernel'a eklenebilen bileşen (2) |
| Loopback (127.0.0.1) | Geri döngü adresi | Makinenin kendisini gösteren IP (3) |
| Long-term scheduler | Uzun vadeli zamanlayıcı | Diskten belleğe alınacak işleri seçer; multiprogramming derecesini belirler (3) |
| Many-to-one / one-to-one / many-to-many | — | User thread'lerin kernel thread'lere eşleştirilme modelleri (4) |
| Mechanism vs policy | Mekanizma vs kural | Nasıl yapılacağı vs ne yapılacağı (2) |
| Medium-term scheduler | Orta vadeli zamanlayıcı | Swapping ile process'leri bellekten çıkarıp geri alır (3) |
| Message passing | Mesaj geçirme | Process'lerin send/receive ile haberleşmesi (2, 3) |
| Microkernel | Mikroçekirdek | Kernel'da sadece temel işlevlerin kaldığı, gerisinin user modda çalıştığı yapı (2) |
| Middleware | Ara katman yazılım | Mobil OS'te geliştiricilere ek servis sunan framework (1) |
| Monolithic | Tek parça | Tüm OS işlevlerinin tek kernel'da toplanması (2) |
| Multicore | Çok çekirdekli | Tek çipte birden fazla çekirdek (1, 4) |
| Multiprogramming | Çoklu programlama | Bellekte birden fazla iş tutup bekleyen işten diğerine geçmek (1) |
| Multitasking / time sharing | Çoklu görev / zaman paylaşımı | CPU'nun işler arasında çok sık geçiş yapması (1) |
| Multithreaded | Çok thread'li | Birden fazla thread'i olan process (1, 4) |
| NUMA / UMA | Tek düze olmayan / tek düze bellek erişimi | Bellek erişim süresinin CPU'ya göre farklı / aynı olması (1) |
| NVRAM | Kalıcı RAM | Bataryalı, elektrik kesilince silinmeyen DRAM (1) |
| OpenMP | — | C/C++/Fortran için paralel bölgeleri işaretleyen derleyici direktifleri (4) |
| Overhead | Ek yük | Faydalı iş dışında harcanan zaman/kaynak (1, 3) |
| P2P | Eşler arası | İstemci/sunucu ayrımı olmayan ağ mimarisi (1) |
| Parallelism | Paralellik | Görevlerin gerçekten aynı anda çalışması (4) |
| Parent / child | Ebeveyn / çocuk | Process oluşturan ve oluşturulan process (3) |
| PCB | Process kontrol bloğu | Process'in tüm bilgilerini tutan kernel yapısı (3) |
| pid | Process kimliği | Her process'e verilen tekil numara (3) |
| Port | Port | Bir makinede process'i ayırt eden numara (HTTP 80, FTP 21) (3) |
| Privileged instruction | Ayrıcalıklı komut | Sadece kernel modda çalıştırılabilen komut (1) |
| Process | Süreç | Çalışmakta olan program; aktif varlık (1, 3) |
| Producer–consumer | Üretici–tüketici | Bir process'in üretip diğerinin paylaşılan buffer'dan tükettiği model (3) |
| Program counter (PC) | Program sayacı | Sıradaki komutun adresini tutan register (1, 3) |
| Protection / security | Koruma / güvenlik | Kaynak erişiminin iç denetimi / saldırılara karşı savunma (1) |
| Pthreads | POSIX thread'leri | IEEE 1003.1c thread API tanımı (4) |
| Ready queue | Hazır kuyruğu | Bellekte CPU bekleyen process'ler (3) |
| Real-time OS | Gerçek zamanlı OS | İşlerin kesin süre içinde bitmesi gereken OS (1) |
| Register | Yazmaç | CPU içindeki en hızlı saklama birimi (1) |
| Responsiveness | Cevap verebilirlik | Uzun iş sürerken programın kullanıcıya yanıt vermeye devam etmesi (4) |
| Short-term scheduler | Kısa vadeli zamanlayıcı | Ready queue'dan CPU'yu alacak process'i seçer (3) |
| Shared memory | Paylaşılan bellek | Process'lerin ortak bellek bölgesi üzerinden haberleşmesi; daha hızlı (2, 3) |
| Shell / command interpreter | Kabuk / komut yorumlayıcı | Kullanıcı komutlarını alıp çalıştıran program (2) |
| Signal | Sinyal | Process'e bir olayın olduğunu bildiren UNIX mekanizması (4) |
| SMP | Simetrik çoklu işlem | Tüm işlemcilerin eş düzeyde her işi yapabildiği yapı (1) |
| Socket | Soket | İletişim uç noktası = IP adresi + port (3) |
| Stack | Yığın | LIFO yapı; fonksiyon parametreleri, dönüş adresi ve yerel değişkenler (1, 3) |
| Swapping | Takas | Process'i bellekten diske çıkarıp sonra geri almak (3) |
| System call | Sistem çağrısı | Programın OS servisini istediği arayüz; kernel moda geçiş (1, 2) |
| System program | Sistem programı | OS ile uygulamalar arasındaki yardımcı programlar (2) |
| Task parallelism | Görev paralelliği | Farklı işleri farklı çekirdeklerde yapmak (4) |
| task_struct | — | Linux kernel'ında her task'ı temsil eden yapı (4) |
| TCP / UDP | — | Güvenilir, bağlantılı / güvenilmez, bağlantısız protokol (3) |
| Thread | İş parçacığı | Process içinde kendi PC, register ve stack'i olan yürütme birimi (4) |
| Thread pool | Thread havuzu | Önceden oluşturulup tekrar kullanılan sınırlı sayıda thread (4) |
| Throughput | İş hacmi | Birim zamanda tamamlanan iş miktarı (1) |
| Timer | Zamanlayıcı | Belirli süre sonra interrupt üretip kontrolü OS'e veren donanım (1, 2) |
| Trap / exception | Tuzak / istisna | Yazılımın ürettiği interrupt: hata veya system call (1) |
| User thread | Kullanıcı thread'i | Kernel'ın bilmediği, kütüphanenin yönettiği thread (4) |
| Virtualization / VMM | Sanallaştırma / sanal makine yöneticisi | Bir donanımda birden çok OS'i misafir olarak çalıştırmak / bunu yöneten yazılım (1) |
| Volatile / nonvolatile | Geçici / kalıcı | Elektrik gidince silinen / silinmeyen depolama (1) |
| von Neumann | — | Fetch → decode → execute komut döngüsünü kullanan mimari (1) |
| Waiting / wait queue | Bekleme / bekleme kuyruğu | Bir olayı bekleyen process durumu ve kuyruğu (3) |
| WORM | Bir kez yaz, çok oku | Sadece bir kez yazılabilen depolama (1) |