(c) INTRODUZIONE ALLE ARCHITETTURE DI PROCESSORI (II)

Transcript

1 (c) INTRODUZIONE ALLE ARCHITETTURE DI PROCESSORI (II) 1 IL PROCESSORE MIPS ISA RIDOTTO emips PROGRAMMAZIONE ASSEMBLY DELL emips MICROARCHITETTURA SINGOLO CICLO emips-sc SEQUENZA DELLE ARCHITETTURE CHE ANALIZZEREMO DURANTE IL CORSO FRAMEWORK PER L'ESECUZIONE DI APPLICAZIONI ASSEMBLY SUL MODELLO VERILOG DI UN SISTEMA DI ELABORAZIONE BASATO SUL PROCESSORE emips-sc VALUTAZIONE DELLE PRESTAZIONI DEI PROCESSORI MICROARCHITETTURA MULTI-CICLO SEQUENZIALE emips-mc

2 2 LA FAMIGLIA DI PROCESSORI MIPS

3 LA FAMIGLIA MIPS 3 La prima versione dell ISA MIPS è una delle prime architetture di tipo RISC (Reduced Instruction Set Compnent) ed è stata sviluppata da John L. Hennessy. L ISA si è quindi evoluta in innumerevoli versioni ciascuna delle quali è stata implementata da diverse microarchitetture. Si parla di famiglia di processori Mips. Le più evolute versioni di processori MIPS sono attualmente integrate in dispositivi elettronici embedded di largo utilizzo. Consolle per l intrattenimento (la Playstation!!) Stampanti Laser Decoder TV Satellitare Router Navigatori satellitari per automobili Macchine fotografiche digitali

4 MIPS ISA: GENERALITA 4 L architettura dei processori della famiglia Mips è di tipo load/store: non è possibile operare direttamente sui dati residenti in memoria ma è necessario prima copiarli nei registri interni tramite istruzioni dedicate. E prevista la presenza di un moltiplicare integrato per dati a 32 bit con risultato a 64 bit. I registri interni visibili del Mips sono: 32 registri general purpose a 32 bit, il registro zero contiene 0 e non può essere modificato due registri a 32 bit, Hi e Lo, per memorizzare rispettivamente i 32 bit più significativi e i 32 bit meno significativi del risultato di moltiplicazione un registro Program Counter a 32 bit, che contiene l indirizzo dell istruzione da eseguire un registro Interrupt Address Register Registri per elaborazione Floating Point

5 MIPS R2000 ISA : ISTRUZIONI 5 Il documento che specifica l'instruction Set completo è disponibile sul sito community

6 MIPS R2000 ISA DEDICATO AGLI INTERI 6 Ci occuperemo del sottoinsieme dell ISA del MIPS R2000 (da ora in poi semplicemente MIPS ISA) dedicato agli interi. Trascureremo per motivi di tempo la gestione dell elaborazione floating point (che è comunque opzionale nella maggior parte degli ISA per elaborazione embedded) Il sottoinsieme dedicato agli interi consta di 75 istruzioni, che possono essere classificate per funzionalità: Istruzioni di lettura e scrittura dalla memoria (8) Istruzioni aritmetico-logiche (40) Istruzioni di scambio dati fra registri interni (4) Istruzioni di modifica del flusso di esecuzione Salto incondizionato (4) Salto condizionato (17)

7 MIPS ISA: FORMATO DELLE ISTRUZIONI 7 Le istruzioni sono a lunghezza fissa (32 bit), in tre possibili formati: 1. Immediate (I Type) opcode rs rt Immediate 6bit 5bit 5bit 16bit 2. Reg Type (R Type) opcode rs rt rd shamt function 6bit 5bit 5bit 5bit 5bit 6bit 3. Jump (J Type) opcode target 6bit 26bit

8 8 MIPS ISA RIDOTTO: emips

9 INSTRUCTION SET emips 9 Inizieremo la trattazione analizzando nel dettaglio microarchitetture semplificate che implementano un sottoinsieme minimo delle istruzioni, che chiameremo emips Non è implementata la moltiplicazione, non vi sono quindi istruzioni di scambio fra registri interni. L IS semplificato contiene almeno una istruzione per ciascuna delle categorie rimanenti: Istruzioni di lettura e scrittura dalla memoria (2 su 8) Istruzioni aritmetico-logiche (5 su 40) Istruzioni di scambio di dati tra registri interni (0 su 4) Istruzioni di modifica del flusso di esecuzione - Salto incondizionato (0 su 4) - Salto condizionato (1 su 17)

10 INSTRUCTION SET emips 10 load word (lw): carica su un registro interno un valore dalla memoria store word (sw): scrive in memoria il valore contenuto in un registro add : somma del valore di due registri subtract (sub): sottrazione tra il valore di due registri and: and logico bit a bit del contenuto di due registri or: or logico bit a bit del contenuto di due registri set on less than (slt): scrive 1 sul registro destinazione se il primo operando è minore del secondo, zero altrimenti. branch on equal (beq): salto condizionato all'uguaglianza dei valori contenuti nei 2 registri confrontati

11 INSTRUCTION SET emips 11 NOTAZIONE CON INDICAZIONE DI REGISTRI GENERICI DESCRIZIONE Load word Store word Add Subtract And Or Set on less than Branch if equal ASSEMBLY lw Rt, imm(rs) sw Rt, imm(rs) add Rd, Rs, Rt sub Rd, Rs, Rt and Rd, Rs, Rt or Rd, Rs, Rt slt Rd, Rs, Rt beq Rs, Rt, label1 FUNZIONALITA REGS[Rt] = Mem(REGS[Rs]+imm) Mem(REGS[Rs] + imm) = REGS[Rt] REGS[Rd] = REGS[Rs] + REGS[Rt] REGS[Rd] = REGS[Rs] REGS[Rt] REGS[Rd]= REGS[Rs] and REGS[Rt] REGS[Rd] = REGS[Rs] or REGS[Rt] if (REGS[Rs]<REGS[Rt]) REGS[Rd] = 1 if (REGS[Rs]==REGS[Rt]) PC = PC+4+imm N.B. REGS[Rs] = contenuto del registro Rs del register file imm = valore che concorre a definire la locazione di memoria interessata al trasferimento

