İşlemcinin Çalışma Mantığı ve Programlamanın İşleyişi Nasıl Anlatılır?

, , , ,
1

Bana bir islemcinin (cpu) calisma mantigini oyle bir anlatki 5 yasindaki bir cocuk bile anlayabilsin. programlamanin ve bunun islemci tarafindan nasil islendigini, sonuclari nasil ele aldigini ve nasil bittigini detayli ve cok basit orneklerle anlat lutfen.

2

Bir bilgisayarı, içinde milyonlarca çok hızlı çalışan minik işçi olan bir fabrika gibi düşünelim.
İşçilerin adı: işlemci (CPU). Şimdi bunu 5 yaşındaki bir çocuğa anlatır gibi gidelim.

1. İşlemci nedir? (Süper Hızlı Düşünen Beyin)

Bilgisayarın içinde:

  • Ekran: Sana resmi, yazıyı gösteren pencere
  • Klavye / fare: Senin bilgisayara konuşma şeklin
  • Hafıza (RAM, disk): Defter ve dolap
  • İşlemci (CPU): Bütün işi yöneten beyin

Yani CPU şunu yapar:
“Bana ne emir verdiniz, onu çok hızlı bir şekilde yapayım.”

2. Program nedir? (Talimat Kağıdı)

Program, işlemci için yazılmış bir talimat listesidir.

Mesela annen sana şöyle der:

  1. Odana git
  2. Oyuncaklarını topla
  3. Işığı kapat
  4. Geri gel

Bu bir program gibi.
Bilgisayardaki program da CPU’ya şöyle der:

  1. Şu sayıyı oku
  2. Buna 5 ekle
  3. Sonucu ekrana yaz
  4. Bitir

CPU, bu talimatları teker teker, sırayla yapar.

3. İşlemcinin içi: Çok hızlı ama çok basit işçi

CPU, aslında çok basit işler yapabilir ama milyarlarca kez çok hızlı yapar.

Temel bildiği şeyler:

  • Topla: 2 + 3 = 5
  • Çıkar: 7 - 2 = 5
  • Karşılaştır: “Bu ondan büyük mü, küçük mü, eşit mi?”
  • Kopyala: “Şu bilgiyi şuradan al, şuraya koy.”
  • Zıpla: “Eğer şu doğruysa, şuradan devam et.”

Hepsi bu.
Ama bu basit hareketleri çok çok hızlı yaptığı için:

  • Oyun çalışıyor
  • Video oynuyor
  • İnternet açılıyor
  • Yazılar yazılıyor

4. Bilgi nasıl duruyor? (Kutucuklar: 0 ve 1)

İşlemci ve hafıza içindeki her şey aslında küçük ışıklar gibi düşünülebilir:

  • Işık kapalı: 0
  • Işık açık: 1

Bilgisayar sadece 0 ve 1 anlar.
Buna bit denir. Birkaç bit birleşince sayı, harf, renk, her şey ortaya çıkar.

Örnek:

  • 00000001 → 1
  • 00000010 → 2
  • 00000011 → 3
  • 01000001 → ‘A’ harfi gibi…

Yani CPU şunu yapar:
“Önümde bir sürü 0 ve 1 var, bana diyorlar ki, bunları topla, karşılaştır, kopyala…”

5. Program işlemcide nasıl çalışır? (Adım adım)

Bir programın içerideki yolculuğu:

  1. Diskte durur

    • Program önce bilgisayarın diskinde (hard disk / SSD) dosya halinde durur.
    • Yani henüz sadece raftaki kitap gibi, okunmamış.

  2. RAM’e (hafızaya) yüklenir

    • Program çalıştırılınca, içindeki talimatlar RAM’e kopyalanır.
    • RAM, işlemcinin hemen yanındaki hızlı defter gibi.

  3. İşlemci talimatı alır (Fetch)

    • CPU, RAM’den bir talimat alır:
      “Şu sayıyı oku”, “topla”, “ekrana yaz” gibi.

  4. Talimatı çözer (Decode)

    • CPU “Bu talimat ne istiyor?” diye bakar.
    • “Toplama mı? Karşılaştırma mı? Ekrana bir şey mi yazacağım?”

  5. İcrâ eder (Execute)

    • CPU gerekli işlemi yapar:
      • Toplarsa: 2 + 3 hesaplar
      • Karşılaştırırsa: “5, 3’ten büyük mü?” diye bakar
      • Ekrana yazacaksa: Sonucu ekrana göndermek için ekrana emir yollar.

