Дослідження програмної моделі RISC CPU. Звіт до лабораторної роботи з АМО. Робота № 526771

Перехід до торгівельного партнера Binance

Дослідження програмної моделі RISC CPU

Інформація про навчальний заклад

ВУЗ:

Національний університет Львівська політехніка

Інститут:

Не вказано

Факультет:

КН

Кафедра:

Кафедра ЕОМ

Інформація про роботу

Рік:

2013

Тип роботи:

Звіт до лабораторної роботи

Предмет:

АМО

Завантажити

Частина тексту файла (без зображень, графіків і формул):

Міністерство освіти, науки, молоді та спорту України Національний університет “Львівська політехніка” Кафедра ЕОМ Звіт до Лабораторної роботи №5 «Дослідження програмної моделі RISC CPU» Варіант 4 Підготував: ст.гр. КІ-35 Мацюк Тарас Перевірив: Ігнатович А.О. Львів 2013 Мета роботи : Навчитися здійснювати оцінку структури об’єкта (RISC CPU) на існуючій програмній моделі. Навчитись встановлювати структуру інтерфейсів об’єкта . ХІД ВИКОНАННЯ РОБОТИ: Перелік блоків програмної моделі RISC CPU: FETCH_BLOCK DECODE_BLOCK EXEC_BLOCK FLOAT_BLOCK MMX_BLOCK BIOS_BLOCK PAGING_BLOCK ICACHE_BLOCK DCACHE_BLOCK PIC_BLOCK Призначення блоків у структурі RISC CPU: FETCH_BLOCK – вибирає (розпізнає) команду. DECODE_BLOCK – вибирає з команди операнди. EXEC_BLOCK – блок, в якому команда виконується. FLOAT_BLOCK – виконуються операції над числами з плаваючою комою. MMX_BLOCK – виконуються mmx операції. BIOS_BLOCK – реалізує bios. PAGING_BLOCK – сторінковий блок. ICACHE_BLOCK – кеш для інструкцій. DCACHE_BLOCK – кеш для даних. PIC_BLOCK – модуль переривань. Вхідні та вихідні інтерфейси для кожного блоку RISC CPU окремо: FETCH_BLOCK sc_in<unsigned > ramdata;/ instruction from RAM/ інструкція з оперативної ПАМ'ЯТІ sc_in<unsigned > branch_address; // branch target address/ цільова адреса, що відгалужується sc_in<bool> next_pc; // pc ++ sc_in<bool> branch_valid; // branch_valid sc_in<bool> stall_fetch; // STALL_FETCH sc_in<bool> interrupt; // interrrupt sc_in<unsigned> int_vectno; // interrupt vector number номер вектора переривання sc_in<bool> bios_valid; // BIOS input valid Вхід BIOS, дійсний sc_in<bool> icache_valid; // Icache input valid Вхід Icache, дійсний sc_in<bool> pred_fetch; // branch prediction fetch sc_in<unsigned >pred_branch_address; // branch target address цільова адреса, що відгалужується sc_in<bool> pred_branch_valid; // branch prediction fetch sc_out<bool> ram_cs; // RAM chip select sc_out<bool> ram_we; // RAM write enable for SMC sc_out<unsigned > address; // address send to RAM адреса відправляють оперативній ПАМ'ЯТІ sc_out<unsigned > smc_instruction; // for self-modifying code для однорідний-змінюючого коду sc_out<unsigned> instruction; // instruction send to ID інструкція відправляють ID sc_out<bool> instruction_valid; // inst valid sc_out<unsigned > program_counter; // program counter sc_out<bool> interrupt_ack; // interrupt acknowledge переривання визнають sc_out<bool> branch_clear; // clear outstanding branch sc_out<bool> pred_fetch_valid; // branch prediction fetch sc_out<bool> reset; // reset sc_in_clk CLK; DECODE_BLOCK sc_in<bool> resetin; // input reset sc_in<unsigned> instruction; // fetched instruction неприродна інструкція sc_in<unsigned> pred_instruction; // fetched instruction sc_in<bool> instruction_valid; // input valid вхід, дійсний sc_in<bool> pred_inst_valid; // input valid sc_in<bool> destreg_write; // register write enable запис регістра вирішують sc_in<unsigned> destreg_write_src; // which register to write? який регістр написати? sc_in<signed> alu_dataout; // data from ALU sc_in<signed> dram_dataout; // data from Dcache sc_in<bool> dram_rd_valid; // Dcache read data valid sc_in<unsigned> dram_write_src; // Dcache data write to which reg sc_in<signed> fpu_dout; // data from FPU sc_in<bool> fpu_valid; // FPU data valid sc_in<unsigned> fpu_destout; // write to which register sc_in<bool> clear_branch; // clear outstanding branch sc_in<bool> display_done; // display to monitor done sc_in<unsigned > pc; // program counter from IFU sc_in<bool> pred_on; // branch prediction is on sc_out<unsigned > br_instruction_address; // branch invoke instruction sc_out<bool> next_pc; // next pc ++ ? sc_out<bool> branch_valid; // branch valid signal sc_out<unsigned > branch_target_address; // branch target address sc_out<bool> mem_access; // memory access valid sc_out<unsigned > mem_address; // memory physical address sc_out<int> alu_op; // ALU/FPU/MMU Opcode sc_out<bool> mem_write; // memory write enable sc_out<unsigned> alu_src; // destination register number sc_out<bool> reg_write; // not implemented sc_out<signed int> src_A; // operand A sc_out<signed int> src_B; // operand B sc_out<bool> forward_A; // data forwarding to operand A sc_out<bool> forward_B; // data forwarding to operand B sc_out<bool> stall_fetch; // stall fetch due to branch sc_out<bool> decode_valid; // decoder output valid sc_out<bool> float_valid; // enable FPU sc_out<bool> mmx_valid; // enable MMU sc_out<bool> pid_valid; // load process ID sc_out<signed> pid_data; // process ID value sc_in_clk CLK; EXEC_BLOCK sc_in<bool> reset; // reset not used. sc_in<bool> in_valid; // input valid sc_in<int> opcode; // opcode from ID sc_in<bool> negate; // not implemented sc_in<int> add1; // not implemented sc_in<bool> shift_sel; // not implemented sc_in<signed int> dina; // operand A sc_in<signed int> dinb; // operand B sc_in<bool> forward_A; // data forwarding A valid sc_in<bool> forward_B; // data forwarding B valid sc_in<unsigned> dest; // destination register number sc_out<bool> C; // Carry bit sc_out<bool> V; // Overflow bit sc_out<bool> Z; // Zero bit sc_out<signed int> dout; // output data sc_out<bool> out_valid; // output valid sc_out<unsigned> destout; // write to which registers? sc_in_clk CLK; FLOAT_BLOCK sc_in<bool> in_valid; // input valid bit sc_in<int> opcode; // opcode sc_in<signed int> floata; // operand A sc_in<signed int> floatb; // operand B sc_in<unsigned> dest; // write to which register sc_out<signed int> fdout; // FPU output sc_out<bool> fout_valid; // output valid sc_out<unsigned> fdestout; // write to which register sc_in_clk CLK; MMX_BLOCK sc_in<bool> mmx_valid; // MMX unit enable sc_in<int> opcode; // opcode sc_in<signed int> mmxa; // operand A sc_in<signed int> mmxb; // operand B sc_in<unsigned> dest; // Destination register number sc_out<signed int> mmxdout; // MMX output sc_out<bool> mmxout_valid; // MMX output valid sc_out<unsigned> mmxdestout; // destination number sc_in_clk CLK; BIOS_BLOCK sc_in<unsigned > datain; // modified instruction sc_in<bool> cs; // chip select sc_in<bool> we; // write enable for SMC sc_in<unsigned > addr; // physical address sc_out<unsigned > dataout; // ram data out sc_out<bool> bios_valid; // out valid sc_out<bool> stall_fetch; // stall fetch if output not valid sc_in_clk CLK; PAGING_BLOCK sc_in<unsigned > paging_din; // input data sc_in<bool> paging_csin; // chip select sc_in<bool> paging_wein; // write enable sc_in<unsigned > logical_address; // logical address sc_in<unsigned > icache_din; // data from BIOS/icache sc_in<bool> icache_validin; // data valid bit sc_in<bool> icache_stall; // stall IFU if busy sc_out<unsigned > paging_dout; // output data sc_out<bool> paging_csout; // output cs to cache/BIOS sc_out<bool> paging_weout; // write enable to cache/BIOS sc_out<unsigned > physical_address; // physical address sc_out<unsigned > dataout; // dataout from memory sc_out<bool> data_valid; // data valid sc_out<bool> stall_ifu; // stall IFU if busy sc_in_clk CLK; ICACHE_BLOCK sc_in<unsigned > datain; // modified instruction sc_in<bool> cs; // chip select sc_in<bool> we; // write enable for SMC sc_in<unsigned > addr; // address sc_in<bool> ld_valid; // load valid sc_in<signed> ld_data; // load data value sc_out<unsigned > dataout; // ram data out sc_out<bool> icache_valid; // output valid sc_out<bool> stall_fetch; // stall fetch if busy sc_in_clk CLK; DCACHE_BLOCK sc_in<signed> datain; // input data sc_in<unsigned> statein; // input state bit MESI(=3210) sc_in<bool> cs; // chip select sc_in<bool> we; // write enable sc_in<unsigned > addr; // address sc_in<unsigned> dest; // write back to which register sc_out<unsigned> destout; // write back to which register sc_out<signed> dataout; // dataram data out sc_out<bool> out_valid; // output valid sc_out<unsigned> stateout; // state output sc_in_clk CLK; PIC_BLOCK sc_in<bool> ireq0; // interrupt request 0 sc_in<bool> ireq1; // interrupt request 1 sc_in<bool> ireq2; // interrupt request 2 sc_in<bool> ireq3; // interrupt request 3 sc_in<bool> cs; // chip select sc_in<bool> rd_wr; // read or write sc_in<bool> intack_cpu; // interrupt acknowledge from CPU sc_out<bool> intreq; // interrupt request to CPU sc_out<bool> intack; // interrupt acknowledge to devices sc_out<unsigned> vectno; // vector number //////////////////////////////////////////////////////////////////////////// // MAIN PROGRAM //////////////////////////////////////////////////////////////////////////// sc_clock clk("Clock", 1, 0.5, 0.0); printf("// Module : main of CPU Model\n"); printf("// Purpose : This is a simple CPU modeling using SystemC.\n"); printf("// Instruction Set Architecure defined by Martin Wang.\n"); printf("// SystemC (TM) Copyright (c) 1988-2000 by Synopsys, Inc. \n"); fetch IFU("FETCH_BLOCK"); IFU.init_param(delay_cycles); IFU << ram_dataout << branch_target_address << next_pc << branch_valid << stall_fetch << intreq << vectno << bios_valid << icache_valid << pred_fetch << pred_branch_address << pred_branch_valid << ram_cs << ram_we << addr << ram_datain << instruction << instruction_valid << program_counter << intack_cpu << branch_clear << pred_fetch_valid << reset << clk; decode IDU("DECODE_BLOCK"); IDU << reset << instruction << pred_instruction << instruction_valid << pred_inst_valid << out_valid << destout << dout << dram_dataout << dram_rd_valid << destout << fdout << fout_valid << fdestout << branch_clear << dsp_data_valid << program_counter << pred_on << branch_instruction_address << next_pc << branch_valid << branch_target_address << mem_access << mem_address << alu_op << mem_write << alu_src << reg_write << src_A << src_B << forward_A << forward_B << stall_fetch << decode_valid << float_valid << mmx_valid << pid_valid << pid_data << clk; exec IEU("EXEC_BLOCK"); IEU << reset << decode_valid << alu_op << negate << add1 << shift_sel << src_A << src_B << forward_A << forward_B << alu_src << c << v << z << dout << out_valid << destout << clk; floating FPU("FLOAT_BLOCK"); // order dependent FPU << float_valid << alu_op << src_A << src_B << alu_src << fdout << fout_valid << fdestout << clk; mmxu MMXU("MMX_BLOCK"); MMXU << mmx_valid << alu_op << src_A << src_B << alu_src << fdout << fout_valid << fdestout << clk; bios BIOS("BIOS_BLOCK"); BIOS.init_param(delay_cycles); BIOS.datain(ram_datain); // order independent BIOS.cs(ram_cs); BIOS.we(ram_we); BIOS.addr(addr); BIOS.dataout(ram_dataout); BIOS.bios_valid(bios_valid); BIOS.stall_fetch(stall_fetch); BIOS.CLK(clk); paging PAGING("PAGING_BLOCK"); PAGING << ram_datain << ram_cs << ram_we << addr << icache_din << icache_validin << icache_stall << paging_dout << paging_csout << paging_weout << physical_address << ram_dataout << icache_valid << stall_fetch << clk ; icache ICACHE("ICACHE_BLOCK"); ICACHE.init_param(delay_cycles); ICACHE << paging_dout << paging_csout << paging_weout << physical_address << pid_valid << pid_data << icache_din << icache_validin << icache_stall << clk; dcache DCACHE("DCACHE_BLOCK"); DCACHE.init_param(delay_cycles); DCACHE << mmic_datain << mmic_statein << mmic_cs << mmic_we << mmic_addr << mmic_dest << mmic_destout << mmic_dataout << mmic_out_valid << mmic_stateout << clk; pic APIC("PIC_BLOCK"); APIC << ireq0 << ireq1 << ireq2 << ireq3 <<intack_cpu << rd_wr << intack_cpu << intreq << intack << vectno; time_t tbuffer = time(NULL); sc_start(clk, -1); cout << "Time for simulation = " << (time(NULL) - tbuffer) << endl; Блок-схема алгоритму: Висновки: на цій лабораторній роботі я навчився здійснювати оцінку структури об’єкту (RISC CPU) на існуючій програмній моделі, а також навчилася встановлювати структуру інтерфейсів об’єкту .

Звіт до лабораторної роботи АМО

taras1993

06.12.2014 16:12-

Коментарі

Ви не можете залишити коментар. Для цього, будь ласка, або зареєструйтесь.

Ділись своїми роботами та отримуй миттєві бонуси!

Маєш корисні навчальні матеріали, які припадають пилом на твоєму комп'ютері? Розрахункові, лабораторні, практичні чи контрольні роботи — завантажуй їх прямо зараз і одразу отримуй бали на свій рахунок! Заархівуй всі файли в один .zip (до 100 МБ) або завантажуй кожен файл окремо. Внесок у спільноту – це легкий спосіб допомогти іншим та отримати додаткові можливості на сайті. Твої старі роботи можуть приносити тобі нові нагороди!

поділитись