caf İşlemci - mcu turkey · web viewİlerleyen bölümlerde caf İşlemci tasarımı ve mimarisi...

CITIUS-ALTIUS-FORTIUSİŞLEMCİ

PROJE SORUMLUSU : BERKAY AYBAR MURAT GOKSEL

E-MAIL : [email protected], [email protected]

1

1

2

34

5

6

8

91011121314151617

2

mailto:[email protected]

CAF İşlemci

İÇİNDEKİLER

CAF İşlemci Proje Özeti........................................................................................................31 GİRİŞ....................................................................................................................................4

1.1 FPGA .....................................................................................................................51.2 RISC İşlemci ......................................................................................................... 61.3 EDA Yazılımları ..................................................................................................... 7

2 FPGA ile Fiziksel İşlemci Tasarımı Uygulaması................................................................. 92.1 RISC Komut Seti Mimarisi..................................................................................... 102.2 RISC İşlemci Mimarisi ...........................................................................................122.3 RISC İşlemci Verilog Uygulaması.......................................................................... 13

2.3.1 Komut Yakalama Birimi....................................................................... 142.3.2 Komut Çözümleme Birimi.................................................................... 152.3.3 Çalışma Ünitesi.................................................................................... 162.3.4 Hafıza Birimleri.................................................................................... 17

3 16-bitlik Ardisil Duzen Uygulamasi........................................................................................ 193.1 Ardisil Duzen Tehlikeleri.............................................................................................19

4 Islemci Simulasyonu ve Testbench.........................................................................................205 Sonuç................................................................................................................................

Referanslar.......................................................................................................................

Appendiks............................................................................................................................24A. Komut

Açıklamaları...........................................................................................................24B. CAF İşlemci Verilog Kodu................................................................................................28C. CAF İşlemci Testbench Verilog Kodu...............................................................................29

Sanal İşlemci Tasarımı 2

3

4

1820

21222324252627282930313233343536373839404142434445464748495051525354555657

567

CAF İşlemci

CAF İŞLEMCİ PROJE ÖZETİ

Bu proje kapsamında verilen komut setinin tasarımda öncelikli olarak en verimli şekilde gerçeklenmesi öngörülmüştür. Tasarımı zenginleştirmek için verilen komut setine ek olarak güncel işlemcilerde kullanılan yaygın komutlar da eklenecektir(örn: POP, PUSH… ). Tasarım 16-bitlik pipelined RISC mimarisi gerçekleştirilerek uygulanacaktır. CAF_İşlemci tasarımının dört farklı bölümden oluşması öngörülmüştür, bunlar sırasıyla;

1) Komut Yakalama Bölümü (Instruction Fetch Stage)2) Komut Cözümleme Bölümü (Instruction Decoding Stage)3) Çalışma Bölümü (Execution Stage)4) Geri Okuma Bölümü( Write Back Stage)

Her bölüm bir veya birden fazla verilog modülünden oluşacaktır.Projenin iki fazdan oluşturulması öngörülmüştür. Birinci faz verilen komut kümesinin ve buna ek olarak güncel komutların kullanılacağı 16-bitlik RISC işlemci tasarımıdır. İkinci fazda ek olarak IEEE 754 Floating Point Ünitesinin de donanıma entegre edilip komut kümesini zenginleştirmek aynı zamanda tasarlanacak işlemcinin işlem yapabilme gücünü artırmak olarak hedeflenmiştir. Proje kapsamında tasarlanacak işlemci ile örnek bir FIR filtre uygulaması yapılması planlanmaktadır.Proje kapsamında özellikle fonksiyonel simülasyonları ve post-synthesis simülasyonlarını gerçekleştirmek için gerekli olan EDA yazılımları ve bir geliştirme boardi talep edilmektedir. ‘C’, ‘A’, ‘F’ harfleri latince Citius- Altius- Fortius kelimelerinin baş harflerinden gelmektedir. Latincede bu kelimeler sırasıyla “Daha hızlı, Daha Yüksek, Daha Güçlü” anlamına gelmektedir. Tasarlanacak işlemcinin de bütün bu özellikleri sağlaması hedeflendiği için bu isim proje için uygun görülmüştür.


8

958

5960616263646566676869707172737475767778798081828384

101112

1 GİRİŞ

1.1 FPGABu projenin amacı FPGA içerisinde 16 bitlik RISC işlemci tasarlamak ve bu işlemciyi kullanarak bir uygulama gerçekleştirmektir. Bu proje raporu ileride eğitim amaçlı kullanılacağı düşünülerek sayısal tasarım ve FPGA teknolojisi hakkında genel bilgiler de içermektedir.

FPGA teknolojisi sayısal tasarımcılara çok büyük esneklik sağlamaktadır.Bunun en büyük sebeplerinden biri FPGA’ in tekrar programlanabilme ozelligi olmasidir. Ayni zamanda FPGA’ ların kısmen düşük fiyatlı olması ve FPGA şirketlerinin(Xilinx, Altera, Actel gibi...) sağladıkları gelişmiş yazılım araçları sayısal tasarımla uğraşan donanım mühendislerinin hayatını kolaylaştırır.

FPGA ile yeni çalışmaya başlayan genç mühendisler genellikle FPGA yı farklı bir tür mikroişlemci zannederler. Fakat FPGA kullanım amacı ile mikroişlemcinin kullanım amacı çogu zaman birbirlerinden çok farklıdır. FPGA in iki farklı kullanım alanı vardır bunlardan ilki ASIC prototip gerçeklemesidir. ASIC tasarımcıları yaptıkları tasarımları bilgisayar üzerinde yaptıkları simülasyonlardan sonra FPGA üzerine taşırlar. Çünkü FPGA üzerine taşınan bir tasarım gerçek zamanda fonksiyonellik gösterir . Tasarımcı kendisinden istenen tasarımın kriterleri gerçekleşip gerçekleşmediğini bu evrede test etme şansı bulur. Tasarım mühendisleri için tasarımlarının kriterleri oluşturup oluşturmadığını görmelerini sağlayan önemli bir fırsattır. Bundan sonraki adım tasarımın ASIC(Chip) in fabrikasyonu için prosese gönderilmesidir. FPGA başka bir kullanım alanı ise düşük hacimde sistem üretimlerinde ASIC ye bir alternatiftir. ASIC üretimi çok maliyetli bir iş olduğu için ancak yüksek hacimde üretim yapıldığı zaman ASIC in birim fiyatı makul bir değere ulaşır. Ama eğer yüksek hacimli bir üretim yapılmayacaksa ASIC üretimi çok pahalı olabilir. Bu noktada FPGA boşluğu doldurur, tasarımcılara hem fiyat hem de tasarım kolaylığı açısından çok fazla avantaj sağlar. Tasarlanacak olan spesifik devre FPGA içinde gerçekleştirilir ve sistem içinde çalıştırılır.


13

85

86878889

9091929394

9596979899100101102103104105106107108109

110

111

112113114115116

1415

1.2 RISC İşlemciBu projede yer alan işlemci mimarisi RISC işlemci mimarisidir. RISC (Reduced Instruction Set Computer )”Komut Seti Azaltılmış Bilgisayar” anlamına gelmektedir. Komut setinin azaltılması, çoğu zaman işlemcinin komut kümesindeki kompleks komutların çıkartılması ile gerçekleşir. Bu, RISC işlemci mimarisini daha az kompleks yapar. RISC işlemcilerde asıl amaç tasarlanan komut kümesini basit yapmak ve bunun sonucunda komutları hızlı işleyen bir işlemci elde etmektir. RISC işlemcilerde komutların işlenmesi bir saat çevrimi sürer ve komutların uzunluğu sabittir.

RISC işlemci mimarisi bir başka işlemci mimarisi olan CISC(Complex Instruction Set Computer) mimarisine alternatif olarak tasarlanmıştır. Günümüzde kullanılan bir çok kişisel bilgisayar CISC mimarisi içerir. 1970lerin başında ilk mikroişlemci tasarlandığında hafıza birimleri pahalı olduğundan komutları mümkün olduğu kadar kompleks tasarlayıp oluşturulacak programların hafızada daha az yer kaplaması amaçlanmıştır. O dönemde hafıza birimleri maliyetli olduğu için işlemci tasarımcılarını bu yola yöneltmiştir. Hafıza maliyetlerinin düşmesi, tasarımcıları RISC işlemci mimarisine geri yöneltmiştir.

RISC ve CISC komut setleri arasındaki ilişkiyi güzel bir analoji yaparak açıklamaya çalışalım. Örneğin Latin alfabesi kullanılarak yazılmış bir kitabın toplam sayfa sayısı ile aynı kitabın Çince yazılmış versiyonu aynı sayıda değildir. Çince yazılan kitap çok daha az sayfadan oluşur bunun sebebi Çin alfabesinde 4000 den fazla farklı sembolün oluşudur. Semboller çok spesifik anlamlar içerebilirler, fakat bunun sonucunda çok kompleks ve öğrenilmesi çok zordur. Latin alfabesinde ise sadece 23 farklı sembol vardır. Bununla beraber ayni kitap çok daha fazla sayfa içermektedir. RISC İşlemci ve CISC İşlemci komut seti arasındaki fark da buna çok benzerdir. RISC islemci komutlari CISC islemciye gore cok daha basittir fakat CISC İşlemcilerini çözümlemek çok daha karışık ve zordur.

Genel RISC mimarisi dört bölümden oluşmuştur. Bunlar sırasıyla

1. Komut Yakalama Evresi(Instruction Fetch Stage)

2. Komut Çözümleme Evresi(Instruction Decode Stage)

3. Komut Çalıştırma Evresi (Instruction Execution Stage)

4. Geri Yazma Evresi(Write Back)

İlerleyen bölümlerde CAF İşlemci tasarımı ve mimarisi ile ilgili daha detaylı bilgi verilecektir.


16

117

118119120121122123124

125126127128129130131

132133134135136137138139140

141

142

143

144

145

146

147

148

1718

1.3 EDA YazılımlarıBu bölümde CAF İşlemcinin tasarımı sırasında kullanılan yazılım araçlarına ve bu araçlardan simülasyon yazılımına nasıl geçildiği anlatılmıştır.

FPGA şirketleri, donanım mühendislerinin işini kolaylaştırmak için çok güçlü yazılım araçları tasarlamıştır. Bu yüzden FPGA teknolojisi son 20 yılda çok hızlı bir gelişme süreci göstermiştir. Her FPGA üretici firmanın kendi FPGA çiplerini programlamak amacıyla geliştirdiği yazılım araçları vardır. Örneğin, Xilinx FPGA lar Xilinx-ISE yazılımıyla programlanır. Altera Quartus yazılımı kullanarak FPGA larını konfigure eder. Yine bir başka FPGA şirketi Actel, kendi oluşturduğu Libero yazılımını kullanır.

CAF İşlemci tasarımında hedef uygulama aracı Xilinx Spartan3 FPGA olduğundan sentez yazılım aracı olarak Xilinx ISE kullanılmıştır. Xilinx ISE yazılımı, Xilinx in internet sitesinden veya aşağıdaki linkten indirilebilir. (www.xilinx.com/ise/logic_design_prod/webpack.htm) .

