---
title: 'Girdi/Çıktı Modelleri'
source: 'https://academia.sh/tr/kurslar/isletim-sistemi-kavramlari/girdi-cikti-modelleri'
course: 'İşletim Sistemi Kavramları'
language: tr
updated: '2026-08-17T18:08:20+00:00'
license: 'CC BY-SA 4.0'
---

# Girdi/Çıktı Modelleri

Engelleyen, engellemeyen ve eşzamansız girdi/çıktının aynı iş yükünde sayılması: yoklamalı model işlemci kullanımını 1,0000 yapıyor ve süreyi hiç değiştirmiyor, eşzamansız model süreyi 248'den 38'e indiriyor.

Önceki ders bir bloğu okumayı bir adım saydı ve o adımın ne kadar sürdüğünü sormadı. Ortak
tanımda bir girdi/çıktı işlemi **30 zaman birimi** sürer; bir hesap adımı ise 1 zaman
birimidir. Aradaki otuz kat, bir sürecin zamanının nerede geçtiğini belirleyen tek sayıdır.

Bu ders, o otuz katın karşısında işlemcinin ne yaptığına dair üç ayrı kararı aynı iş yükünde
sayar. Kararlar şunlardır: bekle, sor, ya da başka iş yap. Sonuç, kursun en aykırı ölçümünü
üretir — üç modelden biri işlemciyi tamamen doldurur ve işini bir zaman birimi bile erken
bitirmez.

## Üç Model

**Engelleyen (blocking)** çağrıda süreç isteği verir ve tamamlanana kadar hazır kuyruğundan
çıkar; işlemci bu süre boyunca başka bir sürece verilebilir, ama isteği veren süreç hiçbir şey
yapmaz. **Yoklamalı (polling)** kurulumda süreç engellenmez, tamamlandı mı diye sormaya devam
eder; bu bir **meşgul beklemedir** ve işlemciyi elinde tutar. **Eşzamansız (asynchronous)**
kurulumda süreç isteği verir, hemen döner, başka iş yapar ve tamamlanma bir bildirimle
ulaşır. Bildirimin donanım tarafındaki karşılığı bir kesmedir; kesmenin kendisi
Bilgisayarlar Nasıl Çalışır kursunun Kesmeler dersinde tanımlandı ve burada yalnız
tamamlanma bildirimi olarak kullanılıyor.

- **BD27** — Bir girdi/çıktı işleminin gecikmesi 30 zaman birimi, istek başına işlemcide
  yapılan iş 1 zaman birimidir. Sekiz istek ölçülür.
- **BD28** — Eşzamansız modelde sekiz istek aynı anda uçuşta olabilir ve gecikmeleri tümüyle
  örtüşür; disk sekiz isteği paralel karşılar.
- **BD29** — İşlemci kullanımı, işlemcinin dolu geçirdiği adımın toplam süreye oranıdır. Meşgul
  bekleme dolu sayılır — işlemci gerçekten bir komut yürütüyordur.
- **BD30** — Bu ders tek makinedir. Hiçbir ağ bedeli, uzak çağrı ya da veri taşıma maliyeti
  yoktur.

```python
"""M01/K05 ortak tanim (kesit): girdi/cikti modelleri."""
BEKLEME_SURESI = 30       # bir girdi/cikti isleminin gecikmesi , zaman birimi


def gc_modeli(istek, yordam="engelleyen", gecikme=BEKLEME_SURESI, is_basina=1):
    """istek: kac girdi/cikti islemi. Doner: sure , mesgul adim , islemci kullanimi."""
    if yordam == "engelleyen":
        sure = istek * (gecikme + is_basina)
        mesgul = istek * is_basina
    elif yordam == "yoklamali":
        sure = istek * (gecikme + is_basina)
        mesgul = sure                      # mesgul bekleme: islemci hep dolu
    else:
        sure = gecikme + istek * is_basina
        mesgul = istek * is_basina
    return {"sure": sure, "mesgul": mesgul, "kullanim": round(mesgul / sure, 4)}


print("sekiz istek , ortak tanimin olcumu")
for y in ("engelleyen", "yoklamali", "eszamansiz"):
    print(f"  {y:12s}", gc_modeli(8, y))
print()
print("istek   engelleyen        yoklamali        eszamansiz")
print("        sure  kullanim    sure  kullanim    sure  kullanim")
for istek in (1, 2, 4, 8, 16, 32):
    e = gc_modeli(istek, "engelleyen")
    y = gc_modeli(istek, "yoklamali")
    a = gc_modeli(istek, "eszamansiz")
    print(f"{istek:5d}  {e['sure']:4d}  {e['kullanim']:8.4f}  {y['sure']:6d}"
          f"  {y['kullanim']:8.4f}  {a['sure']:6d}  {a['kullanim']:8.4f}")
```

