İşletim sistemi Böl. 1
Tanım: kullanıcı ile donanım arasında aracı olarak çalışan program (“a program that acts as an intermediary between a user of a computer and the computer hardware”). Amaç: kullanıcı programlarını çalıştırmak, sistemi kullanışlı yapmak, donanımı verimli kullanmak.
Rolleri: kaynak dağıtıcı (resource allocator), kontrol programı (control program). Çekirdek (kernel): her zaman çalışan tek program; geri kalanı sistem programı ya da uygulama.
Görevleri: süreç yönetimi, bellek yönetimi, dosya/depolama yönetimi, G/Ç (I/O) yönetimi, koruma ve güvenlik, kullanıcı arayüzü.
Bileşenler (soyut model): kullanıcılar → uygulama programları → işletim sistemi → donanım (CPU, bellek, G/Ç).
Kullanıcı bakışı: kullanım kolaylığı, performans (kaynak kullanımıyla ilgilenmez). Sistem bakışı: kaynak dağıtıcı ve kontrol programı; adil ve verimli kullanım.
Kesme (interrupt) Böl. 1
Bir aygıtın ya da yazılımın CPU'ya “beni dinle” sinyali. CPU o anki işi bırakır, durumu saklar, kesme vektöründen (interrupt vector) ilgili servis rutinini (ISR) bulur, çalıştırır, kaldığı yere döner.
- Türler: donanım kesmesi (aygıt, timer) / yazılım kesmesi = trap / exception (sıfıra bölme, geçersiz bellek, sistem çağrısı). Maskelenebilir / maskelenemez (NMI).
- Kesme zinciri (chaining): vektördeki her girdi bir işleyici listesini gösterir; sırayla denenir, isteği karşılayan bulunur. Vektör küçük kalır.
- Kesme önceliği: önemli kesme önemsizi bekletir, gerekirse onu keser.
İS kesme güdümlüdür (interrupt driven).
Bellek hiyerarşisi Böl. 1
registers ▲ hızlı, küçük, pahalı/bit
cache (L1/L2/L3) │
ana bellek (RAM) │ ← uçucu (volatile)
SSD / NVM │ ← kalıcı (nonvolatile)
sabit disk (HDD) │
optik disk, teyp ▼ yavaş, büyük, ucuz/bit
Yukarı çıktıkça hız ve maliyet artar, kapasite azalır. Kazanım: önbellekleme (caching) sayesinde sık kullanılan veri hızlı katmanda; ortalama erişim süresi RAM'e yakın, maliyet diske yakın.
64 GB register? Pahalı, fiziksel olarak büyük → CPU'dan uzak → yavaş (register olmaktan çıkar); komutlarda adres bitleri yetmez; her context switch'te kaydet/yükle maliyeti devasa; güç/ısı.
Dual-mode, sistem türleri Böl. 1
Mod biti: çekirdek = 0, kullanıcı = 1. Ayrıcalıklı komutlar (privileged) yalnızca çekirdek modunda. Sistem çağrısı → trap → mod 0 → çağrıyı işle → “return from system call” → mod 1. Timer sonsuz döngüyü engeller.
kullanıcı süreci ─ syscall çağır ─────────── çağrıdan dön
(mod biti = 1) │ ▲
───────────────────────│──────────────────────────│──────
çekirdek (mod biti = 0)▼ trap, mod = 0 mod = 1│
syscall'ı çalıştır ───────────┘
- Çoklu programlama (multiprogramming): bellekte birden çok iş; biri G/Ç beklerken CPU başkasına geçer → CPU boş kalmaz.
- Çok görevlilik / zaman paylaşımı (multitasking / time-sharing): CPU işler arasında çok sık geçer → her kullanıcı etkileşimli; tepki < 1 sn. Çoklu programlamanın mantıksal uzantısıdır; o olmadan geçilecek iş olmaz.
- Eşzamanlılık (concurrency): birden çok iş ilerliyor (tek çekirdekte iç içe). Paralellik (parallelism): aynı anda birden çok iş çalışıyor (çok çekirdek).
Sistem çağrısı Böl. 2
Programların çekirdek servislerine erişim arayüzü. Programcı genelde API kullanır (Win32, POSIX, Java API); API'nin kütüphane fonksiyonu sistem çağrısını yapar.
uygulama: printf("…") (API)
↓
C kütüphanesi (libc): write() (kütüphane fonk.)
↓ trap, mod 0
sistem çağrısı arayüzü → tablodan numara → çekirdek
↓ sonuç / durum kodu
uygulamaya dön (mod 1)
Parametre geçirme: registerlar, bellekte blok/tablo (adresi registerda), yığıt (stack).
6 tür: süreç kontrolü, dosya yönetimi, aygıt yönetimi, bilgi bakımı, iletişim, koruma.
Olmasaydı: her program donanıma doğrudan erişirdi → koruma yok, taşınabilirlik yok, bir hata bütün sistemi çökertir.
İS servisleri Böl. 2
- Kullanıcı arayüzü (CLI, GUI, dokunmatik)
- Program çalıştırma (yükle, çalıştır, sonlandır)
- G/Ç işlemleri
- Dosya sistemi işlemleri
- İletişim (shared memory, message passing)
- Hata algılama
- Kaynak ayırma, kayıt tutma (accounting), koruma ve güvenlik
Policy / mechanism: mekanizma = nasıl yapılacağı, politika = ne yapılacağı. Örnek: timer mekanizması CPU'yu korur; bir kullanıcıya ne kadar süre verileceği politikadır. Ayrı olunca politika değişir, mekanizma kalır (esneklik).
Çekirdek yapıları Böl. 2
| Fikir | Artı | Eksi |
|---|
| Monolitik | Her şey tek adres alanında çekirdekte (UNIX, Linux) | Hızlı, az ek yük | Bir hata hepsini çökertir, büyük |
|---|
| Katmanlı | Katman 0 donanım … N kullanıcı; her katman alttakini kullanır | Basit hata ayıklama | Katmanları tanımlamak zor, yavaş |
|---|
| Mikro çekirdek | Çekirdekte yalnızca IPC, bellek, zamanlama; sürücü/dosya kullanıcı modunda (Mach) | Güvenli, güvenilir, genişletilebilir, taşınabilir | Mesajlaşma ek yükü → yavaş |
|---|
| Modüler | Çekirdek çekirdeği + çalışırken yüklenen modüller (Linux LKM) | Esnek, hızlı, güncellenebilir | Modül hatası yine çekirdekte |
|---|
| Hibrit | Karışım: macOS/iOS (Mach + BSD), Windows | Performans + modülerlik | Karmaşık |
|---|
Güncellenebilirlik + hata izolasyonu: mikro çekirdek en iyisi; pratik uzlaşma modüler.
Boot, bağlama, sanallaştırma Böl. 1–2
Boot: güç → ROM/EEPROM'daki BIOS/UEFI (bootstrap) donanımı sınar → disk boot bloğundaki bootloader (GRUB) → çekirdeği belleğe yükler → çekirdek donanımı başlatır, kök dosya sistemini bağlar → ilk süreç (systemd/init).
Dinamik yükleme: rutin çağrılana kadar belleğe alınmaz → az kullanılan kod bellek harcamaz (program yapar). Dinamik bağlama: kütüphane (DLL, .so) çalışma zamanında bağlanır; tek kopya süreçler arasında paylaşılır; kütüphane güncellenince yeniden derleme gerekmez (İS desteği gerekir).
Sanallaştırma: tek donanımı birden çok çalıştırma ortamına soyutlar; her biri kendi makinesinde gibi. VMM/hipervizör donanımı paylaştırır. Host OS: fiziksel makinedeki İS (tip 2'de VMM onun üstünde). Guest OS: sanal makinede çalışan İS. Fayda: yalıtım/güvenlik, sunucu birleştirme (kaynak kullanımı), anlık görüntü/taşıma (bakım kolay); maliyet: ek yük, hipervizör tek hata noktası.
Süreç Böl. 3
Süreç: yürütülmekte olan program. Program pasif (diskte dosya), süreç aktif (PC, registerlar, bellek, açık dosyalar). Bir program birden çok süreç olabilir.
max ┌────────────┐
│ stack │ yerel değişken, dönüş adresi ↓
├────────────┤
│ ↓ ↑ │
├────────────┤
│ heap │ dinamik (malloc/new) ↑
├────────────┤
│ data │ global değişkenler
├────────────┤
0 │ text │ çalıştırılabilir kod
└────────────┘
PCB: süreç durumu, program sayacı (PC), CPU registerları, zamanlama bilgisi (öncelik, kuyruk işaretçileri), bellek yönetimi bilgisi, hesap (accounting) bilgisi, G/Ç durum bilgisi (açık dosyalar).
Süreç durumları Böl. 3
new ─admitted→ ready ─dispatch→ running ─exit→ terminated
▲ ◀interrupt─┘ │
│ (quantum bitti) │ I/O / olay bekle
I/O / olay │ ▼
tamamlandı └───────────── waiting
- Context switch: CPU başka sürece geçerken eskinin durumu PCB'ye kaydedilir, yeninin durumu yüklenir. Saf ek yük (overhead): o sırada faydalı iş yok. Artıran: çok register, TLB/önbellek soğuması, bellek değişimi. Azaltan: donanım register setleri, thread (aynı adres alanı), daha büyük quantum.
- Planlayıcılar: uzun vadeli (job) — hangi iş belleğe girer, çoklu programlama derecesini belirler, seyrek; kısa vadeli (CPU) — hazırdan kim çalışacak, çok sık (ms); orta vadeli — swap out/in.
IPC, yarışma durumu Böl. 3–4
| Shared memory | Message passing |
|---|
| Nasıl | Ortak bellek bölgesi, süreçler doğrudan okur/yazar | send() / receive(), çekirdek taşır |
|---|
| Hız | Hızlı (kurulduktan sonra çekirdek yok) | Yavaş (her mesaj syscall) |
|---|
| Senkronizasyon | Programcının işi | Kolay, çekirdek halleder |
|---|
| Uygun | Büyük veri, aynı makine (video işleme) | Az veri, dağıtık sistem (istemci-sunucu) |
|---|
Bounded buffer: in, out; dolu: (in+1) % BUFFER_SIZE == out. counter++ ve counter-- makine dilinde 3 adım (oku, değiştir, yaz); iç içe geçerse counter=5 → 4 ya da 6 olur: yarışma durumu (race condition). Çözüm: kritik bölge, mutex/semafor.
Thread Böl. 4
Thread: CPU kullanımının temel birimi; süreç içinde ayrı yürütme akışı. Paylaşır: kod, veri, açık dosyalar. Kendine ait: thread ID, PC, registerlar, yığıt. Süreçler birbirinden yalıtık; aynı sürecin thread'leri adres alanını paylaşır.
Faydalar: tepki süresi (responsiveness), kaynak paylaşımı, ekonomi (oluşturma ve geçiş ucuz), ölçeklenebilirlik (çok çekirdek).
| Model | Eşleme | Bloklanma | Ölçeklenme |
|---|
| Many-to-One | çok user → 1 kernel | Biri bloklanırsa hepsi | Paralel yok |
|---|
| One-to-One | 1 → 1 (Linux, Windows) | Yalnızca o thread | İyi, ama thread sayısı sınırlı |
|---|
| Many-to-Many | m user → n ≤ m kernel | Diğerleri çalışır | En esnek, uygulaması zor |
|---|
Amdahl: $\text{hızlanma}\le \dfrac{1}{S+\frac{1-S}{N}}$. %30 seri: N=2 → 1.54, N=4 → 2.11, N=8 → 2.58, N=∞ → 3.33.
Thread havuzu: sabit sayıda thread önceden oluşturulur; istek gelince boştaki alır. Oluşturma maliyeti yok, kaynak sınırlı.
CPU zamanlama Böl. 5
| Kriter | Hedef |
|---|
| CPU kullanımı (utilization) | max |
| Throughput: birim zamanda biten süreç | max |
| Dönüş (turnaround) = bitiş − varış | min |
| Bekleme (waiting) = dönüş − burst | min |
| Tepki (response) = ilk çalışma − varış | min |
| Alg. | Kesmeli? | Not |
|---|
| FCFS | hayır | Basit; konvoy etkisi (uzun iş kısaları bekletir) |
|---|
| SJF | hayır | Ort. beklemede optimal; burst'ü bilmek zor; uzunlar aç kalabilir |
|---|
| SRTF | evet | Kesmeli SJF; daha kısa kalanlı gelirse keser |
|---|
| RR | evet | Quantum q; adil, iyi tepki; q büyük → FCFS, q küçük → geçiş yükü. Kural: burst'lerin %80'i q'dan kısa |
|---|
| Öncelik | ikisi de | Açlık (starvation) → çözüm yaşlandırma (aging) |
|---|
| MLQ / MLFQ | evet | Ön plan (RR) / arka plan (FCFS); MLFQ'da kuyruklar arası geçiş + aging |
|---|
Priority inversion: düşük öncelikli L kilidi tutarken yüksek H bekler, orta M, L'yi keser → H dolaylı olarak M'yi bekler. Çözüm: öncelik kalıtımı (priority inheritance).
Gerçek zamanlı sistemler: kesmeli, öncelik tabanlı zamanlama gerekir (son tarih kaçmasın).
Soru 50 ve 51 P1=6, P2=2, P3=8, P4=3
FCFS — bekleme 0, 6, 8, 16 → 7.5; dönüş 12.25
SJF — bekleme P2=0, P4=2, P1=5, P3=11 → 4.5; dönüş 9.25
RR, q=3 — bekleme P1=8, P2=3, P3=11, P4=8 → 7.5; dönüş 12.25; 5 bağlam değişimi
Soru 59 (SRTF) varış 0, 2, 4, 5
P1(0,7), P2(2,4), P3(4,1), P4(5,4)
t=2 P2(4) < P1 kalan 5 → keser; t=4 P3(1) < P2 kalan 2 → keser; t=5 en kısa P2(2); t=7 P4(4) < P1(5); t=11 P1.
Dönüş 16, 5, 1, 6 → 7; bekleme 9, 1, 0, 2 → 3.
Veri yapısı: kalan süreye göre min-heap (öncelik kuyruğu): en kısayı bulmak O(1), ekle/çıkar O(log n). Varışlar için varış zamanına göre sıralı liste.