Bölüm 1: Giriş

İşletim Sistemleri

İşletim sistemi nedir?Kullanıcı ve çekirdek moduGenişletilmiş makine Kaynak yöneticisiTarihçeİşlemci ve bellek hiyerarşisi Disk ve SSDSorgulama, kesme, DMAVeri yolları ÖnyüklemeİS çeşitleriPolitika ve mekanizma

Sercan KÜLCÜ · Giresun Üniversitesi · Bilgisayar Mühendisliği

Giriş

Öğrenme Çıktıları

Tanım ve konum

İşletim sisteminin donanım ile uygulamalar arasındaki yerini ve iki temel rolünü (genişletilmiş makine, kaynak yöneticisi) açıklamak.

Koruma

Çekirdek modu ile kullanıcı modunu ve aralarındaki kontrollü geçişi (sistem çağrısı, kesme, istisna) açıklamak.

Tarihsel gelişim

Toplu iş, çoklu programlama ve zaman paylaşımı fikirlerinin hangi sorunları çözdüğünü anlatmak.

Donanım temelleri

İşlemci, bellek hiyerarşisi, önbellek, disk/SSD ve veri yollarının İS'yi nasıl etkilediğini yorumlamak.

G/Ç yöntemleri

Sorgulama, kesme ve DMA'yı karşılaştırmak; açılış (önyükleme) sırasını izlemek.

Kavramlar

İS çeşitlerini, İS hizmetlerini ve politika–mekanizma ayrımını örneklerle açıklamak.

Giriş

İşletim Sistemi Nedir?

Modern bir bilgisayar; çok çekirdekli işlemci, GB'larca bellek, SSD, ağ kartı, GPU ve onlarca aygıttan oluşur.
Uygulama geliştiricinin bu donanımın her ayrıntısını bilmesi ve doğrudan programlaması imkânsızdır.
İşletim sistemi (İS): donanımı yöneten, uygulamalara basit, güvenli ve ortak bir arayüz sunan yazılım katmanı.
Çekirdek (kernel): her zaman bellekte duran, ayrıcalıklı kısım; dar anlamda "işletim sistemi" budur.
Kullanıcılar bilgisayarla kabuk (shell, komut satırı) ya da GKA (grafik kullanıcı arayüzü, GUI) üzerinden etkileşir.

MasaüstüWindows 11, macOS, Linux dağıtımları (Ubuntu, Fedora), ChromeOS

MobilAndroid, iOS / iPadOS, HarmonyOS

Sunucu ve bulutLinux, Windows Server, FreeBSD

Gömülü ve IoTZephyr, FreeRTOS, Contiki-NG, VxWorks, QNX

Giriş

Bilgisayar Sisteminin Bileşenleri

Donanım: işlemci, bellek, depolama ve G/Ç aygıtları. Yazılım: çekirdek modunda çalışan işletim sistemi ve kullanıcı modunda çalışan her şey; kabuk/GKA bile sıradan bir kullanıcı programıdır.

Giriş

Kabuk ve GKA

Kabuk (shell): komut satırı arayüzü (CLI) · bash, zsh, fish, PowerShell, cmd.exe.
GKA (GUI): pencere, simge, menü ve işaretçi (WIMP) ile görsel etkileşim · Windows Gezgini, macOS Finder, GNOME, KDE Plasma.
İkisi de çekirdeğin parçası değildir: kullanıcı modunda çalışan programlardır ve çekirdek hizmetlerini sistem çağrılarıyla isterler. Bu yüzden değiştirilebilir, kişiselleştirilebilir; aynı anda birden çoğu çalışabilir.

Giriş

Kabuk mu, GKA mı?

Kabuk

Betiklerle (script) otomasyon: aynı işi binlerce kez tekrarlamak kolay.
Boru hattı: ps aux | grep ssh | wc -l gibi küçük araçları birleştirme.
Az kaynak; SSH ile uzaktan sunucu yönetimi.
Belirli görevleri hızlı ve kesin biçimde yapar.

GKA

Sezgisel ve keşfedilebilir: komut ezberlemek gerekmez.
Görsel içerik (fotoğraf, harita, tasarım) için doğal.
Geniş bir kullanıcı kitlesine ulaşır; erişilebilirlik araçları.
Dokunmatik ve sesli arayüzler de bu ailededir.

İkisi birbirinin rakibi değil, tamamlayıcısıdır: günlük işler için GKA, tekrarlı ve uzaktan işler için kabuk. Her ikisi de aynı çekirdek hizmetlerini kullanır; çekirdek, isteğin hangi arayüzden geldiğini bilmez.

Giriş

Aygıt Yöneticisi

Windows'ta bilgisayara bağlı donanım aygıtlarını ve sürücülerini listeleyen yönetim aracıdır (devmgmt.msc, bir MMC eklentisi).
Aygıtın türünü, üreticisini, sürücü sürümünü ve kullandığı kaynakları (kesme, bellek aralığı) gösterir.
Sürücüyü güncelleme / geri alma, aygıtı devre dışı bırakma; sorunlu aygıtlar uyarı simgesiyle işaretlenir.
Asıl işi çekirdekteki Tak-Çalıştır (PnP) yöneticisi ve aygıt sürücüleri yapar; araç onların bir görünümüdür.
Linux karşılıkları: lspci, lsusb, lsblk, lsmod, /sys ve udev.

Konum ve Modlar

İşletim Sisteminin Konumu

İS, donanım (fiziksel bileşenler: CPU, RAM, disk) ile yazılım (bilgisayarın yapacağı işleri tarif eden kod) arasındaki arayüzdür.
Uygulamalar donanıma doğrudan değil, İS'nin sunduğu sistem çağrıları üzerinden erişir.

Konum ve Modlar

Çekirdek Modu ve Kullanıcı Modu

İşlemcide bir mod biti / ayrıcalık seviyesi vardır: x86 ring 0–3, ARMv8 EL0–EL3, RISC-V U/S/M.
Çekirdek modu: tüm komutlar ve tüm bellek kullanılabilir; G/Ç, kesmeleri kapatma, sayfa tablosunu değiştirme gibi ayrıcalıklı komutlar serbesttir.
Kullanıcı modu: ayrıcalıklı komutlar yasaktır; denenirse işlemci bir istisna (trap) üretir ve çekirdek süreci sonlandırabilir.
Kabuk ve GKA, kullanıcı modu yazılımının en alt seviyesidir.
Kullanıcıdan çekirdeğe yalnızca kontrollü kapılardan geçilir: sistem çağrısı, kesme, istisna.

Konum ve Modlar · Animasyon

Mod Geçişi Adım Adım: `read()` Sistem Çağrısı

Süreç kullanıcı modunda çalışıyor (mod biti = 1). Bir dosyadan okumak istiyor; diske kendisi erişemez.

C kütüphanesindeki read() sarmalayıcısı çağrı numarasını (x86-64 Linux: read = 0, rax) ve argümanları yazmaçlara koyar, syscall komutunu çalıştırır.

Trap: donanım mod bitini 0 yapar, dönüş adresini kaydeder ve çekirdeğin sabit giriş noktasına atlar. Süreç nereye atlanacağını seçemez.

Çekirdek, numarayla sistem çağrısı tablosundan sys_read()'i bulur; argümanları doğrular (buf gerçekten sürecin mi?) ve işi yapar.

Sonuç (okunan bayt sayısı) rax'a yazılır; sysret mod bitini 1 yapar ve süreç read()'ten sonraki komuttan devam eder.

Konum ve Modlar

Fiziksel Aygıtlar, Mikro Mimari, Makine Dili

Fiziksel aygıtlarYongalar, bellek modülleri, SSD, G/Ç aygıtları.