CAF İşlemci projesinde sanal İşlemci tasarımı için kullanılan simülasyon aracı ModelSim6.3 dur. Modelsim6.3 yazılımı yine Xilinx’in internet sitesinden indirilebilir.


19

149

150151152

153154155156157158

159160161

162163

164

2021

Figure1.1 Xilinx ISE 9.2 Tasarım Özeti Sayfası

Yukarıdaki Figür 1.1 Xilinx-ISE ‘nin tasarım özeti bölümünden alınmıştır. Tasarım özeti, tasarlanan hdl kodunun hedeflenen FPGA için de ne kadar donanım kullanıldığını özetleyen bir bölümdür. Burada asıl gösterilmek istenen Xilinx ISE de tasarlanan bir HDL kodun Modelsim simülasyon aracı kullanılarak nasıl test edildiğidir. Xilinx ISE yazılımı kendi simülasyon aracına sahiptir (ISE-Simulator) fakat çoğu zaman bu simülasyon aracı tercih edilmez. Xilinx kendi sistemi için de MentorGraphics firmasının ürettiği simülasyon programı olan Modelsimi kullanmaya olanak kılar. Eğer yeni bir proje başlatılıyorsa karşınıza çıkan “New Project Wizard-Device Properties” penceresinde Simülator kısmından Modelsim yazılımı kullanılacak simülatör olarak seçilebilir. Modelsim SE (Starter) yazılımına Xilinx in web sitesinden de ulaşılabilir.

Figür 1.2 Xilinx ISE Araç Özellikleri Penceresi(Device Properties)


22

165

166167168169170171172173174

175

176

177

178

179

180

181

2324

2 FPGA ile Fiziksel İşlemci Uygulaması

2.1 Komut Seti MimarisiGenel olarak RISC İşlemcilerde basit ve tekdüze bir komut formatı kullanılır. RISC İşlemcilerde çok fazla komut formatı olmaması komut çözümlemesini önemli ölçüde kolaylaştırır. CAF İşlemci komut mimarisi de 33 komuttan oluşmuştur. İleride ek komutların mimariye eklenmesi planlanmıştır. Genel RISC İşlemci mimarisinde iki veya üç farklı adresleme tekniği kullanılır ve en genel adresleme teknikleri “acil(Immediate)”, “direct” ve “indexed” dir. CAF İşlemci komut setinde de ayni şekilde üç farklı adresleme tekniği kullanılmıştır. Diğer gerekli adresleme modları bu temel adresleme modlarından elde edilebilir.

CAF İşlemcisindeki komutları fonksiyonelliklerine göre gruplandırıldığında dört farklı gruba ayrılır.

1. Branş(Dallanma) Komutları (Branch Instructions)2. Veri İşleme Komutları (Data Processing Instructions)3. Yükleme ve Depolama Komutları (Load & Store Instructions)4. Kesme ve Diğer Komutlar (Interrupt)

Branş Komutları: CAF İşlemcide üç çeşit Branş komutu vardır bunlar koşulsuz(Branch Always),koşullu(Branch Equal, Branch Not Equal) ve altprogramlardır(Branc&Link). Branş komutları program sayacının içeriğini değiştirerek hafıza içerisinde farklı bir bölgeye yönlendirirler. Koşullu branş komutlarında programı yönlendirmek için koşulun sağlanması gerekir. Koşul sağlanırsa program sayacı ana-rutinden çıkar ve altprogramın komutlarını İşlemeye başlar. CAF İşlemcide koşulsuz branş komutu program sayacını 1Kbyte ileri veya geri götürebilirler. Koşullu branş komutu ise ancak 256 byte ileri veya geri götürebilir.


25

182

183

184

185

186

187

188

189

190191192193194195196197198199200201202203204205206207208209210211212213214215216217

2627

Veri İşleme Komutları: CAF İşlemci de toplama, çıkarma, ve çarpma gibi aritmetik işlemleri yapan komutların yani sıra ayini zamanda VE, VEYA, mantıksal işlem yapan komutlarda yer almaktadır.

Yükleme ve Depolama Komutları: CAF İşlemci de YÜKLEME(LOAD) ve DEPOLAMA (STORE) komutları İşlemcinin dışındaki hafıza birimi ile arayüz sağlayarak, hafıza birimindeki verilere İşlemcinin ulaşmasını veya İşlemcinin hafızaya veri yazmasını sağlar.

CAF_İşlemci Komut KümesiKomut Sembol OPKOD Ornek AnlamToplama ADD 00 0001 Ra +Rb ->Rc

Toplama Acil(Immediate)

ADDi 00 0010 Ra + Imm -> Rc

Çıkarma SUB 00 0011 Ra- Rb -> RcÇıkarma

Acil(Immediate)SUBi 00 0100 Ra – Imm ->

RcÇarpma MUL 00 0101 Ra * Rb ->RcÇarpma

Acil(Immediate)MULi 00 0111 Ra * Imm->Rc

Çarpma İşaretsiz

MULu 00 0110 Ra*Rb->Rc

Kıyaslama CMP 00 1000 Ra >RbVe AND 00 1001 Ra & Rb ->RcVe

Acil(Immediate)ANDi 0 010 Ra & Imm->Rc

Veya OR 00 1011 Ra ||Rb ->RcVeya

Acil(Immediate)Ori 0 100 Ra ||Imm->Rc

Not NOT 00 1111 0 – Ra -> RcXor XOR 00 1101 Ra ^Rb ->RcXor

Acil(Immediate)XORi 00 1110 Ra ^Imm->Rc

Mantıksal sola kaydırma

SLL 01 0000 Ra<<[Rb]->Rc

Mantıksal sağa kaydırma

SRL 01 0001 Ra>>[Rb]->Rc

Aritmetik sola kaydırma

SLA 01 0010 Ra<<[Rb]->Rc

Aritmetik sağa SRA 01 0011 Ra>>[Rb]->Rc


28

218219

220221222

223224225226

2930

kaydırmaKelime Yükleme LW 01 0100 MEM[Ra]-

>KMT[Rc]Kelime

DepolamaSW 01 0101 [Rc] -> MEM[Ra]

TaşımaAcil(Immediate)(en düşük 8 bit)

MOVli 01 0110 8-bit Imm ->KMT[03][7:0]

Taşıma Acil(Immediat

e)(en yüksek 8

bit)

MOVui 01 0111 8-bit Imm -> KMT[0-3][15:8]

Taşıma Immidiate(en düşük 8 bit,KMT[4], KMT[7]).

hMOVli 010111 8-bit Imm-> KMT[4-7][7:0]

Taşıma Immidiate(en yüksek 8 bit,KMT[4], KMT[7]).

hMOVui 011001 8-bit Imm-> KMT[4-7][15:8]

Taşıma MOV 011010 Ra ->KMT[Rc]Koşul(Eğer ‘0’ a eşit ise)

Beq 01 1011 Eğer(Kosul =0)İse program sayiçin a yeni bir değer ver.

Koşul (Eğer ‘0’ eşit değil ise)

Bne 01 1100 Eğer(Kosul !=0)İse program sayiçin a yeni bir değer ver.

Koşul her zaman

Ba 01 1101 Koşula bakmadanProgram sayacını değiştir.

Koşul ve bağlama

BL 100000

İşlem yok Nop 00 0000Dur Halt 01 1110

Kesme Syscall 01 1111Ek Komutlar


31

3233

2.2 RISC İşlemci MimarisiRISC İşlemcilerin komut setinin basit ve kısa olması mimarinin de daha az kompleks olmasında büyük bir etkendir. RISC mimarisinin bir başka özelliği, “yükleme(load)” ve “depolama(store)” komutlarının dışındaki tüm komutlar veriyi İşlemci içerisindeki yazıcılardan okur veya yazarlar. Sadece “yükleme(load)” ve “depolama(store)” komutları dışarıdaki hafıza birimiyle arayüz sağlar. İşlemcinin içindeki genel amacli yazıcılar(register) dışarıdaki hafıza birimlerinden(ana hafıza veya cache hafıza) çok daha hızlı olduğundan komutların çok daha hızlı ve efektif çalıştırılması mümkün olur.

Genel RISC İşlemci mimarisinde “yazıcı dosyaları(register file)” denilen yazıcı kümesi bulunur. Yazıcılar işlemci içerisinde geçici olarak sayısal veri depolamasında kullanılır. RISC İşlemci mimarisinde çok sayıda genel amaçlı yazıcı bulunduğundan komut işleme sırasında gerekli olan veriler burada saklanabilir. Bu da ana hafıza birimine olan bağımlılığı azaltır ve İşlemcinin performansını arttırır. Bilindiği gibi İşlemcinin dışında bulunan hafıza birimine ulaşmak, içerdeki yazıcılara ulaşmaktan çok daha fazla zaman alır.

Yazıcı dosyaları aynı zamanda hızlı ve efektif altprogram çalıştırılması için de kullanılır. Genel RISC İşlemci mimarisinde herhangi bir zamanda anarutin komut sırasında giderken yazıcı dosyalarının belli bir kısmına ulaşılabilir. Örneğin CAF İşlemcide 16 tane 16-bitlik genel amaçlı yazıcı dosyası bulunur fakat bunlardan sadece ilk 8 tanesine ulaşılabilir. Bir altprogram çağrıldığı zaman altprogramın geri kalan 8 yazıcıya ulaşma hakkı vardır. Böylece altprogram çağrıldığı zaman anarutindeki veriler yazıcılarda tutulur.


34

227228

229230231232233234235236

237238239240241242243244245246247248249

250

3536

2.3 RISC İşlemci Verilog Uygulaması

2.3.1 Komut Yakalama Evresi(Instruction Fetch Unit)Komut yakalama evresi CAF RISC İşlemcinin ilk evresini oluşturur. Bu bölüm komut belleğinden 16-bitlik komutları her saat vuruşunda alır ve komut yazıcısına atar(KY_prg_syc). Komut, hafızada program sayacının gösterdiği yerden alınır, başka bir deyişle komut belleğin adresi İşlemcinin içinde bulunan program sayacından çıkar. Program sayacı komut hafıza biriminin adres bilgisini tutar ve komutlar işlendikçe içeriğini artırır. Her komut 2byte olduğu için program sayacı da bir artırılır. Hafızadan komut okunması için “komut_oku” sinyali de sıfıra çekilir. Bir sonraki saat çevriminde hafızadan alınan bir başka komut, KY_prg_syc yazıcısına depolanır. Her komut KY_prg_syc yazıcısında bir saat vuruşu kalır. Komut yakalama evresi her saat çevriminde bu operasyonu yeni komutlar için gerçekleştirir. Böylece komut adresi bir sonraki komut için hazırlanırken aynı zamanda o anda gelen komut da KY_prg_syc yazıcısında depolanır.

Figur 2.1 Komut Yakalama Evresi

Eğer branş gelmediyse programı oluşturan komutlar sıralı bir şekilde çalışır. Eğer bir branş komutu gelirse ve branş için gerekli koşul sağlanırsa o zaman program sayıcısına branşın olduğu adres bilgisi yüklenir.