Bu 3 adım (Fetch–Decode–Execute) sürekli tekrar eder:

Talimat al → Çöz → Uygula → Sonrakine geç → Yine → Yine → Yine…

6. Çok basit bir örnek: 2 + 3 işlemi

Diyelim ki programda şöyle bir şey yazdın (yüksek seviyede):

a = 2
b = 3
c = a + b
ekrana c yaz

CPU bunu direkt anlamaz. Derleyici/yorumlayıcı bunu makine diline çevirir.
Ama mantık şöyle işler:

  1. Hafızaya 2 yaz (bir kutucuğa)
  2. Hafızaya 3 yaz (başka bir kutucuğa)
  3. İşlemci bu iki kutudaki değeri okur (2 ve 3)
  4. Toplama ünitesine gönderir → sonuç: 5
  5. Sonucu başka bir kutuya koyar
  6. “Bu kutudaki 5’i ekrana göster” der

CPU bunu inanılmaz hızlı yapar, sen sadece ekranda 5 görürsün.

7. Karar verme: Eğer… ise… (if)

Programlamada sık sık şöyle şeyler var:

  • “Eğer şifre doğruysa içeri al, yanlışsa ‘hata’ yaz.”

CPU bunu şöyle yapar:

  1. Girilen şifreyle doğru şifreyi karşılaştır
  2. Eğer aynıysa, programın şu kısmına zıpla
  3. Değilse, başka bir kısma zıpla

Yani CPU aslında sadece:

  • Karşılaştır
  • Doğruysa buraya atla, yanlışsa şuraya atla

gibi çok basit hamleler yapar. Ama bunları birleştirince karar veren bir sistem oluşur.

8. Program ne zaman “biter”?

Programda genelde en sonda şöyle bir talimat olur:

  • “Artık işim bitti, kendimi kapat.”

Bu CPU için şu demek:

  • Yeni talimat yok
  • İşlemci, bu program için artık çalışmayı bırakabilir

Ama fiziksel olarak CPU hâlâ orada, sadece o program için iş almıyor. Başka programların işini yapabilir.

9. Çok basit günlük hayattan analoji

Bir çocukla anlatırken böyle diyebilirsin:

  • Bilgisayar bir okul
  • İşlemci (CPU) öğretmen
  • Program öğretmenin elindeki ödev listesi
  • Hafıza (RAM) sıranın üstündeki defter
  • Disk dolaptaki kitaplık

Süreç:

  1. Öğretmen (CPU), dolaptan (disk) kitabı alıp sıraya (RAM) koyuyor.
  2. Deftere (RAM) soru yazıyor.
  3. Öğretmen her soruyu tek tek okuyor (Fetch).
  4. Ne istendiğini anlıyor (Decode).
  5. Cevabı yazıyor (Execute).
  6. Bittiğinde: “Ödev bitti, artık başka işe geçebilirim.” diyor.

10. Özet cümle (5 yaş seviyesinde)

  • Bilgisayarın içinde çok hızlı düşünen küçük bir beyin var, buna işlemci denir.
  • Bu beyin, önüne gelen komutları sırayla okur.
  • Her komut ona “şunu topla, şunu karşılaştır, bunu ekrana yaz” gibi şeyler söyler.
  • İşlemci bunları çok hızlı yapar; biz de oyunu, videoyu, yazıları, her şeyi sanki sihirliymiş gibi görürüz.
  • Aslında yaptığı iş: “0 ve 1’lerle yazılmış talimatları, sırayla, çok hızlı uygulamak.”

İstersen bir sonraki adımda, çok basit bir pseudo-code ve yanında “CPU şu anda ne yapıyor?” diye adım adım giden bir tablo da hazırlayabilirim; hatta bunu bir oyun gibi kurgulayabiliriz: “Sen CPU’sun, sana komut veriyorum, ne yaparsın?” diye.

