la famiglia di processori mips - home - dipartimento di … · 2005-10-05 · il processore mips...

Architetture dei Sistemi Embedded 2005/06 S.M. Carta

1

INTRODUZIONE ALLAPROGRAMMAZIONE 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


3

LA FAMIGLIA MIPS

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 è quindievoluta 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 dispositivielettronici 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’

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 istruzionidedicate.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 modificatodue registri a 32 bit, Hi e Lo, per memorizzare rispettivamente i 32 bit più significativi e i 32 bit meno significativi del risultato di moltiplicazioneun registro Program Counter a 32 bit, che contiene l’indirizzo dell’istruzione da eseguireun registro Interrupt Address RegisterRegistri per elaborazione Floating Point


5

MIPS R2000 ISA : ISTRUZIONI

Il documento che specifica l'Instruction Set completo è disponibile sul sito


6

INSTRUCTION SETMIPS R2000


7

INSTRUCTION SET MIPS R2000

5 load e 3 store. L’indirizzo di accesso (addr) è sempre la somma dell’immediato e del contenuto del registro puntato da rs

Mem[addr]<=Regs[rt][7:0]sb rt, imm(rs)Store byte

Mem[addr]<=Regs[rt][15:0]sh rt, imm(rs)Store half word

Mem[addr]<=Regs[rt]sw rt, imm(rs) Store word

Regs[rt]<={{24{1’b0}}mem[addr]}lbu rt, imm(rs)Load byte unsigned

Regs[rt]<={{16{1’b0}},mem[addr]}lhu rt, imm(rs)Load half word unsigned

Regs[rt]<={{24{mem[addr]31}},mem[addr]}lb rt, imm(rs)Load byte

Regs[rt]<={{16{mem[addr]31}},mem[addr],mem[addr+1]}lh rt, imm(rs)Load half word

Regs[rt]<={mem[addr],mem[addr+1],mem[addr+2],mem[addr+3]}lw rt, imm(rs) Load word

DescrizioneSintassiNome

ISTRUZIONI DI ACCESSO ALLA MEMORIA (8)


8

INSTRUCTION SET MIPS R2000

ISTRUZIONI LOGICO-ARITMETICHE CON INDIRIZZAMENTO IMMEDIATO (10)

Regs[rd]<=Regs[rs]>>shamtsrl rd, rt, shamtShift right logical

Regs[rd]=(Regs[rt]>>shamt)|({32{Regs[rs][31]}}<<(32-shamt))

sra rd, rt, shamtShift right aritmetic

Regs[rd]<=Regs[rs]<<shamtsll rd, rt, shamtShift left logical

Regs[rt]<=Regs[rs]-immsubu rt, rs, immSub Immediatte(without overflow)

Regs[rt]<=Regs[rs]-immsub rt, rs, immSub Immediate(with overflow)

Regs[rt]<=Regs[rs] xor immxori rt, rs, immXor Immediate

Regs[rt]<=Regs[rs] or immori rt, rs, immOr Immediate

Regs[rt]<=Regs[rs] and immandi rt, rs, immAnd Immediate

Regs[rt]<=Regs[rs]+immaddiu rt, rs, immAddition Immediate (without overflow)

Regs[rt]<=Regs[rs]+immaddi rt, rs, immAddition Immediate (with overflow)



9INSTRUCTION SET MIPS R2000ISTRUZIONI LOGICO-ARITMETICHE CON INDIRIZZ. REGISTER (19)

Regs[rt]=Regs[rs] xor Regs[rt]xor rd, rs, rtExclusive or

Regs[rt]=Regs[rs]-Regs[rt]subu rd, rs, rtSubtract(without overflow)

Regs[rt]=Regs[rs]-Regs[rt]sub rd, rs, rtSubtract(with overflow)

Regs[rt]=Regs[rs]+Regs[rt]ror rd, rs, rtRotate right

Regs[rt]=Regs[rs]+Regs[rt]rol rd, rs, rtRotate left

Regs[rd]=(Regs[rt]>>Regs[rs]) | ({32{Regs[rs][31]}}<<(32-Regs[rs]))srav rd, rs, rtShift right aritmetic variable

