LA FAMIGLIA DI PROCESSORI MIPS

Transcript

1 1 INTRODUZIONE ALLA PROGRAMMAZIONE ASSEMBLY DI PROCESSORI MIPS IL PROCESSORE MIPS ISA RIDOTTO emips PROGRAMMAZIONE ASSEMBLY DELL emips FRAMEWORK PER L'ESECUZIONE DI APPLICAZIONI ASSEMBLY SUL MODELLO VERILOG DI UN SISTEMA DI ELABORAZIONE BASATO SUL PROCESSORE emips-sc 2 LA FAMIGLIA DI PROCESSORI MIPS

2 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 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

3 MIPS R2000 ISA : ISTRUZIONI 5 Il documento che specifica l'instruction Set completo è disponibile sul sito 6 INSTRUCTION SET MIPS R2000

4 INSTRUCTION SET MIPS R2000 ISTRUZIONI DI ACCESSO ALLA MEMORIA (8) 5 load e 3 store. L indirizzo di accesso (addr) è sempre la somma dell immediato e del contenuto del registro puntato da rs 7 Nome Load word Load half word Load byte Load half word unsigned Load byte unsigned Store word Store half word Store byte Sintassi lw rt, imm(rs) lh rt, imm(rs) lb rt, imm(rs) lhu rt, imm(rs) lbu rt, imm(rs) sw rt, imm(rs) sh rt, imm(rs) sb rt, imm(rs) Descrizione Regs[rt]<={mem[addr],mem[addr+1],mem[addr+2],mem[addr+3]} Regs[rt]<={{16{mem[addr] 31 }},mem[addr],mem[addr+1]} Regs[rt]<={{24{mem[addr] 31 }},mem[addr]} Regs[rt]<={{16{1 b0}},mem[addr]} Regs[rt]<={{24{1 b0}}mem[addr]} Mem[addr]<=Regs[rt] Mem[addr]<=Regs[rt] [15:0] Mem[addr]<=Regs[rt] [7:0] INSTRUCTION SET MIPS R2000 ISTRUZIONI LOGICO-ARITMETICHE CON INDIRIZZAMENTO IMMEDIATO (10) 8 Nome Addition Immediate (with overflow) Addition Immediate (without overflow) And Immediate Or Immediate Xor Immediate Sub Immediate(with overflow) Sub Immediatte(without overflow) Shift left logical Shift right aritmetic Shift right logical Sintassi addi rt, rs, imm addiu rt, rs, imm andi rt, rs, imm ori rt, rs, imm xori rt, rs, imm sub rt, rs, imm subu rt, rs, imm sll rd, rt, shamt sra rd, rt, shamt srl rd, rt, shamt Descrizione Regs[rt]<=Regs[rs]+imm Regs[rt]<=Regs[rs]+imm Regs[rt]<=Regs[rs] and imm Regs[rt]<=Regs[rs] or imm Regs[rt]<=Regs[rs] xor imm Regs[rt]<=Regs[rs]-imm Regs[rt]<=Regs[rs]-imm Regs[rd]<=Regs[rs]<<shamt Regs[rd]=(Regs[rt]>>shamt) ({32{Regs[rs] [31] }}<<( 32-shamt)) Regs[rd]<=Regs[rs]>>shamt