TERİMLER:

Bit: Bilgisayarda bilgi tutmak için kullanılan en küçük birim; değeri 0 veya 1 olabilir.
CPU (İşlemci): Bilgisayarın beyni; programdaki komutları sırayla okuyup uygulayan donanım parçası.
Disk (Hard disk / SSD): Programların ve dosyaların kalıcı olarak saklandığı depolama alanı.
Fetch–Decode–Execute: İşlemcinin çalışma döngüsü; komutu alma, komutu çözme ve komutu uygulama adımları.
Hafıza (RAM): Program çalışırken verilerin ve talimatların geçici olarak tutulduğu hızlı bellek alanı.
Makine dili: Sadece 0 ve 1’lerden oluşan, işlemcinin doğrudan anlayabildiği en temel komut dili.
Program: İşlemcinin adım adım uygulaması için yazılmış talimatlar listesi.

3

Sen cpu’sun sana komut veriyorum…

elimde 500 sayisi var, bunu 250’'ye bolup cikan sonuc 5 den yukardaysa 6 ekleyip 1 cikarmalisin. 5 den asagidaysa 1 cikartip 5 eklemelisin. butun etaplari islemci mantigiyla sirayla yap. Makine kodunuda ekleyebilirsin ve ram, disk sirasinida goster, yapilan isleri, sonuclari, siradakileri v.s

4

Tamam, şu an ben CPU’yum, sen de bana program yazan kişisin.
Verdiğin komutu, gerçekten içeride ne oluyormuş gibi adım adım anlatalım.

Komutun:

Elimde 500 sayısı var, bunu 250’ye bölüp çıkan sonuç 5’ten büyükse 6 ekleyip 1 çıkarmalısın.
5’ten küçükse 1 çıkartıp 5 eklemelisin.

Başlangıç sayımız: 500

1. Disk → RAM → CPU (Programın ve verinin yüklenmesi)

Diskte neler var?

Diskte (SSD/HDD) şu bilgiler dosya halinde duruyor:

  • Program kodu (yüksek seviye, örneğin pseudo-code):
sayi = 500
bolen = 250
sonuc = sayi / bolen

eğer sonuc > 5 ise:
    sonuc = sonuc + 6
    sonuc = sonuc - 1
aksi halde eğer sonuc < 5 ise:
    sonuc = sonuc - 1
    sonuc = sonuc + 5
programı bitir
  • Bu program, derlenmiş / çevrilmiş ve makine kodu olarak da diskte:
(temsilî, anlaşılır pseudo-assembly)
LOAD R1, [sayi]      ; R1 = 500
LOAD R2, [bolen]     ; R2 = 250
DIV  R3, R1, R2      ; R3 = R1 / R2

CMP  R3, #5          ; R3 ile 5'i karşılaştır
JG   ETIKET_BUYUK    ; Eğer R3 > 5 ise ETIKET_BUYUK'a zıpla
JL   ETIKET_KUCUK    ; Eğer R3 < 5 ise ETIKET_KUCUK'a zıpla
JMP  BITIR           ; Ne büyük ne küçükse (yani eşitse) direkt bitir

ETIKET_BUYUK:
ADD  R3, R3, #6      ; R3 = R3 + 6
SUB  R3, R3, #1      ; R3 = R3 - 1
JMP  BITIR

ETIKET_KUCUK:
SUB  R3, R3, #1      ; R3 = R3 - 1
ADD  R3, R3, #5      ; R3 = R3 + 5
JMP  BITIR

BITIR:
HALT                 ; Programı bitir

Bunlar şimdilik diskte, yani “kitaplıkta duran kitap” gibi.

2. Program çalıştırılıyor: Disk → RAM

Kullanıcı programı tıklayıp çalıştırıyor.

  • İşletim sistemi:
    • Programın makine kodunu diskten okur,
    • Bunları RAM’e kopyalar.
  • Aynı şekilde:
    • sayi = 500
    • bolen = 250
      gibi ilk değerler de RAM’de uygun adreslere yazılır.