Eğer Dur(Hlt) komutu işlenirse bu durumda program sayacı artmayı durdurur ve tum yazıcılar o anda tuttukları verilerle kalırlar.

//Komut_Yakalama: Komut Yakalama Evresialways @ (posedge clk )begin


37

251252253254255256257258259260261262263264

265

266

267268269

270271

272273274

3839

if(~reset_n) begin PS <= 0; //program sayaci ilk kosulukomut_oku <= 1;KY_kmt_yzc <= 0;

end else begin if(branş_aktif)begin

PS <= branş_adres; KY_kmt_yzc <= komut;endelse if(KC_opkod == `HLT) begin PS <= PS;

KY_kmt_yzc <= KY_kmt_yzc;endelse begin komut_oku <= 0; PS <= PS + 1;

KY_kmt_yzc <= komut; // Komut Yakalama Komut Yazicisiend

endend // blok sonu

2.3.2 Komut Çözumleme EvresiKomut çözümleme evresinde KY_prg_syc yazicisinda depolanan komut çözümlenir ve genel amaçlı yazıcılarda (yazıcı dosyası ) bulunan veri, çalıştırma evresinde kullanılmak üzere komut çözücü yazıcılarına aktarılır. Yazıcı dosyalarında bulunan verilerin komut çözücü yazıcılarına aktarılmasının sebebi verilen komutun yazıcı dosyası içinden herhangi bir yazıcıdan veriyi aktarabilmesidir. Bu progamcıya esneklik sağlar. Asağıdaki verilog kodu komut çözümleyici evrenin kodunu göstermiştir. Verilog kodunda örnek olması için sadece “ADD” ve “ADDi” komutları çözümlenmiştir. Komut çözümleme evresinin nasıl çalıştığını daha iyi anlatmak için bir örnek verelim. Komut yakalama evresindeki komut yazıcısının “ADD” komutunu tuttuğunu düşünelim. Bu durumda KC_kmt_yzc[9:7] gösterdiği genel yazıcı ile KC_kmt_yzc[6:4] gösterdiği genel yazıcılardaki veriler sırasıyla KC_yzc_a ve KC_yzc_b ye aktarılır. Burda dikkat edilmesi gereken baska bir husus, toplama islemi icin gereken veriler sadece ilk 8 yazicidan alinip KC_yzc_a ve KC_yzc_b yazicilarina aktarilabilir. Fakat toplama işleminden çıkan sonuç KY_kmt_yzc gösterdiği genel amaçlı yazıcılarin tümüne aktarılabilir.

Always bloğu için de sadece “case statement” kullanılmıştır. Komut çözümleme evresinin tümü Apendiks B kısmında bulunabilir.


40

275276277278279280281282283284285286287288289290291292293294295

296297298299300301302303304305306307308309

310311

4142

Figür 2.2 Komut Çözümleme Evresi

//Komut_Cozucu Evresi always@(posedge clk) begin case(KY_kmt_yzc[15:10]) 6'b00_0001:begin KC_opkod <= `ADD; KC_yzc_b <= gnl_yzc[KY_prg_syc[8:6]]; KC_yzc_b <= gnl_yzc [KY_prg_syc[5:3]]; KC_gnl_yzc_adr <= KY_kmt_yzc[3:0]; 6'b00_0010:begin KC_opkod <= `ADDi; KC_yzc_a <= gnl_yzc [10:8]; KC_acil_ofset[7:0] <= KY_prg_syc[7:0]; . .

..

end caseend // always blok sonu


43

312

313

314

315316317318319320321322323324325326327328329330331332333334335336

4445

2.3.3 Çalıştırma Evresi(Execution Stage)Çalışma evresi, İşlemcinin ALU(Aritmetik Logic Unit) ya sahip olduğu bölümdur. Aritmetik, mantık, kaydırma ve branş islemleri bu bölümde gerçekleştirilir. Komut çözümleme evresinde bulunan KC_yzc_a, KC_yzc_b, KC_yzc_c yazıcılarında tutulan verilerle KC_opkod’un gösterdiği işlem gerçekleştirilip alu_yzc isimli yazıcıya aktarılır.

Çalışma evresi ayni zamanda bayrak operasyonlarının gerçekleştirildiği evredir. Bayraklar alu_yzc isimli yazıcıda tutulan veriye göre set veya reset edilir. Bayrak işlemleri çalışma evresinde olmasına rağmen operasyon ancak alu_yzc güncellendikten sonraki saat vuruşunda gerçekleşir.

Figur 2.3 Calisma Evresi

Çalışma evresinde olusturulan ALU devresi Xilinx ISE sentez programı için de sentezlendiğinden gerekli tüm donanım yazılım tarafından oluşturulmustur. Örnegin çarpma işlemi FPGA içerisinde bulunan 18x18 çarpma modülleriyle gerçekleştirilir. Tasarımcının çarpma işlemi gerçekleştirecek donanımı tanımlamasina gerek yoktur, cünkü sentezleme programı çarpma opereasyonunu görünce otomatik olarak FPGA içinde bulunan çarpmaları modüllerini kullanır. Sentez raporuna bakıldığında FPGA içinde ne kadar kaynak kullanıldığı görülebilir.

//Calisma Evresi...case(KC_opkod) //`NOP : alu_yzc <= alu_yzc;


46

337338339340341

342343344345

346347348349350351352353354355356357358359360361

4748

ÀDD : alu_yzc <= KC_yzc_a + KC_yzc_b;ÀDDi : alu_yzc <= KC_yzc_a + KC_acil_ofset;`SUB : alu_yzc <= KC_yzc_b - KC_yzc_c;`SUBi : alu_yzc <= KC_yzc_a - KC_acil_ofset;`MUL : alux_yzc <= KC_yzc_a * KC_yzc_b;`MULi : alux_yzc <= KC_yzc_a * KC_acil_ofset;`MULu : alux_yzc <= KC_yzc_a * KC_acil_ofset;`CMP : alu_yzc <= gnl_yzc[KY_kmt_yzc[5:3]] - gnl_yzc[KY_kmt_yzc[2:0]];ÀNDi : alu_yzc <= KC_yzc_a & KC_acil_ofset;ÀND : alu_yzc <= KC_yzc_a & KC_yzc_b;ÒRi : alu_yzc <= KC_yzc_a | KC_acil_ofset;ÒR : alu_yzc <= KC_yzc_a | KC_yzc_b;`XORi : alu_yzc <= KC_yzc_a ^ KC_acil_ofset;`XOR : alu_yzc <= KC_yzc_a ^ KC_yzc_b;`SLL : alu_yzc <= KC_yzc_b << KC_acil_ofset[3:0];`SRL : alu_yzc <= KC_yzc_b >> KC_acil_ofset[3:0];`SRA : alu_yzc <= KC_yzc_b >> KC_acil_ofset[3:0];`SLA : alu_yzc <= KC_yzc_b >> KC_acil_ofset[3:0];`NOT : alu_yzc <= 0 - KC_yzc_a;`LW : alu_yzc <= KC_yzc_a;`SW : alu_yzc <= KC_yzc_a;.................case(dis_opkod)//

ÀDD, `SUB, `CMP, `MUL : begindis_alu_yzc[15:0] <= alu_yzc[15:0];ksl_byrk <= alu_yzc[15];sfr_byrk <= (alu_yzc[15:0] == 0);//if(KC_acil_ofset[2:0] != 3'b000) beginelde_byrk <= alu_yzc[15];tasma_byrk <= (alu_yzc[15] != alu_yzc[15]);// end if;End.........

2.3.4 Geri Yazma Evresi (Write Back Stage)Geri yazma evresi İşlemcinin son evresidir ve çalışma evresinde işlenen veriler bu evrede genel amaçlı yazıcılara yazılır. Her komut geri yazma işlemi yapmaz. Bu tarz komutlar için bir işlem yapmaya gerek duyulmaz. Asağıda geri yazma evresinin blok diyagramı görülmektedir. Genel amaçlı yazıcılar içeriklerini


49

362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399

400401402403

5051

çoğu zaman alu_yzc isimli yazıcılardan alır. Bu yazıcıdan almadığı durumlarda yazıcılar veriyi “MOV” komutu ve türevlerinden alırlar.


52

404405

5354

Figur 2.4 geri Yazma Evresi

//Geri Yazma Evresi...case (dis_opkod)ÀDD, ÀDDi, `SUB, `SUBi, ÀND, ÀNDi, ÒR, ÒRi, `XOR, `XORi,`SLL, `SRL, `SRA, `SRL, `NOT : begin

gnl_yzc[dis_gnl_yzc_adr] <= alu_yzc;end

`MUL, `MULi, `MULu : begingnl_yzc[dis_gnl_yzc_adr] <= alux_yzc[15:0];gnl_yzc[dis_gnl_yzc_adr + 1] <= alux_yzc[31:16];

end`LW : gnl_yzc[dis_gnl_yzc_adr] <= veri_ic ;`MOVli : gnl_yzc[dis_gnl_yzc_adr] <= alu_yzc;`hMOVli : gnl_yzc[dis_gnl_yzc_adr] <= alu_yzc;`MOVui : gnl_yzc[dis_gnl_yzc_adr] <= alu_yzc;`hMOVui : gnl_yzc[dis_gnl_yzc_adr] <= alu_yzc;Endcase


55

406

407

408409

410411412413414415416417418419420421422423424425426427

428

5657

3.0 16-bitlik Ardisil Düzen(Pipeline) İşlemci Uygulaması

Ardisil düzen RISC İşlemcilerde uygulanan standart bir tekniktir. Kısaca, farklı komutların İşlemcinin farklı evrelerinde aynı anda çalıştırılmasıdır. Bu şekilde daha fazla komut daha kısa zamanda işlenir ve bu İşlemcinin genel performansını ve hızını arttırır. CAF İşlemci daha önceki bölümlerde de belirtildiği gibi dört farklı evreden oluşmuştur. Genel RISC mimarisine bakıldığında RISC İşlemciler dört evreden oluşurlar. Bu evreler sırasıyla komut yakalama, omut çözümleme, çalıstırma ve geri yazma evreleridir. İşlemci uygulamsında ardisil düzenden kaynaklanan bazı hatalar olabilir. Bu hatalar genellikle İşlemcinin komut düzenini tekrar düzenleyerek giderilebilir.

3.1 Ardisil Düzen TehlikeleriBazı koşullarda komut işlendikten sonra diğer komutların işlenmesi için gecikme işlemi yapılması gerekebilir. Bu gibi durumlar ardisil düzen tehlikesi olarak adlandırılır. Genel olarak üç çesit ardisil düzen tehlikesi vardır. Bunlar sırasıyla yapısal tehlike(structural hazard), verisel tehlike(data hazard) ve kontrol tehlikeleri (control hazards) olarak adlandırılır.

Yapısal tehlike farklı komutların aynı anda aynı donanımı(yaziciyi) kullanmak istemesinden kaynaklanir. Bu tarz tehlikeleri önlemek için İşlemci içerisine fazladan donanım konabilir.

Verisel tehlike ise bir komutun yazımı için değerini değiştirmesi ve bir sonraki komutun ayni yazıcıyı bir önceki değeri ile kullanması oluşur.

Son olarak kontrolsel tehlikeler koşullu ve koşulsuz branş komutlarından kaynaklanır. Branş komutları olmadığı sürece işlemci program sayacını bir artırarak bellekten komutları sırasıyla alır. Eğer branş komutları gelirse bu program sayacını farklı bir adres verisi ile yükler farklı bir komut sırasına gider bu arada branş komutundan sonra gelen komutlar İşlemci tarafindan yanlışlıkla yakalanır ve işlenir.

Ardisil düzen tehlikelerini önlemek genellikle derleyicinin işidir. Derleyici ardisil düzen hatalarını önlemek için İşlemcinin komutlarını belli bir sıraya göre ayarlar. CAF İşlemcide bu tarz hataları engellemek için komutlar arasına gecikme(NOP) komutu konmuştur.


58

429

430431432433434435436437

438439440441442

443444

445446

447448449450

451452453

454

455

456

457

458

459

5960

4 İşlemci Simülasyonu ve Testbench

İşlemci tasarımını simüle etmek diğer modüllere göre daha farklıdır çünkü İşlemciler dışardan gelen herhangi bir uyarı sinyaline ihtiyaç duymaz. Hafıza birimi, işlemci için gerekli GİRİŞ verisini sağlar. İşlemci komutları dışarda bulunan komut hafıza biriminden veriyi de veri hafıza biriminden alır. İşlemci sadece clk(saat) ve reset sinyalleriyle dışarıdan uyarılır.

CAF İşlemcinin simülasyonunda da aynı yöntem uygulanmıştır. Aşağıdaki blok diyagram İşlemci ve hafıza birimiyle olan arayüzü gösterir. Testbench için oluşturulan hafıza birimleri sadece test amaçlıdır.

Figur 4.1

Daha önceden bahsedildiği gibi bu projede kullanılan simülator programı Modelsim6.3 dur. Xilinx ISE üzerinden Modelsim yazılımını açmak için Sources penceresinden Behavioral Simulation seçilmelidir. (Genelde Xilinx ISE açıldıgı zaman Synthesis/Implementation olarak seçilidir). Bu değiştirildikten sonra Sources penceresinin altındaki Processes kısmında bulunan Simulate Behavioral Model çalıştırılmalıdır. (Bu işlem otomatik olarak Modelsim yazılımını açar)

Modelsim de bir sistemi simüle etmek için sistemi oluşturan tüm dosyaların Modelsim tarafından derlenmesi gerekir. Derlenen yeni dosya formatı simülatöre yüklenir ve simülasyon başlatılır. Derlenen dosyalar work ismi altında kullanıcı tarafından oluşturulan kütüphanelerde tutulur. Modelsim için de bu tarz manual işlemleri yapmak için scriptler kullanılabilir. CAF projesinde de Modelsim de simülasyon yapmak için ufak skriptler kullanılmıştır. Derlenen dosyaları tutmak için gerekli kütüphane VLIB komutu ile oluşturulur. (Örn: vsim work)


61

460461

462463464465

466467468

469

470

471472473474475476

477478479480481482

6263

Bu komut work kütüphanesini o anki direktörün altında oluşturur. Kütüphane oluşturulduktan sonra Verilog dosyaları derlenip hedef kütüphanede tutulabilir. Verilog dosyalarının derlenmesi için vlog(VHDL için vcom) komutu kullanılır.(Orn: vlog “caf_İşlemci”). Derlenen Verilog dosyalarını simülator de çalıştırmak için vsim komutu, sinyallerin gösterildiği pencereyi açmak için ise view wave komutları arka arkaya kullanılır. Sistem içinde görülmek istenen sinyalleri dalga ekranında görmek için add wave komutu kullanılır. (Orn: add wave –noupdate –color {yellow} /testbench/uut/clk) . Modelsim için de kullanılan komutlar detaylı olarak Modelsimin kullanıcı kılavuzunda bulunabilir.

Yazılan skriptlerin modelsim de çalıştırılması için modelsimdeki komut satırına do <skript_adi>.do yazılmalıdır. CAF İşlemcinin simülatorde çalıştırılması için runsim.do isimli skript yazılmıştır. Bu skript proje içinde yer alan iki dosyayı, testbench.v ve caf_İşlemci.v, derledikten sonra görülmek istenilen sinyalleri dalga ekranına oluşturur.

4.1 TestbenchTestbench dosyasının içerisinde oluşturulan komut hafıza birimi ve veri hafıza birimi İşlemcinin test edilmesi için gerekli ortamı oluşturur. Bunun için komut hafıza birimindeki hafıza birimine anlamlı komutlar yükleyerek İşlemci test edilmiştir. Asağida yazılı olan kod parçası testbenchden alınmıştır.

.......... İnitial begin

komut_bellegi[0] <= {`NOP}; //Movikomut_bellegi[1] <= {`MOVli, `yzc_i1, 8'hab};komut_bellegi[2] <= {`MOVli, `yzc_i2, 8'hcd};komut_bellegi[3] <= {`MOVli, `yzc_i3, 8'hef};komut_bellegi[4] <= {`NOP};komut_bellegi[5] <= {`ADD, `yzc_a1, `yzc_a2, `yzc_c15};komut_bellegi[6] <={`MOVli, `yzc_i0, 8'h03};komut_bellegi[7] <={`MOVui, `yzc_i1, 8'hDC};komut_bellegi[8] <={`hMOVui, `yzc_i2, 8'hBE};komut_bellegi[9] <={`hMOVli, `yzc_i3, 8'h04};komut_bellegi[10] <={`LW, 2'b00, `yzc_c2, `yzc_c12};komut_bellegi[11] <={`NOP};


64

483484485486487488489490

491492493494

495496497498499

500501502503504505506507508509510511512513514515

516

517

518

519

6566

4.2Sentezlenebilir Testbench CAF islemci projesinde FPGA icerisinde tasarlanan islemci modulunu test edebilmek icin sentezlenebilir bir testbench ortami olusturuldu. Bunun icin FPGA icerisine CAF modulunun yani sira UART modulu ve blok ram olusturuldu. Bu modullerin nasil calistigi bir sonraki bolumde aciklanicak fakat bundan once niye boyle bir yonteme basvuruldugunu aciklanmasi sart. Bilindigi uzere mikroislemciler genellikle programlama dilleri(C, C++) ile programlanir. C veya C++ da yazilan kod parcasi derleyici tarafindan makina koduna cevrilir ve mikroislemcinin bellek bolumune yuklenir ve mikroislemci bellekten aldigi komutlari gercekler. Bu proje kapsaminda CAF islemciye ozel bir derleyici olmadigi icin herhangi bir programlama dili kullanilip makina kodu cikartilamaz, (derleyici tasarimi tek basina bir proje konusu olabilir) bu durumda Kullanici kendi anlamli makina kodunu kendisi olusturur.

CAF islemci icin makina kodunda olusturulan kod iki sekilde calistirilabilir. Bunlardan ilki FPGA icinde olusturulan bellek birimine hdl tasariminda makina kodu hexadecimal olarak atanabilir, tipki simulasyon kisminda olusturuldugu gibi. Fakat boyle bir durumda ne zaman farkli bir kod yuklemek istesek hdl tasarimini degistirip FPGA yi tekrar yuklemek gerekir ki buda efektif bir yontem degildir. Ikinci yontem ise FPGA programlandiktan sonra FPGA icinde olusturulan bellek bloguna veri yazabilmekten gecer. Bunun icin FPGA bordu ile PC arasinda bir haberleseme kanalina ihtiyac vardir. Bu haberlesme kanali en FPGA bordlari icinde en yaygin seri haberlesme standardi olan RS-232 dir. Seri haberlesme kanalini kullanarak PC uzerinden


67

520

521

522523524525526527528529530531532

533534535536537538539540

6869

icerisine ulasilabilir. Bu sekilde FPGA icerisindeki bellek kismina hyperterminal ekranindan komut seti gonderilebilir veya CAF islemci farkli modlarda calistirilabilir.

Figur 4.1 Sentezlenebilir testbench sistemi

Yukardaki figur de sentezlenebilir testbench sistemi gorululyor. FPGA icerisine PC uzerinden ulasmak UART modulu sayesinde mumkun kiliniyor. CAF islemci icin gerekli bellek birimi FPGA icerisinde gomulu olarak bulunuyor.

4.2.1Dual Port Blok RAMFPGA icinde olusturulan blok RAM Xilinx in Core Generator yazilimi kullanilarak olusturulmustur. Olusturulan blok RAM FPGA icerisinde ki blok RAM i baslatir. Olusturulan Blok RAM dual port a sahiptir bunun sebebi ilk port komut bellek birimi icin ikinci port veri bellek birimi icin gerceklenmistir. Core Generator yazilimi farkli blok RAM ler olusturmaya imkan kilar ve istenilen bellek birimi farkli ozellikler katilarak istege bagli olarak uyarlanabilir. CAF islemci icin olusturulan blok RAM 16-bitlik veri genisligine ve 10 bitlik adres genisligine sahiptir.

Core Generator yaziliminin olusturdugu dosya proje klasorunun altina kayit edilmelidir. Olusturulan tum dosyalar proje klasorun altinda olmalidir.


70

541542

543544

545546547

548549550551552553554555

556557

7172

Figure 4.2 Core Generator

4.2.2 UART(Universal Asynchronous Receiver/Transmitter)

UART modulu koru www.opencores.com sitesinden alinmistir ve ust seviyede farkli bir modul olusturularak CAF islemci ile arayuzu saglanmistir. UART modulu 9600 baud rate de calistirilmasi icin ayarlanmistir. Asagida UART icin yapilmasi gereken konfigurasyon ayarlari gosterilmistir. PC uzerinden islemciyi control etmek icin dogru konfigurasyon kullanmak


73

558559560

561562563564565

566

7475

http://www.opencores.com/

Figure 4.4 UART konfigurasyonlari

4.3 Hyper-Terminal Ekranindan CAF Islemci Konfigurasyon AyarlariCAF islemci iki farkli calisma moduna sahiptir. Ilk calisma modu normal calisma modudur. Normal calisma modunda , CAF islemci program sayacinin gosterdigi yerden komutlari alir ve her saat vurusunda komutlari isler. CAF islemcinin ikinci calisma modu ise tek adim modudur. Farkli calisma modlarini hyperterminal uzerinden ayarlamak icin klavye ye “D” ve “K” harfleri girilebilir. “D” harfi ilgili yaziciyi sifira cekerek calisma modunu tek adim calisma moduna ayarlar. “K” harfi ise ilgili yaziciyi bire cekerek calisma modunu normal calisma moduna sokar.

Tek adim modunda program sayacinin artmasi kullanici tarafindan hyperterminal ekranina girilen bir anahtar ile artirilir. Bu anahtar “A”(Adim_at) harfidir. “A” komutunu girip “Enter” tusuna basildiktan sonra program sayaci bir artar. Bu arada kullanici arayuzunde “G”(Goster) harfi girildiginde hyper-terminal ekraninda islemcinin icindeki yazicilarin o anda tutugu veriler hexadecimal olarak gorulur. Bunun amaci CAF islemcinin ic yazicilarini goruntulemek ve simulasyon ile ayni verileri alip almadigini kontrol etmektir. Ayni zamanda CAF islemci mimarisine komut eklendiginde ve bu yeni komut kullanilmak istenildiginde bu yontem kullanilarak debugging yapilabilir ve pipeline den olusan hatalar duzeltilebilir.

Kullanici arayuzunde “S” komutu girildiginde CAF islemci icindeki program sayaci sifirlanir. Yeni bir kod kumesi eklendiginde program sayacinin sifirdan baslamasi icin bunun yapilmasi sarttir.

Kullanici arayuzunde "Y" komutu kullanilmasi durumunda "Z" komutu gonderinceye kadar aradaki onaltilik "Hexadecimal"(?) komutlar adres 0 dan itibaren islemci bellegine yuklenecek. Sayacin oldugu yerden basliyacagi icin "S" komutunun ilk durumda yollanmasi gerekiyor. Bunun icin 8 bit veri yolu ve yazma (aktif konumda 0) kontrolu olacak. Her yazma isareti sonunda adres otelenecek.


76

567

568569570571

572573574575576577578

579580581582583584585586

587588

589590591592593

7778

Apendiks A : Komut Açıklamaları

1)Toplama(ADD)