Mikro mimariİşlemcinin iç tasarımı: veri yolu, yazmaçlar, ALU, önbellekler, denetim birimi.

Makine dili (ISA)Donanımın doğrudan yürüttüğü ikili komutlar: x86-64, ARM64, RISC-V.

İS'nin işiSürücüler, üst katmanın isteklerini aygıtın anlayacağı düşük düzeyli komutlara çevirir.

Düzeltme: Programı makine diline derleyici çevirir, İS değil. İS, derlenmiş programı yükler, çalıştırır ve donanıma erişimine aracılık eder.

İS'nin Rolleri

Genişletilmiş Makine Olarak İS

Donanımın üstüne inşa edilmiş bir yazılımdır; donanımı kullanmayı kolaylaştırır.
Donanımın yeteneklerini kullanılabilir hâle getirir, karmaşık ayrıntılarını gizler.
Uygulamaların donanıma doğrudan erişmesini engeller: hem kolaylık hem koruma için.
Örnek: SSD'ye blok yazmak için NVMe kuyrukları, LBA, hata kodları… Uygulama ise yalnızca write(fd, buf, n) der.
Tanenbaum'un ifadesiyle: İS, çirkin donanımı güzel soyutlamalara dönüştürür.

İS'nin Rolleri

Soyutlamalar ve Roller

Donanım	İS soyutlaması
İşlemci (CPU)	Süreç ve iş parçacığı
Bellek (RAM)	Adres uzayı (sanal bellek)
Depolama (SSD/disk)	Dosya ve dizin
Ağ kartı	Soket
Ekran, klavye	Pencere, terminal

Her soyutlama, donanımın sınırlı ve paylaşılan kaynağını her programa "kendine ait" gibi gösterir.

Donanım tasarımcısıISA'yı, aygıtları ve arayüzlerini tasarlar.

Çekirdek geliştiriciSoyutlamaları donanım üzerinde gerçekler.

Uygulama geliştiriciSoyutlamaları sistem çağrıları ve API'lerle kullanır.

Son kullanıcıYalnızca uygulamaları ve arayüzü görür.

İS'nin Rolleri · Animasyon

Bir `write()` Çağrısının Yolculuğu

Uygulama yalnızca dosya tanımlayıcısı (fd), bir tampon ve uzunluk verir; diskin türünü bile bilmez.

libc sarmalayıcısı argümanları yazmaçlara koyar ve syscall ile çekirdeğe geçer (önceki slayttaki mod geçişi).

VFS: fd, sürecin açık dosya tablosundan bir dosya nesnesine ve inode'a çözülür. Tüm dosya sistemleri için ortak katman.

Dosya sistemi, dosyadaki konumu (ofset) diskteki blok adresine çevirir; gerekirse yeni blok ayırır.

Veri genelde önce sayfa önbelleğine yazılır ve write() hemen döner; diske yazma sonra yapılır (kalıcılık için fsync()).

Sürücü bir NVMe komutu hazırlar; SSD veriyi DMA ile bellekten alıp flash'a yazar ve bitince kesme üretir.

İS'nin Rolleri

Kaynak Yöneticisi Olarak İS

Birden çok programın aynı anda çalışmasına izin verir; CPU, bellek, G/Ç aygıtları gibi kaynakları dağıtır ve korur.
Hedef: kaynakları verimli kullanmak ve programlar arasında adil paylaştırmak.
Yukarıdan aşağı bakış: uygulamalara soyutlamalar sağlar. Aşağıdan yukarı bakış: karmaşık sistemin parçalarını yönetir.
Kaynaklar iki biçimde paylaştırılır: zamanda (sırayla) ve alanda (parçalara bölerek).

Sorular: Birçok program aynı anda yazdırmak isterse? Her sürecin kaynak kullanımı nasıl ölçülür? Kaynaklar çoğaldığında adalet ve verimlilik nasıl sağlanır?

İS'nin Rolleri · Animasyon

Birçok Program Aynı Anda Yazdırmak İsterse

Üç program neredeyse aynı anda yazdırmak istiyor; yazıcı tek. Hepsi yazıcıya doğrudan yazabilseydi sayfalar birbirine karışırdı.

Programlar işlerini yazıcıya değil, İS'nin diskteki biriktirme (spool) kuyruğuna yazar ve hemen kendi işlerine döner.

Yazıcıyı kullanan tek süreç biriktirme hizmetidir (Linux: CUPS, Windows: Print Spooler); karışıklık bu tekellikle önlenir.

Hizmet işleri genellikle geliş sırasıyla (FCFS) gönderir; yönetici öncelik ya da duraklatma uygulayabilir. Şimdi iş 1 basılıyor.

İş 1 bitti, sıradaki iş 2. Yavaş yazıcı beklenirken programlar ve CPU başka işler yapabildi: G/Ç ile hesaplama örtüşür.

İS'nin Rolleri

Kaynak Kullanımını Ölçmek

Kaynak	Ölçüt	Linux	Windows
CPU	Kullanıcı / çekirdek modu CPU zamanı, kullanım yüzdesi	`/proc/[pid]/stat`, `top`, `time`	Görev Yöneticisi, Performans İzleyicisi
Bellek	Yerleşik küme (RSS), sanal boyut, çalışma kümesi; ayırma/serbest bırakma örüntüsü	`/proc/[pid]/status`, `smem`	"Çalışma kümesi" sütunu
G/Ç	Okunan/yazılan bayt, sistem çağrısı ve G/Ç isteği sayısı	`/proc/[pid]/io`, `iotop`, `strace -c`	Kaynak İzleyicisi

$ grep -E 'VmRSS|Threads' /proc/4211/status
VmRSS:    412360 kB
Threads:  57

Ölçümün kaynağı çekirdektir: her bağlam değişiminde, sistem çağrısında ve sayfa hatasında süreç başına sayaçları günceller.

İS'nin Rolleri

Adalet ve Verimlilik

Kaynakların çoğalması (çok çekirdek, büyük bellek) performans ve tepki süresi kazandırır; ama onları adil ve verimli paylaştırmayı zorlaştırır.

ÇizelgelemeHangi süreç ne zaman, hangi çekirdekte çalışacak? Linux 6.6 (2023) ile CFS yerine EEVDF çizelgeleyicisi geldi.

Önceliklendirmenice değerleri, Windows öncelik sınıfları, gerçek zamanlı sınıflar.

Kotalar ve sınırlarLinux cgroups v2 (konteynerler), ulimit, disk kotaları, Windows Job nesneleri.

ÖdünleşimToplam iş hacmi ↔ tepki süresi ↔ adalet: biri iyileşirken diğeri kötüleşebilir.

Doğru yaklaşım iş yüküne bağlıdır: sunucuda iş hacmi, masaüstünde tepki süresi, gerçek zamanlı sistemde son tarihlere uymak önceliklidir.

Tarihçe

İşletim Sistemlerinin Tarihi

Nesiller, donanım teknolojisindeki sıçramalarla (tüp → transistör → tümleşik devre → mikroişlemci) birlikte değişir.
Her nesilde aynı soru yeniden sorulur: pahalı kaynağı (CPU, bellek, insan zamanı) nasıl daha iyi kullanırız?
Son satır Tanenbaum'un nesillerinden biri değildir; bugünkü sistemleri anlamak için eklenmiştir.

Tarihçe

1. ve 2. Nesil

1. nesil (1945–55): vakum tüpleri

Oda büyüklüğünde, yavaş, sık arızalanan makineler (ENIAC, 1945).
Aynı mühendis grubu tasarlar, kurar, programlar, bakımını yapar.
Makine diliyle ya da kablo panolarıyla programlama; 1950'lerin başında delikli kartlar.
Programlama dili ve işletim sistemi yok; çoğunlukla sayısal tablolar hesaplanır.