Regs[rt]=Regs[rs]>>Regs[rt]srlv rd, rs, rtShift right logical variable

Regs[rt]=Regs[rs]<<Regs[rt]sllv rd, rs, rtShift left logical variable

Regs[rt]=Regs[rs] or Regs[rt]or rd, rs, rtOr

Regs[rd]=~Regs[rs]not rt, rsNot

Regs[rt]=Regs[rs] nor Regs[rt]nor rd, rs, rtNor

Regs[rd]=-Regs[rs]negu rd, rsNegate (without overflow)

Regs[rd]=-Regs[rs]neg rd, rsNegate (with overflow)

Come mult senza tener conto del segno degli operandimultu rs, rtUnsigned Multiply

Regs[hi]=(Regs[rs]*Regs[rt])[63:32] Regs[lo]=(Regs[rs]*Regs[rt])[31:0]mult rs, rtMultiply

Regs[rt]=Regs[rs] and Regs[rt]and rd, rs, rtAnd

Regs[rt]=Regs[rs]+Regs[rt]addu rd, rs, rtAddition (without overflow)

Regs[rt]=Regs[rs]+Regs[rt]add rd, rs, rtAddition (with overflow)

Regs[rt]=abs(Regs[rs])abs rt, rsAbsolute value



10INSTRUCTION SET MIPS R2000

ISTRUZIONI DI COMPARAZIONE (12)2 con indirizzamento immediato e 10 con indirizzamento register

If(Regs[rs]!=Regs[rt]) Regs[rd]=1 else Regs[rd]=0sne rd, rs, rtSet on not equal

Come sle senza tenere conto del segno degli operandisleu rd, rs, rtSet on less than or equal unsigned

If(Regs[rs]<=Regs[rt]) Regs[rd]=1 else Regs[rd]=0sle rd, rs, rtSet on less than or equal

Come sgt senza tenere conto del segno degli operandisgtu rd, rs, rtSet on greater than unsigned

If(Regs[rs]>Regs[rt]) Regs[rd]=1 else Regs[rd]=0sgt rd, rs, rtSet on greater than

Come sge senza tenere conto del segno degli operandisgeu rd, rs, rtSet on greater than or equal unsigned

If(Regs[rs]>=Regs[rt]) Regs[rd]=1 else Regs[rd]=0sge rd, rs, rtSet on greater than or equal

If(Regs[rs]=Regs[rt]) Regs[rd]=1 else Regs[rd]=0seq rd, rs, rtSet on equal

Come slti senza tenere conto del segno degli operandisltiu rt, rs, immSet on less than immediate unsigned

If(Regs[rs]<imm) Regs[rd]=1 else Regs[rd]=0slti rt, rs, immSet on less than immediate

Come slt senza tenere conto del segno degli operandisltu rd, rs, rtSet on less than unsigned

If(Regs[rs]<Regs[rt]) Regs[rd]=1 else Regs[rd]=0 slt rd, rs, rtSet on less than




ISTRUZIONI DI SALTO CONDIZIONATO (17)LABEL indica l'istruzione alla quale saltare

Salta se Regs[rs]!=0bnez rs, rt, LABELBranch on not equal zero

Come blt senza tenere conto del segno degli operandibltu rs, rt, LABELBranch on less than unsigned

Salta se Regs[rs]<Regs[rt]blt rs, rt, LABELBranch on less than

Come ble senza tenere conto del segno degli operandibleu rs, rt, LABELBranch on less than equal unsigned

Salta se Regs[rs]<=Regs[rt]ble rs, rt, LABELBranch on less than equal

Come bgt senza tenere conto del segno degli operandibgtu rs, rt, LABELBranch on greater than unsigned

Salta se Regs[rs]>Regs[rt]bgt rs, rt, LABELBranch on greater than

Come bge senza tenere conto del segno degli operandibgeu rs, rt, LABELBranch on greater than equal unsigned

Salta se Regs[rs]>=Regs[rt]bge rs, rt, LABELBranch on greater than equal

Salta se Regs[rs]!=Regs[rt]bne rs, rt, LABELBranch on not equal

