(a) INTRODUZIONE ALLE ARCHITETTURE E ALLA SIMULAZIONE VERILOG DI PROCESSORI

Transcript

1 1 (a) INTRODUZIONE ALLE ARCHITETTURE E ALLA SIMULAZIONE VERILOG DI PROCESSORI ISA E MICROARCHITETTURA DI PROCESSORI IL PROCESSORE MU0 MODELLAZIONE VERILOG E SIMULAZIONE DEL PROCESSORE MU0

2 2 ISA E MICROARCHITETTURA DI PROCESSORI

3 INSTRUCTION SET ARCHITECTURE 3 IL PROCESSORE È UNA MACCHINA SEQUENZIALE CHE ESEGUE DELLE ISTRUZIONI RESIDENTI IN MEMORIA ALLO SCOPO DI MANIPOLARE DEI DATI A LORO VOLTA RESIDENTI IN MEMORIA. L INSTRUCTION SET ARCHITECTURE (ISA) SPECIFICA L INSIEME DELLE CARATTERISTICHE DEL PROCESSORE VISIBILI AL PROGRAMMATORE. ESSO DEFINISCE L INTERFACCIA TRA HARDWARE E SOFTWARE. L'ISA SPECIFICA LA FUNZIONALITA' DEL PROCESSORE IN TERMINI DI: DATI GESTITI REGISTRI INTERNI DESTINATI A CONTENERE I DATI DA MANIPOLARE ISTRUZIONI CHE PRELEVANO DALLA MEMORIA E MANIPOLANO QUESTI DATI ISTRUZIONI DI "SALTO" MODALITA' DI FUNZIONAMENTO SPECIALI ISTRUZIONI SPECIALI

4 C - ASSEMBLY - CODICE MACCHINA 4 CODICE AD ALTO LIVELLO (C) COMPILER CODICE ASSEMBLY ASSEMBLER+LINKER CODICE MACCHINA UN PROCESSORE È L'ESECUTORE DI ISTRUZIONI DEL PROPRIO INSTRUCTION SET TRAMITE LE ISTRUZIONI MACCHINA È POSSIBILE ESEGUIRE UN QUALUNQUE ALGORITMO SPECIFICATO IN UN LINGUAGGIO AD ALTO LIVELLO IL PROCESSORE PUÒ ESEGUIRE LE ISTRUZIONI DEL PROPRIO IS SOLO UNA VOLTA CHE LE STESSE SONO STATE CONVERTITE IN FORMATO BINARIO (CODICE MACCHINA) LA TRASFORMAZIONE DA UNA RAPPRESENTAZIONE ALL'ALTRA VIENE ESEGUITA DA DEI SW DI SUPPORTO, IL COMPILATORE E L'ASSEMBLER MEMORIA ISTRUZIONI INSTRUCTIONS BUS INSTR ADDRESSES PROCESSORE DATA BUS DATA ADDRESSES MEMORIA DATI BUS BUS