2. nesil (1955–65): transistör ve toplu iş

Transistörler tüplerin yerini aldı: daha küçük, güvenilir, enerji verimli.
Ana bilgisayarlar klimalı odalarda; programcı ile makine arasında operatör.
Toplu iş: işler teybe toplanır, küçük bir monitör programı onları sırayla, otomatik çalıştırır; operatör yalnızca teypleri taşır.
Bellekte tek iş: G/Ç sırasında CPU boşta; etkileşim yok.

Toplu işin amacı işler arasındaki el ile geçiş süresini ortadan kaldırmaktı. Etkileşimli ve gerçek zamanlı kullanıma ise uygun değildi.

Tarihçe · Animasyon

Erken Bir Toplu İş Sistemi

(a) Programcılar delikli kart destelerini 1401'in kart okuyucusuna getirir.

(b) Ucuz 1401, bir grup işin kartlarını okuyup giriş teybine yazar (yavaş kart okumayı pahalı makineden ayırır).

(c) Operatör giriş teybini pahalı 7094'e taşır.

(d) 7094, sistem teybindeki monitör programıyla işleri sırayla hesaplar; çıktıları çıkış teybine yazar.

(e) Operatör çıkış teybini yeniden 1401'e taşır.

(f) 1401 çıktıları yazıcıdan basar (çevrim dışı yazdırma). Pahalı 7094 hiç kart okumak ya da yazdırmakla uğraşmadı.

Tarihçe

IBM 1401, 7094 ve System/360

Makine	Yıl	Özellik
IBM 1401	1959	Ticari veri işleme; karakter tabanlı, görece ucuz. Kart okuma, teybe kopyalama, yazdırma gibi G/Ç işlerinde de kullanıldı. 1960'ların en yaygın bilgisayarlarından.
IBM 7094	1962	Bilimsel hesaplama; 36 bit sözcüklü, 1401'den tamamen farklı bir mimari. IBSYS / FMS altında toplu iş çalıştırdı. MIT'de değiştirilmiş bir 7094 üzerinde CTSS ile zaman paylaşımı denendi.
System/360	1964	Küçükten büyüğe aynı mimariyi paylaşan bir aile. İşletim sistemi OS/360: çoklu programlama, biriktirme; milyonlarca satırlık, hatalarla dolu dev bir proje (Brooks, The Mythical Man-Month).

Düzeltme: 1401 ve 7094, OS/360 altında çalışmadı; OS/360, 1964'te duyurulan System/360 ailesi için yazıldı. 7094 de 1401'in "güçlü sürümü" değildi; iki makine birbirini tamamlıyordu (bkz. önceki slayt).

Tarihçe

Tipik Bir FMS İşi

FMS = Fortran Monitor System: IBM 709/7094 için bir toplu iş izleme (monitör) programı.
$ ile başlayan denetim kartları monitöre ne yapacağını söyler: işi başlat, derleyiciyi yükle, programı bağla, çalıştır, bitir.
Bu kartlar bugünkü kabuk betiklerinin ve IBM JCL'nin atasıdır.

Düzeltme: Buradaki FMS, "Esnek Üretim Sistemi" (Flexible Manufacturing System) değildir. Fabrika otomasyonuyla ilgili o kavramın bu bölümle bağlantısı yoktur; o slayt çıkarıldı.

Tarihçe

3. Nesil: Tümleşik Devreler ve Çoklu Programlama

Tümleşik devreler (1965–80): System/360 gibi uyumlu aileler; daha küçük, ucuz, güvenilir.
Çoklu programlama: bellek bölümlere ayrılır, her bölümde bir iş. Bir iş G/Ç beklerken CPU başka işe geçer.
Tek CPU'da işler iç içe ilerler: gerçek paralellik değil, eşzamanlılıktır (concurrency).
İşlerin birbirinin belleğine dokunmaması için koruma donanımı gerekir.
Biriktirme: kartlar doğrudan diske; bir iş bitince sıradaki diskten yüklenir.
Zaman paylaşımı: CTSS (MIT, 1961) → MULTICS → UNIX (Bell Labs, 1969) → BSD, POSIX, MINIX, Linux (1991).

Tarihçe · Animasyon

Çoklu Programlama: CPU Neden Boş Kalmaz?

İki iş (birim zaman): A = CPU 2, G/Ç 4, CPU 2 · B = CPU 3, G/Ç 3, CPU 1. Toplam CPU ihtiyacı 8 birim.

Tek programlı: önce A (t = 0–8), sonra B (t = 8–15). G/Ç sırasında CPU boşta: kullanım 8 / 15 ≈ %53.

Çoklu programlı: A t = 2'de G/Ç'ye gidince CPU hemen B'ye geçer (t = 2–5). A'nın G/Ç'si arka planda sürer.

B t = 5'te G/Ç'ye gider (5–8). A'nın G/Ç'si t = 6'da biter: CPU yalnız 5–6 arasında boşta; A 6–8, B 8–9 çalışır.

Aynı iki iş 15 yerine 9 birimde bitti; CPU kullanımı 8 / 9 ≈ %89. Çoklu programlamanın kazancı, CPU ile G/Ç'nin örtüşmesidir.

Tarihçe

4. Nesil: Kişisel Bilgisayarlar

