MODELLO DLX IN UNISIM

Transcript

1 Architettura e descrizione del modello MODELLO DLX IN UNISIM RINGRAZIAMENTI : I materiali per questa presentazione sono tratti dal tutorial ufficiale di UNISIM -

2 Layout 2 Architettura DLX (MIPS R2000) Breve ricapitolazione Mappatura dell architettura DLX nel modello UNISIM Spiegazione di un modulo (dettagli del modulo Instruction Memory ) Esercizio Completare il modello DLX Obiettivo: Imparare come si crea un modello complesso

3 Processore DLX 3 Introdotto da Hennessy e Patterson Architettura RISC Simile a MIPS R2000 (architettura Load/Store) Pipeline con 5 stadi Formato di istruzioni a 32-bit Per l esercizio si usa un modello DLX semplificato Senza la gestione degli hazard Supponiamo che il compilatore abbia inserito delle nop dentro il programma Un ISA ridotto Il processore DLX reale ha più istruzioni di quello che facciamo

4 Pipeline di DLX 4

5 DLX modello UNISIM 5 Mappatura della pipeline nei moduli di UNISIM

6 Mappatura: Instruction Memory 6 Caratteristiche Contiene le istruzioni dentro un array (si occupa anche di fare il fetch delle istruzioni) Contiene il PC e lo incrementa Connessioni Manda l istruzione corrente al modulo Register File Riceve l indirizzo del salto dal modulo ALU

7 Mappatura: Register File 7 Caratteristiche Legge gli operandi per l istruzione Fa il write-back dei valori calcolati (in EX o MEM) Connessioni Riceve l istruzione dal modulo Instruction Memory Manda l istruzione con gli operandi al modulo ALU Riceve i valori per il write-back dal modulo Multiplexer from Multiplexer

8 Mappatura: ALU 8 Caratteristiche Calcola i risultati per le istruzioni di tipo ALU Calcola gli indirizzi per gli accessi alla memoria e le istruzioni di salto Connessioni Riceve l istruzione con gli operandi dal modulo RF Manda i risultati al modulo Instruction Memory (salti), al modulo Multiplexer (write-back) o al modulo Data Memory to Register

9 Mappatura: Data Memory 9 Caratteristiche Contiene la memoria dei dati (un array) Connessioni Riceve le richieste di lettura o scrittura dal modulo ALU Manda i risultati al modulo Multiplexer to Multiplexer

10 Mappatura: Register 10 Caratteristiche E parte del registro EX/MEM della pipeline DLX originale Aggiunto per facilitare lo sviluppo del modello Solo le istruzioni di memoria passano dal Data Memory Le istruzioni ALU rimangono qua per un ciclo Multiplexer sceglie una delle due istruzioni (da questo modulo o dal modulo Data Memory ) Connessioni Riceve il risultato dal modulo ALU Manda il risultato ricevuto al modulo Multiplexer to Multiplexer

11 Mappatura: Multiplexer 11 Operazione Questo modulo rappresenta lo stadio write-back Riceve i dati dal modulo Register o dal modulo Data Memory Ogni istruzione può essere di tipo ALU o MEM Manda il dato che è disponibile al modulo Register File Connessioni Riceve dati dai moduli ALU e Register Manda il risultato al modulo Register File

12 Comunicazione tra i moduli (1) 12 Esempio : connessione RF ALU Il Register File ha quattro connessioni con il modulo ALU rs1, rs2, valore immediato e PC Tutte le connessioni sono usate contemporaneamente E possibile semplificare il modello? Come creare una connessione invece di quattro? Tutti e 4 i valori si possono mandare tramite una connessione sola Semplificazione Definiamo un tipo di dati che possiamo usare per tutte le connessioni Questo tipo deve contenere tutti i possibili dati che si possono scambiare tra di loro due moduli

13 Comunicazione tra i moduli (2) 13 Tipo di dati instruction Si usa per la comunicazione tra i moduli Contiene i dati che si usano in ogni stadio della pipeline Ogni modulo usa solo i campi che gli servono non modifica gli altri Esiste dentro il modello una classe C++ che si chiama instruction

14 Modulo Instruction Memory (IM) 14 Mappatura del modello