5 INSTRUCTION SET MIPS R2000 ISTRUZIONI LOGICO-ARITMETICHE CON INDIRIZZ. REGISTER (19) 9 Nome Sintassi Absolute value abs rt, rs Addition (with overflow) add rd, rs, rt Addition (without overflow) addu rd, rs, rt And and rd, rs, rt Multiply mult rs, rt Unsigned Multiply multu rs, rt Negate (with overflow) neg rd, rs Negate (without overflow) negu rd, rs Nor nor rd, rs, rt Not not rt, rs Or or rd, rs, rt Shift left logical variable sllv rd, rs, rt Shift right logical variable srlv rd, rs, rt Shift right aritmetic variable srav rd, rs, rt Rotate left rol rd, rs, rt Rotate right ror rd, rs, rt Subtract(with overflow) sub rd, rs, rt Subtract(without overflow) subu rd, rs, rt Exclusive or xor rd, rs, rt Descrizione Regs[rt]=abs(Regs[rs]) Regs[rt]=Regs[rs]+Regs[rt] Regs[rt]=Regs[rs]+Regs[rt] Regs[rt]=Regs[rs] and Regs[rt] Regs[hi]=(Regs[rs]*Regs[rt]) [63:32] Regs[lo]=(Regs[rs]*Regs[rt]) [31:0] Come mult senza tener conto del segno degli operandi Regs[rd]=-Regs[rs] Regs[rd]=-Regs[rs] Regs[rt]=Regs[rs] nor Regs[rt] Regs[rd]=~Regs[rs] Regs[rt]=Regs[rs] or Regs[rt] Regs[rt]=Regs[rs]<<Regs[rt] Regs[rt]=Regs[rs]>>Regs[rt] Regs[rd]=(Regs[rt]>>Regs[rs]) ({32{Regs[rs] [31] }}<<(32-Regs[rs])) Regs[rt]=Regs[rs]+Regs[rt] Regs[rt]=Regs[rs]+Regs[rt] Regs[rt]=Regs[rs]-Regs[rt] Regs[rt]=Regs[rs]-Regs[rt] Regs[rt]=Regs[rs] xor Regs[rt] INSTRUCTION SET MIPS R2000 ISTRUZIONI DI COMPARAZIONE (12) 10 2 con indirizzamento immediato e 10 con indirizzamento register Nome Set on less than Set on less than unsigned Set on less than immediate Set on less than immediate unsigned Set on equal Set on greater than or equal Set on greater than or equal unsigned Set on greater than Set on greater than unsigned Set on less than or equal Set on less than or equal unsigned Set on not equal Sintassi slt rd, rs, rt sltu rd, rs, rt slti rt, rs, imm sltiu rt, rs, imm seq rd, rs, rt sge rd, rs, rt sgeu rd, rs, rt sgt rd, rs, rt sgtu rd, rs, rt sle rd, rs, rt sleu rd, rs, rt sne rd, rs, rt Descrizione If(Regs[rs]<Regs[rt]) Regs[rd]=1 else Regs[rd]=0 Come slt senza tenere conto del segno degli operandi If(Regs[rs]<imm) Regs[rd]=1 else Regs[rd]=0 Come slti senza tenere conto del segno degli operandi If(Regs[rs]=Regs[rt]) Regs[rd]=1 else Regs[rd]=0 If(Regs[rs]>=Regs[rt]) Regs[rd]=1 else Regs[rd]=0 Come sge senza tenere conto del segno degli operandi If(Regs[rs]>Regs[rt]) Regs[rd]=1 else Regs[rd]=0 Come sgt senza tenere conto del segno degli operandi If(Regs[rs]<=Regs[rt]) Regs[rd]=1 else Regs[rd]=0 Come sle senza tenere conto del segno degli operandi If(Regs[rs]!=Regs[rt]) Regs[rd]=1 else Regs[rd]=0