0 0 0 0 0 1 Ra Rb RcOPKOD[15:10] KMT[9:7] KMT[6:4] KMT[3:0]

Toplama(ADD) Komutu: <ID_Ra> yazıcısının içeriği ile <ID_Rb > yazıcısının içeriğini toplayıp<Rc> nin gösterdiği genel amaçlı yazıcıya atar. <ID_Ra> ve <ID_Rb> yazıcılarına atanan veri Ra ve Rb nin gösterdiğii genel amaçlı yazıcılardan atanır. Bu komut N,Z,C ve V koşul bayraklarını harekte geçirir.

2)Toplama-Acil(ADD-Immediate)

0 0 0 0 1 0 Ra Acil-8(Immediate)OPKOD[15:10] KMT[9:8] [7:0]

Toplama-Acil(ADDi) komutu, Ra’nin gösterdiği yazıcı ile 8-bitlik veriyi toplayarak yine aynı yazıcıya aktarır. Bu komut N,Z,C ve V koşul bayraklarını harekte geçirir. Bütün acil veri komutlarında veri sadece genel amaçlı yazıcıların ilk dört yazıcısına aktarilabilir.

3)Çıkarma(SUB)


Çıkarma(SUB) Komutu: <ID_Ra> yazıcısının içeriği ile <ID_Rb > yazıcısının içeriğini çıkarıp<Rc> nin gösterdiği genel amaçlı yazıcıya atar. <ID_Ra> ve <ID_Rb> yazıcılarına atanan veri Ra ve Rb nin gösteri genel amaçlı yazıcılardan atanır. Bu komut N,Z,C ve V koşul bayraklarını harekte geçirir.