```
sekiz istek , ortak tanimin olcumu
  engelleyen   {'sure': 248, 'mesgul': 8, 'kullanim': 0.0323}
  yoklamali    {'sure': 248, 'mesgul': 248, 'kullanim': 1.0}
  eszamansiz   {'sure': 38, 'mesgul': 8, 'kullanim': 0.2105}

istek   engelleyen        yoklamali        eszamansiz
        sure  kullanim    sure  kullanim    sure  kullanim
    1    31    0.0323      31    1.0000      31    0.0323
    2    62    0.0323      62    1.0000      32    0.0625
    4   124    0.0323     124    1.0000      34    0.1176
    8   248    0.0323     248    1.0000      38    0.2105
   16   496    0.0323     496    1.0000      46    0.3478
   32   992    0.0323     992    1.0000      62    0.5161
```

Üç sayı yan yana. **Taban:** engelleyen çağrı, sekiz istek, **248 zaman birimi**, işlemci
kullanımı 0,0323. **Kurulum:** eşzamansız model, **38 zaman birimi**, kullanım 0,2105.
**Bedel:** sekiz tamamlanma bildirimini işlemek ve aynı anda uçuşta olan sekiz isteğin
defterini tutmak — birazdan ikisi de sayılacak.

## Yüksek Kullanım Bir Başarı Ölçüsü Değildir

Tablonun ortasındaki sütun kursun en aykırı sonucudur. Yoklamalı model işlemci kullanımını
**1,0000** yapıyor: işlemci hiç boş kalmıyor, her zaman biriminde bir komut yürütülüyor. Aynı
satırdaki süre ise **248** — engelleyen modelle **birebir aynı**. İşlemciyi tamamen doldurmak
işi bir zaman birimi bile erkene almadı.

Sebebi tanımdan okunur. Yoklamalı modelde işlemcinin yürüttüğü komutlar "tamamlandı mı" diye
soran komutlardır; iş üretmezler. Dolu geçen 248 adımın yalnız 8'i gerçek iştir, kalan 240'ı
bekleme adımının farklı bir biçimde harcanmasıdır. Engelleyen model aynı 240 adımı boş
bırakır; yoklamalı model onları doldurur ve **hiçbir şeyi hızlandırmaz.**

Buradan çıkan kural ölçüt seçimine dairdir. İşlemci kullanımı bir **vekil ölçüttür**: gerçekten
sorulan soru "iş ne zaman bitiyor" olduğu halde, ölçülmesi kolay olduğu için onun yerine
kullanılır. Bu iş yükünde vekil ölçüt tersine dönüyor — en yüksek kullanıma sahip model en iyi
süreyi vermiyor, en iyi süreyi veren eşzamansız modelin kullanımı ise yalnız 0,2105. Bir
kurulumun kullanımı yüksekse **neyle dolu olduğu** sorulmadan hiçbir şey söylenemez.

Eşzamansız modelin nasıl kazandığı da aynı tablodadır. Süresi istek sayısıyla neredeyse
değişmiyor: bir istekte 31, otuz iki istekte 62. Engelleyen model 31'den 992'ye çıkarken
eşzamansız model iki katına bile ulaşmıyor, çünkü otuz birim gecikme bir kez ödeniyor ve
bütün istekler onun içinde örtüşüyor. Kazanç istek sayısıyla büyüyor: sekiz istekte 6,5 kat,
otuz iki istekte 16 kat.