Yıl	Gelişme
1974	Intel 8080 için CP/M (Gary Kildall): mikrobilgisayarlar için disk tabanlı ilk yaygın İS.
1981	IBM PC ve MS-DOS (86-DOS'tan türetildi); BASIC yorumlayıcı ROM'da.
1973–84	Xerox PARC'ın GKA fikirleri → Apple Lisa (1983) ve Macintosh (1984): kullanıcı dostu arayüz.
1985–2000	Windows 1.0 … 3.x MS-DOS üzerinde grafik ortamdı; Windows 95/98/ME hâlâ MS-DOS tabanlıydı.
1993–	Sıfırdan yazılan Windows NT → 2000, XP, 7, 10, 11: bugünkü Windows'un çekirdeği.
1991–	Linus Torvalds'ın Linux çekirdeği; 2001'de UNIX tabanlı Mac OS X (Darwin/XNU) → bugünkü macOS.

Fiyatların hızla düşmesi bilgisayarı herkese açtı; İS'nin hedefi "makineyi verimli kullan"dan "kullanıcıya kolaylık"a kaydı.

Tarihçe

5. Nesil: Mobil ve Günümüz

Mobil cihazlar (1990–)

1990'lar: PDA'lar, Palm OS; 2000'ler: Symbian, BlackBerry OS.
2007 iOS (iPhone), 2008 Android (Linux çekirdeği üzerinde).
Windows Phone 2010'da çıktı, 2017'de geliştirmesi durduruldu.
Bugün pazarı Android ve iOS paylaşır; dokunmatik arayüz, pil yönetimi, izin modeli öne çıkar.

Sanallaştırma ve bulutHipervizörler (KVM, Hyper-V, Xen); tek sunucuda çok sayıda sanal makine.

KonteynerlerDocker, Kubernetes: aynı çekirdeği paylaşan yalıtılmış ortamlar (namespaces, cgroups).

Heterojen donanımCPU + GPU + NPU; büyük ve küçük çekirdekli hibrit işlemciler.

GüvenlikBellek güvenli diller: Linux 6.1'den beri çekirdekte Rust desteği.

Donanım

Kişisel Bilgisayarın Bileşenleri

CPU, bellek ve G/Ç aygıtları bir veri yolu üzerinden haberleşir; her aygıtın bir denetleyicisi vardır.
MMU (bellek yönetim birimi) CPU içindedir ve sanal adresleri fiziksel adrese çevirir.
Gerçek sistemlerde tek ortak hat yerine noktadan noktaya bağlantılar (PCIe) kullanılır; ama kavramsal model aynıdır.

Donanım

Von Neumann Mimarisi

Program ve veri aynı bellekte durur; komutlar da veri gibi okunur (saklı program fikri, 1945).
Komutlar bellekten sırayla getirilir ve yürütülür.
Von Neumann darboğazı: CPU, bellekten çok daha hızlıdır; aradaki dar yol performansı sınırlar → önbellekler.
Harvard mimarisi komut ve veri için ayrı yollar kullanır. Modern CPU'lar "değiştirilmiş Harvard"dır: L1 önbellek komut (L1i) ve veri (L1d) olarak ayrılır.

Donanım

İşlemci ve Yazmaçlar

Bilgisayarın "beyni": tüm komutları işlemci (CPU) yürütür.
Temel döngü: komutu getir (fetch), çöz (decode), yürüt (execute).
Bellek yavaş olduğu için değişkenler ve ara sonuçlar yazmaçlarda tutulur: yükle (bellek → yazmaç), sakla (yazmaç → bellek).
Her işlemci ailesinin kendi komut kümesi vardır: x86-64 programı ARM'da doğrudan çalışmaz.
Performans: saat hızı, çekirdek sayısı, önbellek boyutu, boru hattı derinliği, bellek bant genişliği.
İS, bağlam değiştirirken (süreç değişimi) tüm yazmaçları kaydeder ve geri yükler.

Yazmaç	x86-64	ARM64
Program sayacı: sıradaki komut	`RIP`	`PC`
Yığıt işaretçisi: yığıtın üstü	`RSP`	`SP`
PSW: koşul bitleri, mod, kesme izni	`RFLAGS`	`PSTATE`
Genel amaçlı	16 adet	31 adet

Donanım · Animasyon

Getir–Çöz–Yürüt Döngüsü

Program bellekte 100. adresten başlıyor; PC = 100. Bellek[200] = 7, bellek[204] = 0.

Getir: PC'nin gösterdiği komut IR'ye okunur: LOAD R1, [200]. PC bir sonraki komuta ilerler: 104 (komutlar 4 bayt).

Çöz + yürüt: bellek[200] okunur, R1 = 7.

Getir: IR = ADD R1, R1, #5, PC = 108.

Yürüt: ALU toplar: R1 = 7 + 5 = 12. Belleğe hiç gidilmedi; yazmaç işlemi hızlıdır.

Getir: IR = STORE R1, [204], PC = 112.

Yürüt: R1 belleğe saklanır: bellek[204] = 12. Döngü PC = 112'den sürer.

Donanım

Boru Hattı ve Süperskalar

Boru hattıKomutların aşamaları üst üste bindirilir: biri yürütülürken sonraki çözülür, ondan sonraki getirilir.

SüperskalarBirden çok yürütme birimi; tampondaki komutlar sırası dışında (out-of-order) yürütülebilir.

İS'ye etkisiDallanmada boru hattı boşaltılır; kesmede "hangi komut bitti?" sorusu karmaşıklaşır. Spectre gibi açıklar bu tahminlerden doğdu.

Donanım · Animasyon

Boru Hattı Adım Adım

Çevrim 1: Komut 1 getiriliyor. Diğer birimler boş.

Çevrim 2: Komut 1 çözülüyor, aynı anda Komut 2 getiriliyor.

Çevrim 3: boru hattı dolu: üç komut üç farklı aşamada. Bundan sonra her çevrimde bir komut tamamlanır.

Çevrim 4: Komut 1 bitti; Komut 2 yürütülüyor, 3 çözülüyor, 4 getiriliyor.

Çevrim 5: Komut 3 yürütülüyor, Komut 4 çözülüyor.

Çevrim 6: 4 komut 6 çevrimde bitti; boru hattı olmasaydı 4 × 3 = 12 çevrim sürerdi. Bir dallanma yanlış tahmin edilirse sonraki aşamalar boşaltılır.

Donanım

Çok Çekirdekli Yongalar

Çok çekirdekBir yongada birden çok bağımsız CPU; İS her birini ayrı işlemci olarak görür ve çizelgeler.

SMT / Hyper-ThreadingBir çekirdek iki donanım iş parçacığı çalıştırır; İS'ye iki "mantıksal CPU" görünür ama kaynakları paylaşırlar.

Hibrit çekirdeklerPerformans (P) ve verimlilik (E) çekirdekleri (ARM big.LITTLE, Intel 2021+): çizelgeleyici hangisini seçeceğini bilmelidir.

İS açısından sonuç: paralellik, senkronizasyon ve önbellek tutarlılığı sorunları (Bölüm 6 ve 12).

Donanım

Bellek Hiyerarşisi

Düzey	Erişim (yakl.)	Kapasite (tipik)
Yazmaçlar	< 1 ns	< 1 KB
L1 önbellek	~1 ns	32–64 KB
L2 / L3	3–20 ns	1–100+ MB
DRAM	60–100 ns	8–64 GB
NVMe SSD	20–100 µs	0,5–4 TB
HDD	5–10 ms	2–24 TB

DRAM ve üstü uçucudur (güç gidince silinir); SSD ve HDD kalıcıdır. Değerler 2026 itibarıyla yaklaşık büyüklüklerdir.

Donanım · Animasyon

Bir Okuma Hiyerarşide Nasıl İlerler?

CPU x değişkenini okumak istiyor (LOAD R1, [x]). Önce en yakın ve en hızlı düzeye bakılır.

L1'de yok: ıska (miss). ~1 ns kaybedildi; aramaya bir alt düzeyde devam edilir.

L2 ve L3'te de ıska. Her düzey biraz daha büyük ama daha yavaştır; toplam ~20 ns.

Veri DRAM'den gelir (~80 ns). Tek bir sözcük değil, 64 baytlık satırın tamamı L3, L2 ve L1'e yerleştirilir.

Aynı satırdaki bir veriye ikinci erişim artık L1 isabeti (hit): ~1 ns. Önbellek, yerellik sayesinde işe yarar.

Donanım

Önbellek Satırları

Bellek, önbellek satırlarına (cache line, genelde 64 bayt) bölünür: satır 0 = 0–63, satır 1 = 64–127, …
Adres a için satır numarası ⌊a / 64⌋, satır içi konum a mod 64.
CPU bir sözcük okurken donanım önce önbelleğe bakar: isabet (hit) → L1'de ~4–5 çevrim; ıska (miss) → alt düzey ya da DRAM, yüzlerce çevrim.
Önbellek pahalı olduğundan küçüktür; bu yüzden düzeyler (L1, L2, L3) hâlinde kurulur.
Neden işe yarar? Zamansal yerellik (az önce kullanılan yine kullanılır) ve uzamsal yerellik (komşu adresler birlikte kullanılır).

Donanım · Kodu adım adım çalıştır

Kod İzleme: Doğrudan Eşlemeli Önbellek

Başlangıçta önbellek boş (−1). 64 B satır, 4 küme, doğrudan eşleme: her blok tek bir kümeye gidebilir.

adres[0] = 0 → blok = 0 / 64 = 0, küme = 0 mod 4 = 0.

Küme 0 boş → ıska; blok 0 yüklenir.

adres[1] = 8 → blok = 8 / 64 = 0, küme = 0 mod 4 = 0.

etiket[0] = 0 = blok → isabet. 8, 0 ile aynı 64 baytlık satırda: uzamsal yerellik.

adres[2] = 64 → blok = 64 / 64 = 1, küme = 1 mod 4 = 1.

Küme 1 boş → ıska; blok 1 yüklenir.

adres[3] = 256 → blok = 256 / 64 = 4, küme = 4 mod 4 = 0.

Küme 0'de blok 0 var → ıska; blok 4 onu dışarı atar (çakışma ıskası).

adres[4] = 0 → blok = 0 / 64 = 0, küme = 0 mod 4 = 0.

Küme 0'de blok 4 var → ıska; blok 0 onu dışarı atar (çakışma ıskası).

adres[5] = 72 → blok = 72 / 64 = 1, küme = 1 mod 4 = 1.

etiket[1] = 1 = blok → isabet. 72, 64 ile aynı satırda.

Döngü bitti: 2 isabet, 4 ıska (isabet oranı %33). 0 ve 256 aynı kümeye düştüğü için birbirini kovdu; 2 yollu küme ilişkili önbellek bunu önlerdi. (Burada etiket yerine blok numarasının tamamı saklandı.)

int adres[6] = {0, 8, 64, 256, 0, 72};
int etiket[4] = {-1, -1, -1, -1};
int isabet = 0, iska = 0;
for (int i = 0; i < 6; i++) {
  int blok = adres[i] / 64;
  int kume = blok % 4;
  if (etiket[kume] == blok) isabet++;
  else { etiket[kume] = blok; iska++; }
}

Donanım

Önbellek Tasarım Soruları

1. Ne zaman yerleştirilir?Genelde ıskada; donanım ayrıca sıradaki satırları önceden getirir (prefetch).

2. Hangi satıra konur?Eşleme: doğrudan eşlemeli, k yollu küme ilişkili ya da tam ilişkili.

3. Yer gerekince hangisi çıkar?Değiştirme ilkesi: LRU'ya yakın yaklaşımlar, rastgele, FIFO.

4. Çıkan nereye gider?Değiştirilmişse ("kirli") alt düzeye yazılır (write-back); ya da her yazma hemen aşağı iletilir (write-through).

BoyutBüyük önbellek daha çok isabet ama daha yavaş ve pahalı.

DeğiştirmePerformans ile donanım karmaşıklığı arasında denge.

TutarlılıkÇok çekirdekte aynı satırın kopyaları güncel kalmalı (MESI gibi protokoller).

Aynı dört soru İS'nin yönettiği "önbelleklerde" de karşımıza çıkar: sayfa önbelleği, sanal bellek, TLB.

Donanım

Ana Bellek Türleri

Tür	Özellik	Kullanım
RAM (rastgele erişimli)	Okunur ve yazılır, hızlı, uçucu. DRAM yenileme ister; SRAM daha hızlı ve pahalı.	Ana bellek (DRAM: DDR5, LPDDR5X), önbellekler (SRAM)
ROM (salt okunur)	Üretimde yazılır, değiştirilemez, kalıcı, ucuz.	Basit cihazlar, mikrodenetleyicilerde sabit kod
EEPROM / Flash	Elektrikle silinip yeniden yazılabilir, kalıcı; yazma yavaş ve yazma ömrü sınırlı.	UEFI/BIOS donanım yazılımı (SPI flash), SSD, USB bellek, telefon ve müzik çalar depolaması (NAND flash)
CMOS / NVRAM	Pil ya da flash ile korunan küçük alan.	Saat, önyükleme ayarları

Düzeltme: Bugünkü bilgisayarlarda BIOS/UEFI kodu ROM'da değil flash bellekte durur; bu yüzden güncellenebilir. Taşınabilir müzik çalarlar da disk değil NAND flash kullanır.

Donanım

Disk (HDD) Yapısı

Veriyi kalıcı saklar; ucuz ve büyük ama mekanik olduğu için yavaştır.
Her plaka yüzeyinde eş merkezli izler, izler de sektörlere (512 B / 4 KB) bölünür; aynı konumdaki izlerin kümesi silindirdir.
Tüm kafalar tek bir kola bağlıdır; motor plakaları 5400–7200 (sunucuda 10 000+) devir/dakika döndürür, denetleyici işlemleri yönetir.

Donanım · Animasyon

Diskten Bir Sektör Okumak

Sürücü denetleyiciye "LBA 1234'ü oku" der. Bugün diskler mantıksal blok adresi (LBA) kullanır; denetleyici bunu kendi iç (silindir, kafa, sektör) geometrisine çevirir.

Arama (seek): kol, kafaları doğru silindire taşır. Mekanik hareket: birkaç milisaniye.

Dönme gecikmesi: hedef sektör kafanın altına gelene kadar beklenir. 7200 dev/dk → tur 8,33 ms, ortalama yarım tur 4,17 ms.

Aktarım: sektör kafanın altından geçerken bitler okunur; ECC (hata düzeltme kodu) ile denetlenir, gerekirse düzeltilir.

Veri DMA ile belleğe yazılır, denetleyici kesme üretir. Toplam ~9 ms: CPU bu sürede milyonlarca komut çalıştırabilir, bu yüzden İS beklemez, başka süreç çalıştırır.

Donanım

HDD, SSD ve Sanal Bellek

	HDD	SATA SSD	NVMe SSD
Rastgele erişim	5–10 ms	~0,1 ms	0,02–0,1 ms
Rastgele okuma (IOPS)	100–200	~90 000	500 000–1 000 000+
Sıralı okuma	~250 MB/s	~550 MB/s	3–14 GB/s
Arayüz	SATA / SAS	SATA	PCIe (×4)
Hareketli parça	var	yok	yok

SSD: arama ve dönme gecikmesi yoktur; ama flash yerinde yazılamaz, blok blok silinir. Denetleyicideki FTL katmanı ve İS'nin TRIM komutu bunu yönetir.

Sanal bellek: RAM yetmediğinde az kullanılan sayfalar diske/SSD'ye (takas alanı, pagefile.sys) yazılır; MMU sanal adresleri fiziksel adrese çevirir (Bölüm 8–9).

G/Ç

G/Ç Aygıtları: Denetleyici ve Sürücü

G/Ç aygıtı iki parçadır: aygıtın kendisi ve ona İS'ye basit bir arayüz sunan denetleyicisi.
Aygıt sürücüsü denetleyicinin yazmaçlarına komut yazar, durumunu okur. Yazmaçlara G/Ç portlarıyla (x86 in/out) ya da bellek eşlemeli G/Ç (MMIO) ile erişilir.
Sürücüleri genellikle üretici her İS için yazar; çoğu çekirdek modunda çalışır (Windows .sys, Linux modülleri). Kullanıcı modu sürücüleri de vardır: Windows UMDF, Linux VFIO/UIO.
Sürücü çekirdeğe derlenebilir, açılışta ya da aygıt takıldığında (tak-çalıştır) yüklenebilir.

G/Ç

Üç G/Ç Yöntemi

Yöntem	Nasıl çalışır?	Artı	Eksi
Sorgulama (polling, meşgul bekleme)	CPU, aygıt hazır olana kadar durum yazmacını döngüde okur.	Basit; çok kısa beklemelerde en düşük gecikme.	Beklerken CPU başka iş yapamaz.
Kesme (interrupt)	Aygıt işi bitince CPU'ya sinyal gönderir; CPU o arada başka iş yapar.	CPU serbest; duyarlı.	Her kesmenin bağlam kaydetme maliyeti; çok sık kesme yük olur.
DMA (doğrudan bellek erişimi)	Özel denetleyici bloğu aygıt ile bellek arasında taşır; bitince tek kesme.	Büyük veride çok verimli.	Ek donanım; küçük aktarımda kurulum maliyeti.

Düzeltme: Sorgulama "artık kullanılmıyor" değildir. Çok hızlı aygıtlarda kesme yükü pahalı olduğundan bilerek kullanılır: Linux ağ yığınındaki NAPI (kesme + sorgulama karışımı), NVMe/io_uring sorgulama kipi, DPDK; ayrıca basit gömülü sistemler.

G/Ç · Kodu adım adım çalıştır

Kod İzleme: Programlı G/Ç (Sorgulama)

Çekirdek, kullanıcının "OS" dizesini çekirdek tamponuna kopyalar (n = 2).

Döngü başlar: i = 0, 0 < 2.

Durum yazmacı okunur: HAZIR → bekleme döngüsünden hemen çıkılır.

buf[0] = 'O' veri yazmacına yazılır; yazıcı karakteri basarken MEŞGUL olur.

i = 1, 1 < 2: sıradaki karakter.

Durum MEŞGUL → boş döngü. CPU yalnızca yazmacı yeniden okur.

Yine MEŞGUL. Gerçekte bu döngü binlerce kez dönebilir: CPU zamanı boşa gider.

Yazıcı hazır: HAZIR → döngüden çıkılır.

buf[1] = 'S' gönderilir.

i = 2, 2 < 2 yanlış → döngü biter.

Kullanıcı moduna dönülür. 2 karakter için 4 yoklama yapıldı; tüm süre boyunca CPU bu işe kilitlendi.

copy_from_user(buf, p, n);
for (i = 0; i < n; i++) {
  while (*durum_yaz != HAZIR)
    ;                /* meşgul bekle */
  *veri_yaz = buf[i];
}
return_to_user();

G/Ç · Animasyon

G/Ç Aygıtları: Kesme

1. Sürücü, disk denetleyicisinin yazmaçlarına "sektör oku" komutunu yazar. Süreç bloke olur; CPU başka bir süreci çalıştırmaya döner.

2. Okuma bitince disk denetleyicisi, veri yolu hatları üzerinden kesme denetleyicisine sinyal verir.

3–4. Kesme denetleyicisi (kesme kabul edilebiliyorsa) CPU'nun kesme hattını etkinleştirir ve hangi aygıt olduğunu belirten vektör numarasını verir.

CPU o anki komutu bitirir, PC ve PSW'yi (çekirdek) yığına kaydeder, çekirdek moduna geçer; vektör tablosundan işleyicinin adresini alır.

Kesme işleyicisi denetleyicinin durumunu okur, veriyi alır, bekleyen süreci "hazır" yapar ve kesme denetleyicisine EOI (işlem bitti) bildirir.

iret: kaydedilen PSW ve PC geri yüklenir, kullanıcı moduna dönülür. Kesilen program (ya da çizelgeleyicinin seçtiği başka bir süreç) kaldığı yerden sürer.

G/Ç

Kesme Türleri

Donanım kesmesiDış olay: G/Ç tamamlandı, tuşa basıldı, ağ paketi geldi. Zamanlayıcı kesmesi İS'ye düzenli olarak denetimi geri verir → kesintili (preemptive) çoklu görev.

İstisna (trap)Komutun kendisinden doğar: sıfıra bölme, geçersiz komut, sayfa hatası, kullanıcı modunda ayrıcalıklı komut.

Sistem çağrısıBilerek üretilen trap: syscall, svc, ecall. Kullanıcı programının çekirdekten hizmet isteme yolu.

Kesmeler maskelenebilir ve önceliklendirilebilir; maskelenemeyen kesme (NMI) ciddi donanım hataları içindir.

G/Ç · Animasyon

G/Ç Aygıtları: DMA

1. CPU, DMA denetleyicisine bellek adresini (0x8000), bayt sayısını (4096) ve yönü yazar; diske "oku" komutu verir. Sonra başka işe döner.

2. Disk denetleyicisi bloğu diskten kendi tamponuna okur ve ECC ile doğrular.

3. DMA denetleyicisi, veri yolu üzerinden disk denetleyicisine aktarım isteği gönderir (hedef: 0x8000).

4. Disk denetleyicisi veriyi doğrudan belleğe yazar ve DMA'ya onay (ACK) gönderir; DMA adresi artırır, sayacı azaltır. Bu, 4096 bayt bitene kadar tekrarlanır (burada 64 baytlık bir parçadan sonra).

5. Sayaç 0 olunca DMA CPU'ya tek bir kesme gönderir. CPU yalnızca başta ve sonda devreye girdi. Bugün çoğu aygıt (NVMe, ağ kartı) kendi DMA motoruna sahiptir ve IOMMU erişimi denetler.

G/Ç

Veri Yolları

Veri yolu	Özellik (2026)	Tipik kullanım
PCIe	Seri, noktadan noktaya "hatlar" (×1, ×4, ×16). 5.0: 32 GT/s/hat (~4 GB/s), 6.0: 64 GT/s.	Ekran kartı (×16), NVMe SSD (×4), ağ kartı
USB	2.0: 480 Mb/s · 3.2: 5–20 Gb/s · USB4: 40/80 Gb/s. Tak-çalıştır, güç taşır.	Klavye, fare, bellek, kamera, harici ekran
SATA / SAS	SATA 6 Gb/s; SAS, SCSI'nin seri sürümü (sunucular).	HDD ve eski SSD'ler
DDR5	CPU'daki bellek denetleyicisine doğrudan bağlı bellek kanalları.	Ana bellek
Eski: ISA, PCI, IDE (PATA), paralel SCSI	Paralel, paylaşımlı ve yavaş hatlar; yerlerini PCIe ve SATA aldı.	1980–2000'lerin PC'leri

İS açılışta veri yollarını tarar (PCIe yapılandırma alanı, USB tanımlayıcıları), her aygıtın kimliğini okur ve uygun sürücüyü yükler: tak-çalıştır bu sayede mümkündür.

G/Ç

x86 Sistem Yapısı

Düzeltme / güncelleme: Pentium dönemindeki kuzey köprüsü (northbridge), PCI, ISA ve IDE yolları artık yok. Bellek denetleyicisi CPU'nun içine taşındı (AMD 2003, Intel 2008); hızlı aygıtlar PCIe ile doğrudan CPU'ya, yavaşlar yonga setine bağlanır.

Önyükleme · Animasyon

Bilgisayarın Ayağa Kalkması (UEFI)

Güç verildiğinde CPU sıfırlanır ve donanımın belirlediği sabit bir adresten (flash'taki donanım yazılımı) komut getirmeye başlar.

UEFI donanım yazılımı POST (açılış öz-sınaması) yapar: belleği ve temel aygıtları dener, PCIe/USB aygıtlarını bulur.

Önyükleme yöneticisi NVRAM'deki sırayı okur: hangi diskteki hangi .efi dosyası? (NVMe, USB, ağ/PXE).

GPT diskteki EFI Sistem Bölümünden (FAT32) önyükleyici yüklenir. Secure Boot açıksa imzası doğrulanır.

Önyükleyici çekirdeği ve initramfs'i belleğe yükleyip denetimi verir. Çekirdek bellek yönetimini kurar, aygıtları tanır, sürücüleri yükler, kök dosya sistemini bağlar.

Çekirdek ilk kullanıcı sürecini başlatır: init / systemd (PID 1). O da ağ, günlük, oturum yöneticisi gibi hizmetleri başlatır.

Oturum açma ekranı ya da GKA gelir; sistem kullanıma hazır. Windows'ta karşılıkları: winload.efi → ntoskrnl.exe → smss.exe → winlogon.exe.

Önyükleme

Eski BIOS ve UEFI

Eski (legacy) BIOS akışı

Bellek, klavye ve temel aygıtları dener (POST).
Önyükleme aygıtını seçer (eskiden disket, CD-ROM, disk).
Aygıtın ilk sektörünü (512 B MBR) belleğe okur ve çalıştırır.
MBR kodu bölüm tablosunda etkin bölümü bulur, onun ilk sektöründeki ikincil önyükleyiciyi okur.
Önyükleyici İS'yi o bölümden yükler.

	BIOS	UEFI
Ortaya çıkış	1981 (IBM PC)	2000'ler; bugün standart
Çalışma kipi	16 bit gerçek kip	32/64 bit
Bölüm tablosu	MBR: 4 birincil bölüm, 2 TiB sınırı	GPT: 128+ bölüm, devasa diskler
Önyükleyici	Sektörlerdeki ham kod	ESP'de `.efi` dosyası
Güvenlik	Yok	Secure Boot (imza denetimi)

Birçok UEFI hâlâ eski BIOS'u taklit eden bir uyumluluk kipi (CSM) sunar; yeni sistemlerde bu kip kaldırılmaktadır.

İS Çeşitleri

İşletim Sistemi Çeşitleri (1)

Anabilgisayar (mainframe)Çok yüksek G/Ç kapasitesi, güvenilirlik ve erişilebilirlik; toplu iş, işlem (transaction) ve zaman paylaşımı. Bankalar, havayolları. IBM z/OS, z/VM, Linux on Z, Unisys MCP, Fujitsu BS2000.

Sunucu (server)Ağ üzerinden çok kullanıcıya web, veritabanı, dosya, e-posta hizmeti. Veri merkezleri, bulut, sanallaştırma (KVM, Hyper-V), konteynerler. Linux, Windows Server, FreeBSD.

Çok işlemcili (multiprocessor)Birden çok çekirdek/soket; işleri paralel yürütür, senkronizasyon ve NUMA ile uğraşır. Bugün tüm genel amaçlı İS'ler bu sınıftadır. Linux, Windows, macOS.

Kişisel (personal)Tek kullanıcı, iyi GKA, çoklu görev; tarayıcı, ofis, oyun, dosya yönetimi. Windows 11, macOS, Linux dağıtımları, ChromeOS.

İS Çeşitleri

İşletim Sistemi Çeşitleri (2)

Mobil (handheld)Dokunmatik arayüz, pil ve ısı yönetimi, sensörler, uygulama mağazası ve izin modeli. Android, iOS/iPadOS, HarmonyOS. (Windows Phone 2017'de sona erdi.)

Gömülü (embedded)Araçlar, ev aletleri, ağ cihazları, uçaklar; genellikle kullanıcı yazılım yüklemez, sistem flash'ta sabittir. Gömülü Linux (Yocto), Zephyr, FreeRTOS, QNX, VxWorks.

Algılayıcı düğümü (sensor node)Birkaç on KB RAM, pil ile yıllarca çalışma, olay güdümlü yapı, düşük güçlü radyo (802.15.4, BLE). IoT ve M2M ağları. Contiki-NG, RIOT, Zephyr; TinyOS artık tarihsel.

Akıllı kart (smart card)Çok kısıtlı CPU ve bellek; kimlik doğrulama, ödeme, kriptografi, güvenli saklama. Banka kartı, SIM/eSIM, kimlik kartı. Java Card, MULTOS.

İS Çeşitleri

Gerçek Zamanlı İşletim Sistemleri

Önemli olan hız değil, öngörülebilirlik: iş belirli bir son tarihten (deadline) önce bitmelidir.
Katı (hard): son tarihi kaçırmak felakettir (fren, hava yastığı, uçuş kontrolü, endüstriyel robot).
Yumuşak (soft): ara sıra kaçırmak kabul edilir, kalite düşer (ses/video akışı, oyun).

Örnekler: VxWorks (Mars gezginleri), QNX (araç sistemleri), FreeRTOS, Zephyr.
Linux'un PREEMPT_RT yamaları 2024'te (6.12) ana çekirdeğe katıldı; eski RTLinux projesi sona erdi.
Ses, video, hareket ve algılayıcı verisi işleyen; tren kontrolü, savunma gibi alanlarda kullanılır.

Temel Kavramlar

İşletim Sistemi Hizmetleri

Yeşil hizmetler doğrudan kullanıcıya yardım eder; kırmızı olanlar sistemin verimli ve güvenli çalışmasını sağlar (Silberschatz, Şekil 2.1).

Temel Kavramlar

Politika ve Mekanizma

Politika (policy): ne yapılacak?
Mekanizma (mechanism): nasıl yapılacak?
İkisini ayırmak temel bir tasarım ilkesidir: politika kararları sonradan değiştiğinde mekanizmayı yeniden yazmak gerekmez → en yüksek esneklik.

Örnek: Linux'ta çizelgeleme sınıfı sched_setscheduler() ile, G/Ç zamanlayıcısı /sys üzerinden çalışırken değiştirilebilir; çekirdek kodu değişmez.

Mekanizma	Politika
Zamanlayıcı kesmesi	Zaman dilimi kaç ms olmalı?
Öncelikli çizelgeleyici	Hangi süreç yüksek öncelikli?
Dosya izin bitleri (rwx)	Kime hangi izin verilecek?
Sayfa değiştirme altyapısı	Hangi sayfa dışarı atılacak?
cgroups	Hangi konteynere ne kadar CPU/bellek?

İS tasarımı, bu dengeleri kurmak için mühendislik kadar yaratıcılık da gerektirir.

Temel Kavramlar

MS-DOS ve FreeBSD

MS-DOS: tek görevli, tek bellek alanı. Açılışta kabuk (COMMAND.COM) yüklenir; program onun geçici kısmının üzerine yazılarak yüklenir; bitince kabuk kendini diskten yeniden yükler. Çoklu görev ve koruma yoktur.

FreeBSD (UNIX türevi): çok görevli. Kullanıcı giriş yapınca kabuk başlar; kabuk fork() ile yeni süreç yaratır, exec() ile programı o sürece yükler; sonra programı bekler ya da (& ile) arka planda çalıştırıp komut almaya devam eder.

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

Kod İzleme: Kabuk Gibi `fork` + `exec` + `wait`

Program (PID 1234) fork()'u çağırır. Çekirdek sürecin bir kopyasını çıkaracak.

fork() bir kez çağrılır, iki kez döner: ebeveyne çocuğun PID'si (1235), çocuğa 0. Hangisinin önce çalışacağına çizelgeleyici karar verir.

Ebeveynde pid == 0 yanlış → else dalı.

Ebeveyn waitpid() ile çocuğun bitmesini bekler: bloke olur, CPU başkasına geçer.

Çocukta pid == 0 doğru → if dalı.

execlp() çocuğun adres uzayını ls programıyla değiştirir (PID aynı kalır). Başarılıysa satır 5'e hiç dönülmez. ls dizini listeler.

ls exit(0) ile biter; çocuk ebeveyn onu toplayana kadar kısa süre zombi kalır. waitpid() döner, ebeveyn uyanır.

Ebeveyn "bitti" yazar. waitpid sayesinde çıktı sırası garanti: önce ls, sonra bitti.

Ebeveyn de sonlanır. Kabuk her komutta tam olarak bu fork → exec → wait döngüsünü uygular.

int main(void) {
  pid_t pid = fork();
  if (pid == 0) {              /* çocuk */
    execlp("ls", "ls", NULL);
    perror("exec");            /* yalnız hata olursa */
  } else {                     /* ebeveyn */
    waitpid(pid, NULL, 0);
    printf("bitti\n");
  }
  return 0;
}

Temel Kavramlar

Standart C Kütüphanesi

Başlık	Örnek işlevler
`stdio.h`	printf, fopen, fread, fclose
`stdlib.h`	malloc, free, exit, qsort
`string.h`	strlen, strcpy, memcpy
`math.h` · `time.h`	sqrt, sin · time, clock
`unistd.h` (POSIX)	fork, read, write, close

C kütüphanesi (glibc, musl; Windows'ta UCRT) kullanıcı modunda çalışır. Bir kısmı tamamen kütüphane içindedir (strlen), bir kısmı sistem çağrılarını sarmalar (write). "Merhaba\n" 8 bayttır.

Temel Kavramlar · Animasyon

Yürütülebilir Dosya Oluşturma

Kaynak dosya kod.c: insanın okuduğu C kodu.

Önişlemci (gcc -E): #include ile başlık dosyalarını ekler, makroları genişletir, #ifdef ile koşullu derlemeyi çözer → kod.i.

Derleyici (gcc -S): C kodunu hedef işlemcinin assembly diline çevirir, eniyileme yapar → kod.s.

Assembler (gcc -c): assembly'yi makine koduna çevirir → nesne dosyası kod.o. Dış işlevlerin (printf) adresleri henüz belli değildir.

Bağlayıcı (gcc kod.o diger.o -o prog): nesne dosyalarını ve kütüphaneleri birleştirir, adresleri çözer → yürütülebilir dosya (Linux: ELF, Windows: PE/.exe).

./prog: kabuk fork + exec yapar; çekirdeğin yükleyicisi ELF'i belleğe eşler, dinamik bağlayıcı libc.so'yu bağlar ve program bir süreç olarak çalışır.

Temel Kavramlar

Metrik Birimler

Üs	Ad	Sembol	Üs	Ad	Sembol
10⁻³	mili	m	10³	kilo	k
10⁻⁶	mikro	µ	10⁶	mega	M
10⁻⁹	nano	n	10⁹	giga	G
10⁻¹²	piko	p	10¹²	tera	T
10⁻¹⁵	femto	f	10¹⁵	peta	P
10⁻¹⁸	atto	a	10¹⁸	eksa	E

İkili (IEC)	Değer
1 KiB (kibibayt)	2¹⁰ = 1024 B
1 MiB	2²⁰ B
1 GiB	2³⁰ B
1 TiB	2⁴⁰ B

Bellek genelde ikili (16 GiB RAM), disk ve ağ ondalık ölçülür: 1 TB = 10¹² B ≈ 0,91 TiB; 1 Gb/s = 10⁹ bit/s. Bayt B, bit b.

Özet

Kontrol Soruları

Kullanıcı programı ayrıcalıklı bir komut çalıştırırsa ne olur?
Çoklu programlama CPU kullanımını neden artırır? Gerçek paralellikten farkı nedir?
4 KB'lık bir disk bloğunu belleğe almak için sorgulama, kesme ve DMA'dan hangisi uygundur? Neden?
7200 dev/dk dönen bir diskte ortalama dönme gecikmesi kaç ms'dir?
4 kümeli, 64 B satırlı doğrudan eşlemeli boş önbellekte 0, 128, 256, 0 adreslerine erişiliyor. Kaç isabet olur?
fork() kaç kez döner, çocukta ne döndürür? Politika ile mekanizmayı bir örnekle ayırın.

Cevapları göster

İşlemci istisna (trap) üretir; çekirdek genelde süreci sonlandırır.
G/Ç beklenirken CPU başka işi çalıştırır; tek CPU'da işler iç içe ilerler, aynı anda değil.
DMA: tüm blok CPU'yu meşgul etmeden taşınır, sonunda tek kesme gelir.
60 000 / 7200 = 8,33 ms tur; ortalama yarım tur ≈ 4,17 ms.
Bloklar 0, 2, 4, 0 → kümeler 0, 2, 0, 0. 256 bloğu 0'ı kovar → 0 isabet, 4 ıska.
Bir kez çağrılır, iki kez döner; çocukta 0. Zamanlayıcı kesmesi mekanizma, zaman dilimi uzunluğu politikadır.

Özet

Kaynaklar

A. Silberschatz, P. B. Galvin, G. Gagne, Operating System Concepts, 10. baskı, Wiley, 2018.
A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı, Pearson, 2014; 5. baskı, 2023.
R. H. Arpaci-Dusseau, A. C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces (OSTEP), sürüm 1.10, pages.cs.wisc.edu/~remzi/OSTEP.
Linux kılavuz sayfaları: syscall(2), fork(2), execve(2), proc(5); UEFI Forum, UEFI Specification.
Bu sunum, Sercan KÜLCÜ'nün Tanenbaum Modern Operating Systems 3. baskıdan faydalanarak hazırladığı ders notlarının güncellenmiş sürümüdür.

Son

Bölüm 1: Giriş

Sonraki bölüm: İşletim Sistemi Yapıları

Bölüm 1: Giriş

Öğrenme Çıktıları

İşletim Sistemi Nedir?

Bilgisayar Sisteminin Bileşenleri

Kabuk ve GKA

Kabuk mu, GKA mı?

Kabuk

GKA

Aygıt Yöneticisi

İşletim Sisteminin Konumu

Çekirdek Modu ve Kullanıcı Modu

Mod Geçişi Adım Adım: read() Sistem Çağrısı

Fiziksel Aygıtlar, Mikro Mimari, Makine Dili

Genişletilmiş Makine Olarak İS

Soyutlamalar ve Roller

Bir write() Çağrısının Yolculuğu

Kaynak Yöneticisi Olarak İS

Birçok Program Aynı Anda Yazdırmak İsterse

Kaynak Kullanımını Ölçmek

Adalet ve Verimlilik

İşletim Sistemlerinin Tarihi

1. ve 2. Nesil

Erken Bir Toplu İş Sistemi

IBM 1401, 7094 ve System/360

Tipik Bir FMS İşi

3. Nesil: Tümleşik Devreler ve Çoklu Programlama

Çoklu Programlama: CPU Neden Boş Kalmaz?

4. Nesil: Kişisel Bilgisayarlar

5. Nesil: Mobil ve Günümüz

Mobil cihazlar (1990–)

Kişisel Bilgisayarın Bileşenleri

Von Neumann Mimarisi

İşlemci ve Yazmaçlar

Getir–Çöz–Yürüt Döngüsü

Boru Hattı ve Süperskalar

Boru Hattı Adım Adım

Çok Çekirdekli Yongalar

Bellek Hiyerarşisi

Bir Okuma Hiyerarşide Nasıl İlerler?

Önbellek Satırları

Kod İzleme: Doğrudan Eşlemeli Önbellek

Önbellek Tasarım Soruları

Ana Bellek Türleri

Disk (HDD) Yapısı

Diskten Bir Sektör Okumak

HDD, SSD ve Sanal Bellek

G/Ç Aygıtları: Denetleyici ve Sürücü

Üç G/Ç Yöntemi

Kod İzleme: Programlı G/Ç (Sorgulama)

G/Ç Aygıtları: Kesme

Kesme Türleri

G/Ç Aygıtları: DMA

Veri Yolları

x86 Sistem Yapısı

Bilgisayarın Ayağa Kalkması (UEFI)

Eski BIOS ve UEFI

Eski (legacy) BIOS akışı

İşletim Sistemi Çeşitleri (1)

İşletim Sistemi Çeşitleri (2)

Gerçek Zamanlı İşletim Sistemleri

İşletim Sistemi Hizmetleri

Politika ve Mekanizma

MS-DOS ve FreeBSD

Kod İzleme: Kabuk Gibi fork + exec + wait

Standart C Kütüphanesi

Yürütülebilir Dosya Oluşturma

Metrik Birimler

Kontrol Soruları

Kaynaklar

Son

Mod Geçişi Adım Adım: `read()` Sistem Çağrısı

Bir `write()` Çağrısının Yolculuğu

Kod İzleme: Kabuk Gibi `fork` + `exec` + `wait`