5 INSTRUCTION SET ARCHITECTURE 5 FETCH DELLE ISTRUZIONI (I) ALLO SCOPO DI ESEGUIRE UN ALGORITMO IL PROCESSORE ESEGUE DELLE ISTRUZIONI DEL PROPRIO IS ALL'ISTANTE 0 DELL'ESECUZIONE LE ISTRUZIONI CHE CODIFICANO IL PROGRAMMA DA ESEGUIRE RISIEDONO NELLA MEMORIA ISTRUZIONI PER POTER ESSERE ESEGUITA DAL PROCESSORE CIASCUNA ISTRUZIONE DEVE ESSERE CARICATA IN UN REGISTRO INTERNO DEL PROCESSORE (FETCH DELL'ISTRUZIONE) SOLITAMENTE IL REGISTRO DESTINATO A CONTENERE L'ISTRUZIONE CORRENTE E' DENOMINATO INSTRUCTION REGISTER (IR) IL FLUSSO DI ESECUZIONE DELLE ISTRUZIONI VIENE DEFINITO DALLA DISLOCAZIONE IN MEMORIA DELLE ISTRUZIONI STESSE E DALLA TECNICA DI FETCH UTILIZZATA IL FLUSSO NORMALE DI ESECUZIONE (CHE NON FA USO DELLE ISTRUZIONI DEDICATE CHE SI OCCUPANO DI MODIFICARE TALE FLUSSO) PREVEDE LA ESECUZIONE SEQUENZIALE DELLE ISTRUZIONI SECONDO L'ORDINE DI SALVATAGGIO IN MEMORIA

6 INSTRUCTION SET ARCHITECTURE 6 FETCH DELLE ISTRUZIONI (II) UN REGISTRO INTERNO DEL PROCESSORE CONTIENE L'INDIRIZZO DELLA LOCAZIONE DI MEMORIA ALL'INTERNO DELLA QUALE E' CONTENUTA LA PROSSIMA ISTRUZIONE DA ESEGUIRE. TALE REGISTRO PRENDE IL NOME DI PROGRAM COUNTER (PC) OGNI QUALVOLTA VIENE CARICATA ED ESEGUITA UNA ISTRUZIONE CHE NON PREVEDA LA MODIFICA DEL FLUSSO DI ESECUZIONE IL PC VIENE INCREMENTATO IN AUTOMATICO IN MODO CHE LA PROSSIMA ISTRUZIONE CARICATA SULL'IR E QUINDI ESEGUITA SIA LA SUCCESSIVA A QUELLA ATTUALMENTE ESEGUITA (SEQUENZA DI ESECUZIONE NORMALE) LA MODIFICA DEL FLUSSO DI ESECUZIONE SEQUENZIALE VIENE GESTITA TRAMITE LE ISTRUZIONI DI SALTO. SUPPONENDO CHE LA PRIMA ISTRUZ SIA MEMORIZZATA ALLA LOCAZIONE DI MEMORIA 0, CHE CIASCUINA ISTRUZIONE OCCUPI UNA SOLA LOCAZIONE, E CHE NESSUNA DELLE PRIME 10 ISTRUZIONI SIA UNA ISTRUZIONE DI SALTO, LA SEQUENZA DI ESECUZIONE SAREBBE LA SEGUENTE: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,... SUPPONENDO CHE LA ISTRUZIONE 3 SIA UNA ISTRUZIONE DI SALTO (JUMP 7) LA SEQUENZA DI ESECUZIONE SAREBBE: 0, 1, 2, 3, 7, 8, 9,...

7 INSTRUCTION SET ARCHITECTURE 7 TIPOLOGIE DI ISTRUZIONI LE PRINCIPALI TIPOLOGIE DI ISTRUZIONI SONO 3, A CUI VANNO AGGIUNTE ISTRUZIONI DI TIPO ETEROGENEO NON CLASSIFICABILI IN MANIERA SINTETICA, E CHE PER ORA NON VEDIAMO. 1. ISTRUZIONI DI SPOSTAMENTO DATI: SI OCCUPANO DI SPOSTARE I DATI DALLA MEMORIA AI REGISTRI INTERNI DEL PROCESSORE E VICEVERSA, ESISTONO INOLTRE ISTRUZIONI CHE SPOSTANO I DATI FRA REGISTRI INTERNI E PIU' RARAMENTE ISTRUZIONI CHE SPOSTANO I DATI FRA LOCAZIONI DI MEMORIA 2. ISTRUZIONI DI MANIPOLAZIONE DATI: SI OCCUPANO DI PRELEVARE I DATI DA LOCAZIONI (DI SOLITO DAI REGISTRI INTERNI), DI UTILIZZARLI COME OPERANDI SORGENTE PER DELLE OPERAZIONI LOGICO/ARITMETICHE E DI SALVARE IL RISULTAO IN ALTRE LOCAZIONI (DI SOLITO DAI REGISTRI INTERNI). 2. ISTRUZIONI DI MODIFICA DEL FLUSSO DI ESECUZIONE (SALTO): SI OCCUPANO DI MODIFICARE IL CONTENUTO DEL PC IN MODO DA MODIFICARE IL FLUSSO DI ESECUZIONE DEFINITO DALL'INCREMENTO AUTOMATICO DEL PC STESSO

8 ARCHITETTURA E MICROARCHITETTURA DI PROCESSORI 8 L INSTRUCTION SET ARCHITECTURE (ISA) SPECIFICA L INSIEME DELLE CARATTERISTICHE DEL PROCESSORE VISIBILI AL PROGRAMMATORE. ESSO DEFINISCE L INTERFACCIA TRA HARDWARE E SOFTWARE. PER MICROARCHITETTURA DEL PROCESSORE SI INTENDE L ORGANIZZAZIONE INTERNA DEL PROCESSORE STESSO. PROCESSORI CON DIVERSE MICROARCHITETTURE POSSONO CONDIVIDERE LO STESSO ISA

9 MICROARCHITETTURA DI PROCESSORI 9 ELEMENTI BASE Program Counter (PC) Instruction Register (IR) Arithmetic & Logic Unit (ALU) Registri Interni (GPR, SPR, FPR, ACC) Multiplexers Special Function Units (SFU) Logica di controllo

10 10 ESEMPIO COMPLETO: IL PROCESSORE MU0

11 MU0 ISA 11 Istruzioni Formato unico a 16 bit, 4 di opcode e 12 di indirizzo Dati A 16 bit 4 bit 12 bit opcode address = S

12 MU0 ISA 12 Descrizione dell ISA Modi di indirizzamento Indirizzamento diretto da memoria 1 solo indirizzo specificato Registri Registro Accumulatore ACC (implicito) Program Counter PC (implicito) Tipi di dato Half word signed (16 bit)

13 MU0 ISA 13 INSTRUCTION SET Istruzione Opcode (HEX) Opcode (BIN) Descrizione LDA S ACC = mem[s] STO S mem[s] = ACC ADD S ACC = ACC + mem[s] SUB S ACC = ACC - mem[s] JMP S PC = S JGE S if (ACC >= 0) PC = S JNE S if (ACC!= 0) PC = S STP stop

14 14 UNA POSSIBILE MICROARCHITETTURA DEL PROCESSORE MU0

15 IL PROCESSORE MU0 DATAPATH E CONTROLLO 15 FSM CONTROL SIGNALS OPCODE, OTHER SIGNALS DATAPATH

16 IL PROCESSORE MU0 DATAPATH 16 MEMORY MUX IR PC A ALU B MUX ACC

17 IL PROCESSORE MU0 IMPLEMENTAZIONE DEL CONTROLLO Ciclo di esecuzione dell istruzione 17 Fetch IR <= MEM[PC]; PC <= PC+1; Execute ACC <= ACC +- Mem[S]; or ACC <= Mem[S]; or Mem[S] <= ACC; or PC <= S;

18 IL PROCESSORE MU0 FETCH DELLE ISTRUZIONI 18 PC <= PC+1; IR <= MEM[PC]; MEMORY IR PC A ALU

19 IL PROCESSORE MU0 ESECUZIONE DELLE ISTRUZIONI (1) 19 MEMORY Istruzione LDA S STO S ADD S SUB S JMP S JGE S JNE S STP Descrizione ACC = mem[s] mem[s] = ACC ACC = ACC + mem[s] ACC = ACC - mem[s] PC = S if (ACC >= 0) PC = S if (ACC!= 0) PC = S stop IR ACC

20 IL PROCESSORE MU0 ESECUZIONE DELLE ISTRUZIONI (2) 20 MEMORY Istruzione LDA S STO S ADD S SUB S JMP S JGE S JNE S STP Descrizione ACC = mem[s] mem[s] = ACC ACC = ACC + mem[s] ACC = ACC - mem[s] PC = S if (ACC >= 0) PC = S if (ACC!= 0) PC = S stop IR ACC

21 IL PROCESSORE MU0 ESECUZIONE DELLE ISTRUZIONI (3) 21 MEMORY Istruzione LDA S STO S ADD S SUB S JMP S JGE S JNE S STP Descrizione ACC = mem[s] mem[s] = ACC ACC = ACC + mem[s] ACC = ACC - mem[s] PC = S if (ACC >= 0) PC = S if (ACC!= 0) PC = S stop A IR ALU B ACC

22 IL PROCESSORE MU0 ESECUZIONE DELLE ISTRUZIONI (4) 22 Istruzione LDA S STO S ADD S SUB S JMP S JGE S JNE S STP Descrizione ACC = mem[s] mem[s] = ACC ACC = ACC + mem[s] ACC = ACC - mem[s] PC = S if (ACC >= 0) PC = S if (ACC!= 0) PC = S stop IR PC

23 IL PROCESSORE MU0 ESECUZIONE DELLE ISTRUZIONI (5) 23 Istruzione LDA S STO S ADD S SUB S JMP S JGE S JNE S STP Descrizione ACC = mem[s] mem[s] = ACC ACC = ACC + mem[s] ACC = ACC - mem[s] PC = S if (ACC >= 0) PC = S if (ACC!= 0) PC = S stop IR PC ACC

24 24 PROGRAMMAZIONE DELL MU0: PROGRAMMA 1 (MU0_S1) SOMMA

25 PROGRAMMAZIONE DELL MU0 25 PROGRAMMA MU0_S1 SPECIFICA E CODICE ASSEMBLY SPECIFICA C = A + B; Me0x100] Me0x101] Me0x102] CODICE lda 0x100 add 0x101 sto 0x102

