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

Consideraciones Una única ALU, una única Memoria, un único Banco de Registros. 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 en la misma etapa para dos o más cosas distintas.

Algunos componentes disponibles W r i t e P C A d d r e s s R e a d d a t a 1 6 3 2 S i g n e x t e n d W r i t e d a t a m e m o r y Program Counter Unidad de extensión de signo M e m R e a d Unidad de memoria A L U c o n t r l e s u Z 3 ALU R e g W r i t s a d 1 2 D n u m b 5 Registros

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

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

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

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

Formato R :Ejemplos Add $1, $2, $3 Sub $1, $2, $3 Slt $1, $2, $3 31 26 21 16 11 6 0 Add $1, $2, $3 2 3 1 32 Sub $1, $2, $3 2 3 1 34 31 26 21 16 11 6 0 2 3 1 42 31 26 21 16 11 6 0 Slt $1, $2, $3 Set Less Than si ($2<$3) entonces $1=1sino $1=0 Jr $31 31 8 31 26 21 16 11 6 0 Jump Register PC=$31

Formato I : Immediate $1=$2+100 Addi $1,$2,100 31 26 21 16 0 op rs rt 31 26 21 16 0 op rs rt Address/inmediate Addi $1,$2,100 8 2 1 100 31 26 21 16 0 $1=$2+100

Formato I : Immediate Sw $1, 100($2) Lw $1, 100($2) 31 26 21 16 0 op rs rt Address/inmediate 35 2 1 100 31 26 21 16 0 Lw $1, 100($2) Load Word $1=M[$2+100] 43 2 1 100 31 26 21 16 0 Sw $1, 100($2) Store Word M[$2+100]=$1

Formato I : Immediate Beq $1,$2,100 31 26 21 16 0 op rs rt Address/inmediate 4 1 2 100 31 26 21 16 0 Beq $1,$2,100 Branch Equal si ($1=$2) entonces ir a PC+4+100 5 1 2 100 31 26 21 16 0 Bne $1,$2,100 Branch Not Equal si ($1!=$2) entonces ir a PC+4+100

Formato J : Jumps J 10000 PC 27..2=10000 PC1..0=00 Jal 10000 31 26 0 op Target Address 31 26 0 J 10000 2 10000 PC 27..2=10000 PC1..0=00 31 26 0 Jal 10000 3 10000 JUMP AND LINK $31=PC+4 PC 27..2=10000 PC1..0=00

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

1o Paso: Tipo R (add, sub...) R[rd] = R[rs] ‘op’ R[rt]; PC=PC+4 RTL rs rt rd Sh (5) fun (6) 31 26 21 16 11 6 0 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

1o Paso: Tipo I (Branch) BEQ if (R[rs] == R[rt]) then 31 26 21 16 0 op rs rt Address/inmediate BEQ if (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]

1o Paso: Tipo I (Load) LOAD R[rt]  Mem[ R[rs]+sign_ext(Imm16) ] RTL 31 26 21 16 0 op rs rt Address/inmediate LOAD R[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

1o Paso: Tipo I (Store) STORE Mem[ R[rs]+sign_ext(Imm16) ]  R[rt]; 31 26 21 16 0 op rs rt Address/inmediate STORE Mem[ 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

Resumen de las etapas

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

2o Paso: Componentes del Camino de Datos 1 6 3 2 S i g n e x t d b . - s o u M m R a W r y A P C b . P r o g r a m c o u n t e r A L U c o n t r l e s u Z 3 R e g W r i t s a d 1 2 D n u m b . 5 b . A L U

2o Paso: Componentes del Camino de Datos Elementos de Almacenamiento: Banco de Registro (dos puertos de lectura) RegW CLK LRA LRB ER BusW BusA BusB 32 Registros de 32 bits 32 5 R e a d r e g i s t e r n u m b e r 1 R e g i s t e r R e g i s t e r 1 M u R e a d d a t a 1 x R e g i s t e r n – 1 R e g i s t e r n R e a d r e g i s t e r n u m b e r 2 M u R e a d d a t a 2 x

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

2o Paso: Componentes del Camino de 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

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

3er Paso: Registro ALUout BusB 32 PC MUX ALUctr BusA Inm16 SignExt >>2 4 ALUOut DstW

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

3er Paso: Decode - ID

3er Paso: Ejecución - EX

3er Paso: Operandos - Mem

3er Paso: Write back- WB

Señales de control

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

Grafo de Estados S0 S1 S8 S9 S6 S2 S5 S3 S7 S4

Control de Señales S0 S1 S2 S3 S4 S5 S6 S7 S8 S9 RegWrite IRWrite MemRead MemWrite PCWrite PCWCond PCSource ALUsrcA ALUsrcB MemToReg RegDst IoD ALUop

Control de Señales S0 S1 S2 S3 S4 S5 S6 S7 S8 S9 RegWrite IRWrite 1 IRWrite MemRead MemWrite PCWrite PCWCond PCSource 00 01 10 ALUsrcA ALUsrcB 11 MemToReg RegDst IoD ALUop

Máquina de Estados Finitos Implementación:

Implementación con ROM ROM = "Read Only Memory" Se graba la memoria con valores fijos Se usa la ROM para implementar la Tabla de Verdad Con direcciones de m-bits, podemos direccionar 2m entradas en la ROM. Las salidas son los datos (palabras) direccionadas 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 m n

Implementación con ROM ¿Cuantas entradas tenemos? 6 bits para el opcode 4 bits para el estado = 10 líneas de direcciones (210 = 1024 posibles direcciones) ¿Cuantas salidas? 16 señales de control del camino de datos 4 bits de estado = 20 lineas de salida ROM de 210 x 20bits = 20Kbits 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

Implementación con PLA

ROM vs PLA Se podrían hacer dos ROM: — 4 bits de estado se usan como dirección de las palabras de salida: 24 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): 210 x 4 bits de ROM — Total: 4K bits de ROM 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) En el ejemplo = (10x17)+(20x17) = 460 PLA cells Una celda de PLA es un poco mas grande que una de ROM

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

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

Diseño de microinstrucciones Diferentes señales agrupadas por campos Campo Funció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

Formato de Microinstrucción

Microprogramación Microprogramando!

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