EC1 Tema4

Tema 4
Procesador: camino de
datos y unidad de control
Índice
√ Introducción
√ Estructura básica de la CPU: camino de datos y
control
√ El ciclo de instrucción
√ Diseño de un procesador monociclo
√ Descomposición de la ejecución en etapas
√ Realización multiciclo
√ Diseño de la unidad de control
√ Procesamiento de excepciones
Introducción
En este tema se estudia la Unidad Central de Procesamiento (CPU)
Camino de datos:
Es la sección del computador encargada de manipular y transformar los
datos procedentes de la memoria o los registros internos, para obtener los
resultados
Su labor es soportar el conjunto de operaciones que precisan las
instrucciones del repertorio que es capas de interpretar la unidad de control
Unidad de control:
Es la sección del computador encargada de interpretar las instrucciones del
programa y gobernar la ejecución de las mismas
La organización de los procesadores ha evolucionado con el paso

de los años, guiada por el desarrollo tecnológico y la necesidad de
obtener altas prestaciones
En este tema se analizan las ideas básicas comunes a todos los

procesadores, que sientan las bases para poder comprender los
avances en arquitectura de computadores
Introducción
El procesador es el que se encarga de ejecutar las
instrucciones especificadas por el programa.
Funciones básicas:
Captar instrucciones. El procesador debe leer instrucciones
de la memoria
Interpretar instrucciones. La instrucción debe decodificarse
para determinar qué acción es necesaria
Captar datos. La ejecución puede exigir leer datos de la
memoria o de un módulo de E/S
Procesar datos. La ejecución de una instrucción puede
exigir llevar a cabo alguna operación aritmética o lógica
Escribir datos. Los resultados de una ejecución pueden
tener que ser escritos en la memoria o en un módulo de E/S
Estructura básica de un procesador
El procesador se compone de
varias partes:
1. La unidad de control
2. La unidad aritmético-lógica
3. Un banco de registros
4. Otros registros internos, algunos

de los más importantes:
1. El contador de programa (PC)
2. El registro de instrucciones (IR)

Vamos a construir un camino de datos y su unidad de
control para dos realizaciones diferentes de un
subconjunto del repertorio de instrucciones del MIPS:
Instrucciones de acceso a memoria: lw, sw
Instrucciones aritmético-lógicas: add, sub, or, slt
Instrucción de salto condicional: beq
Instrucción de salto incondicional: j
Datos
PC Dirección Registros
nº de registro ALU Dirección
Instrucción
nº de registro Memoria
Memoria de
instrucciones nº de registro de Datos
Datos
Metodología de sincronización
Las unidades funcionales se clasifican en dos tipos:
combinacionales y secuenciales
La metodología de sincronización define cuándo pueden leerse y
escribirse la diferentes señales
Asumimos sincronización por flancos
Estado 1 Lógica combinatoria Estado 2
Ciclo de reloj
El ciclo de instrucción
El procesamiento que requiere una instrucción se denomina
ciclo de instrucción.
Ciclo básico de instrucción:
INICIO
Captura de
Ciclo de captación
instrucción
Ejecución de
Ciclo de ejecución
la instrucción
FIN
El ciclo de instrucción
Para el subconjunto de instrucciones MIPS, los dos primeros pasos son
idénticos:
Usar el contenido del PC para cargar, desde la memoria que contiene el
código, la siguiente instrucción
Leer uno o dos registros, utilizando para ello los campos de la instrucción
específicos para seleccionarlos
Memoria Procesador
0x40000000 00000001010010110100100000100000 0x40000004 PC

0x40000004 10010101001010100000000000000000
0x40000008 00010001010010111111111111111011 00000001010010110100100000100000 IR
0x4000000C 00000000100001000001000100001010
0x40000000 00000001010010110100100000100000 0x40000004 PC

0x40000004 10010101001010100000000000000000
0x40000008 00010001010010111111111111111011 1001010100101010000000000000000 IR
0x4000000C 00000000100001000001000100001010
0x40000000 00000001010010110100100000100000 0x40000008 PC

0x40000004 10010101001010100000000000000000
0x40000008 00010001010010111111111111111011 1001010100101010000000000000000 IR
0x4000000C 00000000100001000001000100001010
Diseño de un camino de datos sencillo
Procesador monociclo:
Comenzaremos por los elementos básicos y sus

