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