6 INSTRUCTION SET MIPS R2000 ISTRUZIONI DI SALTO CONDIZIONATO (17) 11 LABEL indica l'istruzione alla quale saltare Nome Branch on equal Branch on greater than equal zero Branch on greater than equal zero and link Branch on greater than zero Branch on less than equal zero Branch on less than and link Branch on less than zero Branch on not equal Branch on greater than equal Branch on greater than equal unsigned Branch on greater than Branch on greater than unsigned Branch on less than equal Branch on less than equal unsigned Branch on less than Branch on less than unsigned Branch on not equal zero Sintassi beq rs, rt, LABEL bgez rs, LABEL bgezal rs, LABEL bgtz rs, LABEL blez rs, LABEL bltzal rs, LABEL bltz rs, LABEL bne rs, rt, LABEL bge rs, rt, LABEL bgeu rs, rt, LABEL bgt rs, rt, LABEL bgtu rs, rt, LABEL ble rs, rt, LABEL bleu rs, rt, LABEL blt rs, rt, LABEL bltu rs, rt, LABEL bnez rs, rt, LABEL Descrizione Salta se Regs[rs]=Regs[rt] Salta se Regs[rs]>=0 Salta e Regs[31]<=PC+4 se Regs[rs]>=0 Salta se Regs[rs]>0 Salta se Regs[rs]<=0 Salta e Regs[31]<=PC+4 se Regs[rs]<0 Salta se Regs[rs]<0 Salta se Regs[rs]!=Regs[rt] Salta se Regs[rs]>=Regs[rt] Come bge senza tenere conto del segno degli operandi Salta se Regs[rs]>Regs[rt] Come bgt senza tenere conto del segno degli operandi Salta se Regs[rs]<=Regs[rt] Come ble senza tenere conto del segno degli operandi Salta se Regs[rs]<Regs[rt] Come blt senza tenere conto del segno degli operandi Salta se Regs[rs]!=0 INSTRUCTION SET MIPS R2000 ISTRUZIONI DI SALTO INCONDIZIONATO (4) 12 Nome Jump Jump and link Jump register Jump and link register Sintassi j target jal target jr rs jalr rs, rd Descrizione PC={{(PC+4) [31:28] },{target},{2 b00}} Regs[31]<=PC+4 e PC={{(PC+4) [31:28] },{target},{2 b00}} PC=Regs[rs] Regs[rd]<=PC+4 e PC=Regs[rs]

7 INSTRUCTION SET MIPS R2000 ISTRUZIONI DI SPOSTAMENTO DATI FRA REGISTRI (4) 13 Nome Move from hi Move from lo Move to hi Move to lo Sintassi mfhi rd mflo rd mthi rs mtlo rs Descrizione Regs[rd]=Regs[hi] Regs[rd]=Regs[hi] Regs[hi]=Regs[rs] Regs[lo]=Regs[rs] ISTRUZIONI DI MANIPOLAZIONI COSTANTI A 32 BIT (1) Nome Load upper immediate Sintassi lui rt, imm Descrizione Regs[rt]<= {imm,{16 h0 } } ISTRUZIONI SPECIALI (2) Nome No operation Return from exeption Sintassi nop rfe Descrizione - PC<=IAR e int_enable=1 INSTRUCTION SET MIPS R2000 PSEUDO-ISTRUZIONI (2) 14 Nome Sintassi Descrizione Implementazione move move Rs, Rd Regs[Rd]=Regs[Rs] add Rd, Rs, $0 load 32 bit immediate li Rd, imm 32 Regs[Rd] = imm 32 lui Rd, imm[31:16] ori Rd, Rd, imm[15:0]

8 MIPS R2000 ISA DEDICATO AGLI INTERI 15 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) MIPS ISA: FORMATO DELLE ISTRUZIONI 16 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

9 17 MIPS ISA RIDOTTO: emips INSTRUCTION SET emips 18 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 19 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 INSTRUCTION SET emips 20 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

11 INSTRUCTION SET emips 21 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 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 // 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 22

12 INSTRUCTION SET emips: GESTIONE DELLA MEMORIA 23 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]}; 24 PROGRAMMAZIONE ASSEMBLY DEL PROCESSORE emips-sc

13 25 PROGRAMMAZIONE ASSEMBLY: ISTRUZIONI DI ASSEGNAMENTO SIMULAZIONE emips_s1 Specifica C emips assembly integer A,B,C; // dati a 32 bit C = A + B; Specifica aggiuntiva 1: lw $1,0x0100($0) lw $2, 0x0104($0) add $3,$2,$1 sw $3, 0x0200($0) memoria dati B Specifica aggiuntiva 2: memoria dati (t=fine C 26 PROGRAMMAZIONE ASSEMBLY: ESECUZIONE CONDIZIONALE (1) L'ESECUZIONE CONDIZIONALE PUÒ ESSERE GESTITA TRAMITE L'USO DI ISTRUZIONI DI SALTO CONDIZIONATO E DI SALTO INCONDIZIONATO. if (cond) A; else B; if (cond) A; branch(cond==1),taga; tagb: B; branch(1),end; taga: A; end: branch(cond==1),taga; branch(1),end; taga: A; end:

14 27 PROGRAMMAZIONE ASSEMBLY: ESECUZIONE CONDIZIONALE (2) SIMULAZIONE emips_s2 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: 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) memoria dati (t=fine C PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (1) 28 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

15 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (2) 29 L'ESECUZIONE CICLICA (LOOP) VIENE GESTITA TRAMITE L'UTILIZZO DI UN REGISTRO DETTO INDICE 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 DETTO PUNTATORE CHE: VIENE INIZIALIZZATO ALL'ESTERNO DEL LOOP VINE UTILIZZATO AD OGNI ITERAZIONE DEL LOOP PER COMPORRE L'INDIRIZZO DELLA LOCAZIONE CORRENTE VIENE AGGIORNATO AD OGNI ITERAZIONE DEL LOOP. L'AGGIORNAMENTO DIPENDE DAL NUMERO DI LOCAZIONI DI MEMORIA OCCUPATE DA CIASCUN ELEMENTO DEL VETTORE PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (3) 30 SIMULAZIONE emips_s3: CODIFICA ASSEMBLY UTILIZZO DEI REGISTRI $1 HA LA FUNZIONE DI REGISTRO ACCUMULATORE $2 HA LA FUNZIONE DI INDICE DEL LOOP $3 HA LA FUNZIONE DI PUNTATORE ALL'ELEMENTO CORRENTE DEL VETTORE $4 MEMORIZZA LA COSTANTE USATA PER AGGIORNARE IL REGISTRO INDICE $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

16 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (4) 31 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 indice $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 indice 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 indice 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 indice, 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) ; PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (5) 32 SIMULAZIONE emips_s4: CODIFICA ASSEMBLY E' POSSIBILE UTILIZZARE UN SOLO REGISTRO CHE ACCORPI LE FUNZIONALITA' DI REGISTRO INDICE PER PER IL TEST DI FINE CICLO 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

17 PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (6) 33 SIMULAZIONE emips_s4: CODIFICA ASSEMBLY UTILIZZO DEI REGISTRI $1 HA LA FUNZIONE DI REGISTRO ACCUMULATORE $2 HA LA FUNZIONE DI INDICE 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 INDICE-PUNTATORE LA SEQUENZA UTILIZZATA E' STAVOLTA DECRESCENTE, DALL'ELEMENTO 15 ALL'ELEMENTO 1. L'ELEMENTO 0 E' UTILIZZATO PER INIZIALIZZARE L'ACCUMULATORE PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (7) 34 SIMULAZIONE emips_s4: CODIFICA ASSEMBLY lw $1,0x100($0) ; inizializza l'accumulatore col dato a[0] lw $2,0x400($0) ; inizializza il reg indice/puntatore $2 lw $4,0x404($0) ; inizializza il reg utilizzato per aggiornare il reg indice/puntatore loop: lw $3, 0x100($2); carica il dato su $3, la seq è 15,14,..,1. sub $2,$2,$4 ; aggiorna il registro indice sottraendo 4 add $1,$1,$3 ; aggiorna l'accumulatore beq $2,$0,store ; fa il test del registro indice, 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);

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

19 MIPS: TRADUZIONE ASSEMBLY => LINGUAGGIO MACCHINA 37 CODIFICA IN LINGUAGGIO MACCHINA: emips_s2-istr #1 lw $2, 0x104($0) // inizializza l accumulatore col dato a[0] ASM Op=6h 23 Rs=$0 Rt=$2 Imm=16h 104 BIN BIN HEX 8 c HEX Istruzioni I-type: lw Rt, Imm(Rs) opcode Rs Rt Immediate 6 bit 5 bit 5 bit 8c bit 38 FRAMEWORK PER L'ESECUZIONE DI APPLICAZIONI ASSEMBLY SUL MODELLO VERILOG DI UN SISTEMA DI ELABORAZIONE BASATO SUL PROCESSORE emips-sc

20 MODELLO VERILOG DEL PROCESSORE 39 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)... FRAMEWORK DI SVILUPPO (I) 40 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

21 FRAMEWORK DI SVILUPPO (II) STRUTTURA DI FILE E DIRECTORY 41 emips-sc_s3 S1.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 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 costanti 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. VERIFICARE IL CORRETTO 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. 42

22 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 43 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