funciones asociadas
Veremos los elementos necesarios para
implementarlos
Veremos un conjunto de instrucciones básico
Veremos como implementar estas instrucciones
Contador de programa:
Cada instrucción está en una dirección de memoria dada
Almacenamos la dirección en el registro PC
Tras procesar una instrucción avanzamos el contador hasta la
siguiente instrucción
Sumador
4
PC Dirección
Instrucción
Memoria de
instrucciones

Operaciones tipo R:
Involucran tres registros: dos de lectura y uno de
escritura
Usan la ALU para realizar las operaciones
Reg. de 3 Operación de la ALU

Instrucción lectura 1
REGISTROS
Dato
Reg. de leído 1 ALU
lectura 2 Cero
Reg. de Resultado
escritura Dato de la ALU
Dato a leído 2
escribir
EscribirReg
Acceso a memoria:
Instrucciones lw y sw
La dirección se indica con un registro más un
desplazamiento de 16 bits con signo
El desplazamiento se extiende a 32 bits
lw $t0, 8($s0) 100011 10000 01000 0000000000001000
sw $t0, 32($s0) 101011 10000 01000 0000000000100000
3 Operación de la ALU
Reg. de
Instrucción lectura 1 EscribirMem
REGISTROS
Dato ALU
Reg. de leído 1
lectura 2 Cero
Reg. de Resultado Dato

de la ALU Dirección
escritura Dato leído
Dato a leído 2 Memoria
escribir de Datos
EscribirReg Dato a
escribir
16 32
Extensión
de signo
LeerMem
Saltos condicionales:
Evalúan si dos registros contienen ó no el mismo
valor
Si la condición se cumple aplican el salto
El salto es relativo con signo
Los 16 bits se extienden a 32 y se desplazan 2
posiciones a la izquierda para direccionar sólo
palabras completas
El PC ya se ha actualizado a PC + 4

PC +4 del camino de datos de instrucciones
Resultado Destino salto

Desp. Sumador
2 bits a
la izq.
3 Operación de la ALU
Reg. de
REGISTROS
Dato
Reg. de leído 1
lectura 2 Decidir si se
Cero hace el salto
Reg. de
escritura Dato ALU
Dato a leído 2
escribir
EscribirReg
16 32
Extensión
de signo
Todo junto:
Para construir el camino de datos hemos de
combinar los elementos explicados anteriormente
Intentaremos reutilizar parte del hardware
El hardware compartido selecciona los datos
mediante multiplexores
Parte del hardware no se podrá reutilizar y habrá que
replicarlo

Aritmética + Acceso a Memoria
Reg. de 3 Operación de la ALU

EscribirMem
REGISTROS
Dato
Reg. de leído 1 ALU
Mem2reg
lectura 2 Fuente Cero
Reg. de ALU Resultado Dato
escritura Dato de la ALU Dirección M
M leído u
leído 2
Dato a u Memoria x
escribir de Datos
x
EscribirReg Dato a
escribir
16 32
Extensión
de signo
LeerMem
Incorporamos gestión de PC
Sumador
4
Dirección Reg. de 3 Operación de la ALU
de lectura lectura 1
P EscribirMem
REGISTROS
Dato
C Instrucción Reg. de ALU
leído 1 Mem2reg
Memoria de Reg. de ALU Resultado
instrucciones Dirección Dato M
escritura Dato de la ALU leído
leído 2 M u
Dato a u Memoria x
escribir de Datos
x
EscribirReg Dato a
escribir
16 32
Extensión
de signo
LeerMem

Añadimos saltos condicionales
Origen del PC
M
u
Sumador x
4 Resultado
Desp.
2 bits a Sumador
la izq.
Dirección Reg. de 3 Operación de la ALU

de lectura lectura 1
P EscribirMem
REGISTROS
Dato
C Instrucción Reg. de ALU
leído 1 Mem2reg
Memoria de Reg. de ALU Resultado
escritura Dato de la ALU leído
leído 2 M u
Dato a u Memoria x
escribir de Datos
x
EscribirReg Dato a
escribir
16 32
Extensión
de signo
LeerMem
Diseño de la unidad de control
Realización monociclo: señales de control

Activación de las líneas determinada por el código de operación:
Pasos en la realización de una instrucción tipo R (I):

Pasos en la realización de una instrucción tipo R (II):
Pasos en la realización de una instrucción tipo R (III):

Pasos en la realización de una instrucción tipo R (IV):
Pasos en la realización de una instrucción lw (I):

Pasos en la realización de una instrucción lw (II):
Pasos en la realización de una instrucción lw (III):

Pasos en la realización de una instrucción lw (IV):
Pasos en la realización de una instrucción lw (V):