4)Çıkarma-Acil(SUBi)

0 0 0 1 0 0 Ra Acil-8 (Immediate)OPKOD[15:10] KMT[9:8] [7:0]

Toplama-Acil(ADDi) komutu, Ra’nin gösterdiği yazıcı ile 8-bitlik veriyi toplayarak yine aynı yazıcıya aktarır. Bu komut N,Z,C ve V koşul bayraklarını harekte geçirir.


79

594595

596597

598

599

600601602603

604

605

606607608

609

610

611612613614

615

616

617618619620

8081

5)Çarpma(MUL)


Çarpma(MUL) Komutu: <ID_Ra> yazıcısının içeriği ile <ID_Rb > yazıcısının içeriğini çarpılıp<Rc> nin gösterdiği genel amaçlı yazıcıya ve ondan bir sonraki yazıcıya atar. Çarpma işlemi 16-bitlik iki veri ile yapıldığından çıkacak sonucun 32 bitlik bir yazıcıya yazılmasi gerekir. Bunun için çalışma evresinde “ALUX_out_reg” isimli 32-bitlik yazıcı kullanılır. <ID_Ra> ve <ID_Rb> yazıcılarına atanan veri Ra ve Rb nin gösteri genel amaçlı yazıcılardan atanır. Bu komut N,Z,C ve V koşul bayraklarını harekte geçirir.

6)Çarpma-İşaretsiz(MULu)


İşaretsiz-Çarpma(ADD) Komutu: işaretsiz çarpma

7)Çarpma-Acil(MULi)

0 0 0 1 1 1 Ra Acil-8 (Immediate)OPKOD[15:10] KMT[9:8] KMT[7:0]

Çarpma-Acil(ADDi) komutu, Ra’nın gösterdiği yazıcı ile 8-bitlik veriyi çarpılarak Ra’nın gösterdiği ve ondan sonraki yazıcıya aktarılır. Bu komut N,Z,C ve V koşul bayraklarını harekte geçirir.

8)Kıyaslama(CMP)

0 0 1 0 0 0 X X Ra Rc

OPKOD[15:10] [9:8] KMT[7:4] KMT[3:0]

Kıyaslama(CMP) komutu, Ra’nın gösterdiği yazıcıdan Rc’nin gösterdiği yazıcıyı çıkarır ve Z,N, C ve V koşul bayraklarını harekete geçirir.

9)Ve(AND)



82

621

622

623624625626627628629

630

631

632

633

634

635636637

638

639

640641

642

643

644

8384

Ve(AND) komutu, <ID_Ra> yazıcısının içeriği ile <ID_Rb > yazıcısının içeriğini mantıksal ve işlemi yaptıktan sonra <Rc> nin gösterdiği genel amaçlı yazıcıya atar. <ID_Ra> ve <ID_Rb> yazıcılarına atanan veri Ra ve Rb nin gösteri genel amaçlı yazıcılardan atanır. Bu komut N,Z,C ve V koşul bayraklarını harekte geçirir.

10)Ve-Acil(ANDi)

0 0 1 0 1 0 Ra Acil-8(Immediate)OPKOD[15:10] KMT[9:8] KMT[7:0]

Toplama-Acil(ADDi) komutu, Ra’nin gösterdiği yazıcı ile 8-bitlik veriyi toplayarak yine aynı yazıcıya aktarılır. Bu komut N,Z,C ve V koşul bayraklarını harekete geçirir.

11)Veya(OR)


Ve(AND) komutu, <ID_Ra> yazıcısının içeriği ile <ID_Rb > yazıcısının içeriğini mantıksal ve işlemi yaptıktan sonra <Rc> nin gösterdiği genel amaçlı yazıcıya atar. <ID_Ra> ve <ID_Rb> yazıcılarına atanan veri Ra ve Rb nin gösterdiği genel amaçlı yazıcılardan atanır. Bu komut N,Z,C ve V koşul bayraklarını harekte geçirir.

12)Veya-Acil(ORi)

0 0 1 1 0 0 Ra Acil-8(Immediate) OPKOD[15:10] KMT[9:7] KMT[7:0]


13)Özel-Veya(XOR)




85

645646647648649

650

651

652653654

655

656

657658659660661

662

663

664665666

667

668

669670671672673

8687

14)Özel-Veya Acil(XORi)

0 0 1 1 1 0 Ra Acil-8(Immediate)OPKOD[15:10] KMT[9:7] KMT[7:0]


15)NOT(NOT)

0 0 1 1 1 1 XXOPKOD[15:10] KMT[9:7] KMT[6:4] KMT[3:0]


16)Mantıksal Sola Kaydırma(SLL)


Mantıksal sola kaydırma işlemi(SLL), Ra’nIn gösterdiği yazıcının değerini Rb’nin belirttiği yazıcının içeriği kadar sola kaydırır ve Rc’nin gösterdiği genel amaçlı yazıcıya yazar . Bu komut tüm bayrak yazıcılarını günceller.

17)Mantıksal Sağa Kaydırma(SRL)


Mantıksal sağa kaydırma işlemi(SRL), Ra’nin gösterdiği yazıcının değerini Rb’nin belirttiği yazıcının içeriği kadar sola kaydırır ve Rc’nin gösterdiği genel amaçlı yazıcıya yazar . Bu komut tüm bayrak yazıcılarını günceller.

18)Aritmetik Sola Kaydırma(ADD)



88

674

675

676677678

679

680

681682683684685

686

687

688689690

691

692

693

694695696

697

698

8990

Aritmetik sola kaydırma işlemi(SRL), Ra’nin gösterdiği yazıcının değerini Rb’nin belirttiği yazıcının içeriği kadar sola kaydırır ve Rc’nin gösterdiği genel amaçlı yazıcıya yazar . Bu komut tüm bayrak yazıcılarını günceller.

19)Aritmetik Saga Kaydirma(ADD)


Aritmetik sağa kaydırma işlemi(SRL), Ra’nin gösterdiği yazıcının değerini Rb’nin belirttiği yazcının içeriği kadar sola kaydırır ve Rc’nin gösterdiği genel amaçlı yazıcıya yazar . Bu komut tüm bayrak yazıcılarını günceller.

20)Kelime Yükleme(LW)

0 1 0 1 0 0 XX Ra RcOPKOD[15:10] KMT[9:7] KMT[6:4] KMT[3:0]

Yükleme(LW), komutu CAF İşlemcinin ana hafıza biriminden veri yakalamasını sağlayan tek komuttur. Ra’nin gösterdiği yazıcı ana hafızadaki adresi işaret eder ve Rc’nin gösterdiği yazıcıya bu hafıza biriminden aldığı veriyi yazar.

21)Kelime Depolama(SW)

0 1 0 1 0 1 XX Ra RcOPKOD[15:10] KMT[9:7] KMT[6:4] KMT[3:0]

Kelime Depolama(SW), komutu CAF İşlemcinin ana hafıza birimine veri yazan tek komuttur. Ra’nin gösterdiği yazıcı ana hafızadaki adresi işaret eder ve Rc’nin belirttiği yazcının içeriğini ana hafızadaki alana atar. LW ve SW komutları ana hafıza birimiyle arayüz sağlayan komutlardır.

22)Taşıma-Alçak Bitler-Acil(MOVli)

0 1 0 1 1 0 Ra Acil-(immediate)OPKOD[15:10] KMT[9:8] [7:0]


91

699700701

702

703

704705706

707

708

709710711

712

713

714715716

717

718

719

9293

Taşıma-Acil(MOVli) komutu, CAF İşlemcinin genel amaçlı yazıcılarına hızlı veri yazilabilmesi için fazladan komut setine eklenmiş bir komuttur. Bu komut acil(immediate) verisini Ra’nin gösterdiği genel amaçlı yazıcısının en düşük 8 bitine yazar. Burada dikkat edilmesi gereken, Ra iki bitlik veri içerir ve bu yüzden bu komut ilk dört yazıcıya ulaşabilir. Ra gösterir. Bu komutun sembolündeki ‘h’ yükseği(high) ve ’u’ yukarıyı(low) belirtir.

23)Yüksek Yazıcılar Taşıma-Alçak Bitler-Acil(hMOVli)

0 1 0 1 1 1 Ra Acil-(immediate)OPKOD[15:10] KMT[9:7] KMT[7:0]