Salta se Regs[rs]<0bltz rs, LABELBranch on less than zero

Salta e Regs[31]<=PC+4 se Regs[rs]<0bltzal rs, LABEL Branch on less than and link

Salta se Regs[rs]<=0blez rs, LABELBranch on less than equal zero

Salta se Regs[rs]>0bgtz rs, LABELBranch on greater than zero

Salta e Regs[31]<=PC+4 se Regs[rs]>=0bgezal rs, LABELBranch on greater than equal zero and link

Salta se Regs[rs]>=0bgez rs, LABELBranch on greater than equal zero

Salta se Regs[rs]=Regs[rt]beq rs, rt, LABELBranch on equal




ISTRUZIONI DI SALTO INCONDIZIONATO (4)

Regs[rd]<=PC+4 e PC=Regs[rs] jalr rs, rdJump and link register

PC=Regs[rs]jr rsJump register

Regs[31]<=PC+4 e PC={{(PC+4)[31:28]},{target},{2’b00}} jal targetJump and link

PC={{(PC+4)[31:28]},{target},{2’b00}}j targetJump




ISTRUZIONI DI SPOSTAMENTO DATI FRA REGISTRI (4)

Regs[lo]=Regs[rs]mtlo rsMove to lo

Regs[hi]=Regs[rs]mthi rsMove to hi

Regs[rd]=Regs[hi]mflo rdMove from lo

Regs[rd]=Regs[hi]mfhi rdMove from hi


Regs[rt]<= {imm,{16’h0 } } lui rt, immLoad upper immediate


PC<=IAR e int_enable=1rfeReturn from exeption

-nopNo operation


ISTRUZIONI DI MANIPOLAZIONI COSTANTI A 32 BIT (1)

ISTRUZIONI SPECIALI (2)



PSEUDO-ISTRUZIONI (2)

Regs[Rd] = imm32

Regs[Rd]=Regs[Rs]

Descrizione

lui Rd, imm[31:16]ori Rd, Rd, imm[15:0]

li Rd, imm32load 32 bit immediate

add Rd, Rs, $0move Rs, Rdmove

ImplementazioneSintassiNome


15

MIPS R2000 ISA DEDICATO AGLI INTERI

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 esecuzioneSalto incondizionato (4)

Salto condizionato (17)


16

MIPS ISA: FORMATO DELLE ISTRUZIONI

Le istruzioni sono a lunghezza fissa (32 bit), in tre possibili formati:1. Immediate (I Type)

2. Reg Type (R Type)

3. Jump (J Type)

16bit5bit5bit6bit

Immediatertrsopcode

6bit5bit5bit5bit5bit6bit

functionshamtrdrtrsopcode

26bit6bit

targetopcode


17

MIPS ISA RIDOTTO: eMIPS


18

INSTRUCTION SET eMIPS

Inizieremo la trattazione analizzando nel dettaglio microarchitetturesemplificate che implementano un sottoinsieme minimo delleistruzioni, che chiameremo eMIPSNon è implementata la moltiplicazione, non vi sono quindi istruzionidi scambio fra registri interni. L’IS semplificato contiene almeno una istruzione per ciascuna dellecategorie 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)


19

INSTRUCTION SET eMIPS

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


20INSTRUCTION SET eMIPS

if (REGS[Rs]==REGS[Rt]) PC = PC+4+immbeq Rs, Rt, label1Branch if equal

slt Rd, Rs, Rt

or Rd, Rs, Rt

and Rd, Rs, Rt

sub Rd, Rs, Rt

add Rd, Rs, Rt

sw Rt, imm(Rs)

lw Rt, imm(Rs)

ASSEMBLY

if (REGS[Rs]<REGS[Rt]) REGS[Rd] = 1Set on less than

REGS[Rd] = REGS[Rs] or REGS[Rt]Or

REGS[Rd]= REGS[Rs] and REGS[Rt]And

REGS[Rd] = REGS[Rs] – REGS[Rt]Subtract

REGS[Rd] = REGS[Rs] + REGS[Rt]Add

Mem(REGS[Rs] + imm) = REGS[Rt]Store word

REGS[Rt] = Mem(REGS[Rs]+imm)Load word

