Organización del Computador

Presentación del tema: "Organización del Computador"— 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. 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.

3 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

4 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.

5 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)

6 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 op rs rt Address/inmediate op Target Address

7 Formato R: Register op = 0
rs rt rd Sh (5) fun (6) 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)

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

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

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

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

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

13 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)

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

15 1o Paso: Tipo I (Branch) BEQ if (R[rs] == R[rt]) then
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]

16 1o Paso: Tipo I (Load) LOAD R[rt]  Mem[ R[rs]+sign_ext(Imm16) ] RTL
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

17 1o Paso: Tipo I (Store) STORE Mem[ R[rs]+sign_ext(Imm16) ]  R[rt];
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

18 Resumen de las etapas

19 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

20 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

21 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

22 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

23 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

24 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

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

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

27 3er Paso: Decode - ID

28 3er Paso: Ejecución - EX

29 3er Paso: Operandos - Mem

30 3er Paso: Write back- WB

31 Señales de control

32 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

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

34 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

35 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

36 Máquina de Estados Finitos
Implementación:

37 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 m n

38 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

39 Implementación con PLA

40 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

41 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

42 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

43 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

44 Formato de Microinstrucción

45 Microprogramación Microprogramando!

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