Örneğin RAM’de:

  • Adres 1000 → sayi = 500
  • Adres 1004 → bolen = 250
  • Adres 1008 → sonuc (şimdilik boş)
  • Adres 2000 → Makine kodunun başlangıcı (talimatlar buradan başlıyor)

3. CPU devreye giriyor: Fetch – Decode – Execute döngüsü

Artık CPU şöyle çalışıyor:

Adım 1: Talimat al (Fetch)

  • Program sayacı (PC) = 2000 (ilk komut)
  • CPU, RAM’den 2000 numaralı adresteki talimatı okur:
LOAD R1, [sayi]

Adım 2: Talimatı çöz (Decode)

  • Bu komutun anlamı:
    • “RAM’de sayi değişkeninin bulunduğu adresteki değeri al, R1 isimli register’a koy.”

Adım 3: Uygula (Execute)

  • RAM adres 1000’de sayi = 500
  • CPU, 500’ü alır → R1 register’ına yazar.

Durum:

  • R1 = 500
  • R2, R3: henüz tanımsız
  • RAM 1000: 500
  • RAM 1004: 250

PC (Program Counter) artık bir sonraki komutu gösterir: 2004

Adım 4: İkinci komut

Fetch:

  • PC = 2004 → RAM’den oku:
LOAD R2, [bolen]

Decode:

  • “RAM’de bolen değişkenini bul, değerini R2’ye koy.”

Execute:

  • RAM adres 1004’te bolen = 250
  • CPU, 250’yi alır → R2 register’ına yazar.

Durum:

  • R1 = 500
  • R2 = 250
  • R3: hâlâ tanımsız
  • RAM: sayi=500, bolen=250

PC → 2008

Adım 5: Bölme işlemi

Fetch:

  • PC = 2008 → Komut:
DIV R3, R1, R2

Decode:

  • “R1’i R2’ye böl, sonucu R3’e yaz.”

Execute:

  • R1 = 500
  • R2 = 250
  • Hesap: 500 / 250 = 2
  • R3 = 2

Durum:

  • R1 = 500
  • R2 = 250
  • R3 = 2

PC → 2012

Adım 6: Karşılaştırma (5 ile)

Fetch:

  • PC = 2012 → Komut:
CMP R3, #5

Decode:

  • “R3 ile 5’i karşılaştır, sonucu CPU’nun bayraklarına yaz (büyük mü, küçük mü, eşit mi).”

Execute:

  • R3 = 2, sabit = 5
  • 2 < 5 olduğu için CPU şunu işaretler:
    • “Küçük” bayrağı = 1
    • “Büyük” bayrağı = 0
    • “Eşit” bayrağı = 0

PC → 2016

Adım 7: Koşullu zıplama – Büyük mü?

Fetch:

  • PC = 2016 → Komut:
JG ETIKET_BUYUK

(JG = Jump if Greater → “Eğer büyükse zıpla”)

Decode:

  • “Eğer son karşılaştırmada R3 > 5 ise, ETIKET_BUYUK adlı yere atla.”

Execute:

  • Karşılaştırma sonucunda R3 (2) 5’ten büyük değil.
  • Koşul sağlanmadı, zıplama yapılmaz.
  • PC sadece sıradaki komuta geçer: 2020

Durum değişmedi, sadece PC ilerledi.

Adım 8: Koşullu zıplama – Küçük mü?

Fetch:

  • PC = 2020 → Komut:
JL ETIKET_KUCUK

(JL = Jump if Less → “Eğer küçükse zıpla”)

Decode:

  • “Eğer R3, 5’ten küçükse, ETIKET_KUCUK etiketine git.”

Execute:

  • Karşılaştırmadan biliyoruz: 2 < 5 → doğru.
  • O zaman PC, ETIKET_KUCUK etiketi neredeyse oraya ayarlanır.
  • Diyelim ki ETIKET_KUCUK = adres 2032

PC → 2032

4. Artık “küçükse” kısmındayız

Senin kuralına göre:

5’ten aşağıdaysa 1 çıkartıp 5 eklemelisin.