Taşıma-Acil(MOVli) komutu, CAF İşlemcinin genel amaçlı yazıcılarına hızlı veri yazilabilmesi için fazladan komut setine eklenmiş bir komuttur. Bu komut acil(immediate) verisini Ra’nin gösterdiği genel amaçlı yazıcısının en düşük 8 bitine yazar. Burada dikkat edilmesi gereken, Ra iki bitlik veri içerir ve bu yüzden bu komut 5-8 arasındaki dört yazıcıya ulaşabilir. Bu komutun sembolundeki ‘h’ yükseği(high) ve ’u’ yukarıyı(low) belirtir.

24)Taşıma-Yüksek Bitler(MOVui)

0 1 1 0 0 0 Ra Acil-(immediate)OPKOD[15:10] KMT[9:7] KMT[6:4] KMT[3:0]

Taşıma-Acil(MOVli) komutu, CAF İşlemcinin genel amaçlı yazıcılarına hızlı veri yazilabilmesi için fazladan komut setine eklenmiş bir komuttur. Bu komut acil(immediate) verisini Ra’nin gösterdiği genel amaçlı yazıcısının en yüksek 8 bitine yazar. Burada dikkat edilmesi gereken, Ra iki bitlik veri içerir ve bu yüzden bu komut ilk dört yazıcıya ulaşabilir. Bu komutun sembolündeki ‘h’ yükseği(high) ve ’u’ yukarıyı(low) belirtir.

25)Yüksek Yazıcılar Taşıma-Yüksek(hMOVui)

0 1 1 0 0 1OPKOD[15:10] KMT[9:7] KMT[6:4] KMT[3:0]


94

720721722723724

725

726

727

728729730731732733

734

735

736

737738739740741

742

743

9596

Taşıma-Acil(hMOVui) komutu, CAF İşlemcinin genel amaçlı yazıcılarına hızlı veri yazilabilmesi için fazladan komut setine eklenmiş bir komuttur. Bu komut acil(immediate) verisini genel amaçlı yazıcıların 5-8 yazıcısının en yüksek 8 bitine yazar. Hangi yazıcıya yazacağını Ra gösterir. Bu komutun sembolündeki ‘h’ yükseği(high) ve ’u’ yukarıyı(low) belirtir.

26)Taşıma(MOV)

0 1 1 0 1 0OPKOD[15:10] KMT[9:7] KMT[6:4] KMT[3:0]

Taşıma(MOV) komutu, Ra’nın gösterdiği yazıcının içeriğini Rc’nin gösterdiği yazıyı atar. Sadece genel amaçlı yazıcılar arasında taşıma işlemi yapar.

27)Dallanma-Eşit Koşul(BEQ)

0 1 1 0 1 1 Kosul Acil-(immediate)OPKOD[15:10] KMT[9:8] KMT[7:0]

Dallanma (BEQ)komutu, koşul sağlanırsa program sayacının içeriğini alt programın başladığı değere atar. Sağlanmazsa kaldığı yerden devam eder.

28)Dallanma –Eşit Olmayan Koşul(BNQ)


Dallanma (BEQ)komutu, koşul sağlanmazsa program sayacının içeriğini alt programın başladığı değere atar. Sağlanırsa kaldığı yerden devam eder.

29)Dallanma Koşulsuz(BA)


Dallanma (BA)komutu, koşulsuz olarak program sayacını belli bir değere atar.

30)Koşul ve Bağlama(BL)



97

744745746747

748

749

750751

752

753

754755

756

757

758

759760

761

762

763

764

765

9899

Dallanma (BEQ)komutu, koşul sağlanırsa program sayacının içeriğini alt programın başladığı değere atar. Sağlanmazsa kaldığı yerden devam eder.

31)Dur(HLT)

0 1 1 1 1 0 X X X X X X X X X X XOPKOD[15:10] KMT [9:0]

Dur(HLT) komutu, program sayacının artmasını durdurarak işlemleri durdurur. Programı başlatmak için sistem resetlenmelidir.

32)İşlem Yok(NOP)

0 0 0 0 0 0 X X X X X X X X X X XOPKOD[15:10] [9:0]

İslem Yok(NOP) komutu, uygulandığı zaman herhangi bir işlem yapılmaz. Tüm yazıcılar bir önceki değerlerini korurlar. Bu komut aynı zamanda gecikme yaratmak için de kullanılır.

33)Sistem-Kesme(SYSCALL)


Sistem kesme komutu , dallanma komutu gibi çalışır ve program sayacının değerini değiştirir.


100

766767

768

769

770771

772773

774

775

776

777778

779

780

781

782

783

784

785

786

787

788

789

101102

Apendiks B-1 : Verilog Kodu

//`include "global_parameters_def.v"

module CAF (clk,reset_n,komut_oku,komut_adres,komut,veri_oku,veri_yaz,veri_adres,veri_ic,veri_dis);input clk;input reset_n;output komut_oku;output [15:0] komut_adres;input [15:0] komut;output veri_oku;output veri_yaz;output [7:0] veri_adres;


103

790

791

792

793

794

795

796

797

798

799

800

801

802803804805806807808809810811812813814815816817818819820821822823

104105

input [15:0] veri_ic;output [15:0] veri_dis;

//reg [15:0] data;reg komut_oku;

wire veri_yaz;reg [15:0] PS; //program sayacireg [15:0] BY; //link yazicisireg [15:0] YG; //stackreg [15:0] gnl_yzc[15:0];// genel amacli yazicilarreg ksl_byrk; //condition flags (N = negative)reg sfr_byrk; //Sifirreg elde_byrk;reg tasma_byrk;reg branş_aktif;reg [15:0] branş_adres;reg [15:0] alu_yzc;

integer i, ex_i;//pipeline yazicilarreg [15:0] KY_kmt_yzc;reg [15:0] KY_prg_syc;reg [15:0] ID_PS;reg [15:0] KC_yzc_a;reg [15:0] KC_yzc_b;reg [15:0] KC_yzc_c;reg [15:0] dis_alu_yzc;reg [5:0] KC_opkod;reg [5:0] dis_opkod;reg [10:0] KC_acil_ofset;reg [10:0] dis_acil_ofset;reg [3:0] KC_kosul;reg [3:0] KC_gnl_yzc_adr;reg [3:0] dis_gnl_yzc_adr;reg [31:0] alux_yzc;

assign komut_adres = PS;assign veri_adres = (dis_opkod == 6'b010100) ? alu_yzc[7:0] : 8'bZZZZZZZZ;assign veri_oku = (dis_opkod == 6'b010100 ) ? 1'b0 : 1'b1;assign veri_adres = (dis_opkod == 6'b010101) ? alu_yzc[7:0] : 8'bZZZZZZZZ;//assign veri_yaz = (dis_opkod == 6'b010100) ? 1'b0 : 1'b1;

assign veri_dis = (dis_opkod == 6'b010101) ? gnl_yzc[dis_gnl_yzc_adr] : 16'hZZZZ;assign veri_yaz = (dis_opkod == 6'b010101) ? 0 : 1;


106

824825826

827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868

107108

//Fonksiyon Tanimlarifunction kosul_sağlama;input [3:0] kosul_kodu;

begincase(kosul_kodu)4'b0000 : kosul_sağlama = sfr_byrk;4'b0001 : kosul_sağlama = ~sfr_byrk;4'b0010 : kosul_sağlama = elde_byrk;4'b0011 : kosul_sağlama = ~elde_byrk;

4'b0100 : kosul_sağlama = ksl_byrk;4'b0101 : kosul_sağlama = ~ksl_byrk;4'b0110 : kosul_sağlama = tasma_byrk;4'b0111 : kosul_sağlama = ~tasma_byrk;

4'b1000 : kosul_sağlama = (elde_byrk & (~sfr_byrk));4'b1001 : kosul_sağlama = ((~elde_byrk) & sfr_byrk);4'b1010 : kosul_sağlama = (ksl_byrk == tasma_byrk);4'b1011 : kosul_sağlama = (ksl_byrk != tasma_byrk);

4'b1100 : kosul_sağlama = sfr_byrk & (ksl_byrk == tasma_byrk);4'b1101 : kosul_sağlama = sfr_byrk & (ksl_byrk != tasma_byrk);4'b1110 : kosul_sağlama = 1'b1;

default: kosul_sağlama = 1'b1;endcaseendendfunction

//Komut_Yakalama: Komut Yakalama Evresialways @ (posedge clk )beginif(~reset_n) beginPS <= 0; //program sayaci ilk kosulukomut_oku <= 1;KY_kmt_yzc <= 0;endelse beginif(branş_aktif)beginPS <= branş_adres;KY_kmt_yzc <= komut;endelse if(KC_opkod == `HLT) begin


109

869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914

110111

PS <= PS;KY_kmt_yzc <= KY_kmt_yzc;endelse beginkomut_oku <= 0;PS <= PS + 1;KY_kmt_yzc <= komut; // Komut Yakalama Komut Yazicisiendendend // blok sonu

//Komut_Cozucu Evresialways@(posedge clk) beginif(~reset_n)beginKC_opkod <= 0;KC_yzc_a <= 0;KC_yzc_b <= 0;KC_yzc_c <= 0;KC_acil_ofset <= 0;KC_kosul <= 4'b1111;KC_gnl_yzc_adr <= 0;endelse begincase(KY_kmt_yzc[15:10])6'b000000:beginKC_opkod <= `NOP;KC_yzc_a <= KC_yzc_a;KC_yzc_b <= KC_yzc_b;KC_yzc_c <= KC_yzc_c;end

6'b000001:beginKC_opkod <= `ADD;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[9:7]];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[6:4]];//KC_yzc_c <= gnl_yzc[KY_kmt_yzc[3:0]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end

6'b000010:beginKC_opkod <= `ADDi;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[10:8]];KC_acil_ofset[7:0] <= KY_kmt_yzc[7:0];end

6'b000011:begin


112

915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960

113114

KC_opkod <=`SUB;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[9:7]];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[6:4]];//KC_yzc_c <= gnl_yzc[KY_kmt_yzc[3:0]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end6'b000100:beginKC_opkod <= `SUBi;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[10:8]];KC_acil_ofset[7:0] <= KY_kmt_yzc[7:0];end6'b000101:beginKC_opkod <= `MUL;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[9:7]];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[6:4]];//KC_yzc_c <= gnl_yzc[KY_kmt_yzc[3:0]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end

6'b0001_10:beginKC_opkod <= `MULu;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[9:7]];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[6:4]];//KC_yzc_c <= gnl_yzc[KY_kmt_yzc[3:0]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end6'b000111:beginKC_opkod <= `MULi;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[10:8]];KC_acil_ofset <= gnl_yzc[KY_kmt_yzc[7:0]];end

6'b001000:beginKC_opkod <= `CMP;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[9:7]];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[6:4]];//KC_yzc_c <= gnl_yzc[KY_kmt_yzc[3:0]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end6'b001001:beginKC_opkod <= `AND;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[9:7]];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[6:4]];//KC_yzc_c <= gnl_yzc[KY_kmt_yzc[3:0]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end


115

9619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006

116117

6'b001010:beginKC_opkod <= ÀNDi;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[10:8]];KC_acil_ofset <= gnl_yzc[KY_kmt_yzc[7:0]];end