## Engellemeyen Çağrı ve Yoklama Aralığı

Yoklamalı kurulumun altındaki mekanizma ayrı bir kavramdır ve ayrı adlandırılır.
**Engellemeyen (non-blocking)** çağrı, sonuç hazır değilse süreci uyutmaz; "henüz hazır değil"
diyerek hemen döner. Yoklama, bu çağrının bir döngü içinde tekrarlanmasıdır. İkisi aynı şey
değildir: engellemeyen çağrı bir arayüz özelliğidir, yoklama onu kullanma biçimlerinden
yalnız biridir — ve en pahalısıdır.

Yukarıdaki ölçümde yoklama her zaman biriminde bir yapıldı. Aralık büyütülebilir; o zaman
işlemci daha az sorar, ama tamamlanmayı daha geç fark eder.

- **BD31** — Yoklama sabit aralıklarla yapılır ve her soru bir zaman birimi tutar. Tamamlanma,
  gecikmeden sonraki ilk soruda fark edilir.

```python
"""Engellemeyen cagri: yoklama araligi hangi iki maliyeti karsi karsiya getiriyor."""
GECIKME = 30
ISTEK = 8

print("aralik  yoklama  fark edilme  fazladan gecikme  toplam sure  islemci adimi")
for aralik in (1, 2, 4, 7, 10, 30, 45):
    sorma = -(-GECIKME // aralik)          # tamamlanma fark edilene kadar kac soru
    fark = sorma * aralik                  # fark edilme ani
    print(f"{aralik:6d}  {sorma:7d}  {fark:11d}  {fark - GECIKME:16d}"
          f"  {ISTEK * (fark + 1):11d}  {ISTEK * (sorma + 1):13d}")
```

```
aralik  yoklama  fark edilme  fazladan gecikme  toplam sure  islemci adimi
     1       30           30                 0          248            248
     2       15           30                 0          248            128
     4        8           32                 2          264             72
     7        5           35                 5          288             48
    10        3           30                 0          248             32
    30        1           30                 0          248             16
    45        1           45                15          368             16
```

Aralık 1'den 30'a çıkarıldığında işlemci adımı **248'den 16'ya** iniyor ve süre 248'de
kalıyor: bu iş yükünde yoklamanın 240 adımı tümüyle boşa harcanmış işti. Ama tablo düz
gitmiyor. Aralık 4 ve 7'de fark edilme gecikmesi 2 ve 5 birim uzuyor, süre 264 ile 288'e
çıkıyor; aralık 45'te tamamlanma 15 birim geç fark ediliyor ve süre 368'e fırlıyor. Aralığın
gecikmeyi tam bölmediği her yerde bir artık ödeniyor ve o artığın büyüklüğü, tam olarak ne
zaman tamamlanacağını bilmeyen bir sürecin ödediği bedeldir.

İki uç arasındaki fark şudur: **aralık küçükse işlemci, büyükse yanıt süresi ödüyor.** Ortada
bir en iyi nokta yoktur — 30 birimlik aralık burada iki maliyeti de en aza indiriyor, ama
yalnız gecikmenin tam olarak 30 olduğu bilindiği için. Gecikme değişkense o bilgi yoktur ve
seçim yeniden bir tahmine dönüşür. Tamamlanma bildirimi kullanan eşzamansız model bu tahmini
tümüyle ortadan kaldırır; karşılığında bildirimi işlemek için bir mekanizma ister.

## Eşzamansızlığın İki Sınırı

Yukarıdaki ölçüm iki şeyi ücretsiz saydı: tamamlanma bildirimini işlemeyi ve isteklerin
birbirinden bağımsız olmasını. İkisi de her zaman doğru değildir.

- **BD32** — Bir tamamlanma bildirimini işlemek `bildirim` kadar zaman birimi tutar; bu, kesme
  işleyicisinin çalışması ve isteğin defterden düşülmesidir. Süpürülen değer 0 ile 16
  arasındadır.