26 PROGRAMMAZIONE DELL MU0 26 PROGRAMMA MU0_S1 CODIFICA IN LINGUAGGIO MACCHINA: ISTR #1 lda 0x100 // inizializza l accumulatore col dato A CODIFICA ASM 4 12 Opcode Immediate Op=0x0 Imm=0x100 CODIFICA 0100

27 PROGRAMMAZIONE DELL MU0 27 PROGRAMMA MU0_S1 CODIFICA IN LINGUAGGIO MACCHINA: ISTR #2 add 0x101 // addiziona all accumulatore il dato B CODIFICA ASM Op=0x Opcode Immediate CODIFICA 2101 Imm=0x101

28 PROGRAMMAZIONE DELL MU0 28 PROGRAMMA MU0_S1 CODIFICA IN LINGUAGGIO MACCHINA: ISTR #3 store 0x102 // memorizza il risultato CODIFICA ASM Op=0x Opcode Immediate CODIFICA 1102 Imm=0x102

29 PROGRAMMAZIONE DELL MU0 29 PROGRAMMA MU0_S1 CODIFICA IN LINGUAGGIO MACCHINA: ISTR #4 stop // stoppa la simulazione 4 12 Opcode CODIFICA ASM Op=0x7 CODIFICA 7000

30 30 MODELLAZIONE E SIMULAZIONE DEL PROCESSORE MU0