FUNZIONALITA’DESCRIZIONE

NOTAZIONE CON INDICAZIONE DI REGISTRI GENERICI

N.B. REGS[Rs] = contenuto del registro Rs del register fileimm = valore che concorre a definire la locazione di memoria interessata al trasferimento


21INSTRUCTION SET eMIPS

if (REGS[$2]==REGS[$3]) PC = PC+4+immbeq $2, $3, label1Branch if equal

slt $4, $2, $3

or $4, $2, $3

and $4, $2, $3

sub $4, $2, $3

add $4, $2, $3

sw $3, 0x0100($2)

lw $3, 0x0100($2)

ASSEMBLY

if (REGS[$2]<REGS[$3]) REGS[$4] = 1Set on less than

REGS[$4 = REGS[$2] or REGS[$3]Or

REGS[$4]= REGS[$2] and REGS[$3]And

REGS[$4] = REGS[$2] – REGS[$3]Subtract

REGS[$4] = REGS[$2] + REGS[$3]Add

Mem(REGS[$2] + 0x0100) = REGS[$3]Store word

REGS[$3] = Mem(REGS[$2]+0x0100)Load word

FUNZIONALITA’DESCRIZIONE

N.B.

$2 = REGISTRO 2REGS[$2] = contenuto del registro $2 del register file

NOTAZIONE CON INDICAZIONE DI REGISTRI DI ESEMPIO


22INSTRUCTION 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 bit

@100 01 // Most significant byte del dato 1

@101 21 // byte 2 del dato 1

@102 AB // byte 3 del dato 1

@103 00 // Least significant byte del dato 1

@104 43 // Most significant byte del dato 2

@105 01 // Least significant byte del dato 2

@106 C1 // Dato 3

DATO 1, a 32 bit: 0121AB00

DATO 2, a 16 bit: 4301

always @(Addr) // MODELLO VERILOG DELLA MEMORIA DATIcase (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

DATO 3, a 8 bit: C1


23

@000 01 // Most significant byte dell’istr 1

@001 21

@002 AB

@003 00 // Least significant byte dell’istr 1

@004 43 // Most significant byte dell’istr 2

@005 01

@006 C1

@007 01 // Least significant byte dell’istr 2

ISTRUZIONE 1:0121AB00

ISTRUZIONE 2: 4301C101

always @(Addr) // MODELLO VERILOG DELLA MEMORIA INSTRUZIONI

DataOut = {Data[Addr+0],Data[Addr+1],Data[Addr+2],Data[Addr+3]};

INSTRUCTION SET eMIPS: GESTIONE DELLA MEMORIA

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 VonNeumann) è 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 4.


24

PROGRAMMAZIONE ASSEMBLY DEL PROCESSORE eMIPS-sc


25PROGRAMMAZIONE ASSEMBLY: ISTRUZIONI DI ASSEGNAMENTO

Specifica C

integer A,B,C; // dati a 32 bit

C = A + B;

eMIPS assembly

lw $1,0x0100($0)lw $2, 0x0104($0)add $3,$2,$1sw $3, 0x0200($0)Specifica aggiuntiva 1:

memoria dati (t=0)

@0100 A@0104 B

Specifica aggiuntiva 2:

memoria dati (t=fine simulaz)

@0200 C

SIMULAZIONE eMIPS_S1


26PROGRAMMAZIONE 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;

elseB;

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:


27PROGRAMMAZIONE ASSEMBLY: ESECUZIONE CONDIZIONALE (2)

eMIPS assembly

lw $1,0x0100($0)lw $2, 0x0104($0) beq $1,$2, else_tagif_tag:add $3,$2,$1beq $0,$0, storeelse_tag:sub $3,$2,$1store:sw $3, 0x0200($0)

SIMULAZIONE eMIPS_S2

Specifica C

integer A,B,C; // dati a 32 bit

if (A!=B)

C = A + B;

else

C = A - B;


memoria dati (t=0)

@0100 A@0104 B



@0200 C


28PROGRAMMAZIONE ASSEMBLY: CICLI E VETTORI (1)

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];


memoria dati (t=0)

