Projeto Final de Modelagem em Sistemas de Silício - 2017/1
Alunos:
- Davi Rabbouni de Carvalho Freitas - 150033010
- Iuri de Oliveira Parada - 10/0105840
- Marcos Vinicius Prescendo Tonin - 140153233
- Decode
- Fetch
- Execute
- Breg
- Teste do processador
- Cache
- Shell/ Kernel
- Tipo R
- Respectivas Instruções que serão implementadas
Instrução | Opcode | Funct7 | Funct3 | Operação | Implementado |
---|---|---|---|---|---|
ADD | 0110011 | 0000000 | 000 | R[rd] = R[rs1] + R[rs2] | |
SUB | 0110011 | 0100000 | 000 | R[rd] = R[rs1] - R[rs2] | |
SLL | 0110011 | 0000000 | 001 | R[rd] = R[rs1] << Rrs2 | |
SLT | 0110011 | 0000000 | 010 | R[rd] = (R[rs1] < R[rs2])? 1:0 | |
SLTU | 0110011 | 0000000 | 011 | R[rd] = (R[rs1] < R[rs2])? 1:0 | |
XOR | 0110011 | 0000000 | 100 | R[rd] = R[rs1] xor R[rs2] | |
SRL | 0110011 | 0000000 | 101 | R[rd] = R[rs1] >> Rrs2 | |
SRA | 0110011 | 0100000 | 101 | R[rd] = R[rs1] >> Rrs2 | |
OR | 0110011 | 0000000 | 110 | R[rd] = R[rs1] OR R[rs2] | |
AND | 0110011 | 0000000 | 111 | R[rd] = R[rs1] & R[rs2] |
- Tipo I
- Respectivas Instruções que serão implementadas
Instrução | Opcode | Funct7 | Funct3 | Operação | Implementado |
---|---|---|---|---|---|
ADDI | 0010011 | - | 000 | R[rd] = R[rs1] + imm[11:0] | |
SLTI | 0010011 | - | 010 | R[rd] = (R[rs1] < imm[11:0])? 1:0 | |
SLTIU | 0010011 | - | 011 | R[rd] = (R[rs1] < imm[11:0])? 1:0 | |
X0RI | 0010011 | - | 100 | R[rd] = R[rs1] xor imm[11:0] | |
ORI | 0010011 | - | 110 | R[rd] = R[rs1] OR imm[11:0] | |
ANDI | 0010011 | - | 111 | R[rd] = R[rs1] & imm[11:0] | |
LB | 0000011 | - | 000 | R[rd] = (byte)Mem[R[rs1] + imm[11:0]] | |
LH | 0000011 | - | 001 | R[rd] = (half)Mem[R[rs1] + imm[11:0]] | |
LW | 0000011 | - | 010 | R[rd] = Mem[R[rs1] + imm[11:0]] | |
LBU | 0000011 | - | 110 | R[rd] = (ubyte)Mem[R[rs1] + imm[11:0]] | |
LHU | 0000011 | - | 101 | R[rd] = (uhalf)Mem[R[rs1] + imm[11:0]] | |
JALR | 1100111 | - | 000 | R[rd] = PC+4;PC = [{rs1 + Imm,0}] ??? |
- Casos Especiais (Utilizando o shamt)
shamt = rs2
Instrução | Opcode | Funct7 | Funct3 | Operação | Implementado |
---|---|---|---|---|---|
SLLI | 0010011 | 0000000 | 001 | R[rd] = R[rs1] << shamt | |
SRLI | 0010011 | 0000000 | 101 | R[rd] = R[rs1] >> shamt | |
SRAI | 0010011 | 0100000 | 101 | R[rd] = R[rs1] >> shamt |
- Tipo S
- Respectivas Instruções que serão implementadas
Instrução | Opcode | Funct7 | Funct3 | Operação | Implementado |
---|---|---|---|---|---|
SB | 0100011 | - | 000 | Mem[rs1+Imm]= Rrs2 | |
SH | 0100011 | - | 001 | Mem[rs1+Imm]= Rrs2 | |
SW | 0100011 | - | 010 | Mem[rs1+Imm]= R[rs2] |
- Tipo B
- Respectivas Instruções que serão implementadas
Instrução | Opcode | Funct7 | Funct3 | Operação | Implementado |
---|---|---|---|---|---|
BEQ | 1100111 | - | 000 | if(R[rs1] == R[rs2]) PC= PC+4+Imm | |
BNE | 1100111 | - | 001 | if(R[rs1] != R[rs2]) PC= PC+4+Imm | |
BLT | 1100111 | - | 100 | if(R[rs1] < R[rs2]) PC= PC+4+Imm | |
BGE | 1100111 | - | 101 | if(R[rs1] >= R[rs2]) PC= PC+4+Imm | |
BLTU | 1100111 | - | 110 | if(R[rs1] < R[rs2]) PC= PC+4+Imm | |
BGEU | 1100111 | - | 111 | if(R[rs1] >= R[rs2]) PC= PC+4+Imm |
- Tipo U
- Respectivas Instruções que serão implementadas
Instrução | Opcode | Funct7 | Funct3 | Operação | Implementado |
---|---|---|---|---|---|
LUI | 0110111 | - | - | R[rd] = {Imm,000000000000} | |
AUIPC | 0010111 | - | - | R[rd] = PC+{Imm,000000000000} |
- Tipo J
- Respectivas Instruções que serão implementadas
Instrução | Opcode | Funct7 | Funct3 | Operação | Implementado |
---|---|---|---|---|---|
JAL | 1101111 | - | - | R[rd] = PC+4;PC=Imm |
Devido a falta de um gerador de linguagem de máquinas para o RISC-V através de um simulador, como por exemplo o MARS para o MIPS, foi desenvolvido uma função que tinha por finalidade gerar uma instrução de acordo com os paramêtros passados. A função será:
uint32_t gerainst(int n, ...)
Sendo seu paramêtro:
- De retorno do tipo uint32_t que é um inteiro que representa o código de máquina da instrução requerida
- Já seus paramêtros de entrada serão inteiros, sendo que sempre terá 1 argumento que será OPCODE e outros que serão ilimitados podendo ser qualquer quantia e que, neste caso, será diferente para cada tipo.
- Tipo U válido para o AUIPC e LUI
Este terá dois campos a mais que opcode, o imediato e o registrador destino, nesta ordem.
Sendo :
gerainst(TIPO_LUI ou TIPO_AUIPC, Imediato, registrador destino);
gerainst(TIPO_LUI,931,26);
> LUI $26,931;
-------------------------------------------------
gerainst(TIPO_AUIPC,931,26);
> AUIPC $26,931;
-------------------------------------------------
- TIPO R
Terá cinco campos a mais o funct7, o registrador source 2, registrador source 1, funct3 e por fim registrador destino,nesta ordem.
Então o estilo da função será
gerainst(TIPO_R,funct7, registrador source 2,registrador source 1,funct3 ,registrador destino);
gerainst(TIPO_R,f7_RESTO,30,12,f3_ADD_SUB,7);
> ADD $7,$12,$30;
-------------------------------------------------
gerainst(TIPO_R,f7_SRA_SUB,23,11,f3_ADD_SUB,3);
> SUB $3,$11,$23;
-------------------------------------------------
gerainst(TIPO_R,f7_SRA_SUB,7,29,f3_SRL_SRA,5);
> SRA $5,$29,$7;
-------------------------------------------------
gerainst(TIPO_R,f7_RESTO,17,2,f3_SRL_SRA,17);
> SRL $17,$2,$17;
-------------------------------------------------
gerainst(TIPO_R,f7_RESTO,3,4,f3_SLL,5);
> SLL $5,$4,$3;
-------------------------------------------------
gerainst(TIPO_R,f7_RESTO,17,19,f3_SLT,12);
> SLT $12,$19,$17;
-------------------------------------------------
gerainst(TIPO_R,f7_RESTO,2,2,f3_XOR,1);
> XOR $1,$2,$2;
-------------------------------------------------
gerainst(TIPO_R,f7_RESTO,11,1,f3_AND,22);
> AND $22,$1,$11;
-------------------------------------------------
gerainst(TIPO_R,f7_RESTO,28,21,f3_OR,6);
> OR $6,$21,$28;
-------------------------------------------------
- TIPO I válido para JALR
Três campos a mais: 1.Imediato 2.Registrador source 1 3.Funct3 4.Registrador destino.
Então o estilo da função será
gerainst(TIPO_I,imediato, registrador source 1, funct3 ,registrador destino);
gerainst(TIPO_I2_SHAMT,10, 2, f3_ADDI, 3);
> ADDI $3, $2, 10;
-------------------------------------------------
gerainst(TIPO_I2_SHAMT,10, 2, f3_SLTI, 3);
> SLTI $3, $2, 10;
-------------------------------------------------
gerainst(TIPO_I2_SHAMT,10, 2, f3_SLTIU, 3);
> SLTIU $3, $2, 10;
-------------------------------------------------
gerainst(TIPO_I2_SHAMT,10, 2, f3_XORI, 3);
> XORI $3, $2, 10;
-------------------------------------------------
gerainst(TIPO_I2_SHAMT,10, 2, f3_ORI, 3);
> ORI $3, $2, 10;
-------------------------------------------------
gerainst(TIPO_I2_SHAMT,10, 2, f3_ANDI, 3);
> ANDI $3, $2, 10;
-------------------------------------------------
gerainst(TIPO_JALR,10, 2,0,3);
> JALR $3, $2, 10;
-------------------------------------------------
- TIPO I SHAMT
Outro "tipo" de instrução tipo I será deslocamento tendo seus paramêtros: O funct7, o registrador source 2, registrador source 1, funct3 e por fim registrador destino,nesta ordem.
Então a instrução será
gerainst(TIPO_I2_SHAMT,funct7, SHAMT,registrador source 1,funct3 ,registrador destino);
gerainst(TIPO_I2_SHAMT,f7_SRAI,10, 2, f3_SRLI_SRAI, 3);
> SRAI $3, $2, 10;
-------------------------------------------------
gerainst(TIPO_I2_SHAMT,f7_RESTO,10, 2, f3_SRLI_SRAI, 3);
> SRLI $3, $2, 10;
-------------------------------------------------
gerainst(TIPO_I2_SHAMT,f7_RESTO,10, 2, f3_SLLI, 3);
> SLLI $3, $2, 10;
-------------------------------------------------
- TIPO S
TIPO S => imm(11-5), rs2, rs1, funct3, imm(4-0) Terá quatro campos a mais o imediato, o registrador source 2, registrador source 1, funct3,nesta ordem.
Então o estilo da função será
gerainst(TIPO_S,imediato, registrador source 2,registrador source 1,funct3);
gerainst(TIPO_S,15, 2, 3, f3_SW);
> SW $3, $2, 10;
-------------------------------------------------
gerainst(TIPO_S,15, 2, 3, f3_SH);
> SH $3, $2, 10;
-------------------------------------------------
gerainst(TIPO_S,15, 2, 3, f3_SB);
> SB $3, $2, 10;
-------------------------------------------------
- TIPO J
Este terá dois campos a mais que opcode, o imediato e o registrador destino, nesta ordem.
Sendo :
gerainst(TIPO_JAL, Imediato, registrador destino);
gerainst(TIPO_JAL,255,5);
> JAL $5,255;
-------------------------------------------------
- TIPO B
Quatro campos a mais: 1.Imediato 2.Registrador source 2 3.Registrador source 1 4.Funct3.
gerainst(TIPO_B,Imediato, registrador source 2,registrador source 1,funct3);
gerainst(TIPO_B,2314,15,21,f3_BEQ);
> BEQ $21,$15,2314;
-------------------------------------------------
gerainst(TIPO_B,334,1,17,f3_BNE);
> BNE $17,$1,334;
-------------------------------------------------
gerainst(TIPO_B,827,4,21,f3_BLT);
> BLT $21,$4,827;
-------------------------------------------------
gerainst(TIPO_B,888,5,9,f3_BGE);
> BGE $9,$5,888;
-------------------------------------------------
gerainst(TIPO_B,913,19,2,f3_BLTU);
> BLTU $2,$9,913;
-------------------------------------------------
gerainst(TIPO_B,1829,30,29,f3_BGEU);
> BGEU $29,$30,1829;
-------------------------------------------------
Para os módulos como processadores, memória se conectarem com a NoC deve ser ter uma conexão passando pelo Shell e Kernel. para cada módulo IP-core.
-
Shell : Especifico para cada IP-core e é responsável por adaptar os sinais de dados,controle e endereços do módulo para um formato padrão que será transmitido para outro IP-core, no caso do processador ele envia os dados para memória ou DMA . Os canais entre módulo e o shell serão e comando(load ou store), endereço e dado(SE FOR STORE .... se for load terá que ser recebido um dado).
-
Kernel : Módulo comum para masters e slaves.