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.

1. Organzación de CPU Cecilia Hernández

2. Componentes sistema computacional

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

7. Formato instrucciones MIPS op target address 0 26 31 6 bits 26 bits op rs rt rd shamt funct 0 6 11 16 21 26 31 6 bits 6 bits 5 bits 5 bits 5 bits 5 bits op rs rt immediate 0 16 21 26 31 6 bits 16 bits 5 bits 5 bits R-type I-type J-type

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

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

24. Paso 3c: Operaciones lógicas con constantes R[rt]  R[rs] op ZeroExt[imm16] Ejemplo: ori rt, rs, imm16 32 Result ALUctr Clk busW RegWr 32 32 busA 32 busB 5 5 5 Rw Ra Rb 32 32 - bit Registers Rs ZeroExt Mux Rt Rd RegDst Mux 32 16 imm16 ALUSrc ALU Rt ? 32 Result ALUctr Clk busW RegWr 32 32 busA 32 busB 5 5 5 Rw Ra Rb 32 32 - bit Registers Rs ZeroExt Mux Rt Rd RegDst Mux Rt Rd RegDst Mux 32 16 imm16 ALUSrc ALU Rt ? op rs rt immediate 0 16 21 26 31 6 bits 16 bits 5 bits 5 bits immediate 16 15 31 16 bits 16 bits 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

25. Paso 3d: Lectura de memoria (load) R[rt]  MEM[ R[rs] + SignExt[imm16] ] Ejemplo: lw rt, rs, imm16 32 ALUctr Clk busW RegWr 32 32 busA 32 busB 5 5 5 Rw Ra Rb 32 32 - bit Registers Rs Rt Rd RegDst Extender Mux Mux 32 16 imm16 ALUSrc ExtOp Clk Data In WrEn 32 Adr Data Memory 32 ALU MemWr Mux W_Src ?? Rt ? 32 ALUctr Clk busW RegWr 32 32 busA 32 busB 5 5 5 Rw Ra Rb 32 32 - bit Registers Rs Rt Rd RegDst Extender Mux Mux 32 16 imm16 ALUSrc ExtOp Clk Data In WrEn 32 Adr Data Memory 32 ALU MemWr Mux W_Src ?? Rt ? op rs rt immediate 0 16 21 26 31 6 bits 16 bits 5 bits 5 bits

26. Paso 3e: Escritura en memoria (store) MEM[ R[rs] + SignExt[imm16] ]  R[rt] Ejemplo: sw rt, rs, imm16 32 ALUctr Clk busW RegWr 32 32 busA 32 busB 5 5 5 Rw Ra Rb 32 32 - bit Registers Rs Rt Rt Rd RegDst Extender Mux Mux 32 16 imm16 ALUSrc ExtOp Clk Data In WrEn 32 Adr Data Memory MemWr ALU 32 Mux W_Src 32 ALUctr Clk busW RegWr 32 32 busA 32 busB 5 5 5 Rw Ra Rb 32 32 - bit Registers Rs Rt Rt Rd RegDst Extender Mux Mux 32 16 imm16 ALUSrc ExtOp Clk Data In WrEn 32 Adr Data Memory MemWr ALU 32 Mux W_Src op rs rt immediate 0 16 21 26 31 6 bits 16 bits 5 bits 5 bits

27. Paso 3f: Salto condicional (branch) beq rs, rt, imm6 Mem[PC] Buscar instrucción de memoria Equal  R[rs] == R[rt] ? Calcular condición de salto If (Equal) Calcular dirección de siguiente instrucción PC  PC + 4 + SignExt(imm16) Else PC  PC + 4 op rs rt immediate 0 16 21 26 31 6 bits 16 bits 5 bits 5 bits

28. Paso 3f: Salto condicional (branch) beq rs, rt, imm16 Condición generada por datapath 32 imm16 PC Clk 00 Adder Mux Adder 4 nPC_sel Clk busW RegWr 32 busA 32 busB 5 5 5 Rw Ra Rb 32 32 - bit Registers Rs Rt Equal? Cond PC Ext Inst Address 32 imm16 PC Clk 00 Adder Adder Mux Mux Adder 4 Adder Adder 4 nPC_sel Clk busW RegWr 32 busA 32 busB 5 5 5 Rw Ra Rb 32 32 - bit Registers Rs Rt Equal? Cond PC Ext Inst Address op rs rt immediate 0 16 21 26 31 6 bits 16 bits 5 bits 5 bits

30. Señales de control nPC_MUX_sel 0  PC  PC + 4 1  PC  PC + 4 + SignExt(imm16) || 00

31. Señales de Control ExtOp : “zero”, “sign” MemWr : 1  Escribir en memoria ALUSrc : 0  regB; 1  constante MemToReg : 0  ALU; 1  Mem ALUctr : “add”, “sub”, “or” RegDst : 0  “rt”; 1  “rd” RegWr : 1  Escribir en registro

32. Paso 4: Valores de señales de control

33. RTL: Add add rd, rs, rt Mem[PC] Búsqueda de instrucción R[rd]  R[rs] + R[rt] Ejecución de instrucción PC  PC + 4 Actualización de PC op rs rt rd shamt funct 0 6 11 16 21 26 31 6 bits 6 bits 5 bits 5 bits 5 bits 5 bits

35. Datapath uniciclo durante “add” R[rd]  R[rs] + R[rt] op rs rt rd shamt funct 0 6 11 16 21 26 31

37. Datapath uniciclo durante “ori” R[rt]  R[rs] or ZeroExt(imm16) op rs rt immediate 0 16 21 26 31

38. Datapath uniciclo durante “lw” R[rt]  Dmem[R[rs]+SignExt(imm16)] op rs rt immediate 0 16 21 26 31

39. Datapath uniciclo durante “sw” Dmem[R[rs]+SignExt(imm16)]  R[rt] op rs rt immediate 0 16 21 26 31

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

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.

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