Bizim sonuc = R3 = 2 ve bu 5’ten küçük.
Şimdi o bloğu çalıştırıyoruz.

Adım 9: 1 çıkar

Fetch:

  • PC = 2032 → Komut:
SUB R3, R3, #1

Decode:

  • “R3’ten 1 çıkar, tekrar R3’e yaz.”

Execute:

  • R3 = 2
  • R3 = 2 - 1 = 1

Durum:

  • R3 = 1

PC → 2036

Adım 10: 5 ekle

Fetch:

  • PC = 2036 → Komut:
ADD R3, R3, #5

Decode:

  • “R3’e 5 ekle, sonucu yine R3’e yaz.”

Execute:

  • R3 = 1
  • R3 = 1 + 5 = 6

Durum:

  • R3 = 6

PC → 2040

Adım 11: Bitir’e zıpla

Fetch:

  • PC = 2040 → Komut:
JMP BITIR

Decode:

  • “Şartsız zıplama: Ne olursa olsun BITIR etiketine git.”

Execute:

  • BITIR etiketinin adresi diyelim ki 2050
  • PC → 2050

5. Program sonu

Adım 12: HALT

Fetch:

  • PC = 2050 → Komut:
HALT

Decode:

  • “Programı durdur.”

Execute:

  • CPU, bu program için çalışmayı bırakır.
  • Sonuç olarak R3 = 6 kalır.
  • İstersek program, R3 değerini RAM’de sonuc değişkenine yazar:
STORE R3, [sonuc]   ; RAM 1008'e 6 yaz

Ve işletim sistemi bu değeri alıp ekrana gösterebilir vs.

6. Tüm adımların özeti (CPU bakışıyla)

Başlangıç:

  • RAM:
    • sayi = 500
    • bolen = 250
  • CPU register’ları: boş / anlamsız

Adımlar:

  1. LOAD R1, [sayi] → R1 = 500
  2. LOAD R2, [bolen] → R2 = 250
  3. DIV R3, R1, R2 → R3 = 500 / 250 = 2
  4. CMP R3, #5 → 2, 5’ten küçük → “küçük” bayrağı = 1
  5. JG ... → R3 > 5 değil → zıplama yok
  6. JL ETIKET_KUCUK → R3 < 5 doğru → ETIKET_KUCUK’a zıpla
  7. SUB R3, R3, #1 → R3 = 2 - 1 = 1
  8. ADD R3, R3, #5 → R3 = 1 + 5 = 6
  9. JMP BITIR → programın sonuna git
  10. HALT → program bitti

Nihai sonuç: 6

7. 5 yaşındaki çocuk versiyonu (kısacık)

  • Elimde 500 elma var.
  • Bunları 250’şer 250’şer iki kişiye paylaştırıyorum → Her birine 2 elma yığını düşüyor.
  • Sonuç = 2
  • 2 sayısı, 5’ten küçük olduğu için:
    • Önce 1 eksiltiyorum: 2 → 1
    • Sonra 5 ekliyorum: 1 → 6
  • En son elimdeki sonuç: 6

Ben CPU olarak sadece şunu yaptım:
“Bana verilen sayıları sırayla okudum, böl, karşılaştır, zıpla, ekle, çıkar komutlarını teker teker uyguladım.”

İstersen, aynı mantığı bu sefer sonuc tam 5 çıktığında ne olsun? gibi ek koşullar koyup tekrar oynayabiliriz; veya bu akışı bir tablo halinde “Zaman – Komut – Register değerleri – RAM durumu” diye yazarak daha da sistematik gösterebilirim.

TERİMLER:

CPU (İşlemci): Programdaki komutları sırayla alıp çözerek (decode) uygulayan (execute) bilgisayarın beyni.
Disk: Programın ve verinin kalıcı olarak tutulduğu depolama birimi (HDD/SSD).
Fetch: İşlemcinin RAM’den sıradaki komutu alması adımı.
Halt: Programın çalışmasını sonlandıran komut.
Jump (Zıplama): Program akışını değiştiren, başka bir adrese atlayan komut.
Makine kodu: İşlemcinin doğrudan anlayabildiği, 0 ve 1’lerden oluşan komut dizisi.
RAM: Çalışan programın kod ve verilerinin geçici olarak tutulduğu hızlı bellek.
Register (Yazmaç): İşlemcinin içinde bulunan, çok hızlı küçük veri kutucukları.

