Міністерство освіти, науки, молоді та спорту України Національний університет “Львівська політехніка” Кафедра ЕОМ Звіт до Лабораторної роботи №5 «Дослідження програмної моделі RISC CPU» Варіант 4 Перевірив: Ігнатович А.О. Львів 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) на існуючій програмній моделі, а також навчилася встановлювати структуру інтерфейсів об’єкту .