Organización del Computador CPU 3 y 4 – Diseño de una computadora.

Presentación del tema: "Organización del Computador CPU 3 y 4 – Diseño de una computadora."— Transcripción de la presentación:

1 Organización del Computador CPU 3 y 4 – Diseño de una computadora

2 Consideraciones Una única ALU, una única Memoria, un único Banco de Registros. Una única ALU, una única Memoria, un único Banco de Registros. Dos tipos de problemas: Dos tipos de problemas: Una instrucción utiliza un mismo recurso varias veces y se pierden los valores anteriores. Una instrucción utiliza un mismo recurso varias veces y se pierden los valores anteriores. Una instrucción utiliza un mismo recurso en la misma etapa para dos o más cosas distintas. Una instrucción utiliza un mismo recurso en la misma etapa para dos o más cosas distintas.

3 Algunos componentes disponibles PC 1632 Sign extend MemRead MemWrite memory Write data Read data Address Program Counter Unidad de memoria Unidad de extensión de signo ALU control ALU result ALU Zero 3 ALU

4 Diseño: Pasos necesarios : Analizar el conjunto de instrucciones para determinar los requerimientos del Camino de Datos. 1 er Paso: Analizar el conjunto de instrucciones para determinar los requerimientos del Camino de Datos. : Seleccionar los componentes. 2 o Paso: Seleccionar los componentes. : Construir el Camino de Datos según los requerimientos. 3 o Paso: Construir el Camino de Datos según los requerimientos. : Analizar la implementación de cada instrucción para determinar las señales de control necesarias. 4 o Paso: Analizar la implementación de cada instrucción para determinar las señales de control necesarias. : Construir el Control. 5 o Paso: Construir el Control.

5 1.Fetch de Instrucción (Fetch/IF) 2.Decodificación (y lectura de registros) (Decode/ID) 3.Acceso a datos en memoria (Mem) (previo Cálculo de Dirección de memoria) 4.Ejecución (Execution/EX) 5.Escritura en registros (Write Back/WB) Cinco Etapas (o fases) de Ejecución

6 Formato MIPS de Instrucción Son todas de 32 bits. Tres formatos: Tipo R (register) Tipo R (register) Aritméticas Aritméticas Tipo I (immediate) Tipo I (immediate) Transferencia, salto Transferencia, salto Operaciones con operando inmediato Operaciones con operando inmediato Tipo J (jump) Tipo J (jump) Saltos Saltos oprsrtrd shsh funct 31 26 21 16 11 6 0 oprsrtAddress/inmediate 31 26 21 16 0 opTarget Address 31 26 0

7 Formato R: Register op = 0 op = 0 rs, rt = identificación de los registros fuente rs, rt = identificación de los registros fuente rd = identificación del registro destino rd = identificación del registro destino sh = cantidad de shifts sh = cantidad de shifts func = identifica la operación (ej. add=32, sub=34, sll=0,srl=10) func = identifica la operación (ej. add=32, sub=34, sll=0,srl=10) 0rsrtrd S h (5) fun (6) 31 26 21 16 11 6 0

8 Formato R :Ejemplos Add $1, $2, $3 Add $1, $2, $3 0231 032 31 26 21 16 11 6 0 Sub$1, $2, $3 Sub$1, $2, $3 0231 034 31 26 21 16 11 6 0 Slt$1, $2, $3 Slt$1, $2, $3 0231 042 31 26 21 16 11 6 0 Set Less Than si ($2<$3) entonces $1=1sino $1=0 Jr$31 Jr$31 03100 08 31 26 21 16 11 6 0 Jump Register PC=$31

9 Formato I : Immediate oprsrtAddress/inmediate 31 26 21 16 0 821100 31 26 21 16 0 Addi$1,$2,100 Addi$1,$2,100 $1=$2+100 $1=$2+100

10 Formato I : Immediate 3521100 31 26 21 16 0 Lw $1, 100($2) Lw $1, 100($2) 4321100 31 26 21 16 0 Sw $1, 100($2) Sw $1, 100($2) Load Word $1=M[$2+100] Store Word M[$2+100]=$1 oprsrtAddress/inmediate 31 26 21 16 0

11 Formato I : Immediate 412100 31 26 21 16 0 Beq$1,$2,100 Beq$1,$2,100 512100 31 26 21 16 0 Bne$1,$2,100 Bne$1,$2,100 Branch Equal si ($1=$2) entonces ir a PC+4+100 Branch Not Equal si ($1!=$2) entonces ir a PC+4+100 oprsrtAddress/inmediate 31 26 21 16 0

