Upload
lloyd
View
123
Download
0
Embed Size (px)
DESCRIPTION
Simulación en VHDL del Datapath del MIPS. Descripción. Implementar una versión simplificada del datapath del MIPS Se asume que la memoria de instrucciones y la memoria de datos son externas al sistema. Formato de las instrucciones. Instrucciones I-Type Instrucciones R-Type - PowerPoint PPT Presentation
Citation preview
Simulación en VHDL del Datapath del MIPS
Descripción
• Implementar una versión simplificada del datapath del MIPS
• Se asume que la memoria de instrucciones y la memoria de datos son externas al sistema
Formato de las instrucciones
• Instrucciones I-Type
• Instrucciones R-Type
• Instrucciones J-Type
Formato de las instrucciones
• Opcode: es el codigo que identifica la instruccion. Instrucciones relacionadas pueden tener el mismo opcode, la longitud de este campo es de 6 bits (bit 26 al bit 31).
• RS1,RS2: representan los registros de entrada.
• RD: es el registro de destino
Instrucciones R-Type
• Las instrucciones de tipo R son aquellas en las que los valores de datos usados por la instrucción estan guardados en registros.
Instrucción R-Type
Opcode rs rt shift funct
rs, rt, rdEs la representacion numerica de los registros de operandos y el registro de destino (por ejemplo de 0 a 31). Cada uno de estos campos tiene 5 bits de largo.
Shift: se usa en las operaciones de shift y de rotacion, indica cuantas veces el registro rs es rotado/shifted. Este campo tiene 5 bits.
Funct: para las instrucciones que comparten el mismo opcode, el parametro funct contiene los codigos de control necesarios para diferenciar las distintas instrucciones, Tiene 6 bits de largo
Ejemplos de instrucciones
• add $rd, $rs, $rt
• add $rt, $rs, immed
• j target
R-Type: Shift
IR[31:26] IR[5:0] Mnemonic Effect
000000 0x00 000000 0x00 slli RD = RS1 << SA
000000 0x00 000001 0x01 slai RD = RS1 << SA (arith.)
000000 0x00 000010 0x02 srli RD = RS1 >> SA
000000 0x00 000011 0x03 srai RD = RS1 >> SA (arith.)
000000 0x00 000100 0x04 sll RD = RS1 << RS2[4:0]
000000 0x00 000101 0x05 sla RD = RS1 << RS2[4:0] (arith.)
000000 0x00 000110 0x06 srl RD = RS1 >> RS2[4:0]
000000 0x00 000111 0x07 sra RD = RS1 >> RS2[4:0] (arith.)
R-Type: instrucciones Aritmeticas
IR[31:26] IR[5:0] Mnemonic Effect
000000 0x00 100000 0x20 add RD = RS1 + RS2
000000 0x00 100001 0x21 addu RD = RS1 + RS2 (no overflow)
000000 0x00 100010 0x22 sub RD = RS1 - RS2
000000 0x00 100011 0x23 subu RD = RS1 - RS2 (no overflow)
000000 0x00 100100 0x24 and RD = RS1 Ù RS2
000000 0x00 100101 0x25 or RD = RS1 Ú RS2
000000 0x00 100110 0x26 xor RD = RS1 Å RS2
000000 0x00 100111 0x27 lhg RD = RS2[15:0] 016
R-Type: Test Set instructions
IR[31:26] IR[5:0] Mnemonic Effect
000000 0x00 101000 0x28 clr RD = ( false ? 1 : 0)
000000 0x00 101001 0x29 sgr RD = (RS1 > RS2 ? 1 : 0)
000000 0x00 101010 0x2a seq RD = (RS1 = RS2 ? 1 : 0)
000000 0x00 101011 0x2b sge RD = (RS1 ³ RS2 ? 1 : 0)
000000 0x00 101100 0x2c sls RD = (RS1 < RS2 ? 1 : 0)
000000 0x00 101101 0x2d sne RD = (RS1 ¹ RS2 ? 1 : 0)
000000 0x00 101110 0x2e sle RD = (RS1 £ RS2 ? 1 : 0)
000000 0x00 101111 0x2f set RD = ( true ? 1 : 0)
Instrucciones I-Type
• Las instrucciones I-type son las que involucran valores inmediatos. Estas instrucciones tienen un solo registro fuente (el otro operando es el valor inmediato) y un registro destino.
I-Type: Data Transfer
IR[31:26] Mnemonic d Efecto
Data Transfer, mem = M[RS1 + Sext(imm)]
100000 0x20 lb 1 RD = Sext(mem)
100001 0x21 lh 2 RD = Sext(mem)
100011 0x23 lw 4 RD = mem
100100 0x24 lbu 1 RD = 024mem
100101 0x25 lhu 2 RD = 016mem
101000 0x28 sb 1 mem = RD[7:0]
101001 0x29 sh 2 mem = RD[15:0]
101011 0x2b sw 4 mem = RD
I-Type: Arithmetic, Logical Operation
IR[31:26] Mnemonic d Efecto
001000 0x08 addi RD = RS1 + Sext(imm)
001001 0x09 addiu RD = RS1 + Sext(imm) (no overflow)
001010 0x10 subi RD = RS1 - Sext(imm)
001011 0x11 subiu RD = RS1 - Sext(imm) (no overflow)
001100 0x12 andi RD = RS1 Ù Sext(imm)
001101 0x13 ori RD = RS1 Ú Sext(imm)
001110 0x14 xori RD = RS1 Å Sext(imm)
001111 0x15 lhgi RD = imm016
I-Type: Test Set Operation
IR[31:26] Mnemonic d Efecto
011000 0x18 clri RD = (false ? 1 : 0)
011001 0x19 sgri RD = (RS1 > Sext(imm) ? 1 : 0)
011010 0x1a seqi RD = (RS1 = Sext(imm) ? 1 : 0)
011011 0x1b sgei RD = (RS1 ³ Sext(imm) ? 1 : 0)
011100 0x1c slsi RD = (RS1 < Sext(imm) ? 1 : 0)
011101 0x1d snei RD = (RS1 ¹ Sext(imm) ? 1 : 0)
011110 0x1e slei RD = (RS1 £ Sext(imm) ? 1 : 0)
011111 0x1f seti RD = ( true ? 1 : 0)
I-Type: Control Operations
IR[31:26] Mnemonic d Efecto
000100 0x04 beqz PC = PC + 4 + (RS1 = 0 ? Sext(imm) : 0)
000101 0x05 bnez PC = PC + 4 + (RS1 ¹ 0 ? Sext(imm) : 0)
000110 0x16 jr PC = RS1
000111 0x17 jalr R31 = PC + 4; PC = RS1
Instrucciones J-Type
• Las instrucciones J-Type son las que involucran saltos.
PC <- PC31-28 IR25-0 00
Estas instrucciones modifican el program counter (PC)
J-Type: Control Operation
IR[31:26] Mnemonic Efecto
000010 0x02 j PC = PC + 4 + Sext(imm)
000011 0x03 jal R31 = PC + 4; PC = PC + 4 + Sext(imm)
Link de referencia para las instrucciones del mip:
• http://www.mrc.uidaho.edu/mrc/people/jff/digital/MIPSir.html
Como opera el datapath con las instrucciones R-type.
1. En la primera fase la instruccion se leen los dos registros fuentes rs, rt desde
el register file, direccionados por IR(25-21) y IR(20-16) respectivamente. Los registros fuentes son cargados en los registros A y B.
• La memoria de instrucciones es de 32 bits y la memoria de datos es de 32 bits
• El datapath va a contener un register file compuesto por cuatro registros de 32 bits.
• El control de las entradas del datapath viene dado por algunos campos del Instruction Register. Estos campos son IR(25-11) y IR(10-6).
Como opera el datapath con las instrucciones R-type.
2. En el siguiente ciclo la ALU realiza la operacion deseada sobre los registros A y B. Aqui la señal ALUOp=10 que en conjunto con el campo función que viene en IR(5-0) determina los 3 bits de control de la alu para seleccionar la funcion apropiada de la misma.
Esto se hace con el ALU control block
El resultado es automaitcamente cargado en ALUout Register en cada ciclo de clock
Como opera el datapath con las instrucciones R-type.
• En la ultima fase el contenido de ALUout es guardado en el registro destino.
• Las señales de este ciclo son: MemtoReg=0, RegWrite=1.
• Esto provoca que el registro destino rd direccionado por IR(15-11) sea escrito en el register file
Implementacion
• Primero diseñar los modulos individuales: un registro de instrucción de 32 bitsUn register file de 32x324 to 1 de 32bit MUX con 2 señales de
control (2 MUX)2 bit decoder y el write port para el
Register FileRegistros de 32 bits: A,B, ALuout
Implementacion
Una ALU de 32 bitsEl decoder de control de la ALU