Processador RISC-V + Cache em System C

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

Tarefas

Implementar processador

Implementar uma memória cache de nível 1 (interna ao processador)

Cache

Implementar uma conexão ao roteador (com criação de um módulo Shell)

Shell/ Kernel

Documento de Projeto

Documento

Processador RISC-V

Tipos de Instruções

Tipo R

Respectivas Instruções que serão implementadas

Instrução	Opcode	Funct7	Funct3	Operação
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
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
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
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
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

Teste do Processador

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.

Função gerainst 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;

   -------------------------------------------------

Memória Cache

base teórica : http://www.inf.pucrs.br/~emoreno/undergraduate/SI/orgarq/class_files/Aula12.pdf

Conexão com a Network Operations Center (NOC)

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.

Name		Name	Last commit message	Last commit date
Latest commit History 48 Commits
.settings		.settings
Debug		Debug
Imagens		Imagens
src		src
.cproject		.cproject
.project		.project
LICENSE		LICENSE
README.md		README.md

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

Processador RISC-V + Cache em System C

Tarefas

Implementar processador

Implementar uma memória cache de nível 1 (interna ao processador)

Implementar uma conexão ao roteador (com criação de um módulo Shell)

Documento de Projeto

Processador RISC-V

Tipos de Instruções

Teste do Processador

Função gerainst para cada tipo

Memória Cache

Conexão com a Network Operations Center (NOC)

About

Releases

Packages

Contributors 3

Languages

License

drcfts/SystemC_RISC-V

Folders and files

Latest commit

History

Repository files navigation

Processador RISC-V + Cache em System C

Tarefas

Implementar processador

Implementar uma memória cache de nível 1 (interna ao processador)

Implementar uma conexão ao roteador (com criação de um módulo Shell)

Documento de Projeto

Processador RISC-V

Tipos de Instruções

Teste do Processador

Função gerainst para cada tipo

Memória Cache

Conexão com a Network Operations Center (NOC)

About

Topics

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Contributors 3

Languages

Packages