procesadores risc(mips)

Sistemas de Multiprocesamiento Procesadores RISC

Índice

Vicente Fernández del Rio Luis Alberto Fernández García Elena Redondo Andrés

1

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


Índice


2

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


Índice


3

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


Introducción


4

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


Introducción


5

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.


Introducción


6

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.


Introducción


7

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.


Introducción


8

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


Introducción


9

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.


Set de Instrucciones


10

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

R30 R31

D1

R

D2

Register file

Memoria

Ld r1, [ D2 ]; Ld r1, [ D1 ]; Add r2, r1, r0; St [ R ], r2;

El procesador MIPS presenta

una arquitectura de load/store,

en la que es necesario que los

operandos estén en los registros




11

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




12

El formato para este tipo de instrucciones se corresponde con:

op rs rt rd shamt funct

6 bits 5bits 5bits 5bits 5bits 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




13

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

0 rs rt rd 0 0×20

0 rs rt rd 0 0×21

6 5 5 5 5 6

6 5 5 5 5 6

Suma sin desbordamiento

Suma con desbordamiento




14

Pone la suma de los registros rs y rt en el registro rd. addi rt, rs, inm addu rt, rs, inm

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

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

4 rs rt inm

5 rs rt inm

0 rs rt 0 0×1a

0 rs rt 0 0×1b

0 rs rt 0 0×18

0 rs rt 0 0×19

6 5 5 16

6 5 5 16

Suma inmediata con desbordamiento

Suma inmediata sin desbordamiento

6 5 5 10 6

6 5 5 10 6

División con desbordamiento

División sin desbordamiento

6 5 5 10 6

6 5 5 10 6

Multiplicación

Multiplicación sin signo




15

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 Pone la AND lógica de los registros rs y rt en el registro rd. 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 6 5 5 5 5 6

Pone la NOR lógica de los registros rs y rt en el registro rd. not rdest, rsrc

0 rs rt rd 0 0×24

0×c rs rt inm

0 rs rt rd 0 0×24

6 5 5 5 5 6

6 5 5 1 6




16

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

6 5 5 5 5 6

sra rd, rt, sa

6 5 5 5 5 6 srl rd, rt, sa

6 5 5 5 5 6

Desplaza a la izquierda el registro rt (derecha) la cantidad indicada por el inmediato sa y

pone el resultado en el registro rd.

0 rs rt rd sa 0

0 rs rt rd sa 3

0 rs rt rd sa 2

Desplazamiento lógico a la izquierda

Desplazamiento aritmético a la derecha

Desplazamiento lógico a la derecha




17

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 6 5 5 1 6

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 6 5 5 1 6

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:

4 rs rt desplazamiento

4 rs rt desplazamiento

Saltar sobre igual

Saltar sobre no igual




18

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. jr rs 6 5 1 6 5

3.3.4.- Instrucción Bifurca Y Enlaza.

jal ProcedureAddress

6 2 6

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.

0 rs 0 8

3 destino

Bifurca registro

Bifurca y enlaza




19

lw rt, dirección

6 5 5 1 6

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 6 5 5 1 6

Almacena la palabra del registro rt en dirección.

3.5.-Instrucción De Manipulación De Constantes

lui rt, inm 6 5 5 1 6

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.

0×23 rs rt desplazamiento

0×2b rs rt desplazamiento

0×2b rs rt desplazamiento

Cargar plalabra

Almacena palabra

Carga superior inmediata




20

3.6.- Otras Operaciones.

rfe 6 1 1 9 6

Restaura el registro de STATUS.

syscall

6 20 6

El registro $v0 contiene el número de la llamada al sistema suministrada por SPIM.

break

6 20 6

Provoca un código de excepción. La excepción 1 está reservada al depurador.

nop

6 5 5 5 5 6

No hace nada.

0×10 1 0 0×20

0 0 0×c

0 código 0×d

0 0 1 0 0 0

Vuelta de excepción.

Llamada al sistema

Ruptura

No operación




21

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.


Ruta de datos


22

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.


Ruta de datos


23

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.


Ruta de datos


24

3.2.- Elementos de la ruta de datos

Consta de:

q Unidad Aritmético-Lógica

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

Control

A

B

Acarreo

Overflow

Cero

Resultado

3

n

n

n

Control Función

0 0 0 AND

0 0 1 OR

0 1 0 ADD

1 1 0 SUB

1 1 1 SET-ON-LESS-

THAN


Ruta de datos


25

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.


Ruta de datos


26

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


Ruta de datos


27

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.


Ruta de datos


28

3.3.5.- Fase de postescritura

Escribe el dato cargado en memoria en el archivo de registros.


Ruta de datos


29

4.- Algunos diagramas explicativos

4.1.- Esquema general

PC

MUX

0

1

IorD

MEMORIA

RAdr

Din

WrAdr

MemWr

Dout

IR

IRWr

32

32

32

32

FICHERO DEREGISTROS

Ra

busW

RW

RegWr

Bus B

Rb