- **BD33** — Bağımlı zincirde her istek bir öncekinin sonucunu kullanır; bu yüzden gecikmeler
  örtüşemez.

```python
"""Eszamansiz modelin iki siniri: tamamlanma bildiriminin bedeli ve bagimlilik."""
GECIKME = 30
ISTEK = 8


def eszamansiz(istek, bildirim=0, bagimli=False):
    """bildirim: her tamamlanma bildirimini islemek kac zaman birimi.
    bagimli: her istek bir oncekinin sonucunu bekliyorsa ortusme olmaz."""
    is_basina = 1 + bildirim
    sure = istek * (GECIKME + is_basina) if bagimli else GECIKME + istek * is_basina
    mesgul = istek * is_basina
    return {"sure": sure, "mesgul": mesgul, "kullanim": round(mesgul / sure, 4)}


print("bagimsiz istek , bildirim bedeli supuruluyor")
print("bildirim  sure  mesgul  kullanim  engelleyene gore kazanc")
for b in (0, 1, 2, 4, 8, 16):
    a = eszamansiz(ISTEK, b)
    print(f"{b:8d}  {a['sure']:4d}  {a['mesgul']:6d}  {a['kullanim']:8.4f}"
          f"  {ISTEK * (GECIKME + 1) / a['sure']:22.2f}")
print()
print("bagimli zincir (her istek bir oncekini bekliyor)")
for b in (0, 1):
    a = eszamansiz(ISTEK, b, bagimli=True)
    print(f"  bildirim {b}: sure {a['sure']} kullanim {a['kullanim']}")
print("  engelleyen modelin suresi:", ISTEK * (GECIKME + 1))
```

```
bagimsiz istek , bildirim bedeli supuruluyor
bildirim  sure  mesgul  kullanim  engelleyene gore kazanc
       0    38       8    0.2105                    6.53
       1    46      16    0.3478                    5.39
       2    54      24    0.4444                    4.59
       4    70      40    0.5714                    3.54
       8   102      72    0.7059                    2.43
      16   166     136    0.8193                    1.49

bagimli zincir (her istek bir oncekini bekliyor)
  bildirim 0: sure 248 kullanim 0.0323
  bildirim 1: sure 256 kullanim 0.0625
  engelleyen modelin suresi: 248
```

Birinci sınır bildirimin bedelidir. Her tamamlanmaya 16 zaman birimlik bir işleme eklendiğinde
süre 38'den **166'ya** çıkıyor ve engelleyen modele göre kazanç 6,53 kattan **1,49 kata**
düşüyor. Dikkat çekici olan, kullanımın bu süpürme boyunca **0,2105'ten 0,8193'e yükselmesi**:
model her adımda yavaşlarken ölçütü sürekli iyileşiyor. Kullanımın neden bir başarı ölçüsü
olmadığının ikinci kanıtı budur.

İkinci sınır bağımlılıktır. İstekler birbirinin sonucunu bekliyorsa örtüşecek bir şey yoktur;
eşzamansız model **248 zaman biriminde** bitiyor, yani engelleyen modelle tam olarak aynı.
Bildirim işlemenin bedeli eklendiğinde ise **256**'ya çıkıyor ve eşzamansız kurulum engelleyen
kurulumdan **daha kötü** hâle geliyor. Eşzamansızlığın sattığı şey hız değildir, **örtüşmedir**;
örtüşecek iş yoksa geriye yalnız defter tutma maliyeti kalır.

## Özet

- Sekiz girdi/çıktı isteğinde engelleyen model 248 zaman biriminde bitiyor ve işlemci
  kullanımı 0,0323; yoklamalı model aynı 248'de bitiyor ve kullanımı 1,0000; eşzamansız model
  38'de bitiyor ve kullanımı 0,2105.
- Meşgul bekleme işlemciyi doldurur ve hiçbir şeyi hızlandırmaz: dolu geçen 248 adımın yalnız
  8'i iş üretir, 240'ı "tamamlandı mı" sorusudur.