Pasos en la realización de una instrucción sw (I):
Pasos en la realización de una instrucción sw (II):

Pasos en la realización de una instrucción sw (III):
Pasos en la realización de una instrucción sw (IV):

Pasos en la realización de una instrucción beq (I):
Pasos en la realización de una instrucción beq (II):

Pasos en la realización de una instrucción beq (III):
Pasos en la realización de una instrucción beq (IV):

La función de control para una realización monociclo
está especificada por la siguiente tabla de verdad:
señal Formato R Lw Sw beq
Op5 0 1 1 0
entradas
Op4 0 0 0 0
Op3 0 0 1 0
Op2 0 0 0 1
Op1 0 1 1 0
Ejercicio:
Op0 0 1 1 0
RegDest 1 0 X X
Mapas de Karnaugh
ALUSrc 0 1 1 0
MemtoReg 0 1 X X
Implementación
RegWrite 1 1 0 0
combinacional
salidas
MemRead 0 1 0 0
MemWrite 0 0 1 0
Branch 0 0 0 1
ALUOp1 1 0 0 0
ALUOp0 0 0 0 1
Inconvenientes de la implementación
monociclo
El ciclo de reloj está definido por la instrucción
más lenta
No es posible reutilizar ninguna unidad funcional
Estos inconvenientes se verían agravados en

una arquitectura más compleja que la
arquitectura MIPS
Evaluación del rendimiento

Supóngase los tiempos de ejecución de las unidades
funcionales siguientes:
Acceso a memoria: 2ns
ALU y sumadores: 2ns
Acceso a registros: 1ns
¿Cúal de las siguientes realizaciones será más rápida?

Una realización en la que cada instrucción se ejecuta en un ciclo
de tamaño fijo (cada instrucción tarda lo que tardaría la más
lenta).
Una realización donde cada instrucción se ejecuta en un ciclo de
longitud variable (cada instrucción tarda únicamente lo
necesario)
Cálculo del ciclo de reloj
Inst. [25-0] Desp.
2 bits a Dirección de jump. [31-0]
26 la izq. 28
M
u
2 ns PC + 4 [31-28] M x
u
2 ns
Sumador RegDest x
4 SaltoIncond Resultado
Salt Cond Desp.
2 bits a Sumador
LeerMem
Inst. [31-26] la izq.
Control Mem2reg
EscribirMem
Fuente ALU
Dirección ALUop
de lectura EscribirReg
Inst. [25-21] Reg. de
2 ns
P lectura 1
REGISTROS
Dato
1 ns
C Instrucción Inst. [20-16] Reg. de ALU
leído 1
2 ns
lectura 2 Cero
Memoria de M Reg. de Resultado
u escritura Dato de la ALU
2 ns
Inst. [15-11] M leído u
x leído 2
Dato a u Memoria x
escribir de Datos
x
Dato a
escribir
Inst. [15-0] 16 32
Extensión Control
de signo de la
ALU
Inst. [5-0]
Cálculo del ciclo de reloj
Tipo de
Unidades funcionales utilizadas por cada tipo de instrucción ns
instrucción
Cargar Lectura de Escritura de
Aritmética ALU 6
instrucción registros registros
Cargar Lectura de Lectura Escritura de
lw ALU 8
instrucción registros memoria registros
Cargar Lectura de Escritura en
sw ALU 7
instrucción registros memoria
Salto Cargar Lectura de
ALU 5
condicional instrucción registros
Cargar
Jump 2
instrucción
Evaluación del rendimiento
Aritméticas: 44% lw: 24% sw: 12%
Saltos condicionales: 18% Jump: 2%
Tiempo medio ejecución para monociclo: 8 ns

Tiempo medio ejecución ideal:
6 x 44% + 8 x 24% + 7 x 12% + 5 x 18% + 2 x 2% = 6.3 ns
Rendimiento relativo: 8 / 6.3 = 1.27
Reducción de costes
Inst. [25-0] Desp.
26 la izq. 28
M
u
PC + 4 [31-28] M x
u
Sumador x
4 Resultado
Desp.
2 bits a Sumador
Control
Dirección
de lectura

P lectura 1
REGISTROS
Dato
leído 1
lectura 2 Cero
Inst. [15-11] u escritura Dato de la ALU leído
leído 2 M u
x Dato a Memoria
u x
escribir de Datos
x
Dato a
escribir
16 32
Inst. [15-0] Extensión Control
de signo de la
ALU
Inst. [5-0]
Reducción de costes
Inst. [25-0] Desp.
26 la izq. 28
M
u
PC + 4 [31-28] M x
u
Sumador x
4 Resultado
Desp.
2 bits a Sumador
Control
Dirección
de lectura