5

Islemler sirasindaki bolme yada toplama yada cikarma islemleri nasil calisir? Bunun icin cpu nasil bir yol izler, sirayla ornek bolme islemini cpu kendi icerisinde nasil yapar detaylari sirasiyla anlatirmisin.

6

Buraya kadar hep “CPU 500’ü 250’ye böler, 2 bulur” deyip geçtik.
Şimdi sorunun kalbine girelim: CPU bu bölmeyi kendi içinde nasıl yapıyor?

Aşağıda önce genel fikir, sonra özellikle bölme işlemini, gerçekten içerideki adımlarla anlatacağım.

1. CPU’nun içinde “hesaplayan parça”: ALU

CPU’nun içinde, hesap yapan özel bir bölüm var:
ALU (Arithmetic Logic Unit) = Aritmetik ve Mantık Birimi.

ALU’nun bildiği temel işler:

  • Toplama: A + B
  • Çıkarma: A - B
  • Karşılaştırma: “A mı büyük, B mi?”
  • Basit mantık: VE, VEYA, DEĞİL vb.
  • Bölme / çarpma: Bunlar genelde toplama / çıkarma ve kaydırma ile yapılır.

Yani CPU şöyle çalışır:

  1. Register’lardan sayıları alır (örnek: R1 ve R2).
  2. ALU’ya gönderir.
  3. ALU içeride bir algoritma çalıştırır (toplama, çıkarma, bölme mantığı).
  4. Sonucu tekrar bir register’a yazar (örnek: R3).

2. Toplama nasıl çalışır? (Kısaca)

CPU içindeki toplama, aslında bit bit yapılır.

Örnek: 6 + 5

  • 6 → 0110
  • 5 → 0101

Bit bit toplarsın, “elde” taşırsın.
Bu işi yapan devreye toplayıcı (adder) denir.

Bu konuyu uzatmamak için, asıl istediğin şeye geçiyorum: BÖLME.

3. CPU kendi içinde bölmeyi nasıl yapar?

Basit (öğretici) bakış: CPU, insan gibi düşünür:

“Kaç kere çıkarabilirim?” mantığı.

Mesela 500 / 250

  1. 500’den 250 çıkar → 250 (1 kere çıktı)
  2. 250’den 250 çıkar → 0 (2. kere çıktı)
  3. Artık çıkaramıyorum → Bölüm = 2, kalan = 0

Yani tekrar tekrar çıkarma ile bölme.

Tabii gerçek CPU, bunu bit seviyesinde, daha verimli, özel algoritmalarla yapar:
Örneğin:

  • Restoring division (kalanı geri yüklemeli bölme)
  • Non-restoring division
  • Çarpma için de “kaydır ve topla” yöntemleri vb.

Biz, mantığı anlamak için hem yüksek seviye (insan gibi) hem de bit seviyesi bir örnek görelim.

4. “Tekrar tekrar çıkarma” ile bölme (mantık)

Örnek: 13 / 4

Yüksek seviye pseudo-kod:

bolunen = 13
bolen   = 4
bolum   = 0

while bolunen >= bolen:
    bolunen = bolunen - bolen
    bolum = bolum + 1

kalan = bolunen

Adımlar:

  1. 13 ≥ 4 → evet
    • 13 - 4 = 9 → bolunen = 9
    • bolum = 1
  2. 9 ≥ 4 → evet
    • 9 - 4 = 5 → bolunen = 5
    • bolum = 2
  3. 5 ≥ 4 → evet
    • 5 - 4 = 1 → bolunen = 1
    • bolum = 3
  4. 1 ≥ 4 → hayır → döngü biter
    • bolum = 3
    • kalan = 1

Sonuç: 13 / 4 = 3 kalan 1