- İşlemci kullanımı bir vekil ölçüttür ve bu iş yükünde ters yönde hareket eder; bir kurulumun
  kullanımı yüksekse neyle dolu olduğu sorulmadan hiçbir sonuç çıkarılamaz.
- Engellemeyen çağrı bir arayüz özelliğidir, yoklama onu kullanma biçimidir; yoklama aralığı
  1'den 30'a çıkarıldığında işlemci adımı 248'den 16'ya iniyor, ama aralık gecikmeyi tam
  bölmediğinde süre 288'e ve 368'e kadar uzuyor.
- Eşzamansız modelin kazancı örtüşmeden gelir ve istek sayısıyla büyür: sekiz istekte 6,5 kat,
  otuz iki istekte 16 kat.
- Kazanç iki koşulda erir: tamamlanma bildirimi başına 16 zaman birimi ödendiğinde 1,49 kata
  düşer, istekler birbirine bağımlı olduğunda ise sıfırlanır ve bildirim bedeliyle birlikte
  engelleyen modelin altına iner.

## Kurs Kapanışı

On beş ders tek bir makineyi modelledi ve tek bir soruyu sordu: bir soyutlama kolaylık
sağlarken kaç adım ödetiyor. Her derste üç sayı yan yana durdu — soyutlamasız taban,
soyutlamalı kurulum ve aradaki bedel. Kursun kuralı buydu: **bedeli sayılmayan soyutlama
ölçülmemiş sayılır.**

| Ders | Soyutlamasız taban | Soyutlamalı kurulum | Bedel |
|---|---|---|---|
| Süreç Kavramı | beş süreç peş peşe: **669** zaman birimi | tek çekirdeği paylaşan beş süreç: **194** | **22 bağlam değiştirme = 44 zaman birimi**, gerçek işin (39) üstünde; 111 boş çekirdek adımı |
| Süreç Çatallama | çatallama yok: **0** kopyalanan sayfa | dört çatallama, hevesli kopyalama: **64 sanal sayfa** | yazarken kopyalama **15 sayfaya** indiriyor, 49'u boşaydı; sayfa hatası bedeli **4**'te üstünlük kayboluyor |
| İş Parçacıkları | beş ayrı süreç: **194** zaman birimi, **15** ek sanal sayfa | tek süreçte beş iş parçacığı: **186**, **4** yığıt sayfası | bellekte yüzde **73,33** kazanç, sürede yalnız **8** birim; bedeli **yalıtımın tümüyle kalkması** |
| Süreç ve İş Parçacığı Seçimi | tek adres uzayı: **0** kopyalanan sayfa, yayılma oranı **5,0** | beş ayrı adres uzayı: etkilenen birim **1** | **15** kopyalanan sayfa (hevesliyle 64); kısmi yalıtım doğrusal değil — 6 sayfa 5'i 3'e indiriyor, son 5 sayfa yalnız 1 kazandırıyor |
| Çizelgeleme Algoritmaları | önalımsız sıra: **194** (ikinci iş yükünde 189) | dilimli çizelgeleme: **197** (ikinci iş yükünde 202) | dilim 1'de **206**, **36** bağlam değiştirme, bekleme **33,00**; iki iş yükünde de en iyi yordam **yok** |
| Yarış Koşulları | tek yürütme sırası: **1** sonuç | iki iş parçacığı, bölünebilir üç adım: **20** serpiştirme | **18'i yanlış** (0,9000); dilim 3'te erişilebilen **2** serpiştirmenin **hiçbiri** yanlış değil — hata yok olmuyor, görünmez oluyor |
| Kilitler, Dışlama Kilitleri ve Sayan Semaforlar | tek iş parçacığı: **20** zaman birimi, **0** bekleme adımı | sekiz iş parçacığı, dışlama kilidi: **83** | **252** bekleme adımı, kullanım **1,0000'den 0,2410'a**; bekleme $n(n-1)$'in **4,5** katı |
| Kilitlenme ve Açlık | serbest edinim: 648 durumun **264'ü kilitli** (0,4074) | sıralı edinim: durum uzayı **36**, kilitlenen **0** | sekiz iş parçacığında **+144** bekleme adımı; açlıkta verim düşmüyor, arıza yalnız **dağılımda** görünüyor |
| Çok Çekirdekte Eşzamanlılık | tek çekirdek: **197**, 108 boş çekirdek adımı | dört çekirdek: **179** (alt sınır 173) | **639** boş çekirdek adımı, toplam iş **39'da sabit**; dilim koruması kalkıyor, erişilebilen serpiştirme 2'den **20'ye** |
| Eşzamanlılık Modelleri | iş parçacığı modeli: **197** (ikinci iş yükünde 202) | olay döngüsü **178**, ileti geçişi **179** | aradaki 1 zaman birimi **ölçüm bandının altında**; fark boş çekirdek adımında: **139'a karşı 639** |
| Sanal Bellek | 15 fiziksel sayfa, 15 zorunlu hata, 489 zaman birimi | 2 fiziksel sayfa, sayfalı bellek, ilk giren ilk çıkar | 15 fazladan sayfa hatası, 450 zaman birimi |
| Bellek Ayırma | uç uca ayırma, 6 istek yerleşiyor | bölüm listeli ayırıcı, en iyi uyan, 8 istek yerleşiyor | 10'ar baytlık iki kırıntı, dış parçalanma oranı 0,5000 |
| Çöp Toplama | elle bırakma, 0 tarama adımı | izlemeli toplayıcı, 40 nesnenin 17'si erişilebilir | 17 adım duraklatma, 40 adım süpürme, toplam 57 adım |
| Dosya Sistemi Soyutlaması | bitişik yerleşim, 4741 bayt | 512 baytlık 12 blok, diskte 6144 bayt | 1403 bayt iç parçalanma, 12 blok numarası |
| Girdi/Çıktı Modelleri | engelleyen çağrı, 248 zaman birimi | eşzamansız model, 38 zaman birimi | 8 tamamlanma bildirimi ve uçuştaki 8 isteğin defteri |