P lectura 1
REGISTROS
Dato
leído 1
lectura 2 Cero
Inst. [15-11] u escritura Dato de la ALU leído
leído 2 M u
x Dato a Memoria
u x
escribir de Datos
x
Dato a
escribir
16 32
Inst. [15-0] Extensión Control
de signo de la
ALU
Inst. [5-0]
Implementación multiciclo
Dedicaremos varios ciclos a cada instrucción

Necesitaremos
Más multiplexores
Más registros
Cada dato y resultado estará en un registro para
que no se destruya al terminar el ciclo
Esquema multiciclo
Registro de Reg. de
instrucciones lectura 1
Memoria A
REGISTROS
P Dato
Dirección Reg. de leído 1
C lectura 2
Instrucciones ALU SalidaALU
o datos Reg. de
escritura Dato
Dato Resgistro de leído 2 B
Dato a
datos de escribir
memoria
Implementación multiciclo
Sin coste adicional 0

1
M
Salto u
Desp. 28 incond. [31-0] x
Instrucción [25-0] 26
2 bits a 2
la izq.
PC [31-28]
Instrucción Reg. de 0
P [25-21] lectura 1 M
0
M
REGISTROS
C Memoria Dato u
Instrucción Reg. de leído 1 A
u Dirección x ALU
[20-16] lectura 2 1
x Instrucciones 0 Cero
1
Instrucción M Reg. de
o datos Instr.
[15-0] u escritura Dato Resultado
Salida
[15-11] B 0 ALU
1x
Datos Registro de leído 2
Dato a M ALU
instrucción escribir 4 1
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
memoria Exten. Desp.
signo 32 2 bits a
16 la izq.
Carga de una instrucción IR=Memoria[PC]
PC=PC+4
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucciones Aritmético-Lógicas: Búsqueda

de registros A=Reg[IR[25-21]]
B=Reg[IR[20-16]]
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucciones Aritmético-Lógicas: Ejecución
ALUOut = A op B
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucciones Aritmético-Lógicas: Guarda

resultados en registro
Reg[IR[15-11]]=ALUOut
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción lw:
Búsqueda de registros A=Reg[IR[25-21]]
B=Reg[IR[20-16]]
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción lw:
Cálculo de la dirección
ALUOut = A + signo extendido (IR[15-0])
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción lw:
Lectura de memoria MDR=Memoria[ALUOut]
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción lw:
Guarda dato en registro
Reg[IR[20-16]] = MDR
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción sw:
B=Reg[IR[20-16]]
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción sw:
Cálculo de la dirección
ALUOut = A + signo extendido (IR[15-0])
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción sw:
Escritura en memoria Memoria[ALUOut] = B
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción beq:
B=Reg[IR[20-16]]
ALUOut = PC + (signo extendido (IR[15-0]) << 2)
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción beq:
Comprobación con éxito If (A==B) PC = ALUOut
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción beq:
Comprobación sin éxito
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
Instrucción Jump:
Ejecución del salto PC = PC[31-28] || (IR[25-0] <<2)
0
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
signo 32 2 bits a
16 la izq.
CPI multiciclo
Hemos repartido las operaciones de forma que

el tiempo máximo de computación es el de una
unidad funcional
La unidades más lentas necesitan 2 ns para
completar su funcionamiento
Por tanto el ciclo de reloj durará 2 ns
Por ejemplo, una operación aritmética necesita
4 ciclos = 8 ns
CPI multiciclo
Tipo de instrucción % Multiciclo
Aritmética 44 4
lw 24 5
sw 12 4
Salto condicional 18 3
Jump 2 3
4,04

Realización multiciclo: señales de control
Escribir LeerMem EscrMem EscrIR RegDest EscrReg SelALUA SelALUB FuentePC
PC
0
IoD Mem2Reg
1
M
Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
Datos Registro de 1
x Dato a leído 2
M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro
1x
de datos de
2 bits a Control
16 signo 32 ALU
la izq.
ALUop
Realización multiciclo: señales de control
EscrPC Cond
EscrPC FuentePC
IoD ALUop
LeerMem SelALUB
EscrMem Control SelALUA
Mem2Reg 0
EscrReg
M
EscrIR OP RegDest 1
[31-26] Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
Instrucción Reg. de A
u leído 1 ALU
1x
Dirección [20-16] lectura 2
1x Instrucciones 0 Cero
o datos Instr.
Salida
[15-11] B 0 ALU
1x
Datos leído 2
Registro de Dato a M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro
1x
de datos de
2 bits a Control
16 signo 32 ALU
la izq.