CPU bunu nasıl yapar?

  • CMP bolunen, bolen
  • JL bitir (eğer küçükse bitir)
  • SUB bolunen, bolunen, bolen
  • ADD bolum, bolum, 1
  • JMP dongu_basina

Yani içeride aslında sürekli çıkarma + sayma vardır.

5. Gerçek CPU’da tipik yöntem: Kaydırmalı bölme (ikilik düzende)

Şimdi “CPU’nun içindeki gerçek matematik” kısmına, anlaşılır ama biraz daha teknik girelim.

Basitleştirilmiş ikilik (binary) bölme örneği:
13 / 3

  • 13 (onluk) → 1101 (ikilik)
  • 3 (onluk) → 0011 (ikilik)

Ama bunu elle uzun uzun binary yapmayalım, çok boğucu olur.
Onun yerine, CPU’nun mantığını sadeleştirerek anlatayım:

  1. Bolüneni register’a koy (örnek: R1)
  2. Bölünü kaydırarak hizala (R2)
  3. En yüksek bitten başlayarak, “çıkarabilir miyim?” diye bak:
    • Çıkarabiliyorsam:
      • Çıkar
      • Bölüm’ün ilgili bitini 1 yap
    • Çıkaramıyorsam:
      • Bölüm’ün ilgili bitini 0 yap
  4. Bir bit sağa kay, tekrar et.

Bu, ilkokuldaki “kalem kâğıtla uzun bölme”nin ikilik versiyonu.

6. Basitleştirilmiş “CPU bölmesi”ni adım adım, sayı üstünden gösterelim

Sadece mantığı görmek için:
20 / 3 işlemini “tekrar çıkararak” simüle edelim, ama CPU gözüyle.

Değişkenler:

  • R1 = bolunen
  • R2 = bolen
  • R3 = bolum
  • R4 = kalan (geçici olarak bolunen’i taşıyacak)

Başlangıç:

  • R1 = 20
  • R2 = 3
  • R3 = 0

Pseudo-assembly:

LOAD R1, #20      ; bolunen
LOAD R2, #3       ; bolen
MOV  R4, R1       ; R4 = 20 (geçici bolunen)
MOV  R3, #0       ; bolum = 0

DONGU:
CMP  R4, R2       ; R4 >= R2 ?
JL   BITIR        ; küçükse çık

SUB  R4, R4, R2   ; R4 = R4 - R2
ADD  R3, R3, #1   ; bolum++

JMP  DONGU

BITIR:
; R3 = bolum, R4 = kalan

Adımlar:

  1. R4 = 20, R2 = 3
    • 20 ≥ 3 → Evet
    • R4 = 20 - 3 = 17
    • R3 = 0 + 1 = 1
  2. R4 = 17
    • 17 ≥ 3 → Evet
    • R4 = 17 - 3 = 14
    • R3 = 1 + 1 = 2
  3. R4 = 14
    • 14 ≥ 3 → Evet
    • R4 = 14 - 3 = 11
    • R3 = 2 + 1 = 3
  4. R4 = 11
    • 11 ≥ 3 → Evet
    • R4 = 11 - 3 = 8
    • R3 = 3 + 1 = 4
  5. R4 = 8
    • 8 ≥ 3 → Evet
    • R4 = 8 - 3 = 5
    • R3 = 4 + 1 = 5
  6. R4 = 5
    • 5 ≥ 3 → Evet
    • R4 = 5 - 3 = 2
    • R3 = 5 + 1 = 6
  7. R4 = 2
    • 2 ≥ 3 → Hayır → BITIR

Son:

  • Bölüm (R3) = 6
  • Kalan (R4) = 2

Yani 20 / 3 = 6 kalan 2

Bunu CPU, toplama–çıkarma–karşılaştırma–zıplama dışında ekstra bir şey bilmeden yapabiliyor.

7. Peki gerçek CPU’larda neden özel bölme devresi var?

Çünkü:

  • “Tekrar tekrar çıkarma” çok yavaş (büyük sayılarda).
  • Modern CPU’lar, 32 bit, 64 bit gibi çok büyük sayılarla çalışıyor.
  • Yüzlerce, binlerce çıkarma yapmak yerine:
    • Paralel,
    • Kaydırmalı,
    • Donanımsal olarak optimize edilmiş algoritmalar kullanıyor.

