Camino de Datos y Unidad de Control del Procesador: Arquitectura MIPS

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:
El contador de programa (PC)
El registro de instrucciones (IR)
1.
2.
Estructura básica de un procesador
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
Instrucción
Memoria de
instrucciones
Registros
nº de registro
nº de registro
nº de registro
ALU
Dirección
Memoria
de Datos
Datos
Estructura básica de un procesador
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
instrucción
Ciclo de captación
Ejecución de
la instrucción
Ciclo de ejecució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
0x40000004
0x40000008
0x4000000C
00000001010010110100100000100000
10010101001010100000000000000000
00010001010010111111111111111011
00000000100001000001000100001010
0x40000004
0x40000000
0x40000004
0x40000008
0x4000000C
00000001010010110100100000100000
10010101001010100000000000000000
00010001010010111111111111111011
00000000100001000001000100001010
0x40000004
0x40000000
0x40000004
0x40000008
0x4000000C
00000001010010110100100000100000
10010101001010100000000000000000
00010001010010111111111111111011
00000000100001000001000100001010
0x40000008
PC
00000001010010110100100000100000
IR
PC
1001010100101010000000000000000
IR
PC
1001010100101010000000000000000
IR
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
Diseño de un camino de datos sencillo
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
4
PC
Sumador
Dirección
Instrucción
Memoria de
instrucciones
Diseño de un camino de datos sencillo
Operaciones tipo R:
Involucran tres registros: dos de lectura y uno de
escritura
Usan la ALU para realizar las operaciones
Reg. de
lectura 2
Reg. de
escritura
Dato a
escribir
EscribirReg
3
REGISTROS
Instrucción
Reg. de
lectura 1
Dato
leído 1
Dato
leído 2
ALU
Operación de la ALU
Cero
Resultado
de la ALU
Diseño de un camino de datos sencillo
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
Diseño de un camino de datos sencillo
Reg. de
lectura 2
Reg. de
escritura
Dato a
escribir
3
REGISTROS
Instrucción
Reg. de
lectura 1
Dato
leído 1
ALU
Dato
leído 2
Extensión
de signo
EscribirMem
Cero
Resultado
de la ALU
Dirección
Memoria
de Datos
EscribirReg
16
Operación de la ALU
32
Dato
leído
Dato a
escribir
LeerMem
Diseño de un camino de datos sencillo
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
Diseño de un camino de datos sencillo
PC +4 del camino de datos de instrucciones
Resultado
Desp.
2 bits a
la izq.
Reg. de
lectura 2
Reg. de
escritura
Dato a
escribir
3
REGISTROS
Instrucción
Reg. de
lectura 1
Cero
ALU
EscribirReg
16
Operación de la ALU
Dato
leído 1
Dato
leído 2
Extensión
de signo
32
Destino salto
Sumador
Decidir si se
hace el salto
Diseño de un camino de datos sencillo
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
Diseño de un camino de datos sencillo
Aritmética + Acceso a Memoria
Reg. de
lectura 1
Reg. de
lectura 2
Reg. de
escritura
Dato a
escribir
3
REGISTROS
Instrucción
Dato
leído 1
Dato
leído 2
ALU
Fuente
ALU
M
u
x
EscribirReg
16
Extensión
de signo
32
Operación de la ALU
EscribirMem
Mem2reg
Cero
Resultado
de la ALU
Dirección
Memoria
de Datos
Dato
leído
Dato a
escribir
LeerMem
M
u
x
Diseño de un camino de datos sencillo
Incorporamos gestión de PC
P
C
Dirección
de lectura
Sumador
Reg. de
lectura 1
Instrucción
Memoria de
instrucciones
Reg. de
lectura 2
Reg. de
escritura
Dato a
escribir
3
REGISTROS
4
Dato
leído 1
Dato
leído 2
ALU
Fuente
ALU
M
u
x
EscribirReg
16
Extensión
de signo
Operación de la ALU
EscribirMem
Mem2reg
Cero
Resultado
de la ALU
Dirección
Memoria
de Datos
Dato
leído
M
u
x
Dato a
escribir
32
LeerMem
Diseño de un camino de datos sencillo
Añadimos saltos condicionales
Origen del PC
4
Sumador
Resultado
Desp.
2 bits a
la izq.
Dirección
de lectura
Instrucción
Memoria de
instrucciones
Reg. de
lectura 1
Reg. de
lectura 2
Reg. de
escritura
Dato a
escribir
3
REGISTROS
P
C
M
u
x
Dato
leído 1
Dato
leído 2
ALU
Fuente
ALU
M
u
x
EscribirReg
16
Extensión
de signo
32
Sumador
Operación de la ALU
EscribirMem
Mem2reg
Cero
Resultado
de la ALU
Dirección
Memoria
de Datos
Dato
leído
Dato a
escribir
LeerMem
M
u
x
Diseño de la unidad de control
Realización monociclo: señales de control
Diseño de la unidad de control
Activación de las líneas determinada por el código de operación:
Diseño de la unidad de control
Pasos en la realización de una instrucción tipo R (I):
Diseño de la unidad de control
Pasos en la realización de una instrucción tipo R (II):
Diseño de la unidad de control
Pasos en la realización de una instrucción tipo R (III):
Diseño de la unidad de control
Pasos en la realización de una instrucción tipo R (IV):
Diseño de la unidad de control
Pasos en la realización de una instrucción lw (I):
Diseño de la unidad de control
Pasos en la realización de una instrucción lw (II):
Diseño de la unidad de control
Pasos en la realización de una instrucción lw (III):
Diseño de la unidad de control
Pasos en la realización de una instrucción lw (IV):
Diseño de la unidad de control
Pasos en la realización de una instrucción lw (V):
Diseño de la unidad de control
Pasos en la realización de una instrucción sw (I):
Diseño de la unidad de control
Pasos en la realización de una instrucción sw (II):
Diseño de la unidad de control
Pasos en la realización de una instrucción sw (III):
Diseño de la unidad de control
Pasos en la realización de una instrucción sw (IV):
Diseño de la unidad de control
Pasos en la realización de una instrucción beq (I):
Diseño de la unidad de control
Pasos en la realización de una instrucción beq (II):
Diseño de la unidad de control
Pasos en la realización de una instrucción beq (III):
Diseño de la unidad de control
Pasos en la realización de una instrucción beq (IV):
Diseño de la unidad de control
salidas
entradas
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
Op4
0
0
0
0
Op3
0
0
1
0
Op2
0
0
0
1
Op1
0
1
1
0
Op0
0
1
1
0
RegDest
1
0
X
X
ALUSrc
0
1
1
0
MemtoReg
0
1
X
X
RegWrite
1
1
0
0
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
Ejercicio:
Mapas de Karnaugh
Implementación
combinacional
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]
26
Sumador
Dirección
de lectura
P
C
2 ns
Instrucción
Memoria de
instrucciones
Dirección de jump. [31-0]
28
PC + 4 [31-28]
RegDest
SaltoIncond
Salt Cond
LeerMem
Inst. [31-26]
Control Mem2reg
EscribirMem
Fuente ALU
ALUop
EscribirReg
Inst. [25-21]
Reg. de
lectura 1
Inst. [20-16]
Inst. [15-11]
Inst. [15-0]
M
u
x
Dato
leído 1
1 ns
Reg. de
lectura 2
Reg. de
escritura
Dato a
escribir
16
ALU
Dato
leído 2
Extensión
de signo
M
u
x
M
u
x
M
u
x
2 ns
Resultado
Desp.
2 bits a
la izq.
REGISTROS
2 ns
4
Desp.
2 bits a
la izq.
Sumador
2 ns
Cero
Resultado
de la ALU
Dirección
Dato
leído
2 ns
Memoria
de Datos
M
u
x
Dato a
escribir
32
Control
de la
ALU
Inst. [5-0]
Cálculo del ciclo de reloj
Tipo de
instrucción
Unidades funcionales utilizadas por cada tipo de instrucción
Aritmética
Cargar
instrucción
Lectura de
registros
ALU
Escritura de
registros
lw
Cargar
instrucción
Lectura de
registros
ALU
Lectura
memoria
sw
Cargar
instrucción
Lectura de
registros
ALU
Escritura en
memoria
Salto
condicional
Cargar
instrucción
Lectura de
registros
ALU
Jump
Cargar
instrucción
ns
6
Escritura de
registros
8
7
5
2
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]
26
Desp.
2 bits a
la izq.
Dirección de jump. [31-0]
28
PC + 4 [31-28]
4
Sumador
Resultado
Inst. [31-26]
Desp.
2 bits a
la izq.
Control
M
u
x
M
u
x
Sumador
P
C
Instrucción
Memoria de
instrucciones
Inst. [25-21]
Reg. de
lectura 1
Inst. [20-16]
Reg. de
lectura 2
Inst. [15-11]
Inst. [15-0]
M
u
x
Reg. de
escritura
Dato a
escribir
16
Inst. [5-0]
REGISTROS
Dirección
de lectura
Dato
leído 1
ALU
Dato
leído 2
Extensión
de signo
M
u
x
32
Cero
Resultado
de la ALU
Dirección
Memoria
de Datos
Dato a
escribir
Control
de la
ALU
Dato
leído
M
u
x
Reducción de costes
Inst. [25-0]
26
Desp.
2 bits a
la izq.
Dirección de jump. [31-0]
28
PC + 4 [31-28]
4
Sumador
Resultado
Inst. [31-26]
Desp.
2 bits a
la izq.
Control
M
u
x
M
u
x
Sumador
P
C
Instrucción
Memoria de
instrucciones
Inst. [25-21]
Reg. de
lectura 1
Inst. [20-16]
Reg. de
lectura 2
Inst. [15-11]
M
u
x
Reg. de
escritura
Dato a
escribir
Inst. [15-0]
16
REGISTROS
Dirección
de lectura
Dato
leído 1
ALU
Dato
leído 2
Extensión
de signo
M
u
x
32
Cero
Resultado
de la ALU
Dirección
Memoria
de Datos
Dato
leído
M
u
x
Dato a
escribir
Control
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
Memoria
P
C
Reg. de
lectura 1
Registro de
instrucciones
Reg. de
lectura 2
Dirección
Instrucciones
o datos
Dato
Reg. de
escritura
Resgistro de
datos de
memoria
Dato a
escribir
REGISTROS
Esquema multiciclo
A
Dato
leído 1
ALU
Dato
leído 2
SalidaALU
B
Implementación multiciclo
Sin coste adicional
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
Reg. de
lectura 1
0
M
Instr.
u
[15-11]
1x
0
1
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
B
M
u
x
16
M
u
x
1
A
0
4
M
u
2
x
1
3
Exten.
signo 32
Desp.
2 bits a
la izq.
ALU
Cero
Resultado
ALU
Salida
ALU
Carga de una instrucción
IR=Memoria[PC]
PC=PC+4
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
1x
0
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
A
1
Dato
leído 2
B
ALU
Cero
Resultado
ALU
0
4
M
u
x
1
16
M
u
x
M
u
2
x
1
Salida
ALU
3
Exten.
signo 32
Desp.
2 bits a
la izq.
Instrucciones Aritmético-Lógicas: Búsqueda
de registros
A=Reg[IR[25-21]]
B=Reg[IR[20-16]]
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
Reg. de
lectura 1
0
M
Instr.
u
[15-11]
1x
0
1
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
B
M
u
x
16
M
u
x
1
A
0
4
M
u
2
x
1
3
Exten.
signo 32
Desp.
2 bits a
la izq.
ALU
Cero
Resultado
ALU
Salida
ALU
Instrucciones Aritmético-Lógicas: Ejecución
ALUOut = A op B
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
1x
0
0
REGISTROS
P
C
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
A
1
Dato
leído 2
B
ALU
Cero
Resultado
ALU
0
4
M
u
x
1
16
M
u
x
M
u
2
x
1
Salida
ALU
3
Exten.
signo 32
Desp.
2 bits a
la izq.
Instrucciones Aritmético-Lógicas: Guarda
resultados en registro
Reg[IR[15-11]]=ALUOut
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
Reg. de
lectura 1
0
M
Instr.
u
[15-11]
1x
0
1
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
B
M
u
x
16
M
u
x
1
A
0
4
M
u
2
x
1
3
Exten.
signo 32
Desp.
2 bits a
la izq.
ALU
Cero
Resultado
ALU
Salida
ALU
Instrucción lw:
Búsqueda de registros
A=Reg[IR[25-21]]
B=Reg[IR[20-16]]
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
1x
0
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
A
1
Dato
leído 2
B
ALU
Cero
Resultado
ALU
0
4
M
u
x
1
16
M
u
x
M
u
2
x
1
Salida
ALU
3
Exten.
signo 32
Desp.
2 bits a
la izq.
Instrucción lw:
Cálculo de la dirección
ALUOut = A + signo extendido (IR[15-0])
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
Reg. de
lectura 1
0
M
Instr.
u
[15-11]
1x
0
1
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
B
M
u
x
16
M
u
x
1
A
0
4
M
u
2
x
1
3
Exten.
signo 32
Desp.
2 bits a
la izq.
ALU
Cero
Resultado
ALU
Salida
ALU
Instrucción lw:
Lectura de memoria
MDR=Memoria[ALUOut]
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
1x
0
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
A
1
Dato
leído 2
B
ALU
Cero
Resultado
ALU
0
4
M
u
x
1
16
M
u
x
M
u
2
x
1
Salida
ALU
3
Exten.
signo 32
Desp.
2 bits a
la izq.
Instrucción lw:
Guarda dato en registro
Reg[IR[20-16]] = MDR
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
Reg. de
lectura 1
0
M
Instr.
u
[15-11]
1x
0
1
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
B
M
u
x
16
M
u
x
1
A
0
4
M
u
2
x
1
3
Exten.
signo 32
Desp.
2 bits a
la izq.
ALU
Cero
Resultado
ALU
Salida
ALU
Instrucción sw:
Búsqueda de registros
A=Reg[IR[25-21]]
B=Reg[IR[20-16]]
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
1x
0
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
A
1
Dato
leído 2
B
ALU
Cero
Resultado
ALU
0
4
M
u
x
1
16
M
u
x
M
u
2
x
1
Salida
ALU
3
Exten.
signo 32
Desp.
2 bits a
la izq.
Instrucción sw:
Cálculo de la dirección
ALUOut = A + signo extendido (IR[15-0])
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
Reg. de
lectura 1
0
M
Instr.
u
[15-11]
1x
0
1
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
B
M
u
x
16
M
u
x
1
A
0
4
M
u
2
x
1
3
Exten.
signo 32
Desp.
2 bits a
la izq.
ALU
Cero
Resultado
ALU
Salida
ALU
Instrucción sw:
Escritura en memoria
Memoria[ALUOut] = B
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
REGISTROS
P
C
0
Instr.
[15-11]
0
Dato
Reg. de leído 1
lectura 2
M
u
1x
Reg. de
escritura
Dato a
escribir
0
A
1
Dato
leído 2
B
0
4
M
u
x
1
16
Instrucción beq:
Búsqueda de registros
M
u
x
M
u
2
x
1
ALU
Cero
Resultado
ALU
Salida
ALU
3
Exten.
signo 32
Desp.
2 bits a
la izq.
A=Reg[IR[25-21]]
B=Reg[IR[20-16]]
ALUOut = PC + (signo extendido (IR[15-0]) << 2)
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
1x
0
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
A
1
B
M
u
x
1
16
0
4
M
u
2
x
1
3
Exten.
signo 32
Desp.
2 bits a
la izq.
M
u
x
ALU
Cero
Resultado
ALU
Salida
ALU
Instrucción beq:
Comprobación con éxito
If (A==B) PC = ALUOut
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
1x
0
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
A
1
Dato
leído 2
B
M
u
x
ALU
0
4
M
u
x
1
Cero
Resultado
ALU
M
u
2
x
1
Salida
ALU
3
Exten.
signo 32
16
Desp.
2 bits a
la izq.
Instrucción beq:
Comprobación sin éxito
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
Reg. de
lectura 1
0
M
Instr.
u
[15-11]
1x
0
1
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
B
M
u
x
16
M
u
x
1
A
0
4
M
u
2
x
1
3
Exten.
signo 32
Desp.
2 bits a
la izq.
ALU
Cero
Resultado
ALU
Salida
ALU
Instrucción Jump:
Ejecución del salto
PC = PC[31-28] || (IR[25-0] <<2)
0
Instrucción [25-0]
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
1x
0
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
A
1
B
M
u
x
1
16
0
4
M
u
x
M
u
2
x
1
ALU
Cero
Resultado
ALU
Salida
ALU
3
Exten.
signo 32
Desp.
2 bits a
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
Diseño de la unidad de control
Realización multiciclo: señales de control
Escribir
PC
LeerMem
EscrMem
IoD
EscrIR
RegDest
EscrReg
SelALUA
SelALUB
FuentePC
0
Mem2Reg
Desp. 28
2 bits a
la izq.
26
Instrucción [25-0]
1
Salto
incond. [31-0]
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
x
1
0
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
M
u
x
1
A
B
M
u
0
4
M
u
2
x
1
ALU
Cero
Salida
ALU
Resultado
ALU
3
1x
16
Exten.
signo 32
Desp.
2 bits a
la izq.
Control
ALU
ALUop
Diseño de la unidad de control
Realización multiciclo: señales de control
EscrPC Cond
EscrPC
FuentePC
ALUop
IoD
LeerMem
SelALUB
EscrMem Control SelALUA
Mem2Reg
EscrReg
OP
EscrIR
RegDest
[31-26]
Instrucción [25-0]
0
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
1x
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Reg. de
lectura 2
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
1x
0
REGISTROS
P
C
Reg. de
escritura
Dato a
escribir
0
Dato
leído 1
A
Dato
leído 2
B
M
u
M
u
1x
0
4
M
u
2
x
1
ALU
Cero
Resultado
ALU
Salida
ALU
3
1x
16
Exten.
signo 32
Desp.
2 bits a
la izq.
Control
ALU
Diseño de la unidad de control
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 1
Estado 0
Inicio
Decodificar
instrucciones
Cargar
Registros
Carga
de
instrucción
Acceso a
memoria
Aritméticológicas
beq
jump
Estado 0. Cargar Instrucción
EscrPC Cond
EscrPC
FuentePC
ALUop
IoD
LeerMem
SelALUB
EscrMem Control SelALUA
Mem2Reg
EscrReg
OP
EscrIR
RegDest
[31-26]
Instrucción [25-0]
0
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Estado 0
Instrucción
[15-0]
0
M
LeerMem
Instr.
u
[15-11]
SelALUA = 0
x
1
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato
leído 2
B
selALUB = 01 Dato aA Estado 1
escribir
ALUOp = 00
IoD =00M
Instr.
[15-0]
EscrIRu
EscrPCx
Registro
FuentePC1 = 00
de datos de
Desp.
memoria
Exten.
2 bits a
signo 32
16
la izq.
Datos
Registro de
Inicio
instrucción
M
u
x
1
A
ALU
Resultado
ALU
0
4
Cero
M
u
2
x
1
Salida
ALU
3
Control
ALU
Estado 1. Decodificación
EscrPC Cond
EscrPC
FuentePC
ALUop
IoD
LeerMem
SelALUB
Control
EscrMem
SelALUA
Mem2Reg
EscrReg
OP
EscrIR
RegDest
[31-26]
Instrucción [25-0]
0
Desp. 28
2 bits a
la izq.
26
Salto
incond. [31-0]
1
2
M
u
x
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Estado 1
De Estado 0
SelALUA = 0
selALUB = 11
ALUOp = 00
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos?de
Estado
memoria
0
Instr.
[15-11]
M
u
x
1
0
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
A
1
B
M
u
x
1
16
0
4
M
u
x
M
u
2
x
1
ALU
Cero
Resultado
ALU
3
Exten.
signo 32
Desp.
2 bits a
la izq.
Control
ALU
Salida
ALU
Control del acceso a memoria
De Estado 1
(Op = “LW”) o (Op = “ SW”)
Estado 2
SelALUA = 1
selALUB = 10
ALUOp = 00
Cálculo
dirección de
memoria
(Op = “SW”)
(Op = “LW”)
Estado 5
Estado 3
Leer Mem
IoD = 1
EscrMem
I0D = 1
Acceso a
memor ia
Acceso a
memoria
Estado 4
Esc rReg
Mem2R eg = 1
RegDest = 0
Etapa de escritura
Vuelta al
Estado 0
Control de operaciones aritmético-lógicas
De Estado 1
(Op = Aritmético-lógica)
Estado 6
SelALUA = 1
selALUB = 00
A LUOp = 10
Ejecución de la
operación
(Op = “LW”)
Estado 7
RegDest = 1
EscrRe g
M em2R eg
Finalización de
la operación
Vuelta al
Estado 0
Control de beq
De Estado 1
(Op = “beq”)
Estado 8
SelALUA = 1
selALUB = 00
ALUOp = 01
EscrPCCond
FuentePC = 01
Finalización
de salto condicional
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
gic
a)
SelALUA = 0
selALUB = 11
ALUOp = 00
itm
éti
Ar
(O
p=
Estado 6
Finalización
de salto condicional
Finalización
de jump
EscrPCCond
FuentePC = 10
Estado 7
RegDest = 1
EscrReg
Mem2Reg
EscrMem
I0D = 1
Acceso a
memoria
Estado 9
(Op = “LW”)
Estado 5
LeerMem
IoD = 1
SelALUA = 1
selALUB = 00
ALUOp = 01
EscrPCCond
FuentePC = 01
ALUOp = 10
(Op = “SW”)
(Op = “LW”)
= “j
”)
Estado 8
Ejecución de la SelALUA = 1
operación selALUB = 00
Estado 3
(Op
q”)
Cálculo
dirección de
memoria
“be
SelALUA = 1
selALUB = 10
ALUOp = 00
p=
W”)
p = “S
”) o (O
= “LW
(Op
(O
Estado 2
Estado 1
LeerMem
SelALUA = 0
selALUB = 01
ALUOp = 00
IoD = 0
EscrIR
EscrPC
FuentePC = 00
co
-ló
Estado 0
Inicio
Finalización de
la operación
Acceso a
memoria
Estado 4
EscrReg
Mem2Reg = 1
RegDest = 0
Etapa de escritura
Implementación física
Salidas
Lógica de control
Entradas
Código de
operación desde
el registro de
instrucción
Registro de estado
Señales de control
para el
camino de datos
Concepto
Bits
Señales de
control
16
Código de
operación
6
Estado
4
ROM
64 Veces, una para
cada posible valor de los
6 bits de mayor peso
de la dirección
Salidas
Lógica de control
PLA y/ó ROM
FuentePC (2)
ALUop (2)
SelALUA
SelALUB (2)
EscrReg
RegDest
EscrPC cond
EscrPC
IoD
LeerMem
EscrMem
Mem2Reg
EscrIR
Código de
operación desde
el registro de
instrucción
ROM única
Señales
de control
10
2 palabras de 20 bits
= 20480 bits
Nuevo
estado
Estado
ROM 1
Entradas
Estado
24 palabras de 16 bits
Señales
de control
= 256 bits
Código de operación
Bits [31-26] del
registro de instrucción
Registro de estado
Código de
operación desde
el registro de
instrucción
ROM 2
10
2 palabras de 4 bits
Estado
Nuevo
estado
= 4096 bits
O p5
PLA
O p4
O p3
O p2
O p1
Salidas
Lógica de control
PLA y/ó ROM
Entradas
Código de operación
Bits [31-26] del
registro de instrucción
Registro de estado
FuentePC (2)
ALUop (2)
SelALUA
SelALUB (2)
EscrReg
RegDest
EscrPC cond
EscrPC
IoD
LeerMem
EscrMem
Mem2Reg
EscrIR
O p0
S3
S2
S1
S0
EscrPC
EscrPC cond
IoD
LeerMem
EscrMem
IEscrIR
Mem2Reg
FuentePC1
FuentePC2
ALUOp1
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
Salidas
Lógica de control
PLA y/ó ROM
CtrlDir
Entradas
1
4
Registro de estado
Sumador
6
FuentePC (2)
ALUop (2)
SelALUA
SelALUB (2)
EscrReg
RegDest
EscrPC cond
EscrPC
IoD
LeerMem
EscrMem
Mem2Reg
EscrIR
Selección
• El sumador avanza
secuencialmente por los
estados
• No en todos los casos se
pasa al estado siguiente:
• CtrlDir
Código de operación
Bits [31-26] del
registro de instrucción
• Selecció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
Entradas
• Nueva instrucción
1
• CtrlDir = 1
4
Registro de estado
Sumador
6
3
2
MUX
1
• Tipo de instrucción
• CtrlDir = 2
0
0
Tabla de envío 2
• CtrlDir = 0
Tabla de envío 1
Selección
Código de operación
Bits [31-26] del
registro de instrucción
• Leer/escribir memoria
• CtrlDir = 3
• 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
ALU
Fuente
1
Fuente
2
4
Inicio
Sumar
PC
Sumar
PC
ExtShft
Mem1
Sumar
A
Extend
Control
Regs
Memoria
Leer PC
Control
EscrPC
ALU
Leer
Tabla 1
Leer ALU
Siguiente
Escr Mem
SW2
Ir a 0
Escr ALU
Función
A
B
beq1
Restar
A
B
Ir a 0
Siguiente
Escr ALU
jump1
Siguiente
Tabla 2
LW2
Aritmetico1
Secuencia
Ir a 0
Cond. ALU
Ir a 0
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
código de
operación
Nombre
del código
de
operación
Valor
Campo del
código de
operación
Nombre
del código
de
operación
Valor
000000
lw
Rformat1
100011
lw
LW2
000010
J
JUMP1
101011
sw
SW2
000100
beq
BEQ1
100011
lw
Mem1
101011
sw
Mem1
Tabla 2 de envío de microcódigo
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
Procesamiento de excepciones
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
Procesamiento de excepciones
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)
Procesamiento de excepciones
Camino de datos con los elementos necesarios para el
procesamiento de excepciones:
EscrCausa
CausaInt
EscrEPC
EscrPC Cond
EscrPC
FuentePC
ALUop
IoD
LeerMem
SelALUB
EscrMem Control SelALUA
Mem2Reg
EscrReg
OP
EscrIR
RegDest
[31-26]
0
Desp. 28
2 bits a
la izq.
26
Instrucción [25-0]
Salto
incond. [31-0]
1
2
3
M
u
x
C0000000
PC [31-28]
0
M
u
x
1
Memoria
Dirección
Instrucciones
o datos
Datos
Instrucción
[25-21]
Reg. de
lectura 1
Instrucción
[20-16]
Instrucción
[15-0]
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
0
Instr.
[15-11]
M
u
x
1
0
REGISTROS
P
C
0
Dato
Reg. de leído 1
lectura 2
Reg. de
escritura
Dato a
escribir
Dato
leído 2
A
1
B
M
u
1x
16
0
4
M
u
x
M
u
2
x
1
ALU
Cero
Resultado
ALU
3
Exten.
signo 32
Desp.
2 bits a
la izq.
Control
ALU
Salida
ALU
EPC
Procesamiento de excepciones
EscrCausa
CausaInt
EscrEPC
EscrPC Cond
EscrPC
FuentePC
ALUop
IoD
LeerMem
SelALUB
EscrMem Control SelALUA
Mem2Reg
EscrReg
OP
EscrIR
RegDest
[31-26]
0
Salto
incond. [31-0]
Desp. 28
2 bits a
la izq.
26
Instrucción [25-0]
1
2
3
M
u
x
C0000000
PC [31-28]
M
u
1x
Memoria
Reg. de
lectura 1
Instrucción
[20-16]
Dirección
Instrucciones
o datos
Registro de
instrucción
Instr.
[15-0]
Registro
de datos de
memoria
Instr.
[15-11]
0
Dato
Reg. de leído 1
lectura 2
0
Instrucción
[15-0]
Datos
REGISTROS
0
Instrucción
[25-21]
M
u
x
1
Reg. de
escritura
Dato a
escribir
0
A
1
Dato
leído 2
B
M
u
x
ALU
M
u
2
x
4
Cero
Salida
ALU
Resultado
ALU
0
1
M
u
x
1
3
Exten.
signo 32
16
Desp.
2 bits a
la izq.
Control
ALU
Procesamiento de excepciones
rit m
-Ló
gi c
as
)
Cálculo
dirección de
memoria
Ejecución de la
operac ión
(Op = “SW”)
(Op = “LW”)
LeerMem
IoD = 1
Estado 4
Etapa de escritura
Estado 7
Acc eso a
memoria
S elALUA = 1
s elALUB = 0 0
ALUOp = 01
Es crPCCond
FuentePC = 01
(Op
otr
os
= “j”
)
)
Estado 9
Finalización
de salto condicional
Finalización
de jump
EscrPCCond
Fuente PC = 10
Finalización de
la operación
RegDest = 1
EscrReg
Mem2Reg
EscrMem
I0D = 1
Acceso a
memoria
Estado 8
SelAL UA = 1
selALUB = 00
ALUOp = 10
(Op = “LW”)
Estado 5
(O
p=
q”)
Estado 6
Estado 3
EscrReg
Mem2R eg = 1
RegDes t = 0
W ”)
“b e
SelALUA = 1
selALUB = 1 0
ALUOp = 00
p = “S
p=
”) o (O
= “LW
(Op
SelALUA = 0
selALUB = 11
ALUOp = 0 0
(O
Estado 2
Estado 1
LeerMem
SelALUA = 0
selALUB = 01
ALUOp = 00
IoD = 0
EscrIR
EscrPC
FuentePC = 00
=A
Estado 0
Inicio
(O
p
P
C
Estado 10
Des bordamiento
CausaInt=0
EscrCausa
SelALUA = 0
selALUB = 01
ALUOp = 01
Es crEPC
EscrPC
FuenteP C = 11
Estado 11
CausaInt=1
EscrCausa
SelALUA = 0
selALUB = 01
ALUOp = 01
EscrEPC
EscrPC
FuentePC = 11
EPC