El control del camino de datos multiciclo debe
especificar:
Las señales que se van a inicializar en cada paso
El paso siguiente de la secuencia
Dos técnicas diferentes:

Control cableado. Se basa en las máquinas de
estados finitos.
Control microprogramado. Se representa en forma
de programa de control
Control cableado
Construiremos una máquina de estados finitos (autómata de
Moore)
El camino de datos multiciclo se controla con las salidas de la
unidad de control (la máquina de estados)
Las entradas de la unidad de control serán
Los bits de la instrucción
Los indicadores internos
Máquina de estados finitos:
Cada estado de la máquina representa una etapa y tarda un ciclo
de reloj
Los dos primeros pasos son idénticos para todas las instrucciones
A partir de la tercera etapa depende del código de operación
Después de la última etapa la máquina debe volver al estado inicial
Control cableado
Realización de máquinas de estados finitos de control:
Estado 0 Estado 1
Decodificar
Inicio Carga instrucciones
de Cargar
instrucción Registros
Acceso a Aritmético- beq jump

memoria lógicas
Estado 0. Cargar Instrucción
EscrPC Cond
EscrPC FuentePC
IoD ALUop
LeerMem SelALUB
Mem2Reg EscrReg 0
M
EscrIR OP RegDest 1
[31-26] Salto u
2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
x Instrucciones Cero
1 Estado 0
Instrucción
0
M Reg. de
o datos LeerMem
Instr.
[15-0] u escritura Dato Salida
[15-11]
SelALUA = 0 B 0 Resultado ALU
Datos Registro de x leído 2 M ALU
Inicio selALUB = 01 Dato aA Estado 1
1
ALUOp = 00 u
Instr. IoD =00M 2
x
[15-0] EscrIRu 3
Registro EscrPCx
de datos de FuentePC1 = 00
2 bits a Control
16 signo 32 ALU
la izq.
Estado 1. Decodificación
EscrPC Cond
EscrPC FuentePC
IoD ALUop
LeerMem SelALUB
0
Mem2Reg EscrReg M
EscrIR OP RegDest 1
[31-26] Salto u
26
Instrucción [25-0] 2 bits a 2
la izq.
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU
Datos Registro de 1
x Dato a leído 2
M ALU
u
Instr. 0 2
M x
Estado 1 [15-0] u 3
Registro x
1
De Estado 0 SelALUA = 0 Estado
de datos?de
selALUB = 11 Control
signo 32 2 bits a
ALUOp = 00 16 ALU
la izq.
Control del acceso a memoria
De Estado 1
(Op = “LW”) o (Op = “ SW”)
Estado 2
SelALUA = 1 Cálculo
selALUB = 10 dirección de
ALUOp = 00 memoria
(Op = “LW”) (Op = “SW”)

Estado 5
Estado 3
Leer Mem EscrMem Acceso a

