El documento describe los pasos para diseñar una CPU de propósito general. Explica que la CPU consta de una sección de datos y una unidad de control. La sección de datos incluye componentes como registros, ALU y memoria que manejan el flujo de datos. La unidad de control genera señales para controlar la sección de datos y ejecutar las instrucciones. El diseño se realiza analizando el conjunto de instrucciones, diseñando la sección de datos y generando las señales de control necesarias para cada instrucción.
3. Diseño de Procesador Sección de Datos y Control JerarquíaMemoria Control ALU Registers PC estado Bus Memoria CPU Sección de datos Combinational Secuencial
13. Elementos combinacionales Sumador (adder) Multiplexor (MUX) 32 32 A B 32 Sum Carry 32 32 A B 32 Result OP 32 A B 32 Y 32 Select Adder MUX ALU CarryIn Unidad aritmético-lógica (ALU) Bit Zero Result
14.
15.
16.
17.
18.
19.
20.
21.
22.
23. Diagrama de tiempo 32 Result ALUctr Clk busW RegWr 32 32 busA 32 busB 5 5 5 Rw Ra Rb 32 32-bit Registers Rs Rt Rd ALU Clk PC Rs, Rt, Rd, Op, Func Clk-to-Q ALUctr Instruction Memory Access Time Old Value New Value RegWr Old Value New Value Delay through Control Logic busA, B Register File Access Time Old Value New Value busW ALU Delay Old Value New Value Old Value New Value New Value Old Value Register Write Occurs Here
40. Datapath uniciclo durante “ beq” If (R[rs] – R[rt] == 0) then Zero 1 Else Zero 0 op rs rt immediate 0 16 21 26 31
41. Unidad de fetch al final de “beq” If (Zero == 1) then PC PC + 4 + SignExt[imm16]*4 Else PC PC + 4 op rs rt immediate 0 16 21 26 31
42. Resumen de señales de control Proceso de decodificación de instrucciones consiste en generar estas señales inst Register Transfer ADD R[rd] < – R[rs ] + R[rt ]; PC < – PC + 4 ALUsrc = RegB , ALUctr = “ add ” , RegDst = rd, RegWr , nPC_sel = “ +4 ” SUB R[rd] < – R[rs ] – R[rt ]; PC < – PC + 4 ALUsrc = RegB , ALUctr = “ sub ” , RegDst = rd, RegWr , nPC_sel = “ +4 ” ORi R[rt ] < – R[rs ] + zero_ext(Imm16); PC < – PC + 4 ALUsrc = Im , Extop = “ Z ” , ALUctr = “ or ” , RegDst = rt , RegWr , nPC_sel = “ +4 ” LOAD R[rt ] < – MEM[ R[rs ] + sign_ext(Imm16)]; PC < – PC + 4 ALUsrc = Im , Extop = “ Sn ” , ALUctr = “ add ” , MemtoReg , RegDst = rt , RegWr , nPC_sel = “ +4 ” STORE MEM[ R[rs ] + sign_ext(Imm16)] < – R[rs ]; PC < – PC + 4 ALUsrc = Im , Extop = “ Sn ” , ALUctr = “ add ” , MemWr , nPC_sel = “ +4 ” BEQ if ( R[rs ] == R[rt ] ) then PC < – PC + sign_ext(Imm16)] || 00 else PC < – PC + 4 nPC_sel = “ Br ” , ALUctr = “ sub ” Instrucción Transferencia de registros ADD R[rd] < – R[rs ] + R[rt ]; PC < – PC + 4 ALUsrc = RegB , ALUctr = “ add ” , RegDst = rd, RegWr , nPC_sel = “ +4 ” SUB R[rd] < – R[rs ] – R[rt ]; PC < – PC + 4 ALUsrc = RegB , ALUctr = “ sub ” , RegDst = rd, RegWr , nPC_sel = “ +4 ” ORi R[rt ] < – R[rs ] + zero_ext(Imm16); PC < – PC + 4 ALUsrc = Im , Extop = “ Z ” , ALUctr = “ or ” , RegDst = rt , RegWr , nPC_sel = “ +4 ” LOAD R[rt ] < – MEM[ R[rs ] + sign_ext(Imm16)]; PC < – PC + 4 ALUsrc = Im , Extop = “ Sn ” , ALUctr = “ add ” , MemtoReg , RegDst = rt , RegWr , nPC_sel = “ +4 ” STORE MEM[ R[rs ] + sign_ext(Imm16)] < – R[rs ]; PC < – PC + 4 ALUsrc = Im , Extop = “ Sn ” , ALUctr = “ add ” , MemWr , nPC_sel = “ +4 ” BEQ if ( R[rs ] == R[rt ] ) then PC < – PC + 4 + sign_ext(Imm16)] || 00 else PC < – PC + 4 nPC_sel = “ Br ” , ALUctr = “ sub ”
43. Paso 5: Diseñar lógica de control ALUctr RegDst ALUSrc ExtOp MemtoReg MemWr Equal Instrucción<31:0> <21:25> <16:20> <11:15> <0:15> Imm16 Rd Rs Rt nPC_sel Adr Memoria Instruccion SECCIÓN DE DATOS Decoder Op <21:25> Fun RegWr
44. Resumen de señales de control add sub ori lw sw beq RegDst ALUSrc MemtoReg RegWrite MemWrite nPCsel ExtOp ALUctr<2:0> 1 0 0 1 0 0 x Add 1 0 0 1 0 0 x Subtract 0 1 0 1 0 0 0 Or 0 1 1 1 0 0 1 Add x 1 x 0 1 0 1 Add x 0 x 0 0 1 x Subtract func op 00 0000 00 0000 00 1101 10 0011 10 1011 00 0100 Appendix A 10 0000 Ver 10 0010 No interesa op target address op rs rt rd shamt funct 0 6 11 16 21 26 31 op rs rt immediate R-type I-type J-type add, sub ori, lw, sw, beq jump
45. Decodificación local Unidad de control decodifica parte de la instrucción y ALU hace su propia decodificación local R-type ori lw sw beq RegDst ALUSrc MemtoReg RegWrite MemWrite Branch ExtOp ALUop<N:0> 1 0 0 1 0 0 x “ R-type” 0 1 0 1 0 0 0 Or 0 1 1 1 0 0 1 Add x 1 x 0 1 0 1 Add x 0 x 0 0 1 x Subtract op 00 0000 00 1101 10 0011 10 1011 00 0100
46. Codificación para ALUop ALUop: Instrucciones tipo ‘R’; instrucciones tipo ‘I’ (or, add, subtract) 2 bits R-type ori lw sw beq ALUop (Symbolic) “ R-type” Or Add Add Subtract ALUop<2:0> 1 00 0 10 0 00 0 00 0 01
47. Decodificación de campo ‘func’ op rs rt rd shamt funct 0 6 11 16 21 26 31 R-type R-type ori lw sw beq ALUop (Symbolic) “ R-type” Or Add Add Subtract ALUop<2:0> 1 00 0 10 0 00 0 00 0 01 funct<5:0> Instruction Operation 10 0000 10 0010 10 0100 10 0101 10 1010 add subtract and or set-on-less-than ALUctr<2:0> ALU Operation 000 001 010 110 111 And Or Add Subtract Set-on-less-than ALUctr ALU
48. Tabla de verdad para ALUctr R-type ori lw sw beq ALUop (Symbolic) “ R-type” Or Add Add Subtract ALUop<2:0> 1 00 0 10 0 00 0 00 0 01 ALUop func bit<2> bit<1> bit<0> bit<2> bit<1> bit<0> bit<3> 0 0 0 x x x x ALUctr ALU Operation Add 0 1 0 bit<2> bit<1> bit<0> 0 x 1 x x x x Subtract 1 1 0 0 1 x x x x x Or 0 0 1 1 x x 0 0 0 0 Add 0 1 0 1 x x 0 0 1 0 Subtract 1 1 0 1 x x 0 1 0 0 And 0 0 0 1 x x 0 1 0 1 Or 0 0 1 1 x x 1 0 1 0 Set on < 1 1 1 funct<3:0> Instruction Op. 0000 0010 0100 0101 1010 add subtract and or set-on-less-than
49.
50. Peor caso: instrucción load Critical Path (Load Operation) = PC ’ s Clk - to - Q + Instruction Memory ’ s Access Time + Register File ’ s Access Time + ALU to Perform a 32 - bit Add + Data Memory Access Time + Setup Time for Register File Write + Clock Skew Clk 5 Rw Ra Rb 32 32 - bit Registers Rd ALU Clk Data In Data Address Ideal Data Memory Instruction Instruction Address Ideal Instruction Memory Clk PC 5 Rs 5 Rt 16 Imm 32 32 32 32 A B Next Address Camino Crítico (Instrucción Load) = Tiempo acceso PC + Tiempo de acceso a la memoria + Tiempo de acceso a Banco Reg + ’ ALU para realizar suma de 32 bits+ - Tiempo acceso memoria de datos + Tiempo de seteo escritura en BReg + Clock Skew Clk 5 Rw Ra Rb 32 32 - bit Registros Rd ALU ALU Clk Data In Dir. Data Ideal Memoria Datos Instrucción Dirección Instrucción Ideal Memoria Instrucción Clk PC 5 Rs 5 Rt 16 Imm 32 32 32 32 A B Próx. Dir.
51.
52. Solución Banco registros Fetch Jump Memoria ALU Banco registros Fetch Store ALU Banco registros Fetch Branch Memoria ALU Banco registros Fetch Load Banco registros ALU Banco registros Fetch ALU Uso de unidades funcionales Tipo de instrucción
53. Solución Período de reloj ciclo fijo: 8ns Período de reloj ciclo variable: 6*0.44 + 8*0.24 + 7*0.12 + 5*0.18 + 2*0.02 = 6.3ns Aceleración = 1.27 2 2 Memoria datos 2 2 2 2 ALU 1 1 1 1 Lectura banco registros 2 2 2 2 2 Memoria de instrucción Jump Branch Store Load ALU Tipo de instrucción 2ns 7ns 8ns 6ns Total 1 1 Escritura banco registros
54. Ejemplo Suponer una unidad de punto flotante que suma o resta en 8ns y multiplica o divide en 16ns. Todas las otras unidades funcionales tienen los retardos del ejemplo anterior. ¿Qué tanto más rápida es la implementación de reloj de período variable versus la de reloj de período fijo? Asumir que las frecuencias de ejecución son: 31% loads, 21% stores, ALU 27%, saltos condicionales 5%, saltos absolutos 2%, suma/resta de punto flotante 7%, y multiplicación/división de punto flotante 7%. Tiempo de ejecución suma/resta de punto flotante = 2 + 1 + 8 + 1 = 12ns Tiempo de ejecución multiplicación/división de punto flotante = 2 + 1 + 16 + 1 = 20ns Ciclo de reloj período fijo = 20ns Ciclo de reloj promedio período variable = 8*0.31 + 7*0.21 + 6*0.27 + 5*0.05 + 2*0.02+ 12*0.07 + 20*0.07 = 8.1ns Aceleración = 20/8.1 = 2.47