Дослідження програмної моделі RISC CPU. Звіт до лабораторної роботи з Комп’ютерні системи . Робота № 529952

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

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

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

ВУЗ:

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

Інститут:

Факультет:

КН

Кафедра:

Кафедра ЕОМ

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

Рік:

2024

Тип роботи:

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

Предмет:

Комп’ютерні системи

Завантажити

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

Міністерство освіти, науки, молоді та спорту України Національний університет “Львівська політехніка” Кафедра ЕОМ ЗВІТ до лабораторної роботи №5 на тему: «Дослідження програмної моделі RISC CPU» з предмету: «Комп’ютерні системи» Підготував: ст.гр. КІ-41 Глова Ю.І. Прийняв: Муляревич О.В. Львів 2017 Мета роботи : Навчитися здійснювати оцінку структури об’єкта (RISC CPU) на існуючій програмній моделі. Навчитись встановлювати структуру інтерфейсів об’єкта . Теоретична частина: RISC CPU це процесор, у якому реалізована архітектура із скороченим набором команд (RISC – Reduced Instruction Set Computer). Головні зусилля у архітектурі RISC направлені на побудову максимально ефективного конвейєра команд , тобто такого, де всі команди вибираються із пам’яті і поступають у ЦП на обробку у вигляді рівномірного потоку, причому ні одна команда неповинна знаходитися у стані очікування, а ЦП повинен залишатися завантаженим на протязі усього часу. Цю умову відносно просто можна реалізувати для етапу виборки. Необхідно лише, щоб всі команди мали стандартну довжину, яка дорівнює ширині шини даних, що з’єднує ЦП і пам’ять. Крім однакової довжини команд, важливо мати відносно просту підсистему декодування і управління: складний пристрій управління (УУ) буде вносити додаткові затримки у формування сигналів управління. Шлях суттєвого спрощення УУ – скорочення числа команд, що входять до складу системи команд ЦП, форматів команд і даних, а також видів адресації. Якщо підсумувати наведені вище та інші вимоги до архітектури із скороченим набором команд, то концепцію RISC-комп’ютера можна звести до наступних положень: - виконання всіх (або, не менше, 75 % команд) за один цикл; - стандартна, у одне слово, довжина всіх команд, яка дорівнює природній довжині слова і ширині шини даних і така, що допускає уніфіковану потокову обробку усіх команд; - мале число команд (не більше 128); - мала кількість форматів команд (не більше 4); - мале число способів адресації (не більше 4); - доступ до пам’яті тільки через команди „Читання” і „Запис”; - всі команди, за виключенням „Читання” і „Запис”, використовують внутріщньопроцесорні між регістрові пересилання; - пристрій управління „жорсткою” логікою; - відносно великий (не менше 30) процесорний файл регістрів загального призначення (як відомо, у сучасних RISC CPU число РОН може перевищувати 500). Хід виконання роботи: Перелік блоків програмної моделі 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) на існуючій програмній моделі, а також навчився встановлювати структуру інтерфейсів об’єкту.

Звіт до лабораторної роботи Комп’ютерні системи

380987061473

22.03.2018 19:03-

Коментарі

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

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

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

поділитись