Tablonun ikinci okuması birincisinden değerlidir: **soyutlama bazen kötüleştirir.** Daha akıllı
sayfa değiştirme daha çok hata verebilir, en iyi uyan daha kullanılamaz bir kalıntı bırakır,
duraklatmayı bölmek toplam işi büyütür, günlüklü düzen her baytı iki kez yazar, meşgul bekleme
işlemciyi doldurur ve hiçbir şeyi hızlandırmaz. Bu sonuçların hiçbiri saklanmadı, çünkü bir
soyutlamanın ne zaman kötüleştirdiğini bilmeyen biri onu ne zaman seçeceğini de bilemez.

Üçüncü ve en pahalı sonuç eşzamanlılık konusundan geldi: **doğru çıktı doğru program demek
değildir.** Aynı hata, çizelgeleyicinin dilimi yeterince büyük olduğunda hiç görünmez. Hata
yok olmaz, yalnız görünmez olur — ve görünmeyen bir hatayı gösteren tek şey, mekanizmayı
modelleyip bütün durumları saymaktır.

Kurs boyunca ölçülen her şey **tek bir makinede** ölçüldü. Ağ bedeli, uzak çağrı gecikmesi ve
makineler arası veri taşıma bu ölçümlerin hiçbirinde yoktur; buradaki sayılar dağıtık bir
kuruluma taşındığında geçerliliğini yitirir.

Bir sonraki kurs, **Modelleme ve Gösterim**, modelin kendisini konu edinir. Bu kursta model
çalıştırılabilir bir metindi ve çıktısı sayıydı; orada model bir diyagram olacak ve çıktısı
bir yanıt. Ortak olan disiplin değişmiyor: bir diyagram hangi soruyu yanıtladığı belliyse
işe yarar, tıpkı bir soyutlamanın ancak bedeli sayıldığında ölçülmüş sayılması gibi. Bir
sistemi sınıf, bileşen, sıra ve durum diyagramlarıyla göstermek, bu kursta sayılarla yapılan
şeyin başka bir gösterimle yapılmasıdır — ve orada da gereksiz gösterimden kaçınmanın ölçütü
aynı sorudur: bu neyi ölçüyor.