Bus A5

5rs

rt

MUX

0

1

RegDst

rt

rd

MUX1 0

32

32

Extend16Imm

ExtOp MemtoReg

ALUselA

32

32MUX

0

1

4

MUX

0

1

32

<<2

3

2

ALUSelB

32

ALU control

32

ALUOp

Zero

Target

BrWr

MUX0

1

PCSrcPCWr

PCWrCond

Zero

ALU

32


Ruta de datos


30

4.2.- Carga de la instrucción

4.2.1.- Primera parte

PC

MUX

0

1

IorD

MEMORIA

RAdr

Din

WrAdr

MemWr=?

Dout

IR

IRWr=?

32

32

32

32

FICHERO DEREGISTROS

Ra

busW

RW

RegWr

Bus B

Rb

Bus A5

5rs

rt

MUX

0

1

RegDst

rt

rd

MUX1 0

32

32

Extend16Imm

ExtOp MemtoReg

ALUselA

32

32MUX

0

1

4

MUX

0

1

32

<<2

3

2

ALUSelB

32

ALU control=?

32

ALUOp

Zero

Target

BrWr

MUX0

1

PCSrcPCWr=?

PCWrCond

Zero

ALU

32

"Se accede a la dirección de memoria a la que apunta el PC " Se actualiza el valor del PC


Ruta de datos


31

4.2.2.- Segunda parte

PC

MUX

0

1

IorD

MEMORIA

RAdr

Din

WrAdr

MemWr=0

Dout

IR

IRWr=1

32

32

32

32

FICHERO DEREGISTROS

Ra

busW

RW

RegWr

Bus B

Rb

Bus A5

5rs

rt

MUX

0

1

RegDst

rt

rd

MUX1 0

32

32

Extend16Imm

ExtOp MemtoReg

ALUselA

32

32MUX

0

1

4

MUX

0

1

32

<<2

3

2

ALUSelB

32

ALUcontrol=ADD

32

ALUOp

Zero

Target

BrWr

MUX0

1

PCSrcPCWr=1

PCWrCond

Zero

ALU

32

" Se carga la instrucción en el IR " Se actualiza el valor del PC


Ruta de datos


32

4.3.- Decodificación de instrucción y carga de los registros:

4.3.1 Primera parte

PC

MUX

0

1

IorD=x

MEMORIA

RAdr

Din

WrAdr

MemWr=0

Dout

IR

IRWr=0

32

32

32

32

FICHERO DEREGISTROS

Ra

busW

RW

RegWr=0

Bus B

Rb

Bus A5

5rs

rt

MUX

0

1

RegDst=x

rt

rd

MUX1 0

32

32

Extend16

Imm

ExtOp MemtoReg

ALUselA=x

32

32MUX

0

1

4

MUX

0

1

32

<<2

3

2

ALUSelB=xx

32

ALU control

32

ALUOp=xx

Zero

Target

BrWr

MUX0

1

PCSrc=xPCWr=0

PCWrCond=0

Zero

ALU

32

Op

Func

6

6

En el bus A se pone el contenido del registro rs En el bus B se pone el contenido del registro rt


Ruta de datos


33

4.3.2 Segunda parte

PC

MUX

0

1

IorD=x

MEMORIA

RAdr

Din

WrAdr

MemWr=0

Dout

IR

IRWr=0

32

32

32

32

FICHERO DEREGISTROS

Ra

busW

RW

RegWr=0

Bus B

Rb

Bus A5

5rs

rt

MUX

0

1

RegDst=x

rt

rd

MUX1 0

32

32

Extend16

Imm

ExtOp=1 MemtoReg

ALUselA=0

32

32MUX

0

1

4

MUX

0

1

32

<<2

3

2

ALUSelB=10

32

ALU control

32

ALUOp=suma

Zero

Target

BrWr=1

MUX0

1

PCSrc=xPCWr=0

PCWrCond=0

Zero

ALU

32

Op

Func

6

6

Al control para generar Beq, Rtype, Ori, Memory

En caso de que sea un salto se calcula el desplazamiento relativo, se suma al PC y se guarda en el registro Target


Ruta de datos


34

4.4.- Completado del salto

PC

MUX

0

1

IorD=x

MEMORIA

RAdr

Din

WrAdr

MemWr=0

Dout

IR

IRWr=0

32

32

32

32

FICHERO DEREGISTROS

Ra

busW

RW

RegWr=0

Bus B

Rb

Bus A5

5rs

rt

MUX

0

1

RegDst=x

rt

rd

MUX1 0

32

32

Extend16

Imm

ExtOp MemtoReg

ALUselA=1

32

32MUX

0

1

4

MUX

0

1

32

<<2

3

2

ALUSelB=01

32

ALU control

32

ALUOp=Sub

Zero

Target

BrWr=0

MUX0

1

PCSrc=1PCWr=0

PCWrCond=1

Zero

ALU

32

Se carga la dirección de salto en el PC según el resultado de la comparación


Ruta de datos


35