31 MODELLAZIONE VERILOG DELL MU0 31 CODIFICA VERILOG DEL SISTEMA COMPLETO La gerarchia del progetto è la seguente: testbench.v (top della gerarchia) memory.v (istanza MEM) mu0_core.v (istanza MU0) MU0_dp.v (istanza mu0dp) mux2x1.v (istanza MUX_A) mux_2x1_ext.v (istanza MUX_B) reg_rst.v (istanze PC; IR) tri_buffer.v (istanza tribuf) reg_acc.v (istanza ACC) alu.v (istanza ALU) MU0_fsm.v (istanza muofsm)

32 SIMULAZIONE DELL MU0 32 CONVERSIONE IN UN FORMATO LEGGIBILE DAL SIMULATORE VERILOG (READMEMH) CODICE BINARIO CONVERSIONE BINARIA (MANUALE) CODICE ASSEMBLY MEMORIA DATI/ ISTRUZIONI (MODELLO VERILOG) DATA/INSTRUCTIONS BUS ADDRESSES BUS MU0 (MODELLO VERILOG) SIMULATORE VERILOG (MODELSIM) RISULTATI FINALI CONVERSIONE IN UN FORMATO LEGGIBILE DAL SIMULATORE VERILOG (READMEMH) DATI INIZIALI

33 SIMULAZIONE DELL MU0 SIMULATORE VERILOG: MODELSIM 33

34 34 SIMULAZIONE DELL MU0: PROGRAMMA 1- MU0_S1 ISTRUZIONE DI ASSEGNAMENTO CON SOMMA

35 SIMULAZIONE DELL MU0 CODIFICA DEL TESTBENCH 35 vedi sorgente verilog

36 SIMULAZIONE DELL MU0 36 CONTENUTO DELLA MEMORIA: file MU0_S1.hex 0100 //lda 2101 //add 1102 //sto 7000 // stop 0005 // A = 0003 // B = 16'h3 N.B. Reset Vector = 0;

37 37 PROGRAMMAZIONE E SIMULAZIONE DELL MU0: PROGRAMMA 2- MU0_S2 MODIFICA DEL FLUSSO SEQUENZIALE DI ESECUZIONE