6'b001011:beginKC_opkod <= ÒR;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[9:7]];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[6:4]];//KC_yzc_c <= gnl_yzc[KY_kmt_yzc[3:0]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end6'b001100:beginKC_opkod <= ÒRi;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[10:8]];KC_acil_ofset[7:0] <= KY_kmt_yzc[7:0];end6'b001101:beginKC_opkod <= `XOR;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[9:7]];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[6:4]];//KC_yzc_c <= gnl_yzc[KY_kmt_yzc[3:0]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end

6'b001110:beginKC_opkod <= `XORi;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[10:8]];KC_acil_ofset[7:0] <= KY_kmt_yzc[7:0];end6'b001111:beginKC_opkod <= `NOT;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[9:7]];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[6:4]];//KC_yzc_c <= gnl_yzc[KY_kmt_yzc[3:0]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end6'b010000:beginKC_opkod <= `SLL;KC_acil_ofset[3:0] <= KY_kmt_yzc[9:6];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[5:3]];KC_yzc_c <= gnl_yzc[KY_kmt_yzc[2:0]];end6'b010001:beginKC_opkod <= `SRL;KC_acil_ofset[3:0] <= KY_kmt_yzc[9:6];


118

1007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052

119120

KC_yzc_b <= gnl_yzc[KY_kmt_yzc[5:3]];KC_yzc_c <= gnl_yzc[KY_kmt_yzc[2:0]];end6'b010010:beginKC_opkod <= `SLA;KC_acil_ofset[3:0] <= KY_kmt_yzc[9:6];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[5:3]];KC_yzc_c <= gnl_yzc[KY_kmt_yzc[2:0]];end6'b010011:beginKC_opkod <= `SRA;KC_acil_ofset[3:0] <= KY_kmt_yzc[9:6];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[5:3]];KC_yzc_c <= gnl_yzc[KY_kmt_yzc[2:0]];end

6'b010100:beginKC_opkod <= `LW;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[7:4]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end6'b010101:beginKC_opkod <= `SW;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[7:4]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end///////////////MOV/////////////////////////6'b010110:beginKC_opkod <= `MOVli;//KC_yzc_a[7:0] <= KY_kmt_yzc[7:0];KC_gnl_yzc_adr <= {2'b00, KY_kmt_yzc[9:8]};KC_acil_ofset[7:0] <= KY_kmt_yzc[7:0];end6'b010111:beginKC_opkod <= `hMOVli;//KC_yzc_a[7:0] <= KY_kmt_yzc[7:0];KC_gnl_yzc_adr <= {2'b01, KY_kmt_yzc[9:8]};KC_acil_ofset[7:0] <= KY_kmt_yzc[7:0];end6'b011000:beginKC_opkod <= `MOVui;//KC_yzc_a[7:0] <= KY_kmt_yzc[7:0];KC_gnl_yzc_adr <= {2'b00, KY_kmt_yzc[9:8]};KC_acil_ofset[7:0] <= KY_kmt_yzc[7:0];


121

1053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098

122123

end6'b011001:beginKC_opkod <= `hMOVui;//KC_yzc_a[7:0] <= KY_kmt_yzc[7:0];KC_gnl_yzc_adr <= {2'b01, KY_kmt_yzc[9:8]};KC_acil_ofset[7:0] <= KY_kmt_yzc[7:0];end6'b011010:beginKC_opkod <= `MOV;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[7:4]];KC_gnl_yzc_adr <= KY_kmt_yzc[3:0];end////////////////////////////////////////////6'b011011:beginKC_opkod <= `BEQ;KC_kosul <= KY_kmt_yzc[11:8];KC_acil_ofset[7:0] <= KY_kmt_yzc[7:0];ID_PS <= PS;end6'b011100:beginKC_opkod <= `BNQ;KC_kosul <= KY_kmt_yzc[11:8];KC_acil_ofset[7:0] <= KY_kmt_yzc[7:0];end6'b011101:beginKC_opkod <= `BA;KC_acil_ofset[9:0] <= KY_kmt_yzc[9:0];end