15 IM I/O e le variabili interne 15 instrmemory.sim class InstructionMemory : module {public: /* Ports */ inport <instruction> branch; ///< Da ALU outport <instruction> instr; ///< A Register File inclock clock; }; /* State of the module */ uint32_t mem[65536]; ///< La memoria locale uint32_t pc; ///< Valore del PC bool program_finished; ///< Programma finito? uint32_t inum; ///< Numero delle istruzioni eseguite...

16 IM i processi 16 4 processi per controllare il modulo Sensibile a clock clock branch.data instr.accept Operazione Prende un istruzione dalla memoria 1. Incrementa il PC 2. Si occupa delle istruzioni di salto Accetta i dati dalla ALU se arriva un istruzione di salto Abilita l uscita se i dati sono stati accettati

17 IM processi inizio del ciclo 17 void start_of_cycle() { if(program_finished) instr.data.nothing(); else { instruction fetched_instruction = instruction(mem[pc],pc,inum); instr.data = fetched_instruction; // Log that instruction is in IF stage pipeline_log(if_stage,fetched_instruction); } } if(fetched_instruction.opcode == instruction::op_halt) program_finished = true;

18 IM processi fine del ciclo 18 void end_of_cycle() { if(instr.accept) { pc++; inum++; } if(branch.enable) } { } const instruction &br = branch.data; pc = br.rd_value;

19 IM processi branch.data 19 void on_branch() { if(branch.data.known()) { if(branch.data.something()) { branch.accept = true; } else { branch.accept = false; } } }

20 IM processi instruction.accept 20 void on_instr_accept() { instr.enable = instr.accept; }

21 IM startup 21 1) Inizializza le variabili interne 2) Carica il programma dallo stdin InstructionMemory(char *name) : module(name) { // State initialization pc = 0; inum=0; program_finished=false; load(); // Sensitivity list declaration 3) Registra i metodi sensibili } sensitive_pos_method(start_of_cycle) << clock; sensitive_neg_method(end_of_cycle) << clock; sensitive_method(on_branch) << branch.data; sensitive_method(on_instr_accept) << instr.accept;

22 Esercizio 22 dlx.tgz Sorgenti di tutti i moduli completi (*.sim) Makefile Piccoli benchmark power_nop.dlx, power.dlx Sito web Documento con la descrizione del modello (in inglese) Per ogni modulo sono specificate L interfaccia con gli altri moduli La descrizione dei processi per controllarlo

23 Esercizio istruzioni Copiare i sorgenti cp /home/users/docenti/popovzdra/dlx.tgz. tar zxvf dlx.tgz 2. Connettere tutti i moduli Modificare dlx.uni 3. Compilare il simulatore Eseguire make

24 Esercizio Completare dlx.uni 24 /* Includes */ include "alu.sim"; include "datamemory.sim"; include "instrmemory.sim"; include "registerfile.sim"; include "register.sim"; include multiplexer.sim"; /* Instances */ 1. Dichiarare le istanze dei moduli qua! /* Connections */ 2. Connettere i moduli qua! // Display pipeline at the end of each cycle. collector end_of_timestep { init = <<< pipeline_init(); >>>; record = <<< pipeline_display(timestamp()); >>>; };

25 Solution dlx.uni Dichiarare tutte le istanze instance InstructionMemory imem; instance RegisterFile regf; instance ALU alu; instance DataMemory dmem; instance Register reg; instance Multiplexer mux; 2. Connettere le istanze imem.instr >> regf.read; regf.out >> alu.in; alu.out_result >> reg.in; alu.out_branch_address >> imem.branch; alu.out_mem_address >> dmem.request; dmem.out >> mux.in1; reg.out >> mux.in2; mux.out >> regf.write;

26 Eseguire power_nop.dlx (1) 26 Un loop semplice Fa 5 iterazioni e finisce in 70 cicli Le nop sono qua per evitare gli hazard della pipeline addi r1, r0, 5 addi r2, r0, 1 nop nop nop add r2, r2, r2 addi r1, r1, -1 nop nop nop seq r10, r1, r0 nop nop nop beqz r10, -9 nop nop halt r1 5 r2 1 L0: r2 r2 + r2 r1 r r10 = (r1 == r0) if (r10 == 0) L0 halt

27 Eseguire power_nop.dlx (2) 27 $./dlx < power_nop.dlx I0 addi r1,r0,5 I1 addi r2,r0, rest of the instructions I16 nop I17 halt cycle IF ID EX MEM WB 1 I0(0) I1(1) I0(0) I2(2) I1(1) I0(0) I3(3) I2(2) I1(1) I0(0) - 5 I4(4) I3(3) I2(2) I1(1) I0(0) Rest of the pipeline log I17(65) I16(64) I15(63) - I13(61) 67 - I17(65) I16(64) I15(63) I13(61) I17(65) I16(64) I15(63) I17(65) I16(64) I17(65) Finish time: 70/0

28 Eseguire power.dlx (1) 28 power.dlx Stessa funzionalità di power_nop.dlx Senza istruzioni nop addi r1, r0, 5 addi r2, r0, 1 add r2, r2, r2 addi r1, r1, -1 seq r10, r1, r0 beqz r10, -9 nop nop halt Eseguire l esempio r1 5 r2 1 L0: r2 r2 + r2 r1 r r10 = (r1 == r0) if (r10 == 0) L0 halt./dlx < power.dlx Non finisce mai l esecuzione Interrompere la simulazione usando Ctrl + C

29 Eseguire power.dlx (2) 29 Come gestire gli hazard? E implementata la gestione degli hazard! Si deve cambiare il codice registerfile.sim, linea 19: //#define WITH_DEPENDENCY_BUBBLES Modificare in #define WITH_DEPENDENCY_BUBBLES Eseguire make un altra volta!

30 Eseguire power.dlx (3) 30 $./dlx < power.dlx I0 addi r1,r0,5 I1 addi r2,r0,1 I2 add r2,r2,r2 I3 addi r1,r1,-1 I4 seq r10,r1,r0 I5 beqz r10,-3 I6 nop I7 nop I8 halt cycle IF ID EX MEM WB 1 I0(0) I1(1) I0(0) I2(2) I1(1) I0(0) - - Rest of the pipeline log I8(32) I7(31) I8(32) Finish time: 70/0