38 PROGRAMMAZIONE E SIMULAZIONE DELL MU0 PROGRAMMA MU0_S2: CONTENUTO DELLA 0100 //lda 2101 //add 1102 //sto 4005 //j 1103 //sto 1104 //sto 5008 //jge 1103 //sto 0100 //load 3100 //sub 3100 //sub 5012 //jge 1105 //sto // A = 0003 // B = 16'h3 Salto incondizionato: scrive M[100]+M[101] alla loc. 104 ma non alla 103 Salto condizionato eseguito (ACC>0) : non scrive alla loc 103 Salto condizionato non eseguito: scrive alla loc

39 39 PROGRAMMAZIONE E SIMULAZIONE DELL MU0: PROGRAMMA 3- MU0_S3 VETTORI E LOOP

40 PROGRAMMAZIONE ASSEMBLY: ESECUZIONE CONDIZIONALE (1) 40 L'ESECUZIONE CONDIZIONALE PUÒ ESSERE GESTITA TRAMITE L'USO DI ISTRUZIONI DI SALTO CONDIZIONATO E DI SALTO INCONDIZIONATO. if (cond) A; else B; branch(cond==1),taga; tagb: B; branch(1),end; taga: A; end: if (cond) A; branch(cond==1),taga; branch(1),end; taga: A; end:

41 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (2) 41 NORMALMENTE L'ESECUZIONE CICLICA (LOOP) VIENE GESTITA TRAMITE L'UTILIZZO DI UN REGISTRO CONTATORE GESTISCE IL NUMERO DI ITERAZIONI UN REGISTRO INDICE PER LA GESTIONE DELL'ACCESSO AGLI ELEMENTI DI OGNI VETTORE L'ISA DEL PROCESSORE MU0 PRECEDE LA PRESENZA DEL SOLO REGISTRO ACCUMULATORE, E SUPPORTA ESCLUSIVAMENTE L'INDIRIZZAMENTO IMMEDIATO (L'INDIRIZZO DELLA LOCAZIONE DI MEMORIA CUI ACCEDERE E' CABLATO NEL CODICE). DI CONSEGUENZA LA GESTIONE DELL'ACCESSO AGLI ELEMENTI DI UN VETTORE ALL'INTERNO DI UN LOOP PUO' ESSERE CODIFICATO SOLO CON L'UNROLLING DEL LOOP STESSO (A MENO DI NON SCRIVERE CODICE AUTOMODIFICANTE).

42 PROGRAMMAZIONE DELL MU0 42 PROGRAMMA MU0_S3: SPECIFICA // Codice C S = 0; for( i=0; i<5;i++ ) if (a[i] >= 0) S = S + a[i]; S = 2*S; Contenuto della memoria all istante 0 Mem[12 h100] Mem[12 h101]. Mem[12 h104] h200] Contenuto richiesto della memoria alla fine della simulazione S Mem[12 h200]

43 PROGRAMMAZIONE DELL MU0 PROGRAMMA MU0_S3: CODICE LDA 100; // carica a[0] nell JGE 003; // se a[0] >= 0 salta all istruz che scrive a[0] nella loc di mem sulla quale accumulo il risultato J 004; // altrimenti salta all istruz che carica a[1] nell STO 200; // scrive a[0] nella loc di mem sulla quale accumulo il risultato parziale LDA 101; // carica a[1] nell JGE 007; // se a[1] >= 0 salta all istruz che lo addiziona al ris J 009; // altrimenti salta all istruz che carica ADD 200; // addiziona il ris parziale ad STO 200; // scrive il nuovo risultato parziale nella loc di mem LDA 102; // carica a[2] nell JGE 00C; // se a[2] >= 0 salta all istruz che lo addiziona al ris J 00E; // altrimenti salta all istruz che carica ADD 200; // addiziona il ris parziale ad STO 200; // scrive il nuovo risultato parziale nella loc di mem LDA 103; // carica a[3] nell JGE 011; // se a[3] >= 0 salta all istruz che lo addiziona al ris J 013; // altrimenti salta all istruz che carica ADD 200; // addiziona il ris parziale ad STO 200; // scrive il nuovo risultato parziale nella loc di mem LDA 104; // carica a[4] nell JGE 016; // se a[4] >= 0 salta all istruz che lo addiziona al ris J 018; // altrimenti salta all istruz che carica il risultato finale della somma nell ADD 200; // addiziona il ris parziale ad STO 200; // scrive il risultato finale della somma nella loc di mem LDA 200; // carica il risultato finale della somma nell ADD 200; // addiziona il risultato finale della somma a se STO 200; // scrive il valore finale di S nella loc di mem STP; // stoppa la simulazione 43