IoD = 1 I0D = 1 memor ia
Acceso a
memoria
Estado 4
Etapa de escritura
Esc rReg
Mem2R eg = 1 Vuelta al
RegDest = 0 Estado 0
Control de operaciones aritmético-lógicas
De Estado 1
(Op = Aritmético-lógica)
Estado 6
SelALUA = 1 Ejecución de la
selALUB = 00 operación
A LUOp = 10
(Op = “LW”)
Estado 7
RegDest = 1 Finalización de
EscrRe g la operación
M em2R eg
Vuelta al
Estado 0
Control de beq
De Estado 1
(Op = “beq”)
Estado 8
SelALUA = 1 Finalización
selALUB = 00 de salto condicional
ALUOp = 01
EscrPCCond
FuentePC = 01
Vuelta al
Estado 0
Control de jump
De Estado 1
(Op = “j”)
Estado 9
Finalización
EscrPCC ond
FuentePC = 10 de jump
Vuelta al
Estado 0
Máquina de estados completa
Estado 0 Estado 1
LeerMem
SelALUA = 0
Inicio selALUB = 01 SelALUA = 0
ALUOp = 00 selALUB = 11
IoD = 0 ALUOp = 00
EscrIR
EscrPC
a)
FuentePC = 00
gic
-ló
(O
(Op
= “j
co
p=
W”) ”)
éti
p = “S
“be
itm
”) o (O
= “LW
Ar
q”)
Finalización
(Op
p=
Estado 2 Estado 6 Estado 9 de jump
Estado 8
(O
SelALUA = 1 Finalización
SelALUA = 1 Cálculo Ejecución de la SelALUA = 1 selALUB = 00
de salto condicional EscrPCCond
selALUB = 10 dirección de operación selALUB = 00 ALUOp = 01 FuentePC = 10
ALUOp = 00 memoria ALUOp = 10 EscrPCCond
FuentePC = 01
(Op = “LW”) (Op = “SW”) (Op = “LW”)

Estado 5
Estado 3 Estado 7
RegDest = 1 Finalización de
LeerMem EscrMem EscrReg
IoD = 1 I0D = 1 la operación
Mem2Reg
Acceso a Acceso a
memoria memoria
Estado 4
Etapa de escritura
EscrReg
Mem2Reg = 1
RegDest = 0
Implementación física
Señales de control
Salidas para el
camino de datos
Concepto Bits
Lógica de control Señales de

16
control
Código de
6
Entradas
operación
Estado 4
Código de Registro de estado

operación desde
el registro de
instrucción
ROM
64 Veces, una para
cada posible valor de los
6 bits de mayor peso
de la dirección
FuentePC (2)
ALUop (2)
SelALUA Código de
SelALUB (2) operación desde
el registro de
EscrReg instrucción Señales
de control
ROM única
RegDest
Salidas EscrPC cond 10
2 palabras de 20 bits
EscrPC
Lógica de control IoD = 20480 bits
LeerMem Estado Nuevo
estado
PLA y/ó ROM EscrMem

Mem2Reg
EscrIR
ROM 1
Señales
Entradas Estado
24 palabras de 16 bits
de control
= 256 bits
Código de operación Registro de estado Código de

operación desde
Bits [31-26] del el registro de ROM 2
instrucción Nuevo
registro de instrucción 10
2 palabras de 4 bits estado
Estado = 4096 bits
O p5
PLA O p4
O p3
O p2
O p1
FuentePC (2) O p0
ALUop (2)
SelALUA S3
SelALUB (2)
EscrReg
RegDest S2
Salidas EscrPC cond
EscrPC S1
Lógica de control IoD
LeerMem S0
Mem2Reg
EscrIR EscrPC
EscrPC cond
IoD
LeerMem
Entradas
EscrMem
IEscrIR
Mem2Reg
FuentePC1
Código de operación Registro de estado FuentePC2
Bits [31-26] del ALUOp1
registro de instrucción ALUOp2
SelALUB1
SelALUB0
SelALUA
EscrReg
RegDest
NS3
NS2
NS1
NS0
Control microprogramado
Cada grupo de señales causa la ejecución de una operación básica
específica: microoperación.
La interpretación y ejecución de una instrucción da lugar a una
secuencia de operaciones máquina básicas (microoperaciones),
cada una controlada por un grupo de señales de control,
microinstrucción.
Una secuencia de microinstrucciones constituye un microprograma.
El código de operación de una instrucción máquina, cuando es
decodificado, señala la microrrutina apropiada incluida en la
memoria microprogramada.
Las microinstrucciones suelen estar ubicadas en una ROM o en una
PLA, por lo que pueden asignarse direcciones a las
microinstrucciones.
Control microprogramado
FuentePC (2)
ALUop (2)
SelALUA
SelALUB (2)
EscrReg
RegDest
Salidas EscrPC cond
EscrPC
Lógica de control IoD
LeerMem
Mem2Reg
EscrIR
Entradas
CtrlDir
• El sumador avanza
secuencialmente por los
1
4 estados
Registro de estado
Sumador
• No en todos los casos se
6
Selección pasa al estado siguiente:
• CtrlDir
Código de operación
Bits [31-26] del • Selección
registro de instrucción
Secuencia de estados
Tras terminar una instrucción se ha de retornar al estado 0
Las instrucciones sólo tienen algunos estados en común, después divergen
Esta divergencia puede ocurrir en varios lugares en el diagrama de estados
Necesitamos contemplar estos casos
PLA y/ó ROM

CtrlDir • CtrlDir = 0
Entradas
• Nueva instrucción
1
4
• CtrlDir = 1
Sumador Registro de estado
6
• Tipo de instrucción
MUX
3 2 1 0
• CtrlDir = 2
0
• Leer/escribir memoria
Tabla de envío 2 Tabla de envío 1
Selección
• CtrlDir = 3
Código de operación
Bits [31-26] del
registro de instrucción
• Secuencia normal
Secuencia de estados
Cada tabla de envío está asociada a un estado del que no

tiene un único estado destino
En el caso general crearemos una tabla (ROM/PLA) para

cada estado con múltiples estados-destino
En general, en un procesador complejo, los estados se

seleccionarán de forma secuencial con pocas excepciones
Formato de la microinstrucción
Etiqueta Control Fuente Fuente Control Memoria Control Secuencia
ALU 1 2 Regs EscrPC
Inicio Sumar PC 4 Leer PC ALU Siguiente

Sumar PC ExtShft Leer Tabla 1
Mem1 Sumar A Extend Tabla 2
LW2 Leer ALU Siguiente
Escr Mem Ir a 0
SW2 Escr ALU Ir a 0
Aritmetico1 Función A B Siguiente

Escr ALU Ir a 0
beq1 Restar A B Cond. ALU Ir a 0
jump1 dir. jump Ir a 0
Traducción de un microprograma a circuitos
Cada campo del microcódigo

se traduce en un conjunto
de señales de control que
deben activarse
Traducción de un microprograma a circuitos
Las dos ROMs de envío de microcódigo mostrando el contenido en forma
simbólica y usando las etiquetas del microprograma
Campo del Nombre Campo del Nombre
código de del código Valor código de del código Valor
operación de operación de
operación operación
000000 lw Rformat1 100011 lw LW2
000010 J JUMP1 101011 sw SW2

000100 beq BEQ1
Tabla 2 de envío de microcódigo
100011 lw Mem1
101011 sw Mem1
Tabla 1 de envío de microcódigo
Contenido de la memoria de control

Procesamiento de excepciones
Una excepción es un suceso inesperado que se produce en el
procesador, por ejemplo el desbordamiento aritmético
Una interrupción es un suceso que provoca un cambio inesperado,
pero se produce externamente al procesador
Ejemplos de implementación de excepciones:
Instrucción indefinida
Desbordamiento aritmético
Métodos para comunicar la causa de una excepción
Registro de estado (denominado registro Causa o Cause Register), que
contiene un campo que indica la razón de la excepción. Es el método
utilizado en la arquitectura MIPS. Se utiliza un único punto de entrada al
sistema operativo para toda las excepciones
Interrupciones vectorizadas. La dirección a la que se transfiere el
control viene determinada por la causa de la excepción. Por ejemplo,
Tipo de excepción Dirección del vector de excepciones
Instrucción indefenida 0xC000 0000
Desbordamiento arimético 0xC000 0020
Acciones a realizar:
Guardar la dirección de la instrucción causante en el registro contador

de programa de la excepción (EPC)
Transferir el control al sistema operativo en alguna dirección específica
El sistema operativo ejecuta una rutina específica
Finalizar el programa o continuar con su ejecución, usando EPC para

saber dónde retomar la ejecución
Ejemplo de implementación:
Saltaremos a la dirección 0xC0000000
Necesitamos lo siguientes registros
Un registro de 32 bits para el EPC
Un registro de 1 bit para el Registro de Causa
Y las señales de control
Escribir en EPC
Escribir en Registro de Causa
Tipo de excepción (1 bit, pues solo consideramos dos tipos
de excepciones)
Camino de datos con los elementos necesarios para el
procesamiento de excepciones:
EscrCausa
CausaInt
EscrPC Cond EscrEPC
EscrPC FuentePC
IoD ALUop
LeerMem SelALUB
Mem2Reg 0
EscrReg M
OP Salto 1
EscrIR RegDest Desp. 28 incond. [31-0] u
[31-26] Instrucción [25-0] 26
2 bits a 2
x
la izq. 3
C0000000
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1
o datos Instr.
Salida
[15-11] B 0 ALU EPC
Datos Registro de 1
x Dato a leído 2
M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro
1x
de datos de
2 bits a Control
16
signo 32 ALU
la izq.
EscrCausa
CausaInt
EscrPC Cond EscrEPC
EscrPC FuentePC
IoD ALUop
LeerMem SelALUB
Mem2Reg 0
EscrReg M
OP Salto 1
EscrIR RegDest Desp. 28 incond. [31-0] u
[31-26] Instrucción [25-0] 26
2 bits a 2
x
la izq. 3
C0000000
PC [31-28]
0
M
REGISTROS
C Memoria Dato u
u Dirección x ALU
[20-16] lectura 2 1
1x Instrucciones 0 Cero
o datos Instr.
Salida
[15-11] B 0 ALU EPC
Datos Registro de 1
x Dato a leído 2
M ALU
u
Instr. 0 2
M x
[15-0] u 3
Registro x
1
de datos de
2 bits a Control
16 signo 32 ALU
la izq.
Estado 0 Estado 1
LeerMem
SelALUA = 0
Inicio selALUB = 01 SelALUA = 0
ALUOp = 00 selALUB = 11
IoD = 0 ALUOp = 0 0
EscrIR
EscrPC
)
as
FuentePC = 00
gi c
(Op
(O
-Ló
W ”) = “j”
p=
(O
p = “S )
rit m
p=
”) o (O
“b e
= “LW otr
=A
(Op os Finalización
q”)
) de jump
p
Estado 2 Estado 6 Estado 8 Estado 9

(O
S elALUA = 1 Finalización
SelALUA = 1 Cálculo Ejecución de la SelAL UA = 1
dirección de s elALUB = 0 0 de salto condicional EscrPCCond
selALUB = 1 0 operac ión selALUB = 00 ALUOp = 01 Fuente PC = 10
ALUOp = 00 memoria ALUOp = 10 Es crPCCond
FuentePC = 01
(Op = “LW”) (Op = “SW”) (Op = “LW”)

Finalización de
Estado 5 la operación
Estado 3 Estado 7
RegDest = 1
Estado 10 Estado 11
LeerMem EscrMem CausaInt=0 CausaInt=1
EscrReg EscrCausa EscrCausa
IoD = 1 I0D = 1 Mem2Reg SelALUA = 0 SelALUA = 0
Acceso a Acc eso a selALUB = 01 selALUB = 01
memoria memoria Des bordamiento ALUOp = 01 ALUOp = 01
Es crEPC EscrEPC
EscrPC EscrPC
FuenteP C = 11 FuentePC = 11
Estado 4
Etapa de escritura
EscrReg
Mem2R eg = 1
RegDes t = 0

EC1 Tema4

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

EC1 Tema4

Diunggah oleh

Hak Cipta:

Format Tersedia

Tema 4

La organización de los procesadores ha evolucionado con el paso

En este tema se analizan las ideas básicas comunes a todos los

4. Otros registros internos, algunos

Estructura básica de un procesador

Estado 1 Lógica combinatoria Estado 2

0x40000000 00000001010010110100100000100000 0x40000004 PC

0x40000000 00000001010010110100100000100000 0x40000004 PC

0x40000000 00000001010010110100100000100000 0x40000008 PC

Diseño de un camino de datos sencillo

Comenzaremos por los elementos básicos y sus

Diseño de un camino de datos sencillo

Reg. de 3 Operación de la ALU

lw $t0, 8($s0) 100011 10000 01000 0000000000001000

sw $t0, 32($s0) 101011 10000 01000 0000000000100000

Diseño de un camino de datos sencillo

Reg. de Resultado Dato

Diseño de un camino de datos sencillo

Resultado Destino salto

Diseño de un camino de datos sencillo

Reg. de 3 Operación de la ALU

Diseño de un camino de datos sencillo

Dirección Reg. de 3 Operación de la ALU

Diseño de la unidad de control

Diseño de la unidad de control

Diseño de la unidad de control

Diseño de la unidad de control

Diseño de la unidad de control

Diseño de la unidad de control

Diseño de la unidad de control

Diseño de la unidad de control

Diseño de la unidad de control

Diseño de la unidad de control

Estos inconvenientes se verían agravados en

Evaluación del rendimiento

¿Cúal de las siguientes realizaciones será más rápida?

Cálculo del ciclo de reloj

Aritméticas: 44% lw: 24% sw: 12%

Saltos condicionales: 18% Jump: 2%

Tiempo medio ejecución para monociclo: 8 ns

Rendimiento relativo: 8 / 6.3 = 1.27

Inst. [25-21] Reg. de

Inst. [25-21] Reg. de

Dedicaremos varios ciclos a cada instrucción

Sin coste adicional 0

Instrucciones Aritmético-Lógicas: Búsqueda

Instrucciones Aritmético-Lógicas: Guarda

Hemos repartido las operaciones de forma que

Tipo de instrucción % Multiciclo

Diseño de la unidad de control

Diseño de la unidad de control

Dos técnicas diferentes:

Acceso a Aritmético- beq jump

(Op = “LW”) (Op = “SW”)

Leer Mem EscrMem Acceso a

Control de operaciones aritmético-lógicas

(Op = “LW”) (Op = “SW”) (Op = “LW”)

Lógica de control Señales de

Código de Registro de estado

PLA y/ó ROM EscrMem

Código de operación Registro de estado Código de

Estado = 4096 bits

PLA y/ó ROM