6'b011110:beginKC_opkod <= `HLT;KC_yzc_a <= KC_yzc_a;KC_yzc_b <= KC_yzc_b;KC_yzc_c <= KC_yzc_c;end6'b011111:beginKC_opkod <= `SYSCALL;KC_yzc_a <= gnl_yzc[KY_kmt_yzc[8:6]];KC_yzc_b <= gnl_yzc[KY_kmt_yzc[5:3]];KC_yzc_c <= gnl_yzc[KY_kmt_yzc[2:0]];end

endcase


124

1099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144

125126

endend

////Calisma Evresialways@(posedge clk)beginif(~reset_n)beginalu_yzc <= 0;alux_yzc <= 0;ksl_byrk <= 0;sfr_byrk <= 0;elde_byrk <= 0;tasma_byrk <= 0;branş_aktif <= 0;branş_adres <= 0;endelse begin if(branş_aktif)begindis_opkod <=6'b000000;branş_aktif <= 1'b0;endelse begincase(KC_opkod) //`NOP : alu_yzc <= alu_yzc;ÀDD : alu_yzc <= KC_yzc_a + KC_yzc_b;ÀDDi : alu_yzc <= KC_yzc_a + KC_acil_ofset;`SUB : alu_yzc <= KC_yzc_b - KC_yzc_c;`SUBi : alu_yzc <= KC_yzc_a - KC_acil_ofset;`MUL : alux_yzc <= KC_yzc_a * KC_yzc_b;`MULi : alux_yzc <= KC_yzc_a * KC_acil_ofset;`MULu : alux_yzc <= KC_yzc_a * KC_acil_ofset;`CMP : alu_yzc <= gnl_yzc[KY_kmt_yzc[5:3]] - gnl_yzc[KY_kmt_yzc[2:0]];ÀNDi : alu_yzc <= KC_yzc_a & KC_acil_ofset;ÀND : alu_yzc <= KC_yzc_a & KC_yzc_b;ÒRi : alu_yzc <= KC_yzc_a | KC_acil_ofset;ÒR : alu_yzc <= KC_yzc_a | KC_yzc_b;`XORi : alu_yzc <= KC_yzc_a ^ KC_acil_ofset;`XOR : alu_yzc <= KC_yzc_a ^ KC_yzc_b;`SLL : alu_yzc <= KC_yzc_b << KC_acil_ofset[3:0];`SRL : alu_yzc <= KC_yzc_b >> KC_acil_ofset[3:0];`SRA : alu_yzc <= KC_yzc_b >> KC_acil_ofset[3:0];`SLA : alu_yzc <= KC_yzc_b >> KC_acil_ofset[3:0];`NOT : alu_yzc <= 0 - KC_yzc_a;`LW : alu_yzc <= KC_yzc_a;`SW : alu_yzc <= KC_yzc_a;


127

1145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190

128129

//MOV`MOVli : alu_yzc <= {8'b0, KC_acil_ofset};`hMOVli : alu_yzc <= {8'b0, KC_acil_ofset};`MOVui : alu_yzc <= {KC_acil_ofset, 8'b0};`hMOVui : alu_yzc <= {KC_acil_ofset, 8'b0};`MOV : alu_yzc <= gnl_yzc[KY_kmt_yzc[7:4]];//Kosul Komutlari`BEQ : beginif(kosul_sağlama(0))beginfor(i = 15; i > 8; i = i-1)alu_yzc[i] <= KC_acil_ofset[7];alu_yzc[8:1] <= KC_acil_ofset[7:0];alu_yzc[0] <=1'b0;branş_aktif <= 1'b1;branş_adres <= 128;//(ID_PS +1) + alu_yzc[15:0];endend`BNQ : beginif(~kosul_sağlama(KC_kosul))beginfor(i = 15; i > 8; i = i-1)alu_yzc[i] <= KC_acil_ofset[7];alu_yzc[8:1] <= KC_acil_ofset[7:0];alu_yzc[0] <=1'b0;branş_aktif <= 1'b1;branş_adres <= (ID_PS +1) + alu_yzc[15:0];endend`BA : begin

for(i = 15; i > 8; i = i-1)alu_yzc[i] <= KC_acil_ofset[7];alu_yzc[8:1] <= KC_acil_ofset[7:0];alu_yzc[0] <=1'b0;branş_aktif <= 1'b1;branş_adres <= (ID_PS + 1) + alu_yzc[15:0];end`HLT : beginalu_yzc <= alu_yzc;end`SYSCALL :beginbranş_aktif <= 1'b1;branş_adres <= ID_PS - 1;endendcase// Bu bölüm Flag operasyonlarini kontrol etmek için yazilmistir.


130

1191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236

131132

//

case(dis_opkod)

ÀDD, `SUB, `CMP, `MUL : begindis_alu_yzc[15:0] <= alu_yzc[15:0];ksl_byrk <= alu_yzc[15];sfr_byrk <= (alu_yzc[15:0] == 0);//if(KC_acil_ofset[2:0] != 3'b000) beginelde_byrk <= alu_yzc[15];tasma_byrk <= (alu_yzc[15] != alu_yzc[15]);// end if;end

ÀDDi, `SUBi : begindis_alu_yzc[15:0] <= alu_yzc[15:0];ksl_byrk <= alu_yzc[15];sfr_byrk <= (alu_yzc[15:0] == 0);if(KC_acil_ofset[2:0] != 3'b000) beginelde_byrk <= alu_yzc[15];tasma_byrk <= (alu_yzc[15] != alu_yzc[15]);endend`MULi : begin// dis_alu_yzc[31:0] <= alu_yzc[31:0];ksl_byrk <= alu_yzc[15];sfr_byrk <= (alu_yzc[15:0] == 0);if(KC_acil_ofset[2:0] != 3'b000) beginelde_byrk <= alu_yzc[15];// tasma_byrk <= (alu_yzc[32] != alu_yzc[31]);endendÀND, `XOR, `XORi, ÒR , `NOT: begindis_alu_yzc[15:0] <= alu_yzc[15:0];ksl_byrk <= alu_yzc[15];sfr_byrk <= (alu_yzc[15:0] == 0);endendcasedis_opkod <= KC_opkod ;dis_gnl_yzc_adr <= KC_gnl_yzc_adr;dis_acil_ofset <= KC_acil_ofset;dis_alu_yzc <= alu_yzc;

endend // process sonuend // calisma evresi sonu


133

1237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282

134135

//Geri Yazmaalways@(posedge clk)beginif(~reset_n)for( i = 0; i <=15 ; i = i + 1)gnl_yzc[i]<= 0;else begincase (dis_opkod)ÀDD, ÀDDi, `SUB, `SUBi, ÀND, ÀNDi, ÒR, ÒRi, `XOR, `XORi,`SLL, `SRL, `SRA, `SRL, `NOT : begingnl_yzc[dis_gnl_yzc_adr] <= alu_yzc;end

`MUL, `MULi, `MULu : begingnl_yzc[dis_gnl_yzc_adr] <= alux_yzc[15:0];gnl_yzc[dis_gnl_yzc_adr + 1] <= alux_yzc[31:16];end`LW : gnl_yzc[dis_gnl_yzc_adr] <= veri_ic ;`MOVli : gnl_yzc[dis_gnl_yzc_adr] <= alu_yzc;`hMOVli : gnl_yzc[dis_gnl_yzc_adr] <= alu_yzc;`MOVui : gnl_yzc[dis_gnl_yzc_adr] <= alu_yzc;`hMOVui : gnl_yzc[dis_gnl_yzc_adr] <= alu_yzc;endcase

endend

endmodule


136

12831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311

137138


module testbench();

wire komut_oku;wire [15:0] komut_adres;wire [15:0] komut;wire veri_oku;wire veri_yaz;wire [7:0] veri_adres;wire [7:0] veri_adres_yzc;wire [15:0] veri_ic;wire [15:0] veri_dis;

reg reset_n ; reg clk;reg [15:0] komut_dis_yzc;reg [15:0] veri_dis_yzc;reg [15:0] yazilan_veri;//instantiate the unit under testCAF UUT (.clk(clk), .reset_n(reset_n), .komut_oku(komut_oku), .komut_adres(komut_adres), .komut(komut_dis_yzc), .veri_oku(veri_oku), .veri_yaz(veri_yaz), .veri_adres(veri_adres), .veri_ic(veri_ic), .veri_dis(veri_dis));

initial beginclk = 0;reset_n = 0;#(`PERIYOT1/4) reset_n = 0;#(`PERIYOT1 * 2) reset_n = 1;

end//always #(`PERIYOT1/2) clk = ~clk;

reg [15:0] komut_bellegi [0 : `BELLEK_MIKTARI - 1];reg [15:0] veri_bellegi [0:`BELLEK_MIKTARI - 1];

//assign komut = komut_oku ? 16'hXXXX : komut_dis_yzc;

always beginif(komut_oku == 0) begin #`GECIKME1;


139

1312

140141

komut_dis_yzc = komut_bellegi[komut_adres[7:0]]; wait ((komut_oku == 1) || (komut_dis_yzc != komut_bellegi[komut_adres[7:0]])); endelse begin #`SABIT_ZAMAN;komut_dis_yzc <= 16'h0000;wait(komut_oku == 0);end end // always blockassign data = veri_oku ? 16'hzzzz : veri_dis_yzc;assign veri_ic = veri_dis_yzc;

always beginif(veri_oku == 0)begin

#`GECIKME1;veri_dis_yzc = veri_bellegi[veri_adres[7:0]];wait ((veri_oku == 1) ||(veri_dis_yzc != veri_bellegi[veri_adres[7:0]]));end

else begin#`SABIT_ZAMANveri_dis_yzc = 16'hzzzz;wait(veri_oku == 0);end

end always begin

wait (veri_yaz == 0);yazilan_veri = veri_dis;//veri_adres_yzc = veri_adres; wait ((veri_yaz == 1) || (veri_dis != yazilan_veri));if (veri_yaz == 1) begin

//#`GECIKME1;veri_bellegi[veri_adres_yzc[7:0]] = yazilan_veri;

endelse

yazilan_veri = veri_dis;end //

initial begin

//****************Test6***********************************************/* komut_bellegi[0] <= {`NOP}; //Movi

komut_bellegi[1] <= {`MOVli, `yzc_i1, 8'hab};komut_bellegi[2] <= {`MOVli, `yzc_i2, 8'hcd};komut_bellegi[3] <= {`MOVli, `yzc_i3, 8'hef};komut_bellegi[4] <= {`NOP};komut_bellegi[5] <= {`ADD, `yzc_a1, `yzc_a2, `yzc_c15};komut_bellegi[6] <={`MOVli, `yzc_i0, 8'h03};komut_bellegi[7] <={`MOVui, `yzc_i1, 8'hDC};komut_bellegi[8] <={`hMOVui, `yzc_i2, 8'hBE};komut_bellegi[9] <={`hMOVli, `yzc_i3, 8'h04};komut_bellegi[10] <={`LW, 2'b00, `yzc_c2, `yzc_c12};komut_bellegi[11] <={`NOP};

*/


142

143144

//****************Test5***********************************************/* komut_bellegi[1] <= 16'h5DAA; //Movi

komut_bellegi[2] <= 16'h5E55; //Movi komut_bellegi[3] <= 16'h5F66; //Movi

komut_bellegi[4] <= 16'h6C00; //NOPkomut_bellegi[5] <= 16'h6C00; //NOPkomut_bellegi[6] <= 16'h240F; // AND Reg[0] and Reg[1] -> Reg[7]komut_bellegi[7] <= 16'h2C0F; // OR Reg[0] and Reg[1] -> Reg[7]komut_bellegi[8] <= 16'h380F; // XOR Reg[0] and Reg[1] -> Reg[7]komut_bellegi[9] <= 16'h6C00; //NOP

*///******************Test4*********************************************// komut_bellegi[0] <= {`MOVi, 10'b0000001011}; //16'h5C0D//Movi

komut_bellegi[1] <= 16'h6C00; //NOPkomut_bellegi[2] <= 16'h5D0D; //Movi

komut_bellegi[3] <= 16'h6C00; //NOPkomut_bellegi[4] <= 16'h6C00; //NOPkomut_bellegi[5] <= 16'h5023; //LWkomut_bellegi[6] <= 16'h6C00; //NOPkomut_bellegi[6] <= 16'h5054; //LWkomut_bellegi[7] <= 16'h14E5; //MUL

//**********************TEST3************************************************* /* komut_bellegi[0] <= 16'h5C0A; //move data to registerfile 1

komut_bellegi[1] <= 16'h5D0B; //move data to registerfile 2 komut_bellegi[2] <= 16'h5E0A; //move data to registerfile 3

komut_bellegi[3] <= 16'h5F05; //move data to registerfile 4komut_bellegi[4] <= 16'h6C00; // NOPkomut_bellegi[5] <= 16'h6C00; // NOPkomut_bellegi[6] <= 16'h1415; //multiply reg[0] * reg[2] -> reg[5]komut_bellegi[7] <= 16'h6C00; // NOPkomut_bellegi[8] <= 16'h6C00; // NOPkomut_bellegi[9] <= 16'h7000; // HALT

*///***************************TEST2*********************************************/* komut_bellegi[0] <= 16'h5CBE; //move data to registerfile 1

komut_bellegi[1] <= 16'h5D05; //move data to registerfile 2 komut_bellegi[2] <= 16'h5EAC; //move data to registerfile 3

komut_bellegi[3] <= 16'h5FBE; //move data to registerfile 4komut_bellegi[4] <= 16'h2003; //compare the data in reg0 and reg1komut_bellegi[5] <= 16'h6C00; // NOPkomut_bellegi[6] <= 16'h6080; //BEQ komut_bellegi[7] <= 16'h6C00; // NOPkomut_bellegi[8] <= 16'h7000; // HALTkomut_bellegi[128] <= 16'h5C02; // move reg[0] <= 2;komut_bellegi[129] <= 16'h5D04; // move reg[1] <= 4;

komut_bellegi[130] <= 16'h6C00; // NOPkomut_bellegi[131] <= 16'h6C00; // NOPkomut_bellegi[132] <= 16'h040F; // Add reg[0] + reg[1] -> reg[7]komut_bellegi[133] <= 16'h7000; //Halt

*/


145

146147

//***************************TEST1********************************************* /*komut_bellegi[6] <= 16'h500A; //Load Word 1 komut_bellegi[7] <= 16'h5DAA; //Move data x"AA" komut_bellegi[8] <= 16'h500A; //Store word komut_bellegi[10] <= 16'h5DAA; //store word komut_bellegi[8] <= 16'h6C00; //NOP komut_bellegi[9] <= 16'h0415; //ADD REG0 + REG2 => REG5 komut_bellegi[10] <= 16'h5C85;*/

veri_bellegi[0] <= 16'h0000; veri_bellegi[1] <= 16'h0000; veri_bellegi[2] <= 16'hACCA; veri_bellegi[3] <= 16'h0001; veri_bellegi[4] <= 16'hBEEF; veri_bellegi[5] <= 16'hDEAD; veri_bellegi[6] <= 16'hFACE; veri_bellegi[7] <= 16'hBEEF; veri_bellegi[8] <= 16'h0000; veri_bellegi[9] <= 16'h0000; veri_bellegi[10] <= 16'h10FF; veri_bellegi[11] <= 16'hFAFA; veri_bellegi[12] <= 16'h0020; veri_bellegi[13] <= 16'h4568; veri_bellegi[14] <= 16'h4586; veri_bellegi[15] <= 16'h0000;

end

endmodule


148

149150


define PERIYOT1 100`define GECIKME1 80

`define SABIT_ZAMAN 10`define BELLEK_MIKTARI 256`define word_size 16`define reg_file_size 16

//`define yzc_i0 2'b00`define yzc_i1 2'b01`define yzc_i2 2'b10`define yzc_i3 2'b11//`define yzc_a0 3'b000`define yzc_a1 3'b001`define yzc_a2 3'b010`define yzc_a3 3'b011 `define yzc_a4 3'b100`define yzc_a5 3'b101`define yzc_a6 3'b110`define yzc_a7 3'b111//`define yzc_b0 3'b000`define yzc_b1 3'b001`define yzc_b2 3'b010`define yzc_b3 3'b011 `define yzc_b4 3'b100`define yzc_b5 3'b101`define yzc_b6 3'b110`define yzc_b7 3'b111//`define yzc_c0 4'b0000`define yzc_c1 4'b0001`define yzc_c2 4'b0010`define yzc_c3 4'b0011`define yzc_c4 4'b0100`define yzc_c5 4'b0101`define yzc_c6 4'b0110`define yzc_c7 4'b0111`define yzc_c8 4'b1000`define yzc_c9 4'b1001`define yzc_c10 4'b1010`define yzc_c11 4'b1011


151

1313

1314

1315

152153

`define yzc_c12 4'b1100`define yzc_c13 4'b1101`define yzc_c14 4'b1110`define yzc_c15 4'b1111

//Kmoutlar ve Opcodelar `define NOP 6'b0000_00 //Test`define ADD 6'b0000_01 //Test`define ADDi 6'b0000_10`define SUB 6'b0000_11`define SUBi 6'b0001_00 `define MUL 6'b0001_01 //Test`define MULu 6'b0001_10`define MULi 6'b0001_11`define CMP 6'b0010_00`define AND 6'b0010_01`define ANDi 6'b0010_10`define OR 6'b0010_11`define ORi 6'b0011_00`define XOR 6'b0011_01`define XORi 6'b0011_10`define NOT 6'b0011_11`define SLL 6'b0100_00`define SRL 6'b0100_01`define SLR 6'b0100_10`define SLA 6'b0100_11`define LW 6'b0101_00 //Test`define SW 6'b0101_01 //Test`define MOVli 6'b0101_10 //Test`define hMOVli 6'b0101_11`define MOVui 6'b0110_00`define hMOVui 6'b0110_01`define MOV 6'b0110_10`define BEQ 6'b0110_11 //Test `define BNQ 6'b0111_00`define BA 6'b0111_01`define HLT 6'b0111_10 //Test`define SYSCALL 6'b0111_11


154

155156

caf İşlemci - mcu turkey · web viewİlerleyen bölümlerde caf İşlemci tasarımı ve mimarisi...

Documents