@100 a[0]

@104 a[1]

…

@13C a[15]

@400 0x1F

@404 0x4



@0200 acc



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



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



SIMULAZIONE eMIPS_S3: CODIFICA ASSEMBLYlw $1,0x100($0) ; inizializza il registro accumulatore $1 col dato a[0] add $2,$0,$0 ; inizializza il reg indice $2 a 0add $3,$0,$0 ; inizializza il reg puntatore $3 a 0lw $4,0x400($0) ; inizializza il reg $4 utilizzato per aggiornare il registro indicelw $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 1add $3,$3,$5 ; aggiorna il registro puntatore sommando 4lw $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 bufferbeq $2,$6,store ; fa il test del registro indice, se $2=$6 interrompe il ciclobeq $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 simulazionelw $10, 0x500($0);sw $0, 0x0($10) ;



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





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 15ALL'ELEMENTO 1. L'ELEMENTO 0 E' UTILIZZATO PER INIZIALIZZARE L'ACCUMULATORE




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);


35

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 100011 00000 00001 0000000100000000

BIN 1000 1100 0000 0001 0000 0001 0000 0000

HEX 8 c 0 1 0 1 0 0

HEX 8c010100

Istruzioni I-type: lw Rt, Imm(Rs)

MIPS: TRADUZIONE ASSEMBLY => LINGUAGGIO MACCHINA

16 bit5 bit5 bit6 bit

ImmediateRtRsopcode


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 100011 00000 00010 0000000100000100

BIN 1000 1100 0000 0010 0000 0001 0000 0100

HEX 8 c 0 2 0 1 0 4

HEX 8c020104

Istruzioni I-type: lw Rt, Imm(Rs)

MIPS: TRADUZIONE ASSEMBLY => LINGUAGGIO MACCHINA

16 bit5 bit5 bit6 bit

ImmediateRtRsopcode


38

FRAMEWORK PER L'ESECUZIONE DI APPLICAZIONI ASSEMBLY SUL

MODELLO VERILOG DI UN SISTEMA DI ELABORAZIONE BASATO SUL

PROCESSORE eMIPS-sc


39

MODELLO VERILOG DEL PROCESSORE

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)....

MODELLO VERILOG DEL SISTEMA COMPLETO


40

FRAMEWORK DI SVILUPPO (I)

SIMULATOREVERILOG

(MODELSIM)

CODICEASSEMBLY

MIPS(MODELLOVERILOG)

MEMORIAISTRUZIONI(MODELLOVERILOG)

INSTR ADDRESSES

BUS

INSTRUCTIONS

BUS

DATIINIZIALI

CONVERSIONE IN UNFORMATO LEGGIBILE

DAL SIMULATOREVERILOG (READMEMH)

MEMORIADATI

(MODELLOVERILOG)

DATA

BUS

DATA ADDRESSES

BUS

MIPSASSEMBLER

CON CONVERSIONE IN UNFORMATO LEGGIBILE DAL

SIMULATORE VERILOG(READMEMH)

fileinstructions.hex

filedata_RAM.hex


41

FRAMEWORK DI SVILUPPO (II)STRUTTURA DI FILE E DIRECTORY

eMIPS-sc_S3S1.mpfcompila.bateMIPS_S3.asmHEX

instructions.hexdata_ram.hex ASM

file eseguibili dell'assembler.....VERILOG

testbench_eMIPS_S3.vMemorieseMIPS-sc


42

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ù errori5. Editare il file data_RAM.hex per definire l'inizializzazione dei dati iniziali e delle

costanti del programma6. 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.


43

STOP DELLA SIMULAZIONEFRAMEWORK DI SVILUPPO (IV)

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

ASSEMBLY LEVEL - FRAMMENTO DI CODICE...lw $10, 0x500($0);sw $0, 0x0($10) ;...

VERILOG LEVEL - PROCESSO DEDICATO PER IL BREAKPOINTalways @(posedge 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

ASSEMBLY LEVEL - INIZIALIZZ MEMORIA DATI

...@500 00 00 7F FF...

la famiglia di processori mips - home - dipartimento di … · 2005-10-05 · il processore mips...

Documents