# Bilgisayar Organizasyonu ve Temel İşlemci Yapısı > Sayısal lojikten yazmaç aktarımlarına, mikroişlemlerden komut çevrimine, mikroprogramlı denetimden CPU organizasyonuna uzanan bilgisayar organizasyonu ders notları. - Author: Muhammet Ali Köker - Language: tr - Canonical: https://alikoker.com.tr/bilgisayar-organizasyonu-ve-temel-islemci-yapisi - Translation: https://alikoker.com.tr/en/computer-organization-and-basic-processor-structure - Published: 2013-09-18T20:15:00+03:00 - Modified: 2026-06-12T21:20:00+03:00 - Verified: 2026-08-08T15:00:00+03:00 - Type: article Bu metin, bilgisayar organizasyonu dersinde 2013-2015 döneminde tuttuğum notların genişletilmiş sürümüdür. İlk notlardaki yazmaç aktarımı, mikroişlem ve temel bilgisayar modeli sırasını korudum; daha sonraki gözden geçirmelerde kavramları güncel işlemci terminolojisiyle karşılaştırarak belirgin hataları düzelttim. Eğitim amaçlı temel bilgisayar modeli ile gerçek bir modern mikro mimari aynı şey değildir; metin boyunca bu ayrımı özellikle korudum. ## Ünite 1: Sayısal Lojik Devrelerin Temelleri ### Sayısal bilgisayar Sayısal bilgisayar, bilgiyi ayrık sembollerle temsil eden ve bu bilgi üzerinde program tarafından belirlenen işlemleri gerçekleştiren bir sistemdir. Güncel bilgisayarların temel fiziksel gösterimi ikili düzene dayanır. İki temel mantık değeri: ```text 0 1 ``` olarak gösterilir. Bu değerler doğrudan belirli bir gerilime eşit değildir. Fiziksel devrede belirli gerilim aralıkları mantıksal `0` ve mantıksal `1` olarak yorumlanır. Bir bilgisayarın temel işlevsel yapısı şu biçimde özetlenebilir: ```text Giriş ↓ İşlemci ↔ Bellek ↓ Çıkış ``` İşlemci içinde başlıca: - aritmetik ve lojik birim, - yazmaçlar, - kontrol birimi bulunur. Ana bellek hem program komutlarını hem de veriyi saklayabilir. Bu yapı klasik saklı program bilgisayarı düşüncesinin temelidir. ### Bilgisayar mimarisi ve organizasyonu Bilgisayar mimarisi ve bilgisayar organizasyonu yakın fakat aynı kavram değildir. **Bilgisayar mimarisi**, yazılım tarafından görülebilen programlama modelini kapsar. Örneğin: - komut kümesi, - yazmaçlar, - veri tipleri, - komut biçimleri, - adresleme biçimleri, - bellek adres uzayı. **Bilgisayar organizasyonu** ise bu mimarinin donanımda nasıl gerçekleştirildiğini inceler. Örneğin: - veri yolları, - ALU, - kontrol işaretleri, - yazmaç bağlantıları, - bellek arabirimi, - komut yürütme mikroişlemleri. Aynı komut kümesi farklı mikro mimarilerle gerçekleştirilebilir. Bu ayrım modern işlemcilerde daha da belirgindir. ### Lojik kapılar Sayısal devrelerin temel işlevsel yapı taşları lojik kapılardır. Temel işlemler: ```text AND OR NOT XOR NAND NOR XNOR ``` İki girişli AND: ```text Y = A B ``` yalnız her iki giriş de `1` olduğunda `1` üretir. OR: ```text Y = A + B ``` en az bir giriş `1` olduğunda `1` üretir. NOT: ```text Y = A' ``` girişi tersler. XOR: ```text Y = A XOR B ``` girişler farklı olduğunda `1` üretir. ### Doğruluk tablosu Bir lojik işlevin bütün giriş kombinasyonlarına karşı ürettiği çıkışlar doğruluk tablosuyla gösterilir. İki giriş için: | A | B | AND | OR | XOR | | --- | --- | --- | --- | --- | | 0 | 0 | 0 | 0 | 0 | | 0 | 1 | 0 | 1 | 1 | | 1 | 0 | 0 | 1 | 1 | | 1 | 1 | 1 | 1 | 0 | `n` ikili giriş için: ```text 2^n ``` farklı giriş birleşimi bulunur. ### Boolean cebri Boolean cebri ikili değişkenler üzerinde tanımlanan cebirdir. Temel kurallardan bazıları: ```text A + 0 = A A + 1 = 1 A A = A A 0 = 0 A + A = A A + A' = 1 A A' = 0 (A')' = A ``` Yutma: ```text A + AB = A A(A + B) = A ``` Dağılma: ```text A(B + C) = AB + AC ``` ve Boolean cebrine özgü diğer dağılım: ```text A + BC = (A + B)(A + C) ``` şeklindedir. ### De Morgan kuralları De Morgan kuralları: ```text (AB)' = A' + B' ``` ```text (A + B)' = A'B' ``` biçimindedir. Bu kurallar özellikle NAND ve NOR tabanlı gerçekleştirimlerde önemlidir. NAND ve NOR **evrensel kapılardır**. Yalnız NAND veya yalnız NOR kullanılarak herhangi bir Boolean işlev gerçekleştirilebilir. ### Karnaugh haritası Karnaugh haritası az sayıda değişken içeren Boolean işlevlerini görsel komşulukla sadeleştirmek için kullanılır. `n` değişkenli bir işlev için: ```text 2^n ``` hücre bulunur. Hücrelerin sıralaması Gray kod düzenindedir: ```text 00 01 11 10 ``` Komşu hücreler yalnız bir değişkende farklıdır. Gruplar: ```text 1, 2, 4, 8, ... ``` gibi ikinin kuvveti büyüklüğünde seçilir. Amaç mümkün olduğunca büyük gruplar kurarak değişen değişkenleri ortadan kaldırmaktır. Karnaugh haritası küçük işlevler için güçlüdür. Daha büyük sayıda değişkende Quine-McCluskey, Espresso benzeri algoritmalar veya modern sentez araçları kullanılır. ### Birleşimsel devreler Birleşimsel, diğer adıyla kombinasyonel, devrede çıkış yalnız o andaki girişlere bağlıdır: ```text Y(t) = F(X(t)) ``` Devrede geçmiş durumu saklayan bellek elemanı bulunmaz. Örnekler: - toplayıcı, - kod çözücü, - kodlayıcı, - çoklayıcı, - karşılaştırıcı. ### Yarım toplayıcı İki biti toplar. Girişler: ```text A, B ``` Toplam: ```text S = A XOR B ``` Elde: ```text C = AB ``` ### Tam toplayıcı Tam toplayıcı iki bit ile önceki basamaktan gelen eldeyi toplar. Girişler: ```text A, B, Cin ``` Toplam: ```text S = A XOR B XOR Cin ``` Elde: ```text Cout = AB + Cin(A XOR B) ``` `n` bitlik basit toplayıcı, tam toplayıcıların zincirlenmesiyle oluşturulabilir. Elde bir basamaktan diğerine yayıldığı için bu yapıya ripple-carry adder denir. ### Flip-floplar Flip-flop bir bitlik durum saklayan devredir. Temel türler: - SR, - JK, - D, - T. Modern senkron tasarımda D flip-flop özellikle yaygındır. D flip-flop için saat kenarında: ```text Q(next) = D ``` olur. JK flip-flop: | J | K | Sonraki durum | | --- | --- | --- | | 0 | 0 | Koruma | | 0 | 1 | 0 | | 1 | 0 | 1 | | 1 | 1 | Tersleme | T flip-flop: ```text T = 0 -> koru T = 1 -> tersle ``` davranışına sahiptir. ### Latch ve flip-flop ayrımı Latch genellikle seviye duyarlıdır. Enable etkin olduğu sürece giriş değişikliklerine tepki verebilir. Flip-flop ise çoğunlukla saat işaretinin belirli kenarında durum değiştirir. Bu ayrım zamanlama analizinde önemlidir. ### Kenar tetikleme Pozitif kenar tetiklemeli flip-flop: ```text 0 -> 1 ``` saat geçişinde giriş değerini örnekler. Negatif kenar tetiklemeli flip-flop: ```text 1 -> 0 ``` geçişinde örnekleme yapar. Gerçek devrede ayrıca: - setup time, - hold time, - clock-to-Q gecikmesi gibi zamanlama sınırları bulunur. ### Ardışıl devreler Ardışıl devrede çıkış yalnız anlık girişe değil, önceki duruma da bağlıdır: ```text Q(next) = F(Q, X) ``` ```text Y = G(Q, X) ``` Bu yapı bir durum makinesidir. Temel tasarım akışı: ```text Problem ↓ Durumlar ↓ Durum diyagramı ↓ Durum tablosu ↓ Flip-flop seçimi ↓ Uyarma denklemleri ↓ Boolean sadeleştirme ↓ Lojik devre ``` ## Ünite 2: Sayısal Bileşenler ### Tümdevreler Tümdevre, çok sayıda elektronik elemanın tek yarıiletken yapı üzerinde gerçekleştirilmesidir. Tarihsel bütünleşme sınıflandırmaları: - SSI, - MSI, - LSI, - VLSI olarak kullanılmıştır. Bu terimler sayısal tasarım tarihini anlamak için yararlıdır. Güncel işlemciler ve bellekler VLSI ölçeğinin çok ötesinde transistor sayıları içerdiğinden eski sayısal sınırlar artık modern teknoloji sınıflandırması olarak kullanılmaz. ### Lojik aileleri Tarihsel ve temel lojik aileler arasında: - TTL, - ECL, - NMOS, - PMOS, - CMOS bulunur. TTL bipolar transistorlara dayanır. ECL transistorları doyuma sokmadan yüksek hız hedefleyen tarihsel bir lojik ailesidir. MOS ailesi alan etkili transistorlara dayanır. CMOS, N-kanal ve P-kanal MOSFET'leri tamamlayıcı biçimde kullanır ve modern sayısal tümdevrelerin temel teknolojisidir. CMOS'un dinamik güç bileşeni yaklaşık olarak: ```text Pdynamic ≈ alpha C V^2 f ``` ilişkisiyle açıklanabilir. Burada: - `alpha`: anahtarlama etkinliği, - `C`: etkin anahtarlanan kapasite, - `V`: besleme gerilimi, - `f`: frekanstır. ### Kod çözücü Decoder, `n` bitlik giriş kodunu en fazla: ```text 2^n ``` ayrı çıkış hattından birine dönüştürür. Örneğin 2-to-4 decoder: ```text 00 -> Y0 01 -> Y1 10 -> Y2 11 -> Y3 ``` seçimini gerçekleştirir. Decoder: - adres çözümleme, - komut kodu çözme, - aygıt seçme, - kontrol işareti üretme işlemlerinde kullanılır. ### Kodlayıcı Encoder, decoder'ın ters yönlü işlevini gerçekleştirir. `2^n` girişten aktif olan hattı `n` bitlik kod olarak üretir. Basit encoder aynı anda yalnız bir girişin aktif olduğunu varsayar. Birden fazla giriş etkin olabiliyorsa **öncelikli kodlayıcı** kullanılır. ### Çoklayıcı Multiplexer, birçok girişten birini seçim hatlarına göre çıkışa aktarır. `2^n` veri girişi için `n` seçim biti gerekir. 2-to-1 MUX: ```text Y = S'D0 + SD1 ``` şeklinde ifade edilir. MUX yalnız veri seçmek için değil, Boolean işlevlerin gerçekleştirilmesinde ve ortak veri yolu yapılarında da kullanılabilir. ### Yazmaç Yazmaç, birden fazla flip-flopun ortak kontrol altında bir araya getirilmesiyle oluşturulan küçük ve hızlı saklama birimidir. `n` bitlik yazmaç: ```text n bit ``` bilgi tutar. Yazmaçların tipik kontrol işlevleri: - yükle, - temizle, - artır, - azalt, - kaydır. İşlemci içindeki yazmaçlar ana belleğe göre çok daha düşük erişim gecikmesine sahiptir. ### Kaydırmalı yazmaç Shift register, saklanan bitleri her saat olayında sağa veya sola kaydırabilir. Örnek: ```text 1011 ↓ sağa kaydır 0101 ``` Yeni giren bitin değeri kaydırma türüne göre belirlenir. Kullanım alanları: - seri-paralel dönüşüm, - paralel-seri dönüşüm, - bit kaydırma, - gecikme, - bazı aritmetik işlemler. ### İki yönlü kaydırmalı yazmaç İki yönlü kaydırmalı yazmaç: - sola kaydırma, - sağa kaydırma, - paralel yükleme, - durumu koruma işlevlerini seçim hatlarıyla gerçekleştirebilir. Bu tür yapının her bitinde bir MUX kullanılarak sonraki girişin hangi kaynaktan alınacağı seçilebilir. ### İkili sayıcı İkili sayıcı belirlenmiş durum dizisini saat darbeleriyle izler. Üç bitlik sayıcı: ```text 000 001 010 011 100 101 110 111 000 ... ``` şeklinde çalışır. `n` bitlik tam ikili sayıcı: ```text 2^n ``` duruma sahiptir. ### Eşzamanlı ve dalgalı sayıcı **Dalgalı sayıcıda** bir flip-flopun çıkışı bir sonrakinin saatini tetikleyebilir. Gecikmeler basamaklar boyunca yayılır. **Eşzamanlı sayıcıda** flip-floplar ortak saat işaretini kullanır. Sonraki durum lojik denklemlerle birlikte hesaplanır. Yüksek hızlı tasarımda eşzamanlı yaklaşım daha uygundur. ### Ana bellek Ana bellek çok sayıda adreslenebilir bellek sözcüğünden oluşur. Genel gösterim: ```text M[address] ``` şeklindedir. Bir bellek biriminin temel işaretleri: - adres, - veri, - okuma, - yazma. ### RAM RAM, seçilen konumdaki veriye adres üzerinden erişilebilen ve normal kullanımda okunup yazılabilen bellektir. İki temel yarıiletken RAM türü: **SRAM:** Hücre başına daha fazla transistor kullanır, yenileme gerektirmez, düşük gecikmelidir. Önbelleklerde yaygındır. **DRAM:** Daha yoğun saklama sağlar ancak hücrelerin periyodik olarak yenilenmesi gerekir. Ana belleklerde yaygındır. "Random access" ifadesi adreslenen herhangi bir konuma benzer erişim modeliyle ulaşılabilmesini ifade eder. ### ROM ve kalıcı bellek ROM ailesi tarihsel olarak: - mask ROM, - PROM, - EPROM, - EEPROM biçimlerinde ele alınır. Flash bellek elektriksel olarak silinip yeniden programlanabilen kalıcı yarıiletken bellek ailesidir. Günümüzde firmware ve kalıcı depolama uygulamalarında klasik ROM sınıflandırmalarının yanında flash tabanlı çözümler yaygındır. ## Ünite 3: Veri Gösterimi ### Sayı sistemleri `r` tabanlı konumsal sayı sisteminde: ```text (dn ... d1 d0 . d-1 d-2 ...)r ``` sayısının değeri: ```text sum di r^i ``` ile bulunur. Bilgisayar sistemlerinde en önemli tabanlar: - 2, - 8, - 10, - 16. ### İkili sistem İkili sistem: ```text 0, 1 ``` rakamlarını kullanır. Örnek: ```text 101101_2 ``` değeri: ```text 1x2^5 + 0x2^4 + 1x2^3 + 1x2^2 + 0x2 + 1 = 45_10 ``` olur. ### Sekizli ve onaltılı gösterim Bir sekizli basamak üç bite karşılık gelir: ```text 7_8 = 111_2 ``` Bir onaltılı basamak dört bite karşılık gelir: ```text F_16 = 1111_2 ``` Bu nedenle uzun ikili diziler daha kısa olarak: ```text 1011 1100 0110_2 = BC6_16 ``` biçiminde yazılabilir. ### Kesirli sayı dönüşümü İkili kesirde basamak ağırlıkları: ```text 2^-1, 2^-2, 2^-3, ... ``` şeklindedir. Örnek: ```text 0.101_2 = 1/2 + 0/4 + 1/8 = 0.625_10 ``` Onluk kesri ikiliye dönüştürmek için kesir kısmı tekrar tekrar 2 ile çarpılabilir. Her adımda oluşan tam kısım sıradaki biti verir. Bazı onluk kesirlerin sonlu ikili gösterimi yoktur. ### ASCII ve karakter kodları ASCII 7 bitlik bir karakter kodlamasıdır ve 128 kod noktası tanımlar. Modern metin sistemlerinde Unicode temel standarttır. Unicode kod noktaları: - UTF-8, - UTF-16, - UTF-32 gibi kodlama biçimleriyle saklanabilir. UTF-8 ilk 128 karakterde ASCII ile uyumludur. ### BCD Binary Coded Decimal, her onluk rakamı ayrı ikili kodla temsil eder. 8421 BCD'de: ```text 59_10 = 0101 1001_BCD ``` olur. Bu değer saf ikili: ```text 111011_2 ``` gösteriminden farklıdır. BCD onluk basamakların tam korunmasının önemli olduğu belirli uygulamalarda kullanılır. ### Tümleyenler Tabanı `r` olan sistemde iki önemli tümleyen vardır: ```text (r - 1) tümleyeni r tümleyeni ``` İkili sistemde bunlar: ```text 1'in tümleyeni 2'nin tümleyeni ``` olarak adlandırılır. Bir bit dizisinin 1'in tümleyeni bütün bitlerin terslenmesiyle bulunur. 2'nin tümleyeni: ```text 1'in tümleyeni + 1 ``` şeklindedir. ### İki'nin tümleyeni Modern işlemcilerde signed integer gösteriminde standart yaklaşım iki'nin tümleyenidir. `n` bitlik signed aralık: ```text -2^(n-1) ... 2^(n-1)-1 ``` olur. 8 bit için: ```text -128 ... +127 ``` ### Çıkarma işlemi İki'nin tümleyeniyle: ```text A - B ``` işlemi: ```text A + two_complement(B) ``` biçimine dönüştürülebilir. Böylece toplama donanımı çıkarma için de kullanılabilir. ### Taşma Signed aritmetikte carry ile overflow aynı kavram değildir. İki'nin tümleyeninde aynı işaretli iki sayının toplamı karşı işaretli sonuç veriyorsa signed overflow oluşur. Örnek 8 bit: ```text 01111111 127 00000001 1 -------- 10000000 -128 olarak yorumlanır ``` Matematiksel sonuç `128` 8 bit signed aralık dışında olduğundan overflow vardır. ### Sabit nokta gösterimi Fixed-point gösterimde ikili noktanın konumu önceden belirlenmiştir. Örneğin `Qm.n` biçiminde: - `m`: tam kısım, - `n`: kesir bitleri için kullanılabilir. Sabit nokta: - öngörülebilir gecikme, - düşük donanım maliyeti, - kontrollü hassasiyet gereken gömülü ve DSP uygulamalarında önemlidir. ### Kayan nokta gösterimi Kayan nokta büyük dinamik aralığı daha az bit ile temsil eder. IEEE 754 binary32: ```text 1 bit işaret 8 bit üs 23 bit kesir ``` binary64: ```text 1 bit işaret 11 bit üs 52 bit kesir ``` kullanır. Normal sayı: ```text (-1)^s x 1.f x 2^(e-bias) ``` biçiminde yorumlanır. IEEE 754 ayrıca: - +0, - -0, - +sonsuz, - -sonsuz, - NaN, - subnormal değerlerini tanımlar. Kayan nokta aritmetiği reel sayı aritmetiğinin tam karşılığı değildir. Yuvarlama hataları normaldir. ### Eşlik biti Parity, tek bitlik basit hata sezme tekniğidir. Çift eşlikte toplam `1` sayısı çift tutulur. Tek eşlikte toplam `1` sayısı tek tutulur. Eşlik biti: - tek sayıda bit hatasını sezebilir, - hatanın yerini belirleyemez, - genel olarak hatayı düzeltemez, - çift sayıda bazı bit hatalarını sezemez. Bu nedenle parity bir hata düzeltme kodu değil, basit hata sezme mekanizmasıdır. ### Hata düzeltme yaklaşımı Daha güçlü kodlarda yalnız hata sezme değil hata konumunu belirleme ve düzeltme de mümkündür. Hamming kodlarının temel düşüncesi veri bitlerine birden çok bağımsız eşlik denetimi eklemektir. Kodun minimum Hamming uzaklığı hata sezme ve düzeltme gücünü belirler. ## Ünite 4: Yazmaç Aktarımları ve Mikroişlemler ### Sayısal bilgisayarın iç yapısı Bir işlemcinin veri yolu açısından temel bileşenleri: ```text Yazmaçlar ↓ Veri yolları ↓ ALU ↓ Yazmaçlar ``` şeklindedir. Kontrol birimi bu yapıların: - hangi kaynağı okuyacağını, - hangi işlemi yapacağını, - sonucun nereye yazılacağını belirleyen işaretleri üretir. ### Yazmaç aktarım dili Register Transfer Language, Türkçede **yazmaç aktarım dili** olarak kullanılabilir. Bir aktarım: ```text R2 <- R3 ``` ifadesiyle gösterilir. Anlamı: > R3 içeriğini R2'ye aktar. Koşullu aktarım: ```text C: R2 <- R3 ``` şeklinde yazılabilir. Anlamı: ```text if C = 1: R2 <- R3 ``` Aynı saat olayında yapılabilen bağımsız işlemler: ```text D: R2 <- R3, R4 <- R5 ``` biçiminde gösterilebilir. ### Mikroişlem Bir veya birkaç yazmaçtaki bilgi üzerinde tek saat adımında gerçekleştirilebilen temel işleme mikroişlem denir. Ana gruplar: - yazmaç aktarımı, - aritmetik mikroişlem, - lojik mikroişlem, - kaydırma mikroişlemi, - bellek mikroişlemi. ### Veri yolu Birden çok birimin ortak iletim hatlarını paylaşması veri yolu yapısını oluşturur. Veri yolu: - veri, - adres, - kontrol işaretlerini taşıyan farklı hat gruplarını içerebilir. Yazmaçlar arasında ortak veri yolu oluşturmak için: - MUX, - üç durumlu tampon, - doğrudan çok portlu bağlantı gibi yöntemler kullanılabilir. ### MUX tabanlı ortak veri yolu `n` adet `m` bitlik kaynaktan biri seçilecekse her bit konumu için MUX kullanılabilir. Seçim hatları bütün bitler için ortaktır. Örneğin: ```text S = 011 ``` belirli bir yazmacı ortak veri yoluna bağlayabilir. Hedef yazmacın yükleme işareti etkinleştirildiğinde: ```text Rdest <- bus ``` aktarımı tamamlanır. ### Üç durumlu tampon Üç durumlu çıkış: ```text 0 1 Z ``` değerlerinden birini alabilir. `Z`, yüksek empedans durumudur. Ortak hatta yalnız bir sürücünün aktif olması sağlanırsa birden çok kaynak aynı fiziksel bağlantıyı paylaşabilir. Çip içi modern tasarım araçlarında büyük iç üç durumlu ağlar yerine MUX tabanlı yapılar yaygındır. Üç durumlu sürücüler özellikle fiziksel G/Ç arabirimlerinde önemini korur. ### Bellek okuma Adres yazmacı `AR`, veri yazmacı `DR` olsun. Okuma: ```text DR <- M[AR] ``` şeklindedir. Burada `AR` okunacak adresi, `DR` okunan veriyi temsil eder. ### Bellek yazma Yazma: ```text M[AR] <- DR ``` şeklinde ifade edilebilir. Gerçek sistemde bellek arabirimi ayrıca: - okuma/yazma işareti, - byte enable, - hazır/bekle, - hata gibi ek protokol işaretleri içerebilir. ### Aritmetik mikroişlemler Temel aritmetik mikroişlemler: ```text R3 <- R1 + R2 R1 <- R1 + 1 R1 <- R1 - 1 R1 <- R1 - R2 ``` gibi işlemlerdir. Toplama tam toplayıcı hücrelerinin paralel bağlanmasıyla gerçekleştirilebilir. ### Toplama ve çıkarma birimi Çıkarma: ```text A - B = A + B' + 1 ``` olduğundan aynı toplayıcı donanımı kullanılabilir. Kontrol biti `SUB` ile: ```text Y = B XOR SUB Cin = SUB ``` seçilirse: ```text SUB = 0 -> A + B SUB = 1 -> A + B' + 1 ``` elde edilir. ### Artırma ve azaltma Artırma: ```text R <- R + 1 ``` azaltma: ```text R <- R - 1 ``` işlemleridir. Program sayacı, yığın işaretçisi ve döngü sayaçları için sık kullanılır. ### Lojik mikroişlemler Bit düzeyinde: ```text R <- A AND B R <- A OR B R <- A XOR B R <- NOT A ``` işlemleri yapılabilir. Her bit konumu bağımsız işlendiği için `n` bitlik lojik birim `n` adet tek bitlik hücrenin paralel çalışmasıyla oluşturulabilir. ### Bit maskeleme Belirli bitleri temizlemek: ```text R <- R AND mask ``` Belirli bitleri kurmak: ```text R <- R OR mask ``` Belirli bitleri değiştirmek: ```text R <- R XOR mask ``` ile yapılabilir. Bu işlemler modern sistem programlamada da temel öneme sahiptir. ### Kaydırma mikroişlemleri Temel kaydırmalar: - lojik sola, - lojik sağa, - aritmetik sağa, - döndürme. Lojik sağa kaydırmada soldan `0` girer. Lojik sola kaydırmada sağdan `0` girer. Signed iki'nin tümleyeni sayıda aritmetik sağa kaydırma işaret bitini korumaya çalışır: ```text 11010000 >> aritmetik 11101000 ``` Dil ve ISA düzeyinde kaydırma davranışının kesin tanımı ilgili standarda göre değerlendirilmelidir. ### Döndürme Rotate işleminde çıkan bit diğer uçtan tekrar girer: ```text 10110001 ROR 1 11011000 ``` Carry üzerinden döndürme bazı tarihsel ve güncel ISA'larda ayrıca bulunabilir. ### ALU Arithmetic Logic Unit, aritmetik ve lojik işlemleri ortak bir donanımda gerçekleştirir. Tipik girişler: ```text A B operation carry-in ``` Tipik çıkışlar: ```text result carry zero sign overflow ``` ALU'nun ürettiği durum bilgileri program durum yazmacında veya bayrak yazmacında tutulabilir. ### ALU ile kaydırıcı Bir veri yolu: ```text Yazmaçlar ↓ ALU ↓ Kaydırıcı ↓ Hedef yazmaç ``` biçiminde düzenlenebilir. Bazı mikro mimarilerde ALU ve barrel shifter paralel veya birleşik veri yolu içinde yer alabilir. ## Ünite 5: Temel Bilgisayar Yapısı ve Komutların Yürütülmesi ### Eğitim amaçlı temel bilgisayar Bu derste kullanılan temel bilgisayar, işlemci organizasyonunun anlaşılması için tasarlanmış sade bir akümülatör makinesidir. Bu model güncel x86, Arm veya RISC-V işlemcisinin birebir yapısı değildir. Ancak: - komut getirme, - komut çözme, - efektif adres bulma, - ALU işlemi, - bellek erişimi, - dallanma, - kesme, - kontrol işareti üretimi kavramlarını açık biçimde gösterir. ### Temel komut biçimi 16 bitlik eğitim modelinde komut: ```text I | opcode | address 1 3 12 bit ``` biçiminde düşünülebilir. 12 bit adres: ```text 2^12 = 4096 ``` bellek sözcüğünü adresleyebilir. `I` biti bellek referanslı komutlarda: ```text 0 -> doğrudan 1 -> dolaylı ``` adresleme seçimi için kullanılır. ### Yazmaçlar Temel bilgisayarın başlıca yazmaçları: | Yazmaç | Bit | İşlev | | --- | ---: | --- | | AR | 12 | Bellek adresi | | PC | 12 | Sonraki komut adresi | | DR | 16 | Bellekten okunan/yazılan veri | | AC | 16 | Akümülatör | | IR | 16 | Komut yazmacı | | TR | 16 | Geçici veri | | INPR | 8 | Giriş verisi | | OUTR | 8 | Çıkış verisi | Ek durum ve kontrol bitleri de bulunabilir. ### Program sayacı Program sayacı: ```text PC ``` bir sonraki getirilecek komutun adresini tutar. Komut getirildikten sonra tipik olarak: ```text PC <- PC + 1 ``` yapılır. Dallanma, alt program veya kesme sırasında PC başka bir adresle yüklenebilir. ### Komut yazmacı Instruction Register: ```text IR ``` o anda çözümlenen ve yürütülen komutu tutar. Kontrol birimi: - opcode, - adres alanı, - adresleme biti gibi alanları IR'den alır. ### Akümülatör Akümülatör tabanlı yapıda birçok aritmetik ve lojik işlem bir operandı AC'de tutar: ```text AC <- AC + M[EA] ``` Bu yaklaşım donanımı sadeleştirir ancak güncel genel amaçlı yazmaç organizasyonlarına göre daha fazla veri hareketi gerektirebilir. ### Doğrudan adresleme Komutun adres alanı efektif adresi doğrudan verir: ```text EA = address ``` Örnek: ```text LDA X ``` anlamı: ```text AC <- M[X] ``` ### Dolaylı adresleme Komutun adres alanı operandın adresinin bulunduğu yeri gösterir: ```text EA = M[address] ``` Sonra: ```text operand = M[EA] ``` alınır. Bir ek bellek erişimi gerektirir. ### Komut getirme çevrimi Temel mikroişlemler: ```text T0: AR <- PC T1: IR <- M[AR], PC <- PC + 1 T2: opcode <- decode(IR), AR <- IR(address), I <- IR(I) ``` Bu üç adım: - komut adresini belleğe sunar, - komutu getirir, - program sayacını ilerletir, - komut alanlarını çözümler. Modern işlemcilerde fetch, decode ve execution birçok komut için örtüşebilir. Ancak bu temel sıra kavramları açıklamak için geçerlidir. ### Dolaylı adres fazı Bellek referanslı komutta dolaylı adresleme seçilmişse: ```text AR <- M[AR] ``` ile efektif adres alınır. Bundan sonra komutun yürütme aşaması başlar. ### Bellek referanslı komutlar Temel eğitim makinesinde tipik komutlar: ```text AND ADD LDA STA BUN BSA ISZ ``` olarak ele alınır. ### AND ```text DR <- M[AR] AC <- AC AND DR ``` işlemlerini gerçekleştirir. ### ADD ```text DR <- M[AR] AC <- AC + DR E <- carry ``` işlemlerini gerçekleştirir. ### LDA ```text DR <- M[AR] AC <- DR ``` ### STA ```text M[AR] <- AC ``` ### BUN Koşulsuz dallanma: ```text PC <- AR ``` ### BSA Branch and Save Return Address, alt program çağrısı için kullanılır. Temel fikir: ```text M[AR] <- PC AR <- AR + 1 PC <- AR ``` Dönüş adresi bellekte saklanır ve yürütme alt programın ilk komutundan devam eder. Modern ISA'larda dönüş adresi çoğunlukla yazmaç veya yığın kullanılarak korunur. ### ISZ Increment and Skip if Zero: ```text DR <- M[AR] DR <- DR + 1 M[AR] <- DR if DR == 0: PC <- PC + 1 ``` Bu komut basit döngü yapılarında kullanılabilir. ### Yazmaç referanslı komutlar Opcode alanının özel değeri, adres alanındaki bitlerin yazmaç üzerinde doğrudan işlem seçmesini sağlayabilir. Klasik eğitim modelindeki örnekler: ```text CLA AC'yi temizle CLE E bitini temizle CMA AC'yi tümle CME E bitini tümle CIR sağa döndür CIL sola döndür INC AC'yi artır SPA AC pozitifse atla SNA AC negatifse atla SZA AC sıfırsa atla SZE E sıfırsa atla HLT dur ``` Bu komutlar güncel işlemci komutlarıyla birebir eşleştirilmemelidir. Ama veri yolu ve kontrol mantığını öğretmek için uygundur. ### Giriş çıkış komutları Temel modelde tipik: ```text INP OUT SKI SKO ION IOF ``` komutları bulunur. `INP` giriş yazmacından veri alır. `OUT` akümülatörün düşük bitlerini çıkış yazmacına aktarabilir. `ION` ve `IOF` kesme etkinliğini denetler. ### Komut çevrimi Genel olarak: ```text Getir ↓ Çöz ↓ Efektif adresi belirle ↓ Yürüt ↓ Kesme denetimi ↓ Sonraki komut ``` çevrimi kullanılır. Güncel işlemcilerde bu aşamalar pipeline, out-of-order execution, speculative execution ve önbellek hiyerarşileri nedeniyle fiziksel olarak çok daha karmaşıktır. ISA açısından görülen sonuç yine komutların tanımlanan mimari etkiyi üretmesidir. ### Zamanlama ve kontrol Temel bilgisayarda zaman adımları: ```text T0, T1, T2, ... ``` biçiminde oluşturulabilir. Bir sıra sayacı ve decoder, her saat aralığı için farklı zaman işareti üretebilir. Kontrol işlevi kabaca: ```text control = f(opcode, I, flags, timing) ``` şeklinde düşünülebilir. ### Donanımsal kontrol Hardwired control: - decoder, - kapılar, - flip-floplar, - durum mantığı ile doğrudan gerçekleştirilir. Avantajları: - düşük kontrol gecikmesi, - özel optimizasyon olanağı. Dezavantajı: - karmaşık tasarımın değiştirilmesinin zor olmasıdır. ### Kesme Kesme, normal komut akışının bir olay nedeniyle geçici olarak başka bir işleyiciye yönlendirilmesidir. Temel süreç: ```text Normal program ↓ Kesme isteği ↓ Mimari durumun gerekli kısmını koru ↓ Kesme servis rutinine git ↓ Olayı işle ↓ Durumu geri yükle ↓ Programa dön ``` Kesme ile polling arasındaki temel fark, işlemcinin aygıt durumunu sürekli sorgulamak zorunda olmamasıdır. ### Kesme bağlamı Modern sistemlerde kesme sırasında hangi durumun otomatik, hangisinin yazılımla saklanacağı ISA ve işletim sistemi sözleşmesine bağlıdır. Korunabilecek durumlar: - PC, - durum yazmacı, - genel amaçlı yazmaçlar, - hata kodları. Kesme, exception ve trap terimlerinin kesin anlamı mimariye göre değişebilir. ## Ünite 6: Temel Bilgisayarda Assembly Programlama ### Makine dili Makine dili işlemcinin doğrudan çözümleyebildiği komut bit dizileridir. Örneğin komut: ```text opcode + adresleme bilgisi + operand/adres alanı ``` şeklinde kodlanabilir. Makine kodu işlemci mimarisine bağımlıdır. ### Assembly dili Assembly dili makine komutlarına simgesel adlar verir. Örneğin: ```text LDA X ADD Y STA Z ``` ifadeleri doğrudan bit dizilerine göre daha okunabilirdir. Assembly dili ile makine dili arasında çoğunlukla yakın ilişki vardır ancak her assembly satırının her mimaride tam olarak tek makine komutuna karşılık gelmesi zorunlu değildir. Makrolar ve pseudo-instruction'lar bu ilişkiyi değiştirebilir. ### Assembler **Assembly**, programlama dilidir. **Assembler**, assembly kaynak kodunu makine koduna dönüştüren araçtır. Girdi: ```text kaynak program ``` Çıktı: ```text nesne kodu ``` olabilir. Bu iki terim birbirine karıştırılmamalıdır. ### Assembly satırı Basit eğitim assembler'ında satır: ```text etiket komut/ifade operand açıklama ``` bölümlerinden oluşabilir. Örnek: ```text LDA X ADD Y STA Z X, DEC -20 Y, DEC 40 Z, DEC 0 END ``` ### Sembolik adres Etiket: ```text X Y Z LOOP ``` gibi isimleri sayısal bellek adresleri yerine kullanmayı sağlar. Assembler bu sembolleri gerçek adreslere dönüştürür. ### Sözde komutlar Assembler directive veya pseudo-operation, doğrudan CPU tarafından yürütülen makine komutu değildir. Eğitim assembler'ında: ```text ORG END DEC HEX ``` gibi ifadeler kullanılabilir. Örneğin: ```text ORG 200 ``` izleyen kodun yerleşmeye başlayacağı adresi belirler. ### İki geçişli assembler Forward reference nedeniyle sembolün adresi ilk kullanıldığı anda bilinmeyebilir. İki geçişli yaklaşım: **Birinci geçiş** - kaynak programı tarar, - location counter tutar, - etiketleri sembol tablosuna yerleştirir, - adresleri belirler. **İkinci geçiş** - komut adlarını opcode'a dönüştürür, - sembolik operandları adreslerle değiştirir, - nesne kodunu üretir. ### Sembol tablosu Örnek: | Sembol | Adres | | --- | ---: | | LOOP | 205 | | X | 230 | | Y | 231 | Assembler ikinci geçişte bu tabloyu kullanır. ### Hata tanılama Assembler en az şu hata sınıflarını bulabilir: - bilinmeyen komut, - tanımsız sembol, - yinelenmiş etiket, - geçersiz sayı, - alan taşması, - sözdizimi hatası. Modern assembler ve linker araçları ayrıca: - relocation, - symbol visibility, - section, - object format gibi kavramlarla çalışır. ### Döngü Assembly düzeyinde yüksek seviyeli `for` yapısı doğrudan bulunmayabilir. Tipik döngü: ```text başlangıç ↓ işlem ↓ sayaç güncelle ↓ koşul ├─ devam └─ çık ``` şeklinde dallanma komutlarıyla gerçekleştirilir. ### Çarpma ve bölme Temel eğitim bilgisayarında doğrudan MUL veya DIV komutu bulunmayabilir. Basit çarpma: - toplama, - kaydırma ile gerçekleştirilebilir. Bölme: - çıkarma, - karşılaştırma, - kaydırma işlemlerinden kurulabilir. Bu durum komut kümesinin hesaplama bakımından yeterli olabileceğini ancak verimli olmayabileceğini gösterir. Modern genel amaçlı işlemciler çoğunlukla donanımsal çarpma ve bölme komutları sağlar. ### Kaydırma ile çarpma İşaretsiz veya uygun signed sayı için: ```text x << 1 ``` matematiksel aralık taşmıyorsa: ```text 2x ``` ile ilişkilidir. Benzer biçimde sağa kaydırma ikiye bölme ile ilişkili olabilir. Ancak signed negatif değerlerde yuvarlama davranışı ve dil/ISA tanımı dikkate alınmalıdır. ### Alt program Alt program, belirli görevi gerçekleştiren ve çağrıldığı yere geri dönen komut dizisidir. Gerekli iki temel bilgi: - alt programın giriş adresi, - dönüş adresi. Dönüş adresi: - belirli yazmaçta, - bellekte, - yığında saklanabilir. ### Yinelemeli çağrılar Tek sabit bellek konumunda dönüş adresi saklayan sistem iç içe veya recursive çağrıları doğrudan desteklemekte zorlanır. Yığın tabanlı çağrı mekanizması: ```text push return_address call ... pop return_address return ``` ile iç içe çağrıları doğal olarak destekler. ### Parametre aktarımı Alt programa parametre: - yazmaç, - bellek, - yığın, - çağrı çerçevesi üzerinden aktarılabilir. Modern ABI'ler hangi parametrelerin hangi yazmaçlarda veya yığında taşınacağını belirler. ### Giriş çıkış programlaması Temel bilgisayar modelinde G/Ç: - veri yazmacı, - hazır bayrağı, - kesme etkinleştirme biti ile modellenebilir. Polling: ```text while ready == 0: bekle ``` şeklindedir. Kesme tabanlı G/Ç'de işlemci başka iş yaparken aygıt hazır olduğunda kesme oluşturur. ### Programlı G/Ç, kesme ve DMA Üç temel yaklaşım: **Programlı G/Ç:** CPU veri aktarımının her adımıyla ilgilenir. **Kesme tabanlı G/Ç:** Aygıt hazır olduğunda CPU'yu haberdar eder. **DMA:** Veri bloklarının bellek ile aygıt arasında CPU'nun her sözcük aktarımına katılması gerekmeden taşınmasını sağlar. Bu üçlü, güncel bilgisayar organizasyonunda da temel kavramsal ayrımdır. ## Ünite 7: Mikroprogramlı Kontrol ### Kontrol biriminin görevi Kontrol birimi işlemcideki veri yolunun ne yapacağını belirleyen kontrol işaretlerini üretir. Örneğin: ```text AR <- PC ``` işlemi için: - PC çıkışının veri yoluna bağlanması, - AR yükleme girişinin etkinleştirilmesi, - uygun saat olayı gerekir. Bu işaretlerin üretimi iki temel yöntemle yapılabilir: - donanımsal kontrol, - mikroprogramlı kontrol. ### Mikroprogramlı kontrol Microprogrammed control'de kontrol işaretleri bir kontrol belleğinde saklanan mikrokomutlarla tanımlanır. Temel yapı: ```text Kontrol adres yazmacı ↓ Kontrol belleği ↓ Mikrokomut yazmacı ↓ Kontrol işaretleri ``` Bir mikrokomut işlemci veri yolunda aynı anda yapılabilecek bir veya daha fazla mikroişlemi kodlayabilir. ### Kontrol belleği Kontrol belleği geleneksel eğitim modelinde ROM olarak düşünülebilir. Her adres bir mikrokomut içerir. Mikrokomut: - veri yolu kontrol alanları, - koşul alanı, - dallanma alanı, - sonraki adres içerebilir. ### Kontrol adres yazmacı Control Address Register: ```text CAR ``` sonraki okunacak mikrokomutun adresini tutar. ### Alt program yazmacı Microprogram kontrolünde: ```text SBR ``` mikroprogram alt rutininin dönüş adresini tutmak için kullanılabilir. Bu, normal programdaki call/return kavramının kontrol birimi içindeki karşılığıdır. ### Mikrokomut biçimi Eğitim modelinde mikrokomut: ```text F1 | F2 | F3 | CD | BR | AD ``` gibi alanlara ayrılabilir. `F1`, `F2`, `F3` mikroişlem gruplarını seçer. `CD` koşulu seçer. `BR` sonraki adres üretme yöntemini seçer. `AD` hedef mikrokomut adresini taşır. Bu özel biçim eğitim mimarisine aittir. Gerçek işlemcilerin mikrocode biçimleri üreticiye özgüdür. ### Mikroprogram dizileme Bir sonraki mikrokomut adresi: - sıradaki adres, - koşullu hedef, - komut opcode'undan eşlenen rutin, - alt rutin dönüş adresi gibi kaynaklardan seçilebilir. Bu işlem **microsequencing** olarak adlandırılır. ### Mapping Makine komutunun opcode'u ilgili mikroprogram rutininin başlangıç adresine eşlenebilir. Kavramsal olarak: ```text opcode ↓ mapping mikroprogram başlangıç adresi ``` şeklindedir. ### Fetch mikroprogramı Komut getirme mikroişlemleri mikroprogramla da tanımlanabilir: ```text AR <- PC DR <- M[AR], PC <- PC + 1 AR <- DR(address) CAR <- routine_address(opcode) ``` Gerçek alan ve veri yolu ayrıntıları tasarıma göre değişir. ### Dolaylı adres rutini Dolaylı adresleme için: ```text AR <- M[AR] ``` mikroişlemiyle efektif adres elde edilir. Birden fazla makine komutunun aynı dolaylı adres rutinini kullanması mikroprogram paylaşımına örnektir. ### ADD mikroprogramı Basit ADD: ```text DR <- M[AR] AC <- AC + DR ``` işlemlerini gerçekleştiren mikrokomut dizisiyle tanımlanabilir. Son mikrokomut yeni makine komutunu almak üzere fetch rutinine döner. ### Mikroprogram alt rutini Ortak mikroişlem dizileri mikroprogram alt rutini olarak kullanılabilir. Çağrıda: ```text SBR <- return_microaddress CAR <- subroutine_address ``` dönüşte: ```text CAR <- SBR ``` mantığı uygulanabilir. ### Yatay ve dikey mikroprogramlama **Yatay mikrokomut** çok sayıda kontrol bitini doğrudan veya az kodlanmış biçimde içerir. Avantajı: - aynı anda çok sayıda mikroişlem, - düşük decode gecikmesi. Dezavantajı: - geniş kontrol sözcüğü. **Dikey mikrokomut** daha yoğun kodlanır. Avantajı: - daha dar kontrol belleği. Dezavantajı: - ek çözme mantığı, - daha düşük doğrudan paralellik. ### Donanımsal ve mikroprogramlı kontrol karşılaştırması | Özellik | Donanımsal | Mikroprogramlı | | --- | --- | --- | | Temel yapı | Mantık devresi | Kontrol belleği | | Değişiklik | Zor | Görece kolay | | Kontrol gecikmesi | Genellikle düşük | Kontrol belleği erişimi içerir | | Karmaşık ISA | Tasarım zorlaşabilir | Mikrocode ile düzenlenebilir | | Basit pipeline | Uygun | Uygulamaya bağlı | Modern işlemciler bu ayrımı mutlak biçimde kullanmak zorunda değildir. Aynı çekirdekte donanımsal decode, mikro-op üretimi ve mikrocode mekanizmaları birlikte bulunabilir. ## Ünite 8: Merkezi İşlem Birimi ### CPU organizasyonu CPU temel olarak: ```text Yazmaç dosyası ↓ ALU ↓ Yazmaç dosyası ``` veri yolu ile kontrol biriminden oluşur. Akümülatör tabanlı tasarım tek ana çalışma yazmacına ağırlık verir. Genel amaçlı yazmaç organizasyonunda birden çok yazmaç işlem operandı olarak kullanılabilir. ### Genel amaçlı yazmaç organizasyonu Birden çok yazmaç: ```text R0 R1 R2 ... Rn ``` bir yazmaç dosyası oluşturabilir. İki kaynak ve bir hedef kullanan işlem: ```text R5 <- R2 + R3 ``` için: - `R2` A girişine, - `R3` B girişine, - ALU `ADD` işlemine, - sonuç `R5` yazma girişine seçilir. ### Kontrol sözcüğü Basit genel yazmaç organizasyonunda kontrol sözcüğü: ```text SELA SELB SELD OPR ``` alanlarından oluşabilir. Burada: - `SELA`: ilk kaynak yazmacı, - `SELB`: ikinci kaynak yazmacı, - `SELD`: hedef yazmacı, - `OPR`: ALU/kaydırma işlemini seçer. Bu düşünce modern işlemcideki register specifier ve function alanlarının donanımsal karşılığıdır. ### Yazmaç dosyası Modern register file genellikle: - birden çok okuma portu, - bir veya daha fazla yazma portu içerebilir. İki kaynaklı bir ALU komutu için iki okuma portu doğal bir düzenlemedir. Daha fazla port: - alan, - güç, - gecikme maliyetini artırır. ### Yığın organizasyonu Stack son giren ilk çıkar davranışına sahiptir: ```text LIFO ``` Temel işlemler: ```text PUSH POP ``` Yığının tepesini: ```text SP ``` yığın işaretçisi gösterir. Yığının büyüme yönü mimari sözleşmeye göre artan veya azalan adresler olabilir. ### PUSH Azalan adresli yığında örnek: ```text SP <- SP - 1 M[SP] <- R ``` ### POP ```text R <- M[SP] SP <- SP + 1 ``` Gerçek sıralama ISA'ya göre değişebilir. ### Yığın ve alt program Yığın: - dönüş adresleri, - yerel değişkenler, - kaydedilen yazmaçlar, - bazı parametreler için kullanılabilir. Fonksiyon çağrısında oluşan düzen **stack frame** olarak adlandırılır. ### Son ekli gösterim Postfix, ters Polonyalı gösterimde işleç operandlardan sonra gelir. Örnek: ```text A B + C * ``` ifadesi: ```text (A + B) * C ``` anlamına gelir. Stack makinesinde: ```text PUSH A PUSH B ADD PUSH C MUL ``` ile doğal biçimde değerlendirilebilir. ### Komut biçimleri Komut biçimi şu alanlardan bazılarını içerebilir: - opcode, - kaynak yazmaç, - hedef yazmaç, - immediate değer, - adresleme modu, - displacement. Komut genişliği: - sabit, - değişken olabilir. RISC-V temel komut kümeleri sabit 32 bit komut biçimlerini yoğun kullanırken sıkıştırılmış uzantılar daha kısa komutlar ekleyebilir. x86 değişken uzunluklu komut biçimi kullanır. ### Üç adresli komut ```text ADD R1, R2, R3 ``` kavramsal olarak: ```text R1 <- R2 + R3 ``` anlamına gelebilir. Kaynak operandlar korunur. ### İki adresli komut ```text ADD R1, R2 ``` tasarıma göre: ```text R1 <- R1 + R2 ``` anlamına gelebilir. Bir operand aynı zamanda hedeftir. ### Tek adresli komut Akümülatör mimarisinde: ```text ADD X ``` genellikle: ```text AC <- AC + M[X] ``` olarak yorumlanır. ### Sıfır adresli komut Stack mimarisinde operand adresleri açıkça belirtilmeyebilir: ```text ADD ``` yığının tepesindeki iki operandı alıp sonucu tekrar yığına koyabilir. ### Adresleme modu Adresleme modu operandın nasıl bulunacağını tanımlar. Temel kavram: ```text EA = effective address ``` yani efektif adrestir. ### Örtük adresleme Operand komutun anlamından çıkarılır. Örneğin: ```text CMA ``` gibi akümülatör komutunda operand açıkça yazılmayabilir. ### Immediate adresleme Operand komutun içindedir: ```text LOAD R1, #5 ``` Burada bellekten operand okumaya gerek yoktur. ### Doğrudan adresleme ```text EA = A ``` Komutun adres alanı operandın adresidir. ### Dolaylı adresleme ```text EA = M[A] ``` Komuttaki alan doğrudan operandı değil, operand adresinin bulunduğu konumu gösterir. ### Yazmaç adresleme Operand doğrudan yazmaçtadır: ```text ADD R1, R2 ``` Bellek erişimi gerektirmez. ### Yazmaç dolaylı adresleme Yazmaç bellek adresini taşır: ```text LOAD R1, [R2] ``` kavramsal olarak: ```text R1 <- M[R2] ``` ### Otomatik artırmalı adresleme Kavramsal olarak: ```text R1 <- M[R2] R2 <- R2 + d ``` işlemlerini birleştirir. Dizi veya ardışık veri dolaşımında yararlı olabilir. ### İndeksli adresleme ```text EA = base_address + index ``` şeklindedir. Dizi elemanlarına erişimde kullanılır. Gerçek işlemcilerde index ayrıca eleman boyutuna göre ölçeklenebilir. ### Baz adresleme ```text EA = base_register + displacement ``` işlemi özellikle: - stack frame, - nesne alanı, - veri yapısı, - bellek bölgesi erişimlerinde yararlıdır. ### PC-relative adresleme ```text EA = PC + displacement ``` şeklindedir. Özellikle: - dallanma, - konumdan bağımsız kod için önemlidir. ### Efektif adres hesabı Güncel ISA'larda bir bellek operandı: ```text base + index*scale + displacement ``` gibi daha zengin adres hesaplarını destekleyebilir. Adresleme modu, yalnız sözdizim özelliği değil veri yolu ve adres üretme donanımının da parçasıdır. ### Program kontrol komutları Program akışını değiştiren komutlar: - koşulsuz dallanma, - koşullu dallanma, - call, - return, - trap/system call, - exception return gibi sınıflara ayrılabilir. ### Durum bayrakları ALU işlemi sonucunda: - zero, - carry, - sign/negative, - overflow gibi durumlar üretilebilir. Bazı ISA'lar genel amaçlı aritmetik için merkezi flags register kullanır. Bazıları karşılaştırma ve dallanmayı farklı biçimde gerçekleştirir. ### RISC yaklaşımı Reduced Instruction Set Computer yaklaşımının temel düşünceleri tarihsel olarak: - basit ve düzenli komut biçimleri, - çok sayıda genel amaçlı yazmaç, - load/store veri erişimi, - pipeline'a uygun yürütme etrafında şekillenmiştir. Modern RISC-V ve Arm mimarileri bu düşüncenin güncel örnekleridir. ### CISC yaklaşımı Complex Instruction Set Computer olarak sınıflandırılan mimariler: - daha zengin komut biçimleri, - değişken uzunluklu kodlama, - karmaşık adresleme ve işlemler içerebilir. x86 bu sınıflandırmanın temel güncel örneğidir. ### RISC ve CISC ayrımının sınırı Güncel mikro mimarilerde RISC/CISC ayrımı tek başına iç donanım karmaşıklığını açıklamaz. Örneğin x86 işlemciler karmaşık mimari komutları iç mikroişlemlere dönüştürebilir. RISC işlemciler de: - out-of-order yürütme, - spekülasyon, - büyük önbellekler, - gelişmiş branch prediction, - vektör birimleri gibi son derece karmaşık mikro mimari teknikler kullanabilir. Bu nedenle RISC/CISC esas olarak ISA tasarım geleneğini açıklayan bir çerçeve olarak düşünülmelidir. ## Ünite 9: Organizasyondan Modern Mikro Mimariye ### Temel modelin güncel karşılığı Dersin temel bilgisayar modeli: ```text PC IR registers ALU memory control ``` bileşenlerini açık biçimde gösterir. Modern işlemci aynı temel kavramları daha fazla paralellik ve ara yapı ile genişletir: ```text Fetch ↓ Decode ↓ Rename ↓ Schedule ↓ Execute ↓ Memory ↓ Retire ``` Bu aşamaların tümü her işlemcide bulunmak zorunda değildir. Ancak güncel yüksek performanslı çekirdeklerde yaygındır. ### Pipeline Pipeline farklı komutların farklı aşamalarını aynı anda çalıştırır. Basit beş aşamalı model: ```text IF komutu getir ID çöz EX yürüt MEM bellek WB geri yaz ``` İdeal durumda pipeline komut gecikmesini değil, komut başına ortalama tamamlanma hızını artırır. ### Veri tehlikesi Bir komut önceki komutun sonucuna ihtiyaç duyarsa veri bağımlılığı oluşur. Örnek: ```text ADD R1, R2, R3 SUB R4, R1, R5 ``` İkinci komut `R1` sonucunu bekler. Basit çözüm: - stall. Daha iyi çözüm: - forwarding/bypassing. ### Kontrol tehlikesi Dallanma komutunda sonraki PC henüz kesin bilinmeyebilir. Çözümler: - pipeline bekletme, - erken branch çözümü, - branch prediction, - speculative execution. ### Yapısal tehlike Aynı donanım kaynağına aynı anda birden fazla aşama ihtiyaç duyarsa structural hazard oluşur. Çözüm: - kaynak çoğaltma, - port artırma, - zamanlama. ### Out-of-order yürütme Komutlar program sırasından farklı bir fiziksel sırada yürütülebilir. Ama mimari sonuç: ```text program sırası ``` ile tutarlı görünmelidir. Bu amaçla: - register renaming, - reservation stations/scheduler, - reorder buffer benzeri yapılar kullanılabilir. ### Yazmaç yeniden adlandırma WAR ve WAW gibi isim bağımlılıklarını fiziksel yazmaçlarla ortadan kaldırır. Mimari yazmaç: ```text R1 ``` farklı zamanlarda farklı fiziksel yazmaçlara eşlenebilir. ### Önbellek hiyerarşisi İşlemci ile DRAM arasındaki gecikme farkı önbelleklerle azaltılır. Tipik yapı: ```text L1 ↓ L2 ↓ L3 ↓ DRAM ``` Bütün işlemciler aynı seviye düzenini kullanmak zorunda değildir. Temel ilke yerelliktir. **Zamansal yerellik:** Yakın zamanda kullanılan verinin tekrar kullanılma olasılığı. **Mekansal yerellik:** Bir adrese yakın verinin yakında kullanılma olasılığı. ### Sanal bellek CPU'nun ürettiği sanal adres: ```text MMU ↓ fiziksel adres ``` dönüşümünden geçebilir. TLB yakın zamanda kullanılan adres çevirilerini önbelleğe alır. Sanal bellek: - süreç izolasyonu, - koruma, - esnek adres uzayı sağlar. ### ISA ile mikro mimari ayrımı ISA programcıya görünen sözleşmedir. Mikro mimari bu sözleşmeyi gerçekleştiren donanımdır. Örneğin iki işlemci: - aynı ISA'yı çalıştırabilir, - aynı programı çalıştırabilir, - farklı pipeline, - farklı cache, - farklı yürütme birimleri kullanabilir. Bu ayrım bilgisayar organizasyonunun en önemli kavramsal sonuçlarından biridir. ## Genel Çerçeve Bilgisayar organizasyonu, lojik kapıdan makine komutuna kadar kesintisiz bir soyutlama zinciridir. ```text Transistor ↓ Lojik kapı ↓ Birleşimsel / ardışıl devre ↓ Yazmaç, MUX, decoder, ALU ↓ Veri yolu ↓ Mikroişlem ↓ Kontrol birimi ↓ Komut çevrimi ↓ ISA ↓ Assembly ↓ Program ``` Alt düzeyde fiziksel devreler bulunur. Üst düzeyde programcı komut kümesini görür. İki düzey arasında bilgisayar organizasyonu yer alır. Bir: ```text ADD R1, R2, R3 ``` komutu programcı açısından tek işlemdir. Donanım açısından ise: ```text R2'yi oku R3'ü oku ALU'ya uygula ADD işlevini seç durum işaretlerini üret sonucu R1'e yaz ``` gibi birçok kontrol ve veri yolu işleminin birleşimidir. Temel bilgisayar modeli bu dönüşümü görünür hale getirir. ## Bu Çalışmaya Atıf Köker, M. A. (2013). Bilgisayar Organizasyonu ve Temel İşlemci Yapısı. alikoker.com.tr. https://alikoker.com.tr/bilgisayar-organizasyonu-ve-temel-islemci-yapisi - BibTeX: https://alikoker.com.tr/bilgisayar-organizasyonu-ve-temel-islemci-yapisi.bib - RIS: https://alikoker.com.tr/bilgisayar-organizasyonu-ve-temel-islemci-yapisi.ris - CSL-JSON: https://alikoker.com.tr/bilgisayar-organizasyonu-ve-temel-islemci-yapisi.csl.json