Ama temel fikir DEĞİŞMİYOR:

  • Çarpma için:
    • “Kaydır + topla” (örneğin 13 \times 4 için 13’ü kaydırıp ekle)
  • Bölme için:
    • “Kaydır + karşılaştır + çıkar + bölüm bitini yaz”

Yani tüm karmaşıklığın altında şu var:

CPU, toplama, çıkarma, kaydırma, karşılaştırma ve zıplamayı kullanarak çarpma ve bölme yapar.

8. RAM ve disk bu işte nasıl rol oynuyor?

  • Disk:

    • Bölme algoritmasını içeren makine kodu önce diskten RAM’e yüklenir.
    • Yani “bölme nasıl yapılır?” adım adım kodla yazılıdır.

  • RAM:

    • Bölünecek sayı, bölen, bölüm, kalan gibi değerler RAM’de tutulur.
    • CPU, her adımda:
      • Gerekli sayıyı RAM’den register’a alır (LOAD)
      • ALU’da işleme sokar
      • Sonucu tekrar RAM’e yazar (STORE) veya register’da tutar.

  • CPU (ALU + register’lar):

    • Sadece anlık olarak küçük sayıları (register’lar) taşır,
    • ALU’da işlem yapar,
    • Sonucu tekrar bellekle paylaşır.

9. Kısaca: CPU içinde bir “bölme” komutu çalışırken neler olur?

Varsayalım komut:

DIV R3, R1, R2   ; R3 = R1 / R2

Özet akış:

  1. Fetch: Komut RAM’den alınır.
  2. Decode: “Bu bir bölme komutu, R1’i R2’ye böleceğim, sonucu R3’e yazacağım.”
  3. CPU içindeki control unit, ALU’ya diyor ki:
    • “Bölme moduna geç.”
  4. ALU:
    • İçeride kendi mini adımlarını çalıştırır:
      • R1’den R2’yi tekrar tekrar çıkar (veya kaydırmalı algoritmayı kullan),
      • Kaç kere çıkardığını say (bölüm),
      • Çıkaramayınca kalan elde et.
  5. Execute bitiş:
    • ALU, bölüm değerini R3’e, kalan değerini isteniyorsa başka bir register’a (örneğin R4) yazar.
  6. CPU bir sonraki komuta geçer.

Yani tek bir DIV komutu, içeride aslında küçük bir mikro-program gibidir.

İstersen bir sonraki adımda:

  • Çok küçük sayılarla (örneğin 13 / 3 ) binary (0-1) seviyesinde uzun bölmeyi, “CPU şu biti şuraya kaydırıyor, burada 1 yazıyor, burada 0 yazıyor” diye tam adım adım gösterebilirim.
  • Veya “çarpma” için de aynı mantıkla, toplama + kaydırma üzerinden bir iç-akış hazırlayabilirim.

TERİMLER:

ALU (Aritmetik ve Mantık Birimi): İşlemcinin içinde toplama, çıkarma, çarpma, bölme ve mantıksal (VE, VEYA vb.) işlemleri yapan donanım parçası.
Binary (İkilik sistem): Sadece 0 ve 1 rakamlarından oluşan sayı sistemi; bilgisayarlar bu sistemle çalışır.
Bölüm: Bir bölme işleminde, “kaç kere sığıyor?” sorusunun cevabı olan sonuç. Örneğin 20 / 3 = 6 işleminde 6 bölümdür.
Kalan: Bölme işleminden sonra artan, tam sığmayan kısım. Örneğin 20 / 3 = 6 kalan 2 işleminde 2 kalandır.
Kaydırma (Shift): İkilik sayıların bitlerinin sağa veya sola kaydırılması işlemi; 2 ile çarpma/bölmeye benzer bir etki yapar.
Pseudo-assembly: Gerçek makine komutlarına benzeyen ama anlaşılır olsun diye basitleştirilmiş, örnek amaçlı yazılan komut dili.