12 INSTRUCTION SET emips 12 NOTAZIONE CON INDICAZIONE DI REGISTRI DI ESEMPIO DESCRIZIONE ASSEMBLY FUNZIONALITA Load word lw $3, 0x0100($2) REGS[$3] = Mem(REGS[$2]+0x0100) Store word sw $3, 0x0100($2) Mem(REGS[$2] + 0x0100) = REGS[$3] Add add $4, $2, $3 REGS[$4] = REGS[$2] + REGS[$3] Subtract sub $4, $2, $3 REGS[$4] = REGS[$2] REGS[$3] And and $4, $2, $3 REGS[$4]= REGS[$2] and REGS[$3] Or or $4, $2, $3 REGS[$4 = REGS[$2] or REGS[$3] Set on less than slt $4, $2, $3 if (REGS[$2]<REGS[$3]) REGS[$4] = 1 Branch if equal beq $2, $3, label1 if (REGS[$2]==REGS[$3]) PC = PC+4+imm N.B. $2 = REGISTRO 2 REGS[$2] = contenuto del registro $2 del register file

13 INSTRUCTION SET emips: GESTIONE DELLA MEMORIA L'ISA MIPS completo gestisce dati di 6 tipi diversi: a 8, 16, 32 bit in rappresentazione naturale o complemento a 2. Il sistema di memoria deve poter gestire tutti i tipi di dato esistenti, fornendo i dati in uscita nella maniera appropriata, a seconda del valore assunto dai bit di controllo associati (optype). Essendo il dato minimo a 8 bit, la locazione di memoria elementare deve essere di 8 01 // Most significant byte del dato 21 // byte 2 del dato AB // byte 3 del dato 00 // Least significant byte del dato 43 // Most significant byte del dato 01 // Least significant byte del dato C1 // Dato 3 DATO 1, a 32 bit: 0121AB00 DATO 2, a 16 bit: 4301 DATO 3, a 8 bit: C1 13 // MODELLO VERILOG DELLA MEMORIA DATI case (optype) (word) DataOut = {Data[Addr+0],Data[Addr+1],Data[Addr+2],Data[Addr+3]}; (halfword) DataOut = {16 h0000,data[addr+0],data[addr+1]}; (byte) DataOut = {24 h000000, Data[Addr] }; endcase

14 INSTRUCTION SET emips: GESTIONE DELLA MEMORIA 14 Per non escludere la possibilità che al processore sia associato un sistema di memoria con memoria dati ed istruzioni non separate (memoria unica, modello di Von Neumann) è necessario che anche la memoria istruzioni sia indirizzabile un byte alla volta, nonostante le istruzioni siano sempre di 4 byte Ciò implica che l'aggiornamento del PC sia di 4 in 01 // Most significant byte dell istr 00 // Least significant byte dell istr 43 // Most significant byte dell istr 01 // Least significant byte dell istr 2 ISTRUZIONE 1:0121AB00 ISTRUZIONE 2: 4301C101 // MODELLO VERILOG DELLA MEMORIA INSTRUZIONI DataOut = {Data[Addr+0],Data[Addr+1],Data[Addr+2],Data[Addr+3]};

15 15 PROGRAMMAZIONE ASSEMBLY DEL PROCESSORE emips-sc

16 PROGRAMMAZIONE ASSEMBLY: ISTRUZIONI DI ASSEGNAMENTO SIMULAZIONE emips_s1 16 Specifica C integer A,B,C; // dati a 32 bit C= A + B; Specifica aggiuntiva 1: memoria dati B emips assembly lw $1,0x0100($0) lw $2, 0x0104($0) add $3,$2,$1 sw $3, 0x0200($0) Specifica aggiuntiva 2: memoria dati (t=fine C

17 PROGRAMMAZIONE ASSEMBLY: ESECUZIONE CONDIZIONALE (2) 17 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:

18 PROGRAMMAZIONE ASSEMBLY: ESECUZIONE CONDIZIONALE (1) SIMULAZIONE emips_s2 18 Specifica C integer A,B,C; // dati a 32 bit if (A!=B) C = A + B; else C = A - B; Specifica aggiuntiva 1: memoria dati B Specifica aggiuntiva 2: memoria dati (t=fine C emips assembly lw $1,0x0100($0) lw $2, 0x0104($0) beq $1,$2, else_tag if_tag: add $3,$2,$1 beq $0,$0, store else_tag: sub $3,$2,$1 store: sw $3, 0x0200($0)

19 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (1) 19 SIMULAZIONI emips_s3 ed emips_s4: SPECIFICA C Specifica C integer acc; // dati a 32 bit integer a[16]; acc = 0; for( i=0; i<16;i++ ) acc=acc+a[i]; Specifica aggiuntiva 1: memoria dati 0x4 Specifica aggiuntiva 2: memoria dati (t=fine acc

20 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (2) 20 L'ESECUZIONE CICLICA (LOOP) VIENE GESTITA TRAMITE L'UTILIZZO DI UN REGISTRO CONTATORE CHE: VIENE INIZIALIZZATO ALL'ESTERNO DEL LOOP IN FUNZIONE DEL NUMERO DI ITERAZIONI DA ESEGUIRE VIENE AGGIORNATO AD OGNI ITERAZIONE DEL LOOP VIENE TESTATO AD OGNI ITERAZIONE DEL LOOP, IL TEST CHE VERIFICA LA FINE DEL CICLO NE INTERROMPE L'ESECUZIONE L'ACCESSO AGLI ELEMENTI DI UN VETTORE CON INDICE DIPENDENTE DALL'INDICE DEL LOOP PUO' ESSERE GESTITA TRAMITE UN REGISTRO PUNTATORE CHE: VIENE INIZIALIZZATO ALL'ESTERNO DEL LOOP VINE UTILIZZATO AD OGNI ITERAZIONE DEL LOOP PER COMPORRE L'INDIRIZZO DELLA LOCAZIONE DI VIENE AGGIORNATO AD OGNI ITERAZIONE DEL LOOP. L'AGGIORNAMENTO DIPENDE DAL NUMERO DI LOCAZIONI DI MEMORIA OCCUPATE DA CIASCUN ELEMENTO DEL VETTORE

21 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (3) 21 SIMULAZIONE emips_s3: CODIFICA ASSEMBLY UTILIZZO DEI REGISTRI $1 HA LA FUNZIONE DI REGISTRO ACCUMULATORE $2 HA LA FUNZIONE DI CONTATORE DEL LOOP $3 HA LA FUNZIONE DI PUNTATORE ALL'ELEMENTO CORRENTE DEL VETTORE $4 MEMORIZZA LA COSTANTE USATA PER AGGIORNARE IL REGISTRO CONTATORE $5 MEMORIZZA LA COSTANTE USATA PER AGGIORNARE IL REGISTRO PUNTATORE $6 MEMORIZZA LA COSTANTE USATA PER IL TEST DI FINE CICLO $7 HA LA FUNZIONE DI BUFFER TEMPORANEO LA SEQUENZA UTILIZZATA E' CRESCENTE, DALL'ELEMENTO 1 ALL'ELEMENTO 15. L'ELEMENTO 0 E' UTILIZZATO PER INIZIALIZZARE L'ACCUMULATORE

22 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (4) 22 SIMULAZIONE emips_s3: CODIFICA ASSEMBLY lw $1,0x100($0) ; inizializza il registro accumulatore $1 col dato a[0] add $2,$0,$0 ; inizializza il reg contatore $2 a 0 add $3,$0,$0 ; inizializza il reg puntatore $3 a 0 lw $4,0x400($0) ; inizializza il reg $4 utilizzato per aggiornare il registro contatore lw $5,0x404($0) ; inizializza il reg $5 utilizzato per aggiornare il reg puntatore lw $6,0x408($0) ; inizializza il registro utilizzato per il test di fine ciclo a 15=0xF loop: add $2,$2,$4 ; aggiorna il registro contatore sommando 1 add $3,$3,$5 ; aggiorna il registro puntatore sommando 4 lw $7, 0x100($3); carica il dato a[i] sul registro buffer $7, la seq è 1,2,..,15. add $1,$1,$7 ; aggiorna l'accumulatore sommando il buffer beq $2,$6,store ; fa il test del registro contatore, se $2=$6 interrompe il ciclo beq $0,$0, loop ; salta all'inizio del ciclo store: sw $1,0x200($0) ; scrive il risultato in memoria ;la coppia di istruzioni seguente provoca lo stop della simulazione lw $10, 0x500($0); sw $0, 0x0($10) ;

23 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (5) 23 SIMULAZIONE emips_s4: CODIFICA ASSEMBLY E' POSSIBILE UTILIZZARE UN SOLO REGISTRO CHE ACCORPI LE FUNZIONALITA' DI REGISTRO CONTATORE E DI REGISTRO PUNTATORE IN QUESTO CASO L'INIZIALIZZAZIONE E L'AGGIORNAMENTO DEL REGISTRO, NONCHE' IL TEST DI FINE CICLO, VANNO GESTITI IN FUNZIONE DEL FATTO CHE LA FUNZIONALITA' DI REGISTRO PUNTATORE RICHIEDE L'ACCESSO A DATI CHE POSSONO OCCUPARE PIU' LOCAZIONI DI MEMORIA

24 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (6) 24 SIMULAZIONE emips_s4: CODIFICA ASSEMBLY UTILIZZO DEI REGISTRI $1 HA LA FUNZIONE DI REGISTRO ACCUMULATORE $2 HA LA FUNZIONE DI CONTATORE DEL LOOP E ANCHE DI PUNTATORE ALL'ELEMENTO CORRENTE DEL VETTORE $3 HA LA FUNZIONE DI BUFFER TEMPORANEO $4 MEMORIZZA LA COSTANTE USATA PER AGGIORNARE IL REGISTRO CONTATORE-PUNTATORE LA SEQUENZA UTILIZZATA E' STAVOLTA DECRESCENTE, DALL'ELEMENTO 15 ALL'ELEMENTO 1. L'ELEMENTO 0 E' UTILIZZATO PER INIZIALIZZARE L'ACCUMULATORE

25 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (7) 25 SIMULAZIONE emips_s4: CODIFICA ASSEMBLY lw $1,0x100($0) ; inizializza l'accumulatore col dato a[0] lw $2,0x400($0) ; inizializza il reg contatore/puntatore $2 lw $4,0x404($0) ; inizializza il reg utilizzato per aggiornare il reg contatore/puntatore loop: lw $3, 0x100($2); carica il dato su $3, la seq è 15,14,..,1. sub $2,$2,$4 ; aggiorna il registro contatore/puntatore sottraendo 4 add $1,$1,$3 ; aggiorna l'accumulatore beq $2,$0,store ; fa il test del registro contatore/puntatore, se $2=0 interrompe il ciclo beq $0,$0, loop ; salta all'inizio del ciclo store: sw $1,0x200($0); scrive il risultato in memoria ;la coppia di istruzioni seguente provoca lo stop della simulazione lw $10, 0x500($0); sw $0, 0x0($10);

26 26 MICROARCHITETTURA SINGOLO CICLO emips-sc

27 ARCHITETTURA DI MEMORIA 27 L architettura di memoria è di Harvard: vi sono 2 memorie separate, una per i dati ed una per le istruzioni. MemRead MemWrite Instr_addr_bus proc_dout_bus INSTRUCTIONS MEMORY Instr_Data_bus emips-sc proc_din_bus Addr_bus DATA MEMORY clk rst clk

28 CARICAMENTO DELLE ISTRUZIONI (FETCH) 28 La prima operazione da eseguire all inizio di ciascuna istruzione è la lettura dell istruzione stessa dalla memoria. Questa operazione è chiamata fetch. Il registro Program Counter contiene l indirizzo da cui leggere l istruzione La fase di fetch si conclude con l incremento del Program Counter in modo che contenga l indirizzo dell istruzione successiva da leggere e quindi eseguire. Il flusso di esecuzione normale del programma è quindi sequenziale. Il PC viene incrementato di 4 anzichè di 1 perchè si suppone sempre di indirizzare una memoria indirizzabile a singoli byte, mentre le istruzioni sono di 4 byte ciascuna. PC nextpc PC_out 4 PC ADDER INSTRUCTION DATA DECODIFICA, LETTURA DEI REGISTRI ECC. INSTRUCTION ADDRESS INSTRUCTIONS MEMORY

29 COMPLETAMENTO DELL ISTRUZIONE LOAD 29 Copia un dato residente in memoria in uno dei registri del register file. L indirizzo di accesso alla memoria è la somma dell immediato e del contenuto del registro rs. Il registro rt è il registro destinazione DESCRIZIONE Load word ASSEMBLY lw Rt, imm(rs) FUNZIONALITA Rt = Mem[Rs+imm] RegWrite Instr[25:21] RaddrA ALU Operation opcode rs rt Immediate Instr[20:16] RaddrB Waddr DataIn REG FILE A B ALU Instr[15:0] IMMEDIATE EXTENDER INSTRUCTIONS MEMORY DataOut AddrIn DATA MEMORY

30 COMPLETAMENTO DELL ISTRUZIONE STORE 30 Copia il dato contenuto di uno dei registri del register file in una locazione di memoria. L indirizzo di accesso alla memoria è la somma dell immediato e del contenuto del registro rs. Il registro rt contiene l indirizzo di memoria sul quale scrivere il dato DESCRIZIONE Store word ASSEMBLY sw Rt, imm(rs) FUNZIONALITA Mem[Rs+imm] = Rt RegWrite opcode rs rt Immediate Instr[25:21] Instr[20:16] RaddrA RaddrB REG Waddr FILE DataIn A B ALU Operation ALU Instr[15:0] IMMEDIATE EXTENDER INSTRUCTIONS MEMORY DataIn AddrIn DATA MEMORY

31 COMPLETAMENTO DELLE ISTRUZIONI ARITMETICO-LOGICHE 31 La ALU compie l operazione specificata dal campo function I 2 operandi sono specificati dal contenuto dei campi rs ed rt. Il risultato va in ingresso al registro specificati dal contenuto dei campi rd DESCRIZIONE Add ASSEMBLY add Rd, Rs, Rt FUNZIONALITA Rd = Rs + Rt RegWrite opcode rs rt rd shamt function Instr[25:21] Instr[20:16] Instr[15:11] RaddrA RaddrB Waddr DataIn REG FILE A B ALU Operation ALU Instr[15:0] INSTRUCTIONS MEMORY

32 COMPLETAMENTO DELLE ISTRUZIONE BRANCH EQUAL 32 Modifica condizionalmente il flusso sequenziale di esecuzione scrivendo il contenuto del campo immediate sul PC nel caso si verifichi la condizione di uguaglianza fra i 2 registri puntati dai campi rs ed rt La ALU genera un segnale di controllo che segnala se il risultato di una operazione è nullo (segnale zero). Si esegue la sottrazione tra i contenuti dei registri rs e rt. Il segnale zero controlla un mux che permette di condividere l ingresso del PC tra PC+4 e l indirizzo di salto. L indirizzo di salto si ottiene sommando PC+4 all immediato (offset). DESCRIZIONE Branch if equal ASSEMBLY beq Rs, Rt, offset FUNZIONALITA if (Rs==Rt) PC = PC+offset opcode rs rt Immediate Instr[25:21] Instr[20:16] RaddrA RegWrite RaddrB REG Waddr FILE DataIn A B PC+4 2 shift ADD Branch zero ALU PC+4 and 0 1 PCSrc PC INSTRUCTIONS MEMORY Instr[15:0] IMMEDIATE EXTENDER

33 COMPOSIZIONE DEL DATAPATH 33 Possiamo ottenere il datapath dall unione dei pezzi di datapath dedicati alla singole classi di istruzioni basandoci sul massimo riutilizzo delle risorse. La maggior parte delle risorse possono infatti essere condivisa da più classi di istruzioni Quando una porta può ricevere segnali diversi a seconda dell istruzione è richiesta la presenza di un multiplexer per condividere la porta. il campo rs dell istruzione va sempre nell ingresso RaddrA del register file il campo rt dell istruzione va sempre nell ingresso RaddrB del register file in ingresso a Waddr può andare o il campo rt o il campo rd a seconda del valore dell opcode Il primo operando della ALU è sempre la prima uscita del register file Il secondo operando della ALU può essere la seconda uscita del register file o l immediato esteso a 32 bit a seconda del valore dell opcode L ingresso DataIn del register file può essere il dato in lettura dalla memoria oppure il risultato della ALU.

34 DATAPATH 34

35 DATAPATH + BLOCCHI AUSILIARI DI CONTROLLO 35

36 MICROARCHITETTURA COMPLETA 36

37 IMPLEMENTAZIONE DEL CONTROLLO 37 Il controllo è implementato tramite una RETE COMBINATORIA che prende in ingresso il campo opcode dell istruzione e produce gli 8 segnali di controllo, 2 che vanno alla alla memoria dati esterna, e 6 che controllano i registri, i mux e gli altri moduli combinatori del datapath opcode 6 Control 2 Regdst RegWrite ALUSrc ALUOp Branch MemtoReg Jump MemRead MemWrite

38 CARICAMENTO DELLE ISTRUZIONI (FETCH) 38 La prima operazione da eseguire all inizio di ciascuna istruzione è la lettura dell istruzione stessa dalla memoria. Questa operazione è chiamata fetch. Il registro Program Counter contiene l indirizzo da cui leggere l istruzione La fase di fetch si conclude con l incremento del Program Counter in modo che contenga l indirizzo dell istruzione successiva da leggere e quindi eseguire. Il flusso di esecuzione normale del programma è quindi sequenziale. Il PC viene incrementato di 4 anzichè di 1 perchè si suppone sempre di indirizzare una memoria indirizzabile a singoli byte, mentre le istruzioni sono di 4 byte ciascuna.

39 DECODIFICA / LETTURA DEI REGISTRI 39 La fase di lettura dei registri prevede che i campi rs ed rt indirizzino il file dei registri e che il campo immediato sia decodificato In questo modo tutti i possibili operandi sono pronti per la fase di esecuzione.

40 FASI DI ESECUZIONE, LETTURA MEMORIA E RISCRITTURA DELL' ISTRUZIONI LW Copia un dato residente in memoria in uno dei registri del register file. L indirizzo di accesso alla memoria è la somma dell immediato e del contenuto del registro rs. Il registro rt è il registro destinazione DESCRIZIONE ASSEMBLY FUNZIONALITA 40 Load word lw Rt, imm(rs) Rt = Mem[Rs+imm]

41 FASI DI ESECUZIONE E LETTURA MEMORIA DELL' ISTRUZIONI SW Copia il dato contenuto di uno dei registri del register file in una locazione di memoria. L indirizzo di accesso alla memoria è la somma dell immediato e del contenuto del registro rs. Il registro rt contiene l indirizzo di memoria sul quale scrivere il dato 41 DESCRIZIONE Store word ASSEMBLY sw Rt, imm(rs) FUNZIONALITA Mem[Rs+imm] = Rt

42 FASI DI ESECUZIONE E RISCRITTURA DELLE ISTRUZIONI ARITMETICO-LOGICHE 42 La ALU compie l operazione specificata dal campo function I 2 operandi sono specificati dal contenuto dei campi rs ed rt. Il risultato va in ingresso al registro specificati dal contenuto dei campi rd DESCRIZIONE Add ASSEMBLY add Rd, Rs, Rt FUNZIONALITA Rd = Rs + Rt

43 FASI DI ESECUZIONE ED EVENTUALE SALTO DELL ISTRUZIONE BRANCH IF EQUAL Modifica condizionalmente il flusso sequenziale di esecuzione scrivendo il contenuto del campo immediate sul PC nel caso si verifichi la condizione di uguaglianza fra i 2 registri puntati dai campi rs ed rt La ALU genera un segnale di controllo che segnala se il risultato di una operazione è nullo (segnale zero). Si esegue la sottrazione tra i contenuti dei registri rs e rt. Il segnale zero controlla un mux che permette di condividere l ingresso del PC tra PC+4 e l indirizzo di salto. L indirizzo di salto si ottiene sommando PC+4 all immediato (offset). DESCRIZIONE Branch if equal ASSEMBLY beq Rs, Rt, offset FUNZIONALITA if (Rs==Rt) PC = PC+offset 43

44 MICROARCHITETTURA SINGOLO CICLO emips-sc 44 PER CHI VOLESSE APPROFONDIRE (?), UNA DESCRIZIONE PIU' DETTAGLIATA SI TROVA IN UNO DEI SEGUENTI LIBRI a) David A. Patterson, John L. Hennessy - "Computer Organization and Design: The Hardware/Software Interface, 2nd Edition" b) David A. Patterson, John L. Hennessy - "Struttura e Progetto dei Calcolatori -- l'interfaccia Hardware-Software"; Zanichelli - ISBN (disponibile in commercio) c) Dominic Sweetman - "See MIPS run "; Morgan Kaufmann; 1st edition (April 15, 1999) - ISBN: (36.99 $ + shipping direttamente da morgan kaufmann) Paragrafi 5.1, 5.2, 5.3.

45 45 SEQUENZA DELLE ARCHITETTURE CHE ANALIZZEREMO DURANTE IL CORSO

46 SEQUENZA DI ARCHITETTURE MIPS Architettura singolo ciclo IS ridotto - emips-sc (teoria+simulaz) 2. Architettura multiciclo IS ridotto - emips-mc (teoria) 3. Architettura multiciclo IS completo (integer) - MIPS-mc (teoria+simulaz) 4. Architettura pipelined IS completo (integer) - MIPS-pipe (teoria)

47 47 MIPS: TRADUZIONE ASSEMBLY -> LINGUAGGIO MACCHINA

48 MIPS: TRADUZIONE ASSEMBLY => LINGUAGGIO MACCHINA 48 CODIFICA IN LINGUAGGIO MACCHINA: emips_s2-istr #0 lw $1, 0x100($0) // inizializza l accumulatore col dato a[0] Istruzioni I-type: lw Rt, Imm(Rs) opcode Rs Rt Immediate 6 bit 5 bit 5 bit 16 bit ASM Op=6h 23 Rs=$0 Rt=$1 Imm=16h 100 BIN BIN HEX 8 c HEX 8c010100

49 MIPS: TRADUZIONE ASSEMBLY => LINGUAGGIO MACCHINA 49 CODIFICA IN LINGUAGGIO MACCHINA: emips_s2-istr #1 lw $2, 0x104($0) // inizializza l accumulatore col dato a[0] Istruzioni I-type: lw Rt, Imm(Rs) opcode Rs Rt Immediate 6 bit 5 bit 5 bit 16 bit ASM Op=6h 23 Rs=$0 Rt=$2 Imm=16h 104 BIN BIN HEX 8 c HEX 8c020104

50 50 FRAMEWORK PER L'ESECUZIONE DI APPLICAZIONI ASSEMBLY SUL MODELLO VERILOG DI UN SISTEMA DI ELABORAZIONE BASATO SUL PROCESSORE emips-sc

51 MODELLO VERILOG DEL PROCESSORE 51 MODELLO VERILOG DEL SISTEMA COMPLETO La gerarchia del modello verilog del sistema è la seguente: testbench.v (istanza testbench) instructions_rom.v (istanza InstrROM) data_ram.v (istanza DataRAM) emips_sc.v (istanza MIPS) pc_reg.v (istanza PC) pc_adder.v (istanza NPC)...

52 FRAMEWORK DI SVILUPPO (I) 52 file instructions.hex MIPS ASSEMBLER CON CONVERSIONE IN UN FORMATO LEGGIBILE DAL SIMULATORE VERILOG (READMEMH) CODICE ASSEMBLY MEMORIA ISTRUZIONI (MODELLO VERILOG) INSTRUCTIONS BUS INSTR ADDRESSES BUS MIPS (MODELLO VERILOG) DATA BUS DATA ADDRESSES BUS MEMORIA DATI (MODELLO VERILOG) SIMULATORE VERILOG (MODELSIM) DATI INIZIALI CONVERSIONE IN UN FORMATO LEGGIBILE DAL SIMULATORE VERILOG (READMEMH) file data_ram.hex

53 FRAMEWORK DI SVILUPPO (II) STRUTTURA DI FILE E DIRECTORY 53 emips-sc_s3 S3.mpf compila.bat emips_s3.asm HEX instructions.hex data_ram.hex ASM file eseguibili dell'assembler... VERILOG testbench_emips_s3.v Memories emips-sc

54 FRAMEWORK DI SVILUPPO (III) SEQUENZA DELLE OPERAZIONI PER LA SIMULAZIONE DELLE APPLICAZIONI 1. Creare il progetto e caricare i file verilog. Il progetto va creato nella cartella cartella2, allo stesso livello delle cartelle HEX e VERILOG. 2. Caricare anche i file assembla.bat, emips_s3.asm, instructions.hex, data_ram.hex 3. Editare il file assembly nella directory ASM. 4. Lanciare il comando assembla.bat rieditando il file instructions.hex fino a verificare che non ci siano più errori 5. Editare il file data_ram.hex per definire l'inizializzazione dei dati iniziali e delle ostanti del programma 6. Impostare la simulazione (modificando opportunamente il testbench) in modo che si stoppi all esecuzione di ogni istruzione oppure solo alla fine della stessa. 7. Compilare il progetto, caricare il top del progetto, e lanciare la simulazione. 8. MONITORARE IL FUNZIONAMENTO DELLA SIMULAZIONE VERIFICANDO CHE I REGISTRI E LE LOCAZ DI MEMORIA INTERESSATI ASSUMANO IL VALORE CORRETTO. Per verificare la sequenza delle istruzioni utilizzare come promemoria i file emips_sx.asm ed instructions.hex. 54

55 FRAMEWORK DI SVILUPPO (IV) STOP DELLA SIMULAZIONE I sistemi di sviluppo dei compilatori mettono a disposizione la possibilità di eseguire dei breakpoints, stoppando la simulazione. Una funzionalità di questo tipo risulta molto utile quando si vuole stoppare la simulazione solo alla fine della stessa. Questa funzionalità è stata implementata nel nostro framework facendo interagire il fw ed il simulatore verilog. Una coppia di istruzioni assembly, accoppiate ad un processo verilog nel testbench, fanno si che all'esecuzione di questa coppia di istruzioni la simulazione sia stoppata tramite una istruzione $stop. La coppia di istruzioni assembly fa si che il processore tenti una scrittura del valore 0 sulla locazione 0x7FFF. La scrittura non ha alcun esito poichè non vi è alcuna locazione di memoria a quell'indirizzo (..) Il processo dedicato esegue la funzione stop e fa il display di una scritta che indica la fine della simulazione 55 ASSEMBLY LEVEL - FRAMMENTO DI CODICE... lw $10, 0x500($0); sw $0, 0x0($10) ;... ASSEMBLY LEVEL - INIZIALIZZ MEMORIA F FF... VERILOG LEVEL - PROCESSO DEDICATO PER IL BREAKPOINT clk) if ( (data_addr_bus == (32'h7FFF)) && (MemWrite == 1)) begin $display(" \n \n STOP FW-SW DELLA SIMULAZIONE \n \n \n \n \n \n \n \n \n "); $stop; end

56 56 VALUTAZIONE DELLE PRESTAZIONI DEI PROCESSORI

57 METRICA DI MISURA 57 La figura di merito utilizzata per la valutazione delle prestazioni di un processore è il Tempo Medio di Istruzione. Tempo Medio di Instruzione = TMI = CPI x CC CPI = numero medio di cicli necessari per l'esecuzione di una istruzione (Clock per Instruction) CC = Clock Cycle = durata del ciclo di clock

58 VALUTAZIONE DELL'ARCHITETTURA SINGOLO CICLO PERCHE' NON SI USANO MICROARCHITETTURE A SINGOLO CICLO Anche se l implementazione a singolo ciclo di clock funziona perfettamente ed è molto semplice, non è usata perché rispetto ad altri tipi di implementazione è inefficiente. TMI = CPI x CC = 1 x CC = CC La durata del ciclo di clock dipende dal tempo che il segnale più lento impiega a percorrere il datapath. Il ciclo di clock deve durare a sufficienza affinchè ciascun segnale in uscita da un registro si sia propagato completamente fino all'ingresso del registro di destinazione che lo deve memorizzare. Il CC è quindi determinato dal segnale o meglio dal percorso del segnale più lento (percorso critico). Nella architettura singolo-ciclo la quantità ed il tipo di reti combinatorie da attraversare sono molto diversi per classi diverse di istruzione, quindi il tempo di propagazione attraverso il datapath sarà molto diverso. Tuttavia il periodo di clock deve essere uguale per ogni istruzione quindi deve essere pari al percorso critico dell istruzione più lenta. Approssimativamente l'istruzione più lenta è quella che deve attraversare il maggior numero di unità funzionali, nel caso è emips-sc l istruzione load, che attraversa anche il sottosistem di memoria 58

59 VALUTAZIONE DELL'ARCHITETTURA SINGOLO CICLO PERCHE' NON SI USANO MICROARCHITETTURE A SINGOLO CICLO La microarchitettura singolo ciclo prevede che tutte le istruzioni potenzialmente più veloci siano rallentate per uniformarsi all istruzione più lenta Questo è estremamente inefficiente. TMI = CPI x CC CPI = OK CC = Per raggiungere prestazioni più accettabili procediamo per gradi: Inizialmente sacrifichiamo il CPI in modo da avere un valore di CC più accettabile. Per fare ciò suddividiamo la esecuzione di ciascuna istruzione in fasi più semplici, ed eseguiamo ciascuna fase in un ciclo di clock. Nel nostro caso CPI = 5. Il risultato è la microarchitettura multiciclo sequenziale emips-mc Stiamo (per ora) sacrificando il CPI per poter ottimizzare il CC. Vedremo in seguito come tenendo basso il CC è possibile ritornare ad un CPI vicino a 1. 59

60 60 MICROARCHITETTURA MULTI- CICLO emips-mc

61 MICROARCHITETTURA SEQUENZIALE 61 In una microarchitettura di tipo sequenziale il datapath è suddiviso in più parti ciascuna delle quali è percorsa dall istruzione in un ciclo di clock. In un ciclo di clock una parte del datapath preleva i dati da uno o più registri, li elabora attraverso blocchi di logica combinatoria e memorizza i risultati in altri registri. Le uscite di questi registri saranno utilizzati nel ciclo successivo di clock nella porzione successiva del datapath. State element 1 LO GICA COMBINAT. State element 2 LO GICA COMBINAT. State element 3 LO GICA COMBINAT. State element 4 clock

62 MICROARCHITETTURA SEQUENZIALE 62 La suddivisione del datapath rispecchia la suddivisione dell esecuzione dell istruzione in operazioni elementari ciascuna eseguita in un ciclo di clock. In un ciclo di clock ogni unità funzionale può compiere una sola operazione: per esempio, si può effettuare un solo accesso alla memoria, la ALU può eseguire una sola operazione e si può eseguire un solo accesso al register file (due letture e una scrittura). Le operazioni elementari in cui dividiamo l esecuzione delle istruzioni sono 5: FETCH DECODE EXECUTE MEMORY ACCESS WRITE BACK

63 MICROARCHITETTURA SEQUENZIALE FASI DI ESECUZIONE INDIVIDUABILI NELLA MICROARCHITETTURA SINGOLO CICLO 63 (scan di figura 6.1 libro)

64 MICROARCHITETTURA SEQUENZIALE FASI DI ESECUZIONE DELLA MICROARCHITETTURA MULTI CICLO 64 (scan di figura 5.38 libro)

65 MICROARCHITETTURA SEQUENZIALE DESCRIZIONE AD ALTO LIVELLO DEL DATAPATH 65 (scan di figura 5.34 del libro)

66 MICROARCHITETTURA SEQUENZIALE COMPLETA 66 Possiamo costruire il datapath per la versione multiciclo sulla base dell' osservazione che alcune unità funzionali che nella versione a singolo ciclo erano state replicate, in questo caso possono essere condivise perché non vengono mai usate per due scopi diversi nello stesso ciclo di clock E' possibile usare una sola memoria sia per i dati che per le istruzioni dal momento che l istruzione è sempre caricata nella fase di IF mentre la lettura o scrittura dei dati avviene sempre nel quarto ciclo di clock. (architettura di VON NEUMANN) E' possibile usare la ALU anche per calcolare PC+4, che avviene sempre nella fase di IF, e per calcolare l indirizzo di salto condizionato, che avviene sempre nella fase di ID, mentre tutte le altre operazioni sono eseguite dalla ALU nel terzo ciclo di clock. Queste condivisioni sono possibili solo con l utilizzo di multiplexer.

67 MICROARCHITETTURA SEQUENZIALE: CICLI DI ESECUZIONE CICLO 1: FETCH Viene caricata sul registro IR l istruzione contenuta nell indirizzo della memoria istruzioni contenuto nel PC. Nello stesso tempo il PC viene aggiornato con il suo stesso valore incrementato di quattro IR <= InstrMem[PC]; PC <= PC+4; PC nextpc PC_out 4 PC ADDER INSTRUCTION DATA IR 67 INSTRUCTION ADDRESS INSTRUCTIONS MEMORY

68 MICROARCHITETTURA SEQUENZIALE: CICLI DI ESECUZIONE CICLO 2: DECODE (I) Si leggono dal register file i valori dei registri puntati dai campi rs e rt dell istruzione e vengono memorizzati rispettivamente nei registri A e B. Nel frattempo i 16 bit meno significativi dell istruzione vengono estesi a 32 bit e moltiplicati per quattro. Il risultato di queste due operazioni non necessita di essere memorizzato in un registro al termine del ciclo di clock perché l uscita dell IR non cambierà fino al prossimo fetch. Viene eseguita la somma dell immediato esteso a 32 bit e moltiplicato per quattro e di PC+4, il risultato viene memorizzato sul registro ALUOut. Questa operazione serve nel caso in cui l istruzione in esecuzione sia BEQ per calcolare l indirizzo di salto condizionato. In tutti gli altri casi il risultato dell operazione sarà ignorato. Questa fase è uguale per tutte le operazioni perché sarà nella fase successiva che si scarteranno i valori che non servono. Per esempio in una istruzione di load il contenuto del registro B non serve, quindi verrà scartato. PC RegWrite ADD ALUOut 68 Instr[25:21] RaddrA A A Instr[20:16] RaddrB Waddr Register File B B DataIn Instr[15:0] Imm Ext left shifter

69 MICROARCHITETTURA SEQUENZIALE: CICLI DI ESECUZIONE CICLO2: DECODE (II) 69 PC RegWrite ADD ALUOut Instr[25:21] RaddrA A A Instr[20:16] RaddrB Waddr Register File B B DataIn Instr[15:0] Imm Ext left shifter

70 MICROARCHITETTURA SEQUENZIALE: CICLI DI ESECUZIONE CICLO 3: EXECUTE - CASO MEMORY REFERENCE La terza fase dipende dal tipo di istruzione che si sta eseguendo la ALU esegue la somma del contenuto del registro A e dell immediato esteso a 32 bit (non shiftato). Il risultato, che è l indirizzo di lettura o scrittura in memoria, viene memorizzato nel registro ALUOut. 70 Instr[15:0] A Imm Ext ALU ALUOut

71 MICROARCHITETTURA SEQUENZIALE: CICLI DI ESECUZIONE CICLO 3: EXECUTE - CASO REGISTER la ALU esegue l operazione specificata dal campo function sui contenuti dei registri A e B Il risultato viene memorizzato nel registro ALUOut 71 A B ALU ALUOut Instr[5:0] ALU ctrl signal ALU_ctrl ALUOp

72 MICROARCHITETTURA SEQUENZIALE: CICLI DI ESECUZIONE CICLO 3: EXECUTE - CASO BEQ La ALU esegue la sottrazione tra i valori dei registri A e B. L uscita zero della ALU va in ingresso alla logica combinatoria che genera, in funzione dei segnali di controllo PCWriteCond e PCWrite, il segnale che abilita la scrittura del PC. Il PC viene sempre aggiornato con PC+4 alla fine del ciclo IF; in questa fase verrà nuovamente aggiornato con l uscita del registro ALUOut scritto nel ciclo precedente se l istruzione in esecuzione è BEQ e la condizione di salto è verificata. PC_Write_Cond PC_Write 72 A zero B ALU ALUOut PC ALU ctrl signal Instr[5:0] ALU_ctrl ALUOp

73 MICROARCHITETTURA SEQUENZIALE: CICLI DI ESECUZIONE CICLO 4: MEMORY - CASO LOAD Questa fase è presente solo per le istruzioni di lettura e scrittura in memoria e per le istruzioni RegType e il comportamento cambia a seconda che l istruzione sia una load, una store o RegType la memoria fornisce il dato presente nella locazione puntata dall indirizzo calcolato nel ciclo precedente e salvato nel registro ALUout Tale dato viene memorizzato nel registro MDR (Memory Data Register) 73 ALUOut MDR Memory Address Memory DataOut

74 MICROARCHITETTURA SEQUENZIALE: CICLI DI ESECUZIONE CICLO 4: MEMORY - CASO STORE Il dato contenuto nel registro B viene scritto in memoria alla locazione puntata dall indirizzo calcolato nel ciclo precedente e memorizzato nel registro ALUout 74 ALUOut B Memory Address Memory DataIn

75 MICROARCHITETTURA SEQUENZIALE: CICLI DI ESECUZIONE CICLO 4: MEMORY - CASO REGISTER Il contenuto del registro ALUOut, scritto nel ciclo precedente con il risultato della ALU, deve essere memorizzato nel registro del register file puntato dal campo rd dell istruzione, ancora memorizzata nell IR. 75 instr[15:11] Waddr DataIn REGISTER FILE ALUOut

76 MICROARCHITETTURA SEQUENZIALE: CICLI DI ESECUZIONE CICLO 5: WRITE BACK Quest ultima fase è compiuta solo dall istruzione di load Il contenuto del registro MDR viene memorizzato nel registro del register file puntato dal campo rt dell istruzione, che è ancora memorizzata nell IR 76 instr[20:16] Waddr DataIn REGISTER FILE MDR

77 MICROARCHITETTURA SEQUENZIALE DATAPATH 77 (scan di figura 5.35 del libro)

78 MICROARCHITETTURA SEQUENZIALE DATAPATH CON INDICAZIONE DEI SEGNALI DI CONTROLLO (scan di figura 5.36 del libro) 78

79 MICROARCHITETTURA SEQUENZIALE RIASSUNTO CICLI DI ESECUZIONE 79 (scan di figura 5.38 del libro)

80 IMPLEMENTAZIONE DEL CONTROLLO 80 Il controllo può essere implementato con una semplice macchina a stati (FSM) Il diagramma di flusso di una possibile macchina a stati che implementa il controllo della microarchitettura emips-mc è descritto in figura Sono presenti 9 stati L'esecuzione di una istruzione può essere completata in 3, 4 o 5 cicli. IF ID Memory reference RegType branch jump MAC EX BC JC load store LMA SMA RC MRC