Download Procesadores RISC. Ejemplo de la arquitectura MIPS

Sistemas de Multiprocesamiento
Procesadores RISC
Índice
INTRODUCCIÓN
1.- Objetivos: .................................................................................................................... 4
2. La aparición de los procesadores RISC:....................................................................... 4
2.1. Que significa RISC................................................................................................ 4
2.2. La base de un sistema RISC: Un set de instrucciones simple ............................... 4
2.3. Características RISC.............................................................................................. 5
3. Dentro de una máquina RISC:...................................................................................... 6
3.1. Pipelining............................................................................................................... 6
3.2. A tener en cuenta en sistemas con pipeline implementado ................................... 7
3.2.1. Velocidad de la memoria................................................................................ 7
3.2.2. Latencia de las instrucciones .......................................................................... 7
3.2.3. Dependencias.......................................................................................................... 8
3.3. Mejora de la velocidad en máquinas con pipeline................................................. 9
3.3.1. Procesadores Superpipeline............................................................................ 9
3.3.2. Procesadores Superescalares .......................................................................... 9
SET DE INSTRUCCIONES
1.- Aspectos Que Deben Concretarse En El Set De Instrucciones................................. 10
2.- Formato De Las Instrucciones .................................................................................. 11
2.1- Instrucciones Tipo R ........................................................................................... 11
2.2.- Intrucciones Tipo I ............................................................................................. 12
2.3.- Intrucciones Tipo J ............................................................................................. 13
3.- Tipos De Instrucciones.............................................................................................. 13
3.1 Intrucciones Aritméticas....................................................................................... 13
3.2.- Instrucciones Lógicas......................................................................................... 15
3.3.- Intrucciones De Comparación Y Salto............................................................... 17
3.3.1 Pseudoinstrucciones. ..................................................................................... 17
3.3.2.- Instrucciones De Toma De Decisiones ....................................................... 17
3.3.3.- Instrucciones De Bifurcar Registro. ............................................................ 18
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
1
Sistemas de Multiprocesamiento
Procesadores RISC
Índice
3.3.4.- Instrucción Bifurca Y Enlaza. ..................................................................... 18
3.4.- Instrucciones De Transferencia De Datos.......................................................... 18
3.5.-Instrucción De Manipulación De Constantes...................................................... 19
3.6.- Otras Operaciones. ............................................................................................. 20
4.-Modos De Direccionamiento ..................................................................................... 21
RUTA DE DATOS
1.- Visión General. ......................................................................................................... 22
2.- Operaciones que soporta la Arquitectura. ................................................................. 22
3.- Ruta de datos ............................................................................................................. 23
3.1.- Fases en la ejecución de una instrucción............................................................ 23
3.2.- Elementos de la ruta de datos............................................................................. 24
3.3.- Descomposición de la ejecución de la instrucción en ciclos de reloj................. 24
3.3.1.- Búsqueda de la instrucción.......................................................................... 24
3.3.2.- Decodificación de la instrucción y búsqueda de registros. ......................... 25
3.3.3.- Ejecución, cálculo de la dirección de memoria o terminación del salto ..... 26
3.3.4.- Acceso a memoria o terminación de la instrucción de tipo R..................... 27
3.3.5.- Fase de postescritura ................................................................................... 28
4.- Algunos diagramas explicativos ............................................................................... 29
4.1.- Esquema general ................................................................................................ 29
4.2.- Carga de la instrucción....................................................................................... 30
4.2.1.- Primera parte ............................................................................................... 30
4.2.2.- Segunda parte .............................................................................................. 31
4.3.- Decodificación de instrucción y carga de los registros:..................................... 32
4.3.1 Primera parte.................................................................................................. 32
4.3.2 Segunda parte ................................................................................................ 33
4.4.- Completado del salto.......................................................................................... 34
4.5.- Ejecución de instrucción aritmético-lógica ........................................................ 35
4.5.1.- Primera parte ............................................................................................... 35
4.5.2.- Segunda parte .............................................................................................. 36
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
2
Sistemas de Multiprocesamiento
Procesadores RISC
Índice
UNIDAD DE CONTROL
1.- Introducción .............................................................................................................. 37
2.- Microprogramación: Simplificar El Diseño Del Control.......................................... 37
3.- Definición Del Formato De Microinstrucción .......................................................... 40
4.- Creación Del Microprograma.................................................................................... 42
BIBLIOGRAFÍA
Bibliografía..................................................................................................................... 48
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
3
Sistemas de Multiprocesamiento
Procesadores RISC
Introducción
1.- Objetivos:
En este capítulo se va a proceder a describir las principales características de la
arquitectura de los procesadores RISC, que en algunas aplicaciones vienen a sustituir a
los antiguos procesadores CISC, como por ejemplo en la nueva generación de sistemas
Macintosh que Apple está desarrollando.
Al final de este capítulo deberemos de ser capaces de:
ü Describir las diferencias más significativas entre el set de instrucciones
de un procesador CISC y un procesador RISC
ü Comprender el pipelining y su implementación en un diseño RISC
ü Definir “stalling” y la planificación de instrucciones
ü Comparar las principales ventajas y desventajas de ambas arquitecturas.
2. La aparición de los procesadores RISC:
2.1. Que significa RISC
A mediados de la década de los 70, el avance en el desarrollo de la tecnología de
los semiconductores se tradujo en una disminución de la diferencia en velocidad entre
la memoria principal y los propios procesadores. A medida que la velocidad de la
memoria se incrementa, y los lenguajes de alto nivel toman cada vez un mayor
protagonismo frente a los ensambladores, las razones para utilizar procesadores CISC se
ven claramente disminuidas, por lo que los diseñadores de sistemas computacionales se
orientan hacia la optimización del rendimiento del sistema mediante la construcción de
un hardware más rápido.
2.2. La base de un sistema RISC: Un set de instrucciones simple
Una de las claves básica para la consecución de la arquitectura RISC es que una
secuencia de instrucciones simples producen los mismos resultados que una
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
4
Sistemas de Multiprocesamiento
Procesadores RISC
Introducción
instrucciones de instrucciones complejas, pero esta secuencia puede ser implementada
con un diseño hardware más sencillo y rápido.
2.3. Características RISC
î Set de instrucciones simple
En un procesador RISC, el juego de instrucciones consta de instrucciones
básicas y simples, de las cuales se pueden ejecutar operaciones complejas.
î Igualdad de longitud de instrucciones
Cada instrucción tiene la misma longitud, por lo que su carga se realizará en una
única transferencia.
î Instrucciones de un ciclo máquina
La mayoría de las instrucciones se completan en un ciclo máquina, lo que
permite al procesador manejar varias instrucciones al mismo tiempo. Este
pipelining es una de las claves para obtener una mayor velocidad de ejecución en
estas máquinas.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
5
Sistemas de Multiprocesamiento
Procesadores RISC
Introducción
3. Dentro de una máquina RISC:
3.1. Pipelining
Uno de los principales objetivos de los diseñadores de máquinas RISC es crear
el chip más rápido posible, para lo cual utilizan un conjunto de técnicas entre las que se
encuentra el pipelining
El pipelining es una técnica de diseño, mediante la cual el hardware del
computador procesa más de una instrucción al mismo tiempo, logrando así, que el
computador no tenga que esperar a que finalice la ejecución de una instrucción para
comenzar la ejecución de la siguiente.
En una máquina CISC las etapas básicas en el ciclo de trabajo eran:
-
Carga
-
Decodificación
-
Ejecución
-
Almacenamiento de resultados
Estas mismas etapas se utilizan en una máquina RISC, pero estas son ejecutadas
en paralelo. Tan pronto como se completa una etapa, pasa su resultado a la siguiente
fase, y comienza a trabajar en la siguiente instrucción.
Por lo tanto, el rendimiento de un sistema pipeline depende del tiempo que tarde
la ejecución de cada fase del pipeline, y no del tiempo de todas las fases.
En un pipeline de una máquina RISC, cada instrucción utiliza 1 ciclo de reloj
para cada fase, por lo que el procesador puede cargar una nueva instrucción por cada
ciclo de reloj. El pipeline no mejora la latencia de las instrucciones ( cada instrucción
sigue necesitando el mismo tiempo para completarse), pero si que mejora el tiempo total
de ejecución.
Como ocurre también en las máquinas CISC, la ejecución ideal no siempre se
consigue. Puede ocurrir que las instrucciones dentro del pipeline necesiten más de un
ciclo para completar una fase. Cuando esto sucede, el procesador tiene que realizar una
espera y no aceptar una nueva instrucción hasta que la instrucción que ha provocado
este retraso haya pasado a la fase siguiente.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
6
Sistemas de Multiprocesamiento
Procesadores RISC
Introducción
3.2. A tener en cuenta en sistemas con pipeline implementado
Un procesador que utiliza un pipeline de instrucciones puede verse
obstaculizado por diversos motivos, como puede ser los retrasos en la lectura de datos
desde la memoria, un diseño del set de instrucciones poco eficiente, o dependencias
entre instrucciones. Para solucionar estos y otros obstáculos los diseñadores proponen
las siguientes soluciones:
3.2.1. Velocidad de la memoria
Los problemas que plantean las memorias se solucionan generalmente
con la utilización de memorias caché. La caché es una porción de la memoria de
mayor velocidad, que se sitúa entre el procesador y la memoria, que
generalmente es más lenta. Cuando el procesador quiere operar sobre una
posición de memoria principal, la posición se copia sobre la caché. Por lo tanto,
referencias posteriores a esa posición, se realizarán sobre la posición en la caché,
que devolverá un resultado más rápidamente que la memoria principal.
Las memorias caché presentan un problema a los diseñadores y a los
programadores: la coherencia. Cuando el procesador escribe un valor hacia la
memoria, el valor va hacia la caché y no hacia la memoria principal. Por lo
tanto, se necesita un hardware especial, generalmente implementado como parte
del propio procesador, para escribir esta información desde la caché a la
memoria principal antes de que algún otro proceso intente leer esa posición, o
utilice esa parte de la caché para otra aplicación.
3.2.2. Latencia de las instrucciones
Un set de instrucciones diseñado de manera poco eficiente puede
provocar que el procesador se vea retrasado frecuentemente. La mayoría de estos
retrasos provienen de:
-
instrucciones altamente codificadas: al igual que ocurre en las
máquinas CISC, requiriendo verificaciones y cálculos para realizar la
decodificación de la instrucción.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
7
Sistemas de Multiprocesamiento
Procesadores RISC
Introducción
-
instrucciones de longitud variable: necesitan varias referencias a
memoria para realizar la carga de la instrucción.
-
Instrucciones que acceden a la memoria principal: en lugar de utilizar
registros que son de carácter mucho más rápido.
-
Instrucciones que realizan la lectura y posterior escritura sobre el
mismo registro.
-
Dependencias de recursos de acceso exclusivo: como el registro de
códigos de condición. Si una instrucción modifica el valor de alguno
de los bits de este registro, y la siguiente instrucción utiliza el valor
modificado, esta segunda instrucción se verá retrasada hasta que se
realice la escritura por parte de la primera instrucción.
3.2.3. Dependencias
Uno de los principales problemas que tiene que afrontar un programador
de sistemas RISC es que el procesador puede verse retrasado por una elección
incorrecta de instrucciones. Por el echo de que cada instrucción utiliza un cierto
tiempo en almacenar su resultado, y como se están ejecutando instrucciones al
mismo tiempo, instrucciones posteriores tendrán que esperar por los resultados
de instrucciones precedentes. Para solventar este inconveniente se utiliza la
planificación de instrucciones.
Otra técnica utilizada para minimizar estas dependencias consiste en
evitar los bucles recursivos, en la cual, en vez de ejecutar una secuencia de
instrucciones dentro del bucle, el compilador planifica las instrucciones las veces
necesarias. Esta técnica elimina el cálculo y verificación de la variable de control
del bucle.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
8
Sistemas de Multiprocesamiento
Procesadores RISC
Introducción
3.3. Mejora de la velocidad en máquinas con pipeline
Se han desarrollado dos técnicas para incrementar la velocidad dentro de los
pipelines:
3.3.1. Procesadores Superpipeline
Un sistema superpipeline divide cada fase del pipeline en dos sub-fases,
para posteriormente internamente la velocidad del reloj. Cada fase sigue
ejecutando un instrucción en cada ciclo de reloj, pero al ser el reloj interno dos
veces más rápido, el pipeline carga dos instrucciones por cada pulso del reloj
(externo).
3.3.2. Procesadores Superescalares
Los procesadores superescalares contienen varias unidades de proceso
que son capaces de trabajar en paralelo. Esto permite al procesador trabajar con
varias instrucciones similares de manera concurrente, enviando cada instrucción
a la primera unidad de proceso que se encuentre disponible.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
9
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
1.- Aspectos Que Deben Concretarse En El Set De Instrucciones
Debemos tener presente los siguientes aspectos:
•
•
Formato de las instrucciones y codificación.
Localización de los operandos: memoria, registros, ...
R0
R1
Register file
Memoria
R30
R31
D1
Ld r1, [ D2 ];
Ld r1, [ D1 ];
Add r2, r1, r0;
St [ R ], r2;
D2
El procesador MIPS presenta
una arquitectura de load/store,
en la que es necesario que los
R
operandos estén en los registros
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
10
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
En cuanto a los registros MIPS dispone de 32 registros de 32 bits cada uno, siendo
estos de propósito general.
•
Cuantos operandos explícitos pueden aparecer en una instrucción.
•
Que operandos están en memoria.
Hemos de tener en cuenta el modo de direccionamiento de la memoria. En el caso
del MIPS es extremista superior, es decir, el byte de mayor peso será el correspondiente
con la dirección de memoria más baja.
•
Operaciones disponibles en el set de instrucciones.
•
Conocer cual es la siguiente instrucción a ejecutar.
2.- Formato De Las Instrucciones
En el microprocesador MIPS que estamos analizando los datos deben encontrarse
almacenado en los registros para poder operar con ellos. Esto hace que el MIPS posea
una estructura Load-Store (carga-almacenamiento).
Debemos tener en cuenta en las instrucciones:
1. Todas las instrucciones del microprocesador MIPS vienen representadas por una
cadena de 32 bits.
2. Se establecen distintos campos para cada tipo de instrucción.
2.1- Instrucciones Tipo R
Todas las instrucciones de este tipo leen dos registros, realizan una operación en la
ALU sobre los contenidos de los registros y escriben el resultado. Llamamos a estas
instrucciones o instrucciones tipo R o bien instrucciones aritmético-lógicas (ya que
realizan operaciones aritméticas o lógicas).
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
11
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
El formato para este tipo de instrucciones se corresponde con:
op
rs
rt
rd
shamt
6 bits
5bits
5bits
5bits
5bits
funct
6bits
op: operación de la instrucción. Indica el tipo de operación que se trata..
rs: primer registro del operando fuente.
rt: segundo registro del operando fuente.
rd: registro del operando destino; obtiene el resultado de la operación.
shamt: cantidad de desplazamiento
funct : función; este campo selecciona la variante de la operación del campo op.
Se presenta el problema cuando una instrucción necesita campos mayores que los
mostrados anteriormente (por ejemplo en una instrucción de carga deben especificarse
dos registros y una dirección, por lo que la dirección se vería reducida a 32 posiciones
de memoria). Esto es muy pequeño para que sea una dirección útil para datos.
Por consiguiente, tenemos un conflicto entre el deseo que todas las instrucciones tengan
la misma longitud y el deseo que las instrucciones tengan un formato sencillo.
Será necesario establecer un segundo tipo de formato de instrucciones.
2.2.- Intrucciones Tipo I
Este tipo de instrucciones son fundamentales puesto que se trata de las
instrucciones para la carga-almacenamiento de los datos, y la ALU únicamente puede
operar con los datos una vez que han sido cargados en los registros. Esto nos lleva a
cargar en los registros aquellas posiciones de memoria con las que deseemos operar.
El formato para las instrucciones de transferencia de datos se corresponde con el
mostrado a continuación.
op
rs
rt
dirección
6 bits
5bits
5bits
16bits
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
12
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
op: tipo de operación.
rs: refistro emplearo para formar la dirección de memoria.
rt: registro donde se recibe el resultado de la operación.
2.3.- Intrucciones Tipo J
El direccionamiento más simple se encuentra en la instrucciones de bifurcación de
MIPS. Utilizan el formato final de instrucción MIPS, denominado tipo J, que consta de
6 bits para el campo de operación y los restantes bits son para el campo de dirección.
El formato de las instrucciones tipo J se corresponde con:
op
Dirección de salto
6 bits
26bits
De forma distinta a la instrucción de bifurcación, la instrucción de salto
condicional debe especificar dos operandos, además de la dirección de salto.
El formato para este tipo de instrucción de salto condicional viene dado por la
siguiente estructura:
op
rs
rt
dirección
6 bits
5bits
5bits
16bits
3.- Tipos De Instrucciones
3.1 Intrucciones Aritméticas.
add rd, rs, rt
addu rd, rs, rt
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
0
rs
rt
rd
6
5
5
5
0
rs
rt
rd
6
5
5
5
0
5
0
5
0×20
Suma con desbordamiento
6
0×21
Suma sin desbordamiento
6
13
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
Pone la suma de los registros rs y rt en el registro rd.
addi rt, rs, inm
addu rt, rs, inm
4
rs
rt
inm
6
5
5
16
5
rs
rt
inm
6
5
5
16
Suma inmediata con desbordamiento
Suma inmediata sin desbordamiento
Pone la suma del registro rs y el inmediato de signo extendido en el registro rd.
Encontraríamos los mismos casos para la resta (sub).
div rs, rt
divu rs,rt
0
rs
rt
0
0×1a
6
5
5
10
6
0
rs
rt
0
0×1b
6
5
5
10
6
División con desbordamiento
División sin desbordamiento
Divide el registro rs por el registro rt. Deja el cociente en el registro lo y el resto
en el registro hi.
mult rs, rt
multu rs, rt
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
0
rs
rt
0
0×18
6
5
5
10
6
0
rs
rt
0
0×19
6
5
5
10
Multiplicación
Multiplicación sin signo
6
14
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
multiplica los registros rs y rt. Deja la palabra de orden inferior del producto en el
registro lo y la de orden superior en el registro hi.
3.2.- Instrucciones Lógicas.
and rd, rs, rt
0
rs
rt
rd
0
0×24
6
5
5
5
5
6
Pone la AND lógica de los registros rs y rt en el registro rd.
0×c
rs
rt
inm
6
5
5
16
andi rt, rs, inm
Pone la AND lógica del registro rs y del cero-extendido inmediato en el registro rd.
Podríamos realizar de igual forma el OR lógico o la operación XOR lógica de dos
registros o bien entre un registro y un inmediato.
neg rdest, rsrc
Valor negado (con desbordamiento)
negu rdest, rsrc
Valor negado (sin desbordamiento)
Pone el negativo del registro rsrc en el registro rdest.
nor rd, rs, rt
0
rs
rt
rd
0
0×24
6
5
5
5
5
6
Pone la NOR lógica de los registros rs y rt en el registro rd.
not rdest, rsrc
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
15
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
Pone la negación lógica bit a bit del registro rsrc en el registro rdest.
rol rdest, rsrc1, rscr2
Desplazamiento cíclico a la izquierda.
ror rdest, rsrc1, rscr2
Desplazamiento cíclico a la derecha.
Desplaza circularmente el registro rsrc1 a la izquierda (derecha) la cantidad indicada por
el rsrc2 y pone el resultado en el registro rdest.
sll rd, rt, sa
sra rd, rt, sa
0
rs
rt
rd
sa
0
6
5
5
5
5
6
0
rs
rt
rd
sa
3
6
5
5
5
5
6
0
rs
rt
rd
sa
2
6
5
5
5
5
6
srl rd, rt, sa
Desplazamiento lógico a la
izquierda
Desplazamiento aritmético
a la derecha
Desplazamiento lógico a la
derecha
Desplaza a la izquierda el registro rt (derecha) la cantidad indicada por el inmediato sa y
pone el resultado en el registro rd.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
16
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
3.3.- Intrucciones De Comparación Y Salto.
3.3.1 Pseudoinstrucciones.
Son instrucciones que como tales no existen, pero el ensamblador se encarga de
traducirlas a instrucciones capaces de ser entendidas por el microprocesador.
Ejemplo: move $2, $1
Transfiere el contenido del registro $1 al $2.
3.3.2.- Instrucciones De Toma De Decisiones
Sirven para romper el flujo secuencial de las instrucciones. La toma de
decisiones se representa normalmente en los lenguajes de programación utilizando la
instrucción if, a veces combinada con instrucciones goto y rótulos. MIPS incluye dos
instrucciones de toma de decisiones análogas a una instrucción if con goto:
beq rs, rt, rótulo
4
rs
rt
Saltar sobre igual
desplazamiento
6
5
5
16
Esta instrucción significa ir a la sentencia rotulada si el valor de rs es igual al valor de rt.
bne rs, rt, rótulo
4
rs
rt
Saltar sobre no igual
desplazamiento
6
5
5
16
Significa ir a la sentencia rotulada si el valor de rs no es igual al valor de rt.
El test para la igualdad o desigualdad es probablemente el má popular, pero a
veces es útil ver si una variable es menor que otra. Estas comparaciones se realizan en
MIPS con una instrucción que compara dos registros y pone un tercer registro a 1 si el
primero es menor que el segundo; en otro caso, lo pone a 0. la instrucción se denomina
inicializar sobre menor que:
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
17
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
slt rdest, rsrc1, rsrc2
Pone el registro rdest a 1 si el valor del registro rsrc1 es menor que el valor del registro
rsrc2;en otro caso, el registro rdest se pone a 0.
3.3.3.- Instrucciones De Bifurcar Registro.
Se trata de una bifurcación incondicional a la dirección especificada en el registro.
0
jr rs
rs
0
Bifurca registro
8
6
5
16
5
3.3.4.- Instrucción Bifurca Y Enlaza.
jal ProcedureAddress
3
destino
6
26
Bifurca y enlaza
Bifurca incondicionalmente a la instrucción de destino. Guarda la dirección de la
siguiente instrucción en el registro rd.
La parte de enlaza del nombre significa que se forma un enlace al sitio que llama
para permitir que el procedimiento vuelva a la dirección adecuada.
3.4.- Instrucciones De Transferencia De Datos.
La instrucción de transferencia de datos que desplaza un dato desde memoria hasta
un registro se denomina carga. El formato de la instrucción es el nombre de la operación
seguido por el registro que se va a cargar, después la dirección de comienzo del array, y
finalmente un registro que contiene el índice del elemento del array que se va a cargar.
Así la dirección de memoria del elemento del array estará formada por la suma de la
parte constante de la instrucción y un registro.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
18
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
lw rt, dirección
0×23
rs
rt
desplazamiento
6
5
5
16
Cargar plalabra
Carga la cantidad de 32 bits en dirección en el registro rt.
La instrucción complementaria a ala de cargar se denomina almacenar; esta
transfiere datos de un registro a memoria. El formato de una instrucción de
almacenamiento es similar al de una carga: el nombre de la operación, seguido por el
registro que se va a almacenar, después la dirección de comienzo del array, y finalmente
un registro que contiene el índice del elemento del array que se va a almacenar.
sw rt, dirección
0×2b
rs
rt
desplazamiento
6
5
5
16
Almacena palabra
Almacena la palabra del registro rt en dirección.
3.5.-Instrucción De Manipulación De Constantes
lui rt, inm
0×2b
rs
rt
desplazamiento
6
5
5
16
Carga superior inmediata
esta instrucción de cargar inmediato superior está desarrollada específicamente para
poner los 16 bits superiores de una constante en un registro, permitiendo que la
instrucción siguiente especifique los 16 bits inferores de la constante.
lui $16, 61
addi $16,$16,2304
Carga la media palabra inferior del inmediato en la media palabra superior del
registro rt. Los bits inferiores del registro se ponen a cero.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
19
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
3.6.- Otras Operaciones.
rfe
0×10 1
6
1
0
0×20
19
6
Vuelta de excepción.
Restaura el registro de STATUS.
syscall
0
6
0
0×c
20
6
Llamada al sistema
El registro $v0 contiene el número de la llamada al sistema suministrada por SPIM.
Ruptura
0
código
0×d
6
20
6
break
Provoca un código de excepción. La excepción 1 está reservada al depurador.
0
0
1
0
0
0
6
5
5
5
5
6
No operación
nop
No hace nada.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
20
Sistemas de Multiprocesamiento
Procesadores RISC
Set de Instrucciones
4.-Modos De Direccionamiento
Los modos de direccionamiento que podemos encontrar en el microprocesador MIPS
son:
1. Direccionamiento de registros, donde el operando es un registro.
2. Direccionamiento base o desplazamiento, donde el operando está en la posición
de memoria cuya dirección es la suma de un registro y una dirección de la
instrucción.
3. Direccionamiento inmediato, donde el operando es una constante que está en la
misma instrucción.
4. Direccionamiento relativo al PC, donde la dirección es la suma del PC y una
constante de la instrucción.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
21
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
1.- Visión General.
La arquitectura MIPS consta de 32 registros de proposito general, para utilizar
como los operandos de las intrucciones artiméticas, lógicas, etc, cada uno de tamaño de
32 bits. En el microprocesador MIPS los operandos de las instrucciones deben partir
obligatoriamente de los registros, y su resultado debe almacenarse también en un
registro. Hay registros que tienen almacenados valores concretos que no se pueden
modificar, como el caso del registro $0, que siempre almacena el valor 0. Otro registro
especial es el $1, que se reserva para que el ensamblador maneje las
pseudoinstrucciones (instrucciones que aunque no están implementadas en el hardware
de la máquina el compilador las entiende y desglosa en las correspondientes
instrucciones de lenguaje máquina) y grandes constantes.
2.- Operaciones que soporta la Arquitectura.
La unidad de proceso soporta las siguientes operaciones:
-
Aritméticas: tanto en coma fija como en coma flotante.
-
Lógicas: entre las que tenemos AND, OR, desplazamientos lógicos, etc.
-
Transferencias de datos: carga y almacenamiento en memoria
-
Saltos condicionales: saltos sobre igual, menor, etc.
-
Saltos incondicionales: llamadas a subrutinas,etc.
Las
operaciones
tanto
aritméticas
como
lógicas
se
deben
realizar
obligatoriamente en los registros del procesador, por lo que será necesario realizar la
carga de los operandos en los registros mediante instrucciones de carga, y almacenar los
resultados en memoria mediante operaciones de almacenamiento. Por este echo se
denomina a este tipo de arquitecturas como de load-store.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
22
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
3.- Ruta de datos
3.1.- Fases en la ejecución de una instrucción
Generalmente la ejecución de una instrucción en un microprocesador conlleva
las siguientes fases
ü Recogida de la instrucción: El procesador busca en la memoria la instrucción a
ejecutar, en nuestro caso la palabra de 32 bits. Se carga en el registro de
instrucciones.
ü Decodificación de la instrucción: Se interpreta cada uno de los campos que
forman la palabra de la instrucción. El primer campo que se interpreta es el
campo ‘op’ que nos va a insdicar el tipo de instrucción a ejecutar.
ü Obtención de los operandos: Se localizan y obtienen los operandos de la
instrucción correspondiente siendo almacenados en los registros.
ü Realizar la operación indicada por la instrucción.
ü Recoger el resultado obtenido que será almacenado en el caso de una operación
lógica o aritmética en un registro.
ü Ir a la proxima dirección de memoria y ejecutar de nuevo estas fases.
Estas fases vienen secuenciadas mediante ciclos de reloj. En el caso del empleo
de un único ciclo para la ejecución de la instrucción con todas las fases
anteriormente enumeradas, hemos de tener en cuienta que la duración del ciclo
de reloj de ser lo suficientemente elevada para que de tiempo a ejecutar todas las
fases.
Con una ruta de datos de ciclo múltiple, como es el caso que nos ocupa, se
realiza una fase en cada ciclo de reloj, dando la posibilidad de utilizar la técnica
del pipeline, aprovechando así los recursos de la arquitectura.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
23
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
3.2.- Elementos de la ruta de datos
Consta de:
q
Unidad Aritmético-Lógica
Control
3
A
Control
n
Función
Cero
n
Resultado
Overflow
B
000
AND
001
OR
010
ADD
110
SUB
111
SET-ON-LESSTHAN
n
Acarreo
La obtención de la respuesta correcta a la salida de la ALU tendrá un cierto
retaso debido al retraso en la propagación de las señales (acarreos intermedios),
y los retrasos propios de la lógica convencional.
q
Registros.
Son flip-flop´s de tipo D con un reloj común para todos ellos. Son de tamaño 32
bits.
q
Registro Programm Counter (PC)
q
Registro de Instrucciones (IR)
q
Multiplexores de diferente número de canales
3.3.- Descomposición de la ejecución de la instrucción en ciclos de reloj
3.3.1.- Búsqueda de la instrucción
Durante este primer ciclo de reloj se realizan las siguientes instrucciones.
-
Generación de la dirección de memoria
-
Calculo de la siguiente dirección de memoria
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
24
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
Una vez que el sistema a ejecutado su secuencia de reset o inicialización (puesta
en tensión) y ha alcanzado un régimen estable, se lleva a cabo la ejecución de
instrucciones.
Cuando la dirección de memoria está estable en el bús de direcciones,
transcurrido un cierto tiempo, la memoria devolverá una instrucción o un dato en
el bus de datos.
En el caso de que esta sea una instrucción, deberá ser una instrucción, esta pasa
al registro de instrucciones IR, almacenandola en el flanco descendente del reloj.
Al mismo tiempo se genera la dirección de la siguiente instrucción a ejecutar.
Como la instrucción tiene un formato de 32 bits, el cálculo se realiza sumando 4
a la dirección actual del Programm Couter. Esta dirección calculada se almacena
de nuevo en el PC.
Debe respetarse un tiempo de hold, para que las lineas correspondientes estén
estables antes de comenzar una nueva fase:
setup
hold
3.3.2.- Decodificación de la instrucción y búsqueda de registros.
En la fase anterior y todavia en esta, nos sabemos de que instrucción se trata. Se
leen los registros que serán utilizados en la ejecución de la instrucción, y que vienen
indicados en los campos ‘rs’ y ‘rt’ de la instrucción. El contenido de los mismos pueden
ser necesarios en operaciones posteriores, por lo cual se hace uso del fichero de
registros.
Con la ALU también se calcula la dirección del salto, en el caso de que la
instrucción fuese de salto. Si la instrucción no fuera de salto, el resultado se ignoraría.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
25
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
Como no sabemos si la instrucción va a ser o no de salto, y porque necesitamos
la ALU en pasos posteriores, guardamos la dirección de destino del hipotético salto en
el registro ‘Target’.
La realización anticipadamente de estas acciones previsoriamente, produce un
beneficio en la disminución de los ciclos necesarios para ejecutar una instrucción.
Despues de este ciclo de reloj, las acciones a tomar dependerán del contenido de
la palabra de instrucción.
3.3.3.- Ejecución, cálculo de la dirección de memoria o terminación del salto
Este es el primer ciclo durante el cual la operación a realizar en el camino de
datos está determinado por el tipo de instrucción que corresponda (R, J, etc.).
En todos los casos la ALU opera sobre los operandos preparados en la fase
anterior, realizando la función correspondiente indicada por sus lineas de control,
dependiendo del tipo de instrucción a realizar.
Denominamos a la salida de la ALU ALUoutput para utilizarlo en etapas
posteriores. Como las entradas de esta están estables (respetando el tiempo de setup), no
es necesario guardar estas en ningún registro a la entrada de la ALU (como podria
espararse en arquitecturas de bus único o bus doble). Las señales de control que afecten
al resultado de la ALU deben mantenerse estables hasta el final del ciclo, hasta que los
resultados se almacenen en el registro correspondiente o no vuelvan a utilizarse (debido
a los retrasos combinacionales, etc. de la ALU).
Cada uno de los registros fuente vendrá codificado en 5 bits (25=32). Es en esta
fase cuando se extraen los contenidos de los registros.
Según sea la instrucción, se realizarán las siguientes operaciones:
ü Instrucciones de referencia a memoria
La ALU suma los operandos para formar la dirección de memoria. La
primera entrada de la ALU será la primera salida del archivo de registros, por
otro lado la salida de la extensión de signo se utiliza como la segunda entrada de
la ALU (la ALU se fuerza a sumar estos operandos).
ü Instrucciones Arimético-Lógicas
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
26
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
La ALU realiza la operación especificada poe el código de operación con
los dos registros leídos en la fase anterior. Esto se corresponderá con situar las
salidas del archivo de registros a la entrada de la ALU.
ü Instrucciones de salto: ‘Salto condicional’
La ALU se utiliza para realizar la comparación entre los dos registros
leídos en el ciclo anterior. La señal ‘Zero’ de salida de la ALU se
utilizará para determinar si hay o no salto. La ALU realizará el test de
igualdad restando ambos registros. Es necesario disparar una señal de
escritura para actualizar el registro Programm Counter si se activa la
señal de Zero.
3.3.4.- Acceso a memoria o terminación de la instrucción de tipo R.
Durante este paso, los accesos a memoria de las operaciones de carga y
almacenamiento y operaciones de carácter aritmético-lógicas pasan a almacenar el
resultado generado.
A la salida de la memoria la denominaremos ‘Memory-Data’, y debido a que su
salida será estable, durante el siguiente ciclo de reloj será cuando se escriba el resultado
en un registro (Una vez ejecutada la operación salvamos el resultado en el fichero de
registros).
Según la operación:
ü Instrucciones de referencia a memoria
Si la operación es de carga, devuelve el dato de memoria. Si la
instrucción es un almacenamiento, entonces el dato se escribe en memoria. En
cualquier caso la dirección utilizada será la calculada en el ciclo anterior.
ü Instrucciones aritmético-lógicas
Se debe colocar el resultado obtenido en la operación de la ALU en el
registro de resultado ‘Result’.
Como las escrituras se realizan cuando llega el flanco descendente, la
escritura del registro ‘rd’ no debe afectar al dato que actualmente se está
leyendo, aunque el registro de destino sea el registro fuente de la instrucción.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
27
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
3.3.5.- Fase de postescritura
Escribe el dato cargado en memoria en el archivo de registros.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
28
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
4.- Algunos diagramas explicativos
4.1.- Esquema general
PCWrCond
PCWr
Zero
PCSrc
IorD
MemWr
IRWr
RegDst
RegWr
BrWr
ALUselA
Target
1
M
U
X
0
PC
0
32
rs
5
rt
5
Ra
32
0
RAdr
M
U
X
32
32
Zero
32
M
U
X
1
Bus A
Rb
1
MEMORIA
IR
rt
32
32
Din
0
A
L
U
4
0
M
U
X
rd
WrAdr
32
FICHERO DE
REGISTROS
RW
32
32
1
Bus B
1
MUX
Dout
busW
32
2
3
1
MUX
0
ALU control
<<2
Imm
32
16
Extend
ExtOp
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
MemtoReg
ALUSelB
ALUOp
29
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
4.2.- Carga de la instrucción
4.2.1.- Primera parte
PCWrCond
PCWr=?
PCSrc
Zero
IorD
MemWr=?
IRWr=?
RegDst
RegWr
BrWr
ALUselA
Target
1
M
U
X
0
PC
0
32
rs
5
rt
5
Ra
32
0
RAdr
M
U
X
32
32
Zero
32
M
U
X
1
Bus A
Rb
1
MEMORIA
IR
rt
32
32
32
Din
0
A
L
U
4
0
M
U
X
rd
WrAdr
FICHERO DE
REGISTROS
RW
32
32
1
Bus B
1
MUX
Dout
busW
32
2
3
1
MUX
0
ALU control=?
<<2
Imm
32
16
Extend
ExtOp
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
"Se accede a
la dirección de
memoria a la
que apunta el
PC
" Se actualiza
el valor del PC
MemtoReg
ALUSelB
ALUOp
30
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
4.2.2.- Segunda parte
PCWrCond
PCWr=1
Zero
PCSrc
IorD
MemWr=0
IRWr=1
RegDst
RegWr
BrWr
ALUselA
Target
1
M
U
X
0
PC
0
32
rs
5
rt
5
Ra
32
0
RAdr
M
U
X
32
32
Zero
32
M
U
X
1
Bus A
Rb
1
MEMORIA
IR
rt
32
32
32
Din
0
A
L
U
4
0
M
U
X
rd
WrAdr
FICHERO DE
REGISTROS
RW
32
32
1
Bus B
1
MUX
Dout
busW
32
2
3
1
MUX
0
ALU
control=ADD
<<2
Imm
32
16
Extend
ExtOp
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
" Se carga la
instrucción en
el IR
" Se actualiza
el valor del PC
MemtoReg
ALUSelB
ALUOp
31
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
4.3.- Decodificación de instrucción y carga de los registros:
4.3.1 Primera parte
PCWrCond=0
PCWr=0
Zero
PCSrc=x
IorD=x
MemWr=0
IRWr=0
RegDst=x
RegWr=0
BrWr
ALUselA=x
Target
1
M
U
X
0
PC
0
Ra
32
0
RAdr
M
U
X
32
32
1
Bus A
5
rt
Zero
32
M
U
X
5
rs
32
Rb
1
MEMORIA
IR
rt
32
32
32
Din
0
A
L
U
4
0
M
U
X
rd
WrAdr
FICHERO DE
REGISTROS
RW
32
32
1
Bus B
1
MUX
Dout
busW
32
2
3
1
MUX
0
ALU control
<<2
Op
6
Func
6
32
16
Extend
Imm
ExtOp
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
MemtoReg
ALUSelB=xx
En el bus A
se pone el
contenido del
registro rs
En el bus B
se pone el
contenido del
registro rt
ALUOp=xx
32
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
4.3.2 Segunda parte
PCWrCond=0
PCWr=0
Zero
PCSrc=x
IorD=x
MemWr=0
IRWr=0
RegDst=x
RegWr=0
BrWr=1
ALUselA=0
Target
1
M
U
X
0
PC
0
32
rs
5
rt
5
Ra
32
0
RAdr
M
U
X
32
32
Zero
32
M
U
X
1
Bus A
Rb
1
MEMORIA
IR
rt
32
32
32
Din
0
A
L
U
4
0
M
U
X
rd
WrAdr
FICHERO DE
REGISTROS
RW
32
32
1
Bus B
1
MUX
Dout
busW
32
2
3
1
MUX
0
ALU control
<<2
En caso de que
sea un salto se
calcula el
desplazamiento
relativo, se
suma al PC y se
guarda en el
registro Target
Op
Al control para
generar Beq,
Rtype, Ori,
Memory
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
6
Func
6
16
Imm
ExtOp=1
32
Extend
MemtoReg
ALUSelB=10
ALUOp=suma
33
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
4.4.- Completado del salto
PCWrCond=1
PCWr=0
Zero
PCSrc=1
IorD=x
MemWr=0
IRWr=0
RegDst=x
RegWr=0
BrWr=0
ALUselA=1
Target
1
M
U
X
0
PC
0
32
rs
5
rt
5
Ra
32
0
RAdr
M
U
X
32
32
Zero
32
M
U
X
1
Bus A
Rb
1
MEMORIA
IR
32
WrAdr
32
32
Din
rt
FICHERO DE
REGISTROS
0
0
M
U
X
rd
A
L
U
4
RW
32
32
1
Bus B
1
MUX
Dout
busW
32
2
3
1
MUX
0
ALU control
<<2
32
16
Extend
Imm
ExtOp
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
Se carga la
dirección de
salto en el PC
según el
resultado de la
comparación
MemtoReg
ALUSelB=01
ALUOp=Sub
34
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
4.5.- Ejecución de instrucción aritmético-lógica
4.5.1.- Primera parte
PCWrCond=0
PCWr=0
Zero
PCSrc
IorD
MemWr=0
IRWr=0
RegDst=1
RegWr=0
BrWr=0
ALUselA=1
Target
1
M
U
X
0
PC
0
32
rs
5
rt
5
Ra
32
0
RAdr
M
U
X
32
32
Zero
32
M
U
X
1
Bus A
Rb
1
MEMORIA
IR
rt
32
32
Din
0
A
L
U
4
0
M
U
X
rd
WrAdr
32
FICHERO DE
REGISTROS
RW
32
32
1
Bus B
1
MUX
Dout
busW
32
2
3
1
MUX
0
ALU control
<<2
Imm
32
16
Extend
ExtOp
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
MemtoReg
ALUSelB=01
ALUOp=Rtype
35
Sistemas de Multiprocesamiento
Procesadores RISC
Ruta de datos
4.5.2.- Segunda parte
PCWrCond=0
PCWr=0
Zero
PCSrc
IorD
MemWr=0
IRWr=0
RegDst=1
RegWr=0
BrWr=0
ALUselA=1
Target
1
M
U
X
0
PC
0
32
rs
5
rt
5
Ra
32
0
RAdr
M
U
X
32
32
Zero
32
M
U
X
1
Bus A
Rb
1
MEMORIA
IR
rt
32
32
32
Din
0
A
L
U
4
0
M
U
X
rd
WrAdr
FICHERO DE
REGISTROS
RW
32
32
1
Bus B
1
MUX
Dout
busW
32
2
3
1
MUX
0
ALU control
<<2
Imm
32
16
Extend
ExtOp
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
MemtoReg
ALUSelB=01
ALUOp=Rtype
36
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
IMPLEMENTACIÓN DEL CONTROL
1.- Introducción
Hay diversas técnicas para implementar la unidad de control. La utilidad de estas
técnicas depende de la complejidad del control, características tales como número
medio de estados siguientes para un estado dado, y la tecnología de implementación.
La forma más sencilla de implementar la función de control es con un bloque de
lógica que tome como entradas el estado actual y el campo de código de operación del
registro de una instrucción y produzca como salidas las señales de control del camino de
datos y el valor del estado siguiente. La representación inicial puede ser un diagrama de
estados finito o un microprograma. En el último caso, cada microinstrucción representa
un estado. En una implementación que utilice un controlador de estados finitos, la
función del estado siguiente se calculará con lógica.
Un método alternativo de implementación calcula la función del estado siguiente
utilizando un contador que incrementa el estado actual para determinar el estado
siguiente. Cuando el estado siguiente no es el siguiente secuencialmente, se utiliza otra
lógica para determinar el estado
2.- Microprogramación: Simplificar El Diseño Del Control
Para el control de un sencillo subconjunto MIPS, una representación gráfica de la
máquina de estados finitos es adecuada, ya que podemos dibujar el diagrama en una
página y traducirlo a ecuaciones sin generar muchos errores. No así podemos considerar
una implementación del repertorio completo de instrucciones MIPS, que contiene unas
cien instrucciones, evidentemente la función de control será mucho más compleja.
En estos casos, especificar la unidad de control con una representación gráfica será
molesto y determinar las ecuaciones con funciones complejas de control, sin cometer
ningún error, es algo prácticamente imposible.
Podemos utilizar algunas ideas de programación para crear un método de
especificación del control que haga más fácil comprenderlo y diseñarlo. Suponer que
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
37
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
consideramos el conjunto de señales de control que deben ser asertadas en un estado
como una instrucción que va a ser ejecutada por el camino de datos. Para evitar
confundir las instrucciones MIPS con las instrucciones de control de bajo nivel, a estas
últimas las denominamos microinstrucciones. Cada microinstrucción define el conjunto
de señales de control del camino de datos que deben ser asertadas en un estado dado.
Ejecutar una microinstrucción
tiene el efecto de asertar las señales de control
especificadas por la microinstrucción.
Además de definir qué señales de control deben ser asertadas, debemos especificar
también el secuenciamiento, es decir, indicar la microinstrucción que debe ejecutarse a
continuación. En la máquina de estados finitos el estado siguiente se determina de una
de dos formas diferentes. A veces un estado sencillo sigue al estado actual
incondicionalmente, en otros casos, la elección del estado siguiente depende de la
entrada. Cuando escribimos los programas, también tenemos una situación análoga. A
veces, un grupo de instrucciones debe ejecutarse de forma secuencial, y en ocasiones
necesitamos saltar. En programación lo implícito es la ejecución secuencial, mientras
que saltar debe indicarse explícitamente.
Lógica de control
Combinacional
Salidas de
control del
camino de datos
Salidas
Entradas
Estado siguiente
Entradas del campo de
Registro
código de operación del
estado
de
registro de instrucción
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
38
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
Para describir el control como un programa, también asumiremos que las
microinstrucciones escritas secuencialmente se ejecutarán en secuencia, mientras que
saltar debe indicarse explícitamente. El mecanismo de secuenciamiento implícito puede
implementarse utilizando una estructura como la de la figura, sin embargo, con
frecuencia es más eficiente implementar el estado secuencial implícito utilizando un
contador.
Registro de
estado
Sumado
MUX
Dispatch ROM1
OP
Name
000000
Rtype
000010
jmp
000100
beq
001011
ori
100011
lw
101011
sw
State
0110
1001
1000
1010
0010
0010
Dispatch ROM2
OP
Name
100011
lw
101011
sw
State
0011
0101
0
ROM1
ROM2
Código de
Diseñar el control como un programa que implementa las instrucciones máquina
en función de microinstrucciones más sencillas se denomina microprogramación. La
idea clave es representar simbólicamente los valores asertados en las líneas de control,
para que el programa sea un representación de microinstrucciones, de la misma forma
que el lenguaje ensamblador es una representación de las instrucciones máquinas. Al
escoger una sintaxis para un lenguaje ensamblador, habitualmente representamos las
instrucciones máquina como una serie de campos (código de operación, registros y
campo de desplazamiento o inmediato), de igual forma, representamos una
microinstrucción sintácticamente como una secuencia de campos cuyas funciones están
relacionadas.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
39
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
3.- Definición Del Formato De Microinstrucción
El microprograma es una representación simbólica del control que será traducido
por un programa a la lógica de control. De esta forma, podemos escoger el número de
campos que tenga una microinstrucción y las señales de control que afectarán a cada
campo. El formato de la microinstrucción debe escogerse para que simplifique la
representación, haciendo más fácil la redacción y comprensión del microprograma. Por
ejemplo, es útil tener un campo que controle la ALU y un conjunto de tres campos que
determinen las dos fuentes para la operación de la ALU así como el destino del
resultado de la ALU. Además para la legibilidad también nos gustaría que el formato de
microprograma hiciese difícil o imposible escribir microinstrucciones inconsistentes.
Una microinstrucción es inconsistente si requiere que una señal de control dad sea
inicializada por dos valores diferentes.
Para evitar un formato que permita microinstrucciones inconsistentes podemos
hacer que cada campo de la microinstrucción sea responsable de especificar un conjunto
de señales de control sin solapamiento en el tiempo. Las señales que nunca son
asertadas simultáneamente pueden compartir el mismo campo.
A continuación se muestra cómo puede descomponerse una microinstrucción en
ocho campos y define la función general de cada campo. Los siete primeros campos de
la microinstrucción controlan el camino de datos, mientras que el campo de
secuenciamiento especifica cómo seleccionar la siguiente microinstrucción.
Nombre campo
Control ALU
Función de campo
Especifica la operación que va a realizar la ALU durante este reloj
SRC1
Especifica la fuente para el primer operando de la ALU
SRC2
Especifica la fuente para el segundo operando de la ALU
Destino ALU
Especifica un registro para escribir el resultado de la ALU
Memoria
Especifica lectura o escritura y la fuente de la dirección
Registro memoria
Especifica el registro destino (para una lectura en memoria) o la fuente
de los valores (para una escritura en memoria).
Control PCWrite
Especifica la escritura del PC.
Secuenciamiento
Especifica cómo escoger la siguiente instrucción que se va a ejecutar
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
40
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
Las microinstrucciones se colocan habitualmente en una ROM o una PLA, así
podemos asignar direcciones a las microinstrucciones. Las direcciones habitualmente se
dan secuencialmente.
Existen tres métodos diferentes para seleccionar la siguiente microinstrucción que
se va a ejecutar:
1.- Incrementar la dirección de la microinstrucción actual para obtener la dirección
de la microinstrucción siguiente. Esto se indica en el microprograma colocando seq en
el campo secuenciamiento. Como la ejecución secuencial de las instrucciones se
encuentra con frecuencia, muchos sistemas de microprogramación hacen esto
implícitamente y sencillamente dejan en blanco la entrada.
2.- Saltar a la microinstrucción donde comienza la ejecución de la siguiente
instrucción en MIPS. Rotularemos esta microinstrucción inicial (correspondiente al
estado 0) como Fetch (Búsqueda) y colocaremos el indicador Fetch en el campo de
secuenciamiento para indicar esta acción.
3.- Seleccionar la siguiente microinstrucción según la entada de la unidad de
control. Seleccionar la siguiente microinstrucción basándose en alguna entrada se
denomina distribución (dispatch). Las operaciones de distribución habitualmente se
implementan creando una tabla que contiene las direcciones de las microinstrucciones
destino. Esta tabla está indexada por la entrada de la unidad de control y puede ser
implementada en una ROM o en una PLA. Con frecuencia hay múltiples tablas de
distribución; para esta implementación necesitamos dos tablas de distribución, una para
distribuir a partir del estado 1 y otra para distribuir a partir del estado 2. indicamos que
la microinstrucción siguiente debería escogerse por una operación de distribución
colocando dispatch i, donde i es el número de la tabla de distribución en el campo
secuenciamiento.
En la siguiente figura se da una descripción de los valores permitidos para cada
campo de la microinstrucción y el efecto de los valores de los diferentes campos.
Nombre de
campo
Valores de
campo
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
Función del campo con valores específicos
41
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
Control ALU
SCR1
SCR2
Destino ALU
Memoria
Registro
memoria
Control PCWrite
Secuenciamiento
Add
Hace que sume la ALU
Func code
Utiliza el código de función de la instrucción para determinar
el control de la ALU
Subt
Hace que reste la ALU
PC
Utiliza el PC como primera entrada a la ALU
Rs
El registro rs es la primera entrada a la ALU
4
Utiliza 4 para la segunda entada a la ALU
Extend
Utiliza la salida de la unidad de extensión de signo como
segunda entrada a la ALU
Extshft
Utiliza la salida del desplazamiento en 2 unidades como
segunda entrada a la ALU
Rt
El registro rt es la segunda entrada a la ALU
Target
La salida de la ALU se escribe en el registro destino
Rd
La salida de la ALU se escribe en el registro rd
Read PC
Lee en memoria utilizando el PC como dirección
Read ALU
Lee en memoria utilizando la salida de la ALU como dirección
Write ALU
Escribe en memoria utilizando la salida de la ALU como
dirección
IR
El dato leído en memoria se escribe en el registro de
instrucción.
Write rt
El dato leído en memoria se escribe en el registro rc
Read rt
El dato leído en memoria se escribe en el registro rt
ALU
Escribe la salida de la ALU en el PC
Target-cond
Si la salida Zero de la ALU está activa, escribe el PC con el
contenido del registro destino
Jump address
Escribe el PC con la dirección de bifurcación de la instrucción
Seq
Elige secuencialmente la siguiente microinstrucción
Fetch
Va a la primera microinstrucción para comenzar una nueva
instrucción.
Dispatch i
Distribuye utilizando la ROM especificada por i
4.- Creación Del Microprograma
Ahora crearemos es microprograma para la unidad de control. Rotularemos las
instrucciones del microprograma con rótulos simbólicos, que se pueden utilizar para
especificar el contenido de las tablas de distribución. Al escribir el microprograma, hay
dos situaciones en las cuales puede ser deseable dejar en blanco un campo de la
microinstrucción. Cuando un campo que controla una unidad funcional o que hace que
se escriba un estado está en blanco. Ninguna señal de control debe ser asertada. Cuando
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
42
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
un campo solamente especifica el control de un multiplexor que de termina la entrada a
una unidad funcional, dejarlo en blanco significa que no nos importa la entrada de la
unidad funcional (la salida del multiplexor).
La forma más fácil de comprender el microprograma es descomponerlo en partes
que traten cada componente de la ejecución de la instrucción. El primer componente de
cada ejecución de instrucción es buscar las instrucciones, a continuación decodificarlas
y calcular por lo tanto el PC secuencial como el PC de destino de salto. Estas dos
acciones corresponden directamente a los dos primeros pasos de ejecución de cualquier
instrucción. Las dos microinstrucciones necesarias para estos dos primeros pasos se
muestran a continuación:
Rótulo
Fetch
Control
ALU
Add
PC
4
Add
PC
Extshft
SRC1
SRC2
Destino
ALU
memoria
Read PC
Registro
memoria
IR
Control
PCWrite
ALU
Target
Secuencia
Seq
Dispatch1
Para comprender qué hace cada microinstrucción, es más fácil observar el efecto
de un grupo de campos. En la primera microinstrucción, los campos asertados y sus
efectos son:
Campos
Control ALU,SCR1,SCR2
Efecto
Calcula PC+4
Memoria y registro memoria
Busca instrucción en IR
Control PCWrite
Hace que la salida de la ALU se escriba en el PC
Secuenciamiento
Va a la siguiente microinstrucción
Para la segunda microinstrucción, los registros se leerán utilizando los campos del
Registro de instrucción. Las demás operaciones controladas por la microinstrucción son:
Campos
Control ALU,SCR1,SCR2
Efecto
Almacena PC+extensión de signo en Destino
Secuenciamiento
Utiliza la tabla de distribución 1 para escoger la dirección de la siguiente
microinstrucción.
Podemos considerar la operación de distribución como una sentencia case que
utiliza el código de operación y la tabla de distribución 1 para seleccionar una de cuatro
secuencias de microinstrucciones (referencia a memoria, instrucciones tipo R, saltos y
bifurcaciones). El microprograma para las instrucciones de referencia a memoria tiene
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
43
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
cuatro microinstrucciones, como mostramos más abajo. La primera instrucción hace el
cálculo de la dirección de memoria. Es necesaria una secuencia de dos instrucciones
para completar una carga (lectura de memoria seguida por escritura en registro),
mientras que el almacenamiento requiere solamente una microinstrucción después del
cálculo de la dirección de memoria:
LWSW1
Control
ALU
Add
rs
Extend
LW2
Add
rs
Extend
ReadALU
SW2
Add
Add
rs
rs
Extend
Extend
ReadALU
ReadALU
Rótulo
SRC1
SRC2
Destino
ALU
Memoria
Registro
memoria
Control
PCWrite
Secuencia
Dispatch2
Seq
Write rt
Read rt
Fetch
Fetch
Examinamos los campos de la primera microinstrucción en esta secuencia:
Campos
Control ALU,SCR1,SCR2
Efecto
Calcula la dirección de memoria: registro(rs)+Signo extendido
Secuenciamiento
Utiliza la tabla de distribución 2 para bifurcar o a LW2 o a SW2
La primera microinstrucción de la secuencia especifica que lw está rotulada en
LW2. esta microinstrucción tiene el siguiente efecto:
Campos
Control ALU,SCR1,SCR2
Efecto
La salida de la Alu es todavía una dirección de memoria
Memoria
Lee en memoria utilizando la salida de la ALU como dirección
Secuenciamiento
Va a la siguiente microinstrucción
La siguiente microinstrucción completa la ejecución con una microinstrucción que
tiene los efectos siguientes:
Campos
Control ALU,SCR1,SCR2
Efecto
La salida de la Alu es todavía una dirección de memoria
Memoria
memoria
Lee en memoria utilizando la salida de la ALU como dirección y escribe
el resultado en el registro designado por rt
y
registro
Secuenciamiento
Va a la microinstrucción rotulada por Fetch
Observar que como los campos de las dos microinstrucciones que completan una
instrucción de cargar una palabra no son contradictorios, podemos combinar estas dos
microinstrucciones en una sola microinstrucción de la forma
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
44
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
Rótulo
LW2
Control
ALU
Add
SRC1
rs
SRC2
Destino
ALU
Extend
Memoria
ReadALU
Registro
memoria
Write rt
Control
PCWrite
Secuencia
Fetch
Este proceso es realizado con frecuencia por un optimizador de microcódigo para
reducir el número de microinstrucciones. Sin embargo, si realizamos este cambio,
probablemente se incrementaría la duración del ciclo de reloj, ya que tanto el acceso a
memoria como la escritura de registros se deberían realizar en una sola
microinstrucción, y cada microinstrucción corresponde a un solo ciclo de reloj. Por
tanto, cuando intentamos optimizar el microcódigo, a mano o con un programa,
debemos saber qué conjuntos de acciones de distribución pueden realizarse en el ciclo
de reloj que estamos diseñando.
La microinstrucción de almacenamiento, rotulada SW2, opera de forma análoga a
la microinstrucción de carga rotulada por LW2:
Campos
Control ALU,SCR1,SCR2
Efecto
La salida de la Alu es todavía una dirección de memoria
Memoria
memoria
Escribe en memoria utilizando la salida de la ALU como dirección y el
registro designado por rt como valor a escribir
y
registro
Secuenciamiento
Va a la microinstrucción rotulada por Fetch
La secuencia del microprograma para las instrucciones tipo R está formadas por
dos microinstrucciones: la primera realiza la operación de la ALU, mientras que la
segunda escribe el resultado en el archivo de registros:
Rótulo
Rformat1
Control
ALU
Funccode
SRC1
SRC2
rs
rt
Funccode
rs
rt
Destino
ALU
Memoria
Registro
memoria
Control
PCWrite
Secuencia
Seq
rd
Fetch
Igual que en el ejemplo de instrucción de carga anterior, podríamos combinar estas
dos microinstrucciones en una sola microinstrucción. Sin embargo, esto significaría que
la ALU y la postescritura en el registro se realizarían en el mismo ciclo de reloj,
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
45
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
desembocando posiblemente en un ciclo de reloj más largo y en una máquina más lenta.
La primera microinstrucción inicia la operación de la ALU:
Campos
Control ALU,SCR1,SCR2
Efecto
La ALU opera sobre el contenido de los registros rs y rt, utilizando el
campo func para especificar la operación de la ALU
Secuenciamiento
Va a la siguiente microinstrucción.
La segunda microinstrucción hace que la salida de la ALU se escriba en el archivo
de registros:
Campos
Control ALU,SCR1,SCR2
Efecto
La ALU continúa la misma operación. El campo destino ALU especifica
que rd se utiliza para escoger el registro destino
Secuenciamiento
Va a la microinstrucción rotulad Fetch
La secuencia de microprograma para saltos requiere una microinstrucción
Rótulo
BEQ1
Control
ALU
Subt
SRC1
SRC2
rs
rt
Destino
ALU
Memoria
Registro
memoria
Control
PCWrite
Targetcond
Secuencia
Fetch
Los campos asertados de esta microinstrucción son:
Campos
Control ALU,SCR1,SCR2
Efecto
La resta los operandos de los registros para generar la salida zero
Control PCWrite
Hace que se escriba en el PC utilizando el valor destino, si la salida zero
de la ALU es verdadera
Secuenciamiento
Va a la microinstrucción rotulad Fetch
La secuencia de microcódigo de bifurcación también está formada por una
microinstrucción:
Rótulo
Control
ALU
SRC1
JUMP1
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
SRC2
Destino
ALU
Memoria
Registro
memoria
Control
PCWrite
Jump
address
Secuencia
Fetch
46
Sistemas de Multiprocesamiento
Procesadores RISC
Unidad de Control
Solamente son asertados dos campos de esta microinstrucción
Campos
Control PCWrite
Efecto
Hace que se escriba en el PC utilizando el campo de bifurcación
Secuenciamiento
Va a la microinstrucción rotulad Fetch
El microprograma completo está formado por las diez microinstrucciones que
aparecían anteriormente. Este microprograma es traducido a microinstrucciones y tablas
de distribución, que después pueden ser implementadas en ROM o PLA. este proceso es
directamente análogo al proceso de traducir un programa del lenguaje ensamblador a
instrucciones máquina.
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
47
Sistemas de Multiprocesamiento
Procesadores RISC
Bibliografia
Bibliografía:
ü “ Organización y diseño de computadores: La interfaz hardware/software”
David A. Patterson—John L. Henessy
McGraw Hill-1995
ü http://www.employees.org/~vivek/html/risc.html
ü http://webopedia.internet.com/TERM/R/RISC.html
ü http://kandor.isi.edu/aliases/PowerPC_Programming_Info/intro_to_risc/irt5_ri
sc2.html
ü http://www.mips.com/
ü http://www.usarc.army.mil/99thrsc/DSCIM/rschtml/hardhtml/risc.htm
ü http://www-flash.stanford.edu/~jlh/
ü http://www.cs.washington.edu/homes/lazowska/cra/risc.html
ü http://www.cs.berkeley.edu/~pattrsn/
ü http://arstechnica.com/cpu/4q99/risc-cisc/rvc-1.html
ü http://www.consulintel.es/Html/Tutoriales/Articulos/risc.html
Vicente Fernández del Rio
Luis Alberto Fernández García
Elena Redondo Andrés
48