4.5.- Ejecución de instrucción aritmético-lógica

4.5.1.- Primera parte

PC

MUX

0

1

IorD

MEMORIA

RAdr

Din

WrAdr

MemWr=0

Dout

IR

IRWr=0

32

32

32

32

FICHERO DEREGISTROS

Ra

busW

RW

RegWr=0

Bus B

Rb

Bus A5

5rs

rt

MUX

0

1

RegDst=1

rt

rd

MUX1 0

32

32

Extend16Imm

ExtOp MemtoReg

ALUselA=1

32

32MUX

0

1

4

MUX

0

1

32

<<2

3

2

ALUSelB=01

32

ALU control

32

ALUOp=Rtype

Zero

Target

BrWr=0

MUX0

1

PCSrcPCWr=0

PCWrCond=0

Zero

ALU

32


Ruta de datos


36

4.5.2.- Segunda parte

PC

MUX

0

1

IorD

MEMORIA

RAdr

Din

WrAdr

MemWr=0

Dout

IR

IRWr=0

32

32

32

32

FICHERO DEREGISTROS

Ra

busW

RW

RegWr=0

Bus B

Rb

Bus A5

5rs

rt

MUX

0

1

RegDst=1

rt

rd

MUX1 0

32

32

Extend16Imm

ExtOp MemtoReg

ALUselA=1

32

32MUX

0

1

4

MUX

0

1

32

<<2

3

2

ALUSelB=01

32

ALU control

32

ALUOp=Rtype

Zero

Target

BrWr=0

MUX0

1

PCSrcPCWr=0

PCWrCond=0

Zero

ALU

32


Unidad de Control


37

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


Unidad de Control


38

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

Entradas

Salidas de control del camino de datos

Entradas del campo de

código de operación del

registro de instrucción

Registro de

estado

Estado siguiente


Unidad de Control


39

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.

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.

SumadoRegistro de

estado

MUX

ROM2ROM1

0

Código de

Dispatch ROM1 OP Name State 000000 Rtype 0110 000010 jmp 1001 000100 beq 1000 001011 ori 1010 100011 lw 0010 101011 sw 0010

Dispatch ROM2 OP Name State 100011 lw 0011 101011 sw 0101


Unidad de Control


40

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 Función de campo

Control ALU 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


Unidad de Control


41

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

Función del campo con valores específicos


Unidad de Control


42

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

Control ALU

Subt Hace que reste la ALU

PC Utiliza el PC como primera entrada a la ALU SCR1

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

SCR2

Rt El registro rt es la segunda entrada a la ALU

Target La salida de la ALU se escribe en el registro destino Destino ALU

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

Memoria

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

Registro memoria

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

Control PCWrite

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.

Secuenciamiento

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


Unidad de Control


43

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 Control ALU

SRC1 SRC2 Destino ALU

memoria Registro memoria

Control PCWrite

Secuencia

Fetch Add PC 4 Read PC IR ALU Seq

Add PC Extshft Target 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 Efecto

Control ALU,SCR1,SCR2 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 Efecto

Control ALU,SCR1,SCR2 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


Unidad de Control


44

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:

Rótulo Control ALU


Memoria Registro memoria

Control PCWrite

Secuencia

LWSW1 Add rs Extend Dispatch2

LW2 Add rs Extend ReadALU Seq

Add rs Extend ReadALU Write rt Fetch

SW2 Add rs Extend ReadALU Read rt Fetch

Examinamos los campos de la primera microinstrucción en esta secuencia:

Campos Efecto

Control ALU,SCR1,SCR2 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 Efecto

Control ALU,SCR1,SCR2 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 Efecto


Memoria y registro memoria

Lee en memoria utilizando la salida de la ALU como dirección y escribe el resultado en el registro designado por rt

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


Unidad de Control


45

Rótulo Control ALU



Control PCWrite

Secuencia

LW2 Add rs Extend ReadALU Write rt 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 Efecto


Memoria y registro memoria

Escribe en memoria utilizando la salida de la ALU como dirección y el registro designado por rt como valor a escribir

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 Control ALU



Control PCWrite

Secuencia

Rformat1 Funccode rs rt Seq

Funccode rs rt 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,


Unidad de Control


46

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 Efecto

Control ALU,SCR1,SCR2 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 Efecto

Control ALU,SCR1,SCR2 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 Control ALU



Control PCWrite

Secuencia

BEQ1 Subt rs rt Target-cond

Fetch

Los campos asertados de esta microinstrucción son:

Campos Efecto

Control ALU,SCR1,SCR2 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


La secuencia de microcódigo de bifurcación también está formada por una

microinstrucción:

Rótulo Control ALU



Control PCWrite

Secuencia

JUMP1 Jump address

Fetch


Unidad de Control


47

Solamente son asertados dos campos de esta microinstrucción

Campos Efecto

Control PCWrite Hace que se escriba en el PC utilizando el campo de bifurcación


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.


Bibliografia


48

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

procesadores risc(mips)

Documents