12 Formato J : Jumps J10000 J10000 PC 27..2 =10000PC 1..0 =00 PC 27..2 =10000PC 1..0 =00 opTarget Address 31 26 0 210000 31 26 0 Jal10000 Jal10000 310000 31 26 0 JUMP AND LINK $31=PC+4 PC 27..2 =10000PC 1..0 =00

13 oprsrtrd sham t funct 31 26 21 16 11 6 0 oprsrtAddress/inmediate 31 26 21 16 0 1 er Paso: Subconjunto MIPS ADD y SUB ADD y SUB ( (R[rd] = R[rs] op R[rt]) addu rd,rs,rt addu rd,rs,rt subu rd, rs,rt subu rd, rs,rt LOAD and STORE LOAD and STORE lw rt, rs, inm16 lw rt, rs, inm16 R[rt] = Mem[ R[rs]+sign_ext(Inm16) ]; R[rt] = Mem[ R[rs]+sign_ext(Inm16) ]; sw rt, rs, inm16 sw rt, rs, inm16 Mem[ R[rs]+sign_ext(Inm16) ]= R[rt]; Mem[ R[rs]+sign_ext(Inm16) ]= R[rt]; BRANCH BRANCH beq rs, rt, inm16 beq rs, rt, inm16 if (R[rs]==R[rt]) then if (R[rs]==R[rt]) thenPC=PC+(sign_ext(Inm16)*4) JUMP JUMP J target J target PC =PC,(target << 2) oprsrtAddress/inmediate 31 26 21 16 0 opop Target Address 31 26 0

14 Uso de U.F PasoRegistrosALUMemoria Fetch Todas PC<--PC+4TodasIR<--M[PC] DecodeTodas Ex Tipo R: operación Lw y Sw: dirección Beq: operación y dirección !! MemLw y Sw PostWLw Tipo R

15 Uso de U.F InstrucciónRegistrosALUMemoria Tipo R ID/WBFetch/EXFetch Lw ID/WB Fetch/EX Fetch/Memoria SwIDFetch/EX Fetch/Memoria BeqID Fetch/ID/EX. Fetch

16 RTL (Registrer Tranfer Language) Cada instrucción está formada por un conjunto de microoperaciones. Cada instrucción está formada por un conjunto de microoperaciones. Se utiliza para determinar la secuencia exacta de microoperaciones. Se utiliza para determinar la secuencia exacta de microoperaciones. Ejemplo (Fetch en Marie): Ejemplo (Fetch en Marie): t1:MAR  (PC) t1:MAR  (PC) t2:MBR  Mem[MAR] t2:MBR  Mem[MAR] PC  (PC) + 1 PC  (PC) + 1 t3:IR  (MBR) t3:IR  (MBR)

17 1 o Paso: Tipo R (add, sub...) R[rd] = R[rs] ‘op’ R[rt]; PC=PC+4 RTL T1: IR  Mem[PC] PC  PC + 4 T2: A  R[rs] B  R[rt] T3: ALUOut  A ‘op‘ B T4: R[rd]  ALUOut 0rsrtrd S h (5) fun (6) 31 26 21 16 11 6 0

18 BEQif (R[rs] == R[rt]) then PC  PC+(sign_ext(Imm16)*4) RTL T1: IR  Mem[PC]; PC  PC + 4 T2: A  R[rs] (Se guardan para el ciclo siguiente) B  R[rt] ALUOut  PC + sign_ext (Imm16) << 2 (calcula la dir. del salto) T3: PC  ALUOut [Si el flag Zero esta activo] oprsrtAddress/inmediate 31 26 21 16 0 1 o Paso: Tipo I (Branch)

19 LOADR[rt]  Mem[ R[rs]+sign_ext(Imm16) ] RTL T1: IR  Mem[PC] PC  PC + 4 T2: A  R[rs] B  R[rt] (B no se usa) T3: ALUOut  A + sign_ext (Imm16) (Calcula la dir.) T4: MBR  Mem[ALUOut] T5: R[rt]  MAR oprsrtAddress/inmediate 31 26 21 16 0 1 o Paso: Tipo I (Load)

20 STOREMem[ R[rs]+sign_ext(Imm16) ]  R[rt]; RTL T1: IR  Mem[PC] PC  PC + 4 T2: A  R[rs] B  R[rt] (valor a escribir) T3: ALUOut  A + sign_ext (imm16) T4: Mem[ALUOut]  B oprsrtAddress/inmediate 31 26 21 16 0 1 o Paso: Tipo I (Store)

21 Jump PC  PC,(target << 2) (Calcula la dirección concatenando los 26 bits del operando) RTL T1: IR  Mem[PC] PC  PC + 4 T2: ¡NADA! T3: PC  PC,(IR << 2) 1 o Paso: Tipo J (jump...) opTarget Address 31 26 0

22 Resumen de las etapas

23 Número de Ciclos Brach y Jump: 3 ciclos (IF,ID,EX) Brach y Jump: 3 ciclos (IF,ID,EX) Las tipo R: 4 ciclos (IF,ID,EX,WB) Las tipo R: 4 ciclos (IF,ID,EX,WB) STORE: 4 ciclos (IF,ID,EX,MEM) STORE: 4 ciclos (IF,ID,EX,MEM) LOAD: 5 (IF,ID,EX,MEM,WB) LOAD: 5 (IF,ID,EX,MEM,WB)

24 1- Fetch (IF) RTL RTL IR  Memory[PC] PC  PC + 4

25 2 - Decode (ID) RTL RTL Opción lectura de registros Opción lectura de registros A  reg[IR[25:21]] B  reg[IR[20:16]] Opción cálculo de salto ALUOut  PC + sign-extend(IR[15:0]) <<2

26 3 - Execute (Ex) RTL RTL Opción artimética/lógica Opción artimética/lógica ALUOut  A op B, o ALUOut  A op sign-extend(IR[15:0]) Cálculo de dirección (Load o Store) ALUOut  A + sign-extend(IR[15:0]) Salto condicional Si A = B, PC  ALUOut Jump PC[31:28]  PC || IR[25:0] <<2

27 4 – Memoria (Mem) Sólo para Load o Store Sólo para Load o Store RTL RTL Opción Lectura Opción Lectura MBR  Memory[ALUOut] Opción Grabado Memory[ALUOut]  B

28 5 - Escritura RTL RTL Opción instrucción tipo R o aritmética inmediata Opción instrucción tipo R o aritmética inmediata reg[ IR[15:11] ]  ALUOut Opción Load (celda de memoria leída en el ciclo anterior) reg[IR[20:16]]  MBR

29 1 er Paso: Requerimientos del Conjunto de Instrucciones Memoria Memoria Para instrucciones y datos Para instrucciones y datos Registros (32x32) Registros (32x32) Leer rs, leer rt Leer rs, leer rt Escribir rt ó rd Escribir rt ó rd PC, MBR PC, MBR A, B para datos intermedios, ALUOut (retener salida ALU) A, B para datos intermedios, ALUOut (retener salida ALU) Extensor de signo (16 a 32) Extensor de signo (16 a 32) Sumar y Restar registros y/o valores inmediatos Sumar y Restar registros y/o valores inmediatos Operaciones lógicas (and/or) registros y/o valores inmediatos Operaciones lógicas (and/or) registros y/o valores inmediatos Sumar 4 al PC ó 4 + inmediato extendido * 4 Sumar 4 al PC ó 4 + inmediato extendido * 4

30 2 o Paso: Componentes del Camino de Datos PC b. Program counter b. ALU ALU control ALU result ALU Zero 3

31 Elementos Combinacionales Elementos Combinacionales ALU y Multiplexor ALU y Multiplexor Suma 32 A B Op Resultado ALU Sel A B 32 MUX

32 2 o Paso: Componentes del Camino de Datos Elementos de Almacenamiento: Banco de Registros Elementos de Almacenamiento: Banco de Registros WE CLK Data Out Data In 32 RegW CLK LRA LRB ER BusW BusA BusB32 Registros de 32 bits 32 5 5 5

33 2 o Paso: Componentes del Camino de Datos Elementos de Almacenamiento: Banco de Registro (dos puertos de lectura) Elementos de Almacenamiento: Banco de Registro (dos puertos de lectura) M u x Register 0 Register 1 Register n – 1 Register n M u x Read data 1 Read data 2 Read register number 1 Read register number 2 RegW CLK LRA LRB ER BusW BusA BusB32 Registros de 32 bits 32 5 5 5

34 2 o Paso: Componentes del Camino de Datos Elementos de Almacenamiento: Banco de Registros (un puerto de escritura) Elementos de Almacenamiento: Banco de Registros (un puerto de escritura) RegW CLK LRA LRB ER BusW BusA BusB32 Registros de 32 bits 32 5 5 5

35 2 o Paso: Componentes del Camino de Datos Una sola memoria para instrucciones y datos Una sola memoria para instrucciones y datos WE CLK dirección Dato In Dato Out Memoria 32 MUX De la ALU Del PC IR IoD IRW

36 3 er Paso: Reuso de Unidades Funcionales: ALU única ALU debe realizar ALU debe realizar operaciones sobre registros operaciones sobre registros base + desplazamiento para loads y stores base + desplazamiento para loads y stores dirección destino de salto: registro + sign_ext(Imm16) * 4 dirección destino de salto: registro + sign_ext(Imm16) * 4 PC=PC+4 PC=PC+4 BusB 32 PC 32 MUXMUX ALUctr MUXMUX BusA 32 Inm16SignExt >>2 4 32

37 3 er Paso: Registro ALUout BusB 32 PC 32 MUXMUX ALUct r MUXMUX BusA 32 Inm16 SignExt >>2 4 32 ALUOut DstW

38 3 er Paso: Fetch - IF Mem[PC]; PC PC + 4 (código secuencial ) Mem[PC]; PC  PC + 4 (código secuencial )

39 3 er Paso: Decode - ID

40 3 er Paso: Ejecución - EX

41 3 er Paso: Operandos - Mem

42 3 er Paso: Write back- WB

43 Señales de control

44 Grafo de Estados IR  MEM[PC]; PC  PC+4 A  R[rs]; B  R[rt]; ALUOut  PC+(signext(inm16)<<2) ALUOut  AopB ALUOut  A+ signext(inm16) Z  A-B si (Z) PC  ALUOut MBR  MEM[ALUOut] R[rd]  ALUOut R[rt]  -MBR MEM[ALUOut]  B Format R Beq PC  PC[31:28] || (IR[25:0] <<2) Jump Lw Sw

45 Grafo de Estados S0 S1 S6 S2 S8 S3 S7S4 S5 S9

46 Control de Señales S0S1S2S3S4S5S6S7S8S9 RegWrite IRWrite MemRead MemWrite PCWrite PCWCond PCSource ALUsrcA ALUsrcB MemToReg RegDst IoD ALUop

47 Control de Señales S0S1S2S3S4S5S6S7S8S9 RegWrite 0000100100 IRWrite 1000000000 MemRead 11 MemWrite 0000010000 PCWrite 1000000001 PCWCond 1 PCSource 000110 ALUsrcA 001111111 ALUsrcB 011110 00 MemToReg 10 RegDst 01 IoD 0111 ALUop 00 1001

48 Control: Especificación e Implementación Representación Inicial Diagrama de Estados Finitos Microprograma Control del Secuenciamiento Función explícita del estado futuro Contador de microprograma + ROM Representación Lógica Ecuaciones Lógicas Tabla de Verdad Técnica de Implementación Array Lógico Programable ROM Control microprogranado Control cableado

49 Implementación: Máquina de Estados Finitos

50 ROM = "Read Only Memory" ROM = "Read Only Memory" Se graba la memoria con valores fijos Se graba la memoria con valores fijos Se usa la ROM para implementar la Tabla de Verdad Se usa la ROM para implementar la Tabla de Verdad Con direcciones de m-bits, podemos direccionar 2 m entradas en la ROM. Con direcciones de m-bits, podemos direccionar 2 m entradas en la ROM. Las salidas son los datos (palabras) direccionadas Las salidas son los datos (palabras) direccionadas Implementación con ROM mn 0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 1 0 1 1 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 1 1 1 0 0 1 1 0 1 1 1 0 1 1 1

51 ¿ Cuantas entradas tenemos? ¿ Cuantas entradas tenemos? 6 bits para el opcode 6 bits para el opcode 4 bits para el estado 4 bits para el estado = 10 líneas de direcciones (2 10 = 1024 posibles direcciones) = 10 líneas de direcciones (2 10 = 1024 posibles direcciones) ¿Cuantas salidas? ¿Cuantas salidas? 16 señales de control del camino de datos 16 señales de control del camino de datos 4 bits de estado 4 bits de estado = 20 lineas de salida = 20 lineas de salida ROM de 2 10 x 20bits = 20Kbits ROM de 2 10 x 20bits = 20Kbits Problema: mucho desperdicio, ya que para muchisimas entradas, las salidas son idénticas. Problema: mucho desperdicio, ya que para muchisimas entradas, las salidas son idénticas. Por ejemplo, el codígo de operación se ignora muchas veces Por ejemplo, el codígo de operación se ignora muchas veces Implementación con ROM

52 Implementación con PLA

53 Se podrían hacer dos ROM: — 4 bits de estado se usan como dirección de las palabras de salida: 2 4 x 16 bits= 256bits de ROM — 10 bits (6 opcode, 4 estado) se usan como dirección para la función de transición (nuevo estado): 2 10 x 4 bits de ROM — Total: 4K bits de ROM Se podrían hacer dos ROM: — 4 bits de estado se usan como dirección de las palabras de salida: 2 4 x 16 bits= 256bits de ROM — 10 bits (6 opcode, 4 estado) se usan como dirección para la función de transición (nuevo estado): 2 10 x 4 bits de ROM — Total: 4K bits de ROM PLA es mas pequeña PLA es mas pequeña — puede compartir términos producto — sólo utiliza las entradas que producen valores — puede considerar los “no importa” Tamaño (#inputs  #product-terms) + (#outputs  #product-terms) Tamaño (#inputs  #product-terms) + (#outputs  #product-terms) En el ejemplo = (10x17)+(20x17) = 460 PLA cells Una celda de PLA es un poco mas grande que una de ROM En el ejemplo = (10x17)+(20x17) = 460 PLA cells Una celda de PLA es un poco mas grande que una de ROM ROM vs PLA

54 Microprogramación La ROM es la memoria donde se guardan las instrucciones para el camino de datos (microinstrucciones) La dirección de la ROM (microPC) es el estado

55 Es una metodología de especificación Es una metodología de especificación Apropiada para arquitecturas con cientos de instrucciones, modos, etc. Apropiada para arquitecturas con cientos de instrucciones, modos, etc. Las señales se especifican simbólicamente usando microinstrucciones Las señales se especifican simbólicamente usando microinstrucciones Se define el formato de la microinstrucción, estructurado en campos. Se define el formato de la microinstrucción, estructurado en campos. Luego cada campo se asocia a un conjunto de señales Luego cada campo se asocia a un conjunto de señales Microprogramación

56 Detalle de implementación O p Adder 1 PLA or ROM Mux 3210 Dispatch ROM 1Dispatch ROM 2 0 AddrCtl Address select logic Instruction register opcode field MicroPC

57 Diseño del Microcódigo Función básica: Proveer señales para el datapath Función básica: Proveer señales para el datapath Dos enfoques: Dos enfoques: Horizontal: Horizontal: La microinstruccion provee todas las señales de control necesarias para un ciclo La microinstruccion provee todas las señales de control necesarias para un ciclo Paralelismo Paralelismo Vertical Vertical Más compacta Más compacta Las señales están codificadas para que ocupen menos bits Las señales están codificadas para que ocupen menos bits Menos paralelismo Menos paralelismo

58 Diseño de microinstrucciones Diferentes señales agrupadas por campos Diferentes señales agrupadas por campos CampoFunción Alu Control Que operación debe hacer la ALU en este ciclo SRC1 Especifica el 1º operando de la ALU SRC2 Especifica el 2º operando de la ALU Register Ctrl Especifica Lectura/Grabación de registros, y la fuente para la grabación Memoria Especifica Lectura/Grabación. En lectura el registro de destino PCWriteCtrl Especifica la grabación del PC Secuencia Determina como elegir la proxima microinstrucción

59 Formato de Microinstrucción

60 Microprogramación Microprogramando! Microprogramando!

61 Microcódigo: Ventajas-Desventajas Ventajas en la especificación: Ventajas en la especificación: Fácil de diseñar: se escribe el microprograma Fácil de diseñar: se escribe el microprograma Implementación en ROM (off-chip) Implementación en ROM (off-chip) Fácil de cambiar Fácil de cambiar Puede emular otras arquitecturas Puede emular otras arquitecturas Puede usar registros internos Puede usar registros internos Desventajas de la implementación Desventajas de la implementación Control se implementa (hoy) en el mismo chip que el camino de datos Control se implementa (hoy) en el mismo chip que el camino de datos La ROM no es mas rápida que la RAM (CISC vs RISC) La ROM no es mas rápida que la RAM (CISC vs RISC)

62 Referencias Capitulo 5 - Patterson Capitulo 5 - Patterson Ver resumen en sección Download Ver resumen en sección Download Capitulo 4 - Tanembaun Capitulo 4 - Tanembaun Capitulo 16 y 17 - Stallings Capitulo 16 y 17 - Stallings Capitulo 4 - Null Capitulo 4 - Null

63 RegW CLK rs rt BusW BusA BusB32 Registros de 32 bits 32 5 5 5 LRA LRB WR rd RegDst MUX Inm16EXtension 32 MUXMUX AluselB Ex/Op 32 PC CLK instrucción Memoria 32 >>2 32 ALUctr MUXMUX @ W_src MUX Pcsrc Instrucción ADD: Fetch ZERO Dst DstW 4 MUXMUX AluselA IRW WE IoD CLK PCW

64 RegW CLK rs rt BusW BusA BusB32 Registros de 32 bits 32 5 5 5 LRA LRB WR rd RegDst MUX Inm16EXtension 32 MUXMUX AluselB Ex/Op 32 PC CLK instrucción Memoria 32 >>2 32 ALUctr MUXMUX @ W_src MUX Pcsrc Add: Decode ZERO Dst DstW 4 MUXMUX AluselA IRW WE IoD CLK PCW oprsrtrd s hamt funct 31 26 21 16 11 6 0

65 RegW CLK rs rt BusW BusA BusB32 Registros de 32 bits 32 5 5 5 LRA LRB WR rd RegDst MUX Inm16EXtension 32 MUXMUX AluselB Ex/Op 32 PC CLK instrucción Memoria 32 >>2 32 ALUctr MUXMUX @ W_src MUX Pcsrc Add: Ejecución ZERO Dst DstW 4 MUXMUX AluselA IRW WE IoD CLK PCW

66 RegW CLK rs rt BusW BusA BusB32 Registros de 32 bits 32 5 5 5 LRA LRB WR rd RegDst MUX Inm16EXtension 32 MUXMUX AluselB Ex/Op 32 PC CLK instrucción Memoria 32 >>2 32 ALUctr MUXMUX @ W_src MUX Pcsrc Add: Write Back ZERO Dst DstW 4 MUXMUX AluselA IRW WE IoD CLK PCW

67 RegW CLK rs rt BusW BusA BusB32 Registros de 32 bits 32 5 5 5 LRA LRB WR rd RegDst MUX Inm16EXtension 32 MUXMUX AluselB Ex/Op 32 PC CLK instrucción Memoria 32 >>2 32 ALUctr MUXMUX @ W_src MUX Pcsrc Instrucción load: Fetch ZERO Dst DstW 4 MUXMUX AluselA IRW WE IoD CLK PCW

68 RegW CLK rs rt BusW BusA BusB32 Registros de 32 bits 32 5 5 5 LRA LRB WR rd RegDst MUX Inm16EXtension 32 MUXMUX AluselB Ex/Op 32 PC CLK instrucción Memoria 32 >>2 32 ALUctr MUXMUX @ W_src MUX Pcsrc Load : Decode ZERO Dst DstW 4 MUXMUX AluselA IRW WE IoD CLK PCW oprsrtAddress/inmediate 31 26 21 16 0

69 RegW CLK rs rt BusW BusA BusB32 Registros de 32 bits 32 5 5 5 LRA LRB WR rd RegDst MUX Inm16EXtension 32 MUXMUX AluselB Ex/Op 32 PC CLK instrucción Memoria 32 >>2 32 ALUctr MUXMUX @ W_src MUX Pcsrc Load : Ejecución ZERO Dst DstW 4 MUXMUX AluselA IRW WE IoD CLK PCW oprsrtAddress/inmediate 31 26 21 16 0

70 RegW CLK rs rt BusW BusA BusB32 Registros de 32 bits 32 5 5 5 LRA LRB WR rd RegDst MUX Inm16EXtension 32 MUXMUX AluselB Ex/Op 32 PC CLK instrucción Memoria 32 >>2 32 ALUctr MUXMUX @ W_src MUX Pcsrc Load : Memoria ZERO Dst DstW 4 MUXMUX AluselA IRW WE IoD CLK PCW oprsrtAddress/inmediate 31 26 21 16 0