UNIDAD 4: El procesador: Camino de los datos y Control. 4.1 Introducción El rendimiento de una máquina depende de tres factores clave: Conteo de Instrucciones, tiempo del ciclo de reloj y ciclos de reloj por instrucción. Para un programa dado, el conteo de instrucciones depende del repertorio de instrucciones y del compilador; sin embargo, el tiempo del ciclo de reloj y los ciclos de reloj por instrucción dependen directamente de la implementación del procesador. En este capítulo revisaremos dos implementaciones diferentes para el repertorio MIPS previamente estudiado. Diseñaremos una implementación que incluya un subconjunto con las instrucciones mas importantes: Instrucciones de acceso a memoria: Carga y almacenamiento de palabras (lw y sw). Instrucciones aritmético-lógicas: add, sub, and, or y slt. Brincos sobre igual (beq) y saltos (j).

No se incluye al repertorio completo por que la idea principal consiste en conocer los principios aplicados en la creación de un camino de datos y el diseño del control. La implementación de las demás instrucciones puede hacerse en forma similar. Entonces, el punto importante consiste en mostrar como el repertorio de instrucciones determina muchos de aspectos de la implementación, y como la elección de diferentes estrategias de implementación afecta al ciclo de reloj y al CPI de la máquina. La mayoría de conceptos expuestos durante la implementación de este sub-conjunto MIPS, son ideas básicas para la construcción de una amplia gama de microprocesadores de propósito general utilizados en computadoras de alto rendimiento, así como en el desarrollo de procesadores de propósito específico, los cuales son usados en una amplia gama de productos desde VCRs hasta automóviles. Un vistazo de la implementación El sub-conjunto a implementar contempla instrucciones aritmético lógicas, instrucciones de referencia a memoria (para carga o almacenamiento de datos) e instrucciones condicionales (brinco sobre igual). Independientemente de la instrucción que se ejecute, los primeros dos pasos son idénticos en todos los casos:

1. Enviar el contador del programa (PC) a la memoria que contiene el código y atrapar la instrucción desde esa memoria.

2. Leer uno o dos registros, usando los campos de la instrucción para seleccionar los

registros a leer. Para la instrucción de carga solo se requiere la lectura de un registro, pero para las demás instrucciones es necesaria la lectura de dos de ellos.

Después de estos dos pasos, las acciones requeridas para completar la instrucción dependen de la clase de instrucción. Sin embargo, a pesar de ser instrucciones diferentes, en el paso

siguiente las tres instrucciones utilizan la unidad aritmético lógica (ALU). Las instrucciones de referencia a memoria usan la ALU para el cálculo de una dirección; las instrucciones aritmético lógicas para la ejecución de la operación y los brincos para la comparación. Como se puede ver, la simplicidad y regularidad del repertorio de instrucciones simplifica la implementación haciendo la ejecución similar en diferentes clases de instrucciones. Después de usar la ALU, las acciones requeridas para completar la instrucción son distintas en cada clase. Las instrucciones de referencia a memoria harán el acceso para la escritura de un dato (en el caso de los almacenamientos) o para su lectura (en el caso de las cargas). Las instrucciones aritmético lógicas escribirán el resultado en un registro y las instrucciones de brincos, tal vez requieran cambiar el valor del contador del programa para continuar con la siguiente instrucción, de acuerdo al resultado de la comparación. En la figura 4.1 se muestra un vistazo de la implementación MIPS. Se muestra la conexión de diferentes bloques funcionales cuyos detalles se irán mostrando a lo largo de la unidad. Por supuesto, estos bloques sólo constituyen parte del camino de los datos, también se mostrará mas adelante el diseño y la implementación del control.

Fig. 4.1 Las unidades principales en la implementación del subconjunto MIPS,

un vistazo de la implementación Convenciones acerca de la Lógica y la sincronización En el diseño de circuitos lógicos, frecuentemente el diseñador cambia el mapeo entre una señal lógicamente verdadera o falsa y el nivel de voltaje asociado. En lógica positiva una señal verdadera corresponde a un nivel de voltaje alto (típicamente 5 V, aunque actualmente se utilizan dispositivos de muy bajo voltaje), sin embargo en lógica negada ocurre lo contrario, una señal verdadera corresponderá a un nivel bajo de voltaje (0 V). En ocasiones es necesario combinar las dos ideas, por que algunos dispositivos, como las memorias, se habilitan con un nivel bajo de voltaje, pero su lectura requiere de una habilitación con un nivel alto de voltaje. Para mantener consistencia, y no entrar en detalles de los valores de voltaje, utilizaremos la palabra acertada para indicar que una señal es lógicamente verdadera.

Las unidades funcionales utilizadas en la implementación, son elementos lógicos de dos tipos diferentes: Los elementos que operan sobre los valores de los datos y los elementos que contienen estado. Los elementos que operan sobre los valores de los datos son combinacionales, lo cual significa que sus salidas dependen únicamente del valor actual de sus entradas. En la figura 4.1, la ALU es un elemento combinacional. Los elementos que no son combinacionales son elementos que contienen estado, es decir, tienen alguna forma de almacenamiento interno. Se les conoce como elementos de estado por que por medio de estos elementos se caracteriza completamente el comportamiento de la máquina. Por ejemplo, si salvamos los elementos de estado, justo antes de retirar la alimentación de la máquina y les restauramos su valor al reactivar la alimentación, podría parecer que la potencia nunca se perdió; por que el estado de la máquina se ha conservado. En la figura 4.1, las memorias de datos e instrucciones, así como los registros son elementos de estado. Un elemento de estado tiene al menos dos entradas y una salida. Las entradas requeridas son: el valor del dato a ser escrito en el elemento y una entrada de reloj, la cual determina cuando el valor del dato va a ser escrito. La salida del elemento de estado proporciona el valor que fue escrito en el ciclo de reloj mas cercano. Un ejemplo simple de un elemento de estado es un flip-flop tipo D; su salida puede leerse en cualquier momento, sin embargo, la señal de reloj determina cuando se hará la escritura. A los elementos lógicos que contienen estado también se les denomina secuenciales por que sus salidas dependen de sus entradas así como también de su estado contenido internamente. Por ejemplo, en la figura 4.1, la salida de la unidad funcional de los registros depende del número de registro suministrado, así como del dato que fue escrito previamente en cada registro. Metodología de Reloj Una metodología de reloj define cuando las señales pueden ser leídas y cuando pueden ser escritas. Es importante especificar los tiempos de lectura y escritura por que, si una señal es leída al mismo tiempo en que se va a escribir, el valor de la lectura podría corresponder al viejo valor, al nuevo valor que será escrito o a alguna mezcla de los dos. Una metodología de reloj debe plantearse para prevenir esas circunstancias; definitivamente no se pueden tener situaciones impredecibles. Los dispositivos actuales utilizan una metodología disparada por flancos, lo que significa que cualquier valor que se almacenará en la máquina se actualizará solamente durante el flanco de reloj. Entonces, los elementos de estado actualizarán sus almacenamientos internos solamente sobre el flanco de reloj. Debido a que los elementos de estado determinan el comportamiento del sistema, cualquier circuito combinacional toma sus entradas como las salidas de alguno de los elementos de estado, y sus salidas las dirige a otro elemento de estado, para que se escriban en el siguiente ciclo de reloj. En la figura 4.2 se muestra a dos elementos de estado conectados por un bloque de lógica combinacional. Todas las señales deben propagarse desde el elemento de estado 1 y a

través de la lógica combinacional, alcanzarán al elemento de estado 2, en el tiempo que tarda el ciclo de reloj. La longitud del ciclo de reloj debe incluir la lectura de los elementos de estado 1 y el tiempo suficiente para que el circuito lógico combinacional produzca sus salidas a partir de sus entradas.

Fig. 4.2 La lógica combinacional, los elementos de estado y la duración del ciclo de reloj

están directamente relacionados.

Por simplicidad, para aquellos elementos de estado que se modificarán en todos los ciclos de reloj, no se colocarán las señales de control específicas, por que su habilitación para la escritura puede tomarse directamente de la señal de reloj. Por lo tanto, solo colocaremos las señales de control en aquellos elementos cuya escritura dependerá de alguna instrucción particular. Una metodología disparada por flancos permite la lectura del contenido de un registro, enviar su valor a través de una lógica combinacional y escribir ese registro en el mismo ciclo de reloj, como se muestra en la figura 4.3. No importa si suponemos que la escritura se hará durante el flanco de subida o de bajada, dado que las entradas al bloque de lógica combinacional no podrán cambiar, excepto en el flanco elegido. Al emplear esta metodología, no hay retroalimentación dentro del ciclo.

Fig. 4.3 Una metodología disparada por flancos permite a un elemento de estado ser leído y escrito en el

mismo ciclo de reloj sin dejar datos indeterminados para algún valor. Primera implementación del subconjunto MIPS Iniciamos con una implementación simple que utiliza un solo ciclo de reloj para cada instrucción y sigue el esquema general mostrado en la figura 4.1. En este primer diseño, cada instrucción inicia su ejecución sobre el flanco de reloj y la completa sobre el siguiente flanco de reloj.

Este enfoque es fácil de entender, sin embargo no es práctico, por que todas las instrucciones tardarán el mismo intervalo de tiempo, lo que significa que las instrucciones mas lentas determinan la duración del ciclo de reloj. Mas adelante se estudiará un segundo enfoque en el cual la ejecución de una instrucción requerirá de múltiples ciclos de reloj, de manera que se podrá usar un reloj con una duración menor y las instrucciones mas lentas requerirán de una cantidad mayor de ciclos que las instrucciones mas rápidas. 4.2 Construyendo un camino de datos Iniciaremos el diseño examinado los principales componentes requeridos para cada clase de instrucción. En principio, necesitamos un lugar para almacenar las instrucciones, un registro que nos indique la instrucción que se está ejecutando y algún medio que nos permita avanzar a la siguiente instrucción. En la figura 4.4 se muestran estos tres elementos. Los dos primeros son elementos de estado, una memoria y un registro, mientras que para calcular la dirección de la siguiente instrucción se utilizará un sumador, por medio del cual se sumará 4 al registro del contador del programa (este elemento mas simple que una ALU, puesto que solo realiza la operación de la suma).

Fig. 4.4 Dos elementos de estado son necesarios para almacenar y accesar a las instrucciones, y un sumador

es necesario para calcular la dirección de la siguiente instrucción.

La conexión de los elementos de la figura 4.4 se muestran en la figura 4.5, el contenido del contador del programa corresponde a la dirección de la instrucción que se está ejecutando, por lo que se conecta al bus de direcciones de la memoria de instrucciones. La dirección de la siguiente instrucción se obtiene sumando 4 al contador del programa. En estos elementos de estado no se muestran sus señales de control, por que serán acertados en todos los flancos de reloj elegidos. Este es el hardware que ejecuta la búsqueda y captura de la instrucción (ciclo de fetch). Ahora consideraremos a las instrucciones tipo R o aritmético-lógicas. Esta clase de instrucciones lee dos registros, realiza alguna operación con la ALU sobre el contenido de los registros y escribe el resultado. En esta clase se incluye a las instrucciones add, sub, slt, and y or.

Fig. 4.5 Una porción del camino de los datos usada para atrapar la instrucción e incrementar al contador del

programa. Los 32 registros del procesador son almacenados en una estructura a la que llamaremos Archivo de Registros. Esta estructura contiene una colección de registros en la que cualquier registro puede ser leído o escrito especificando el número de registro en el archivo. El archivo de registros mantiene el estado de la máquina. Además, necesitaremos de una ALU que opere sobre los datos leídos desde los registros. Debido a que las instrucciones tipo R tienen 3 operandos, para cada instrucción necesitamos leer dos palabras desde el archivo de registros y escribir un dato en un registro del archivo. Las entradas al archivo de registros deben incluir los números de los registros a leer y el número del registro a escribir, así como el dato que se escribirá en el registro especificado. La lectura se realiza en cada flanco del reloj, sin embargo la escritura solo se realiza en algunas instrucciones, por lo tanto, se debe incluir una entrada de control que habilite la escritura de un dato en un registro. Las salidas del archivo de registros corresponden a los dos datos leídos. En la figura 4.6 (a) se muestra al archivo de registros, las entradas que corresponden al número de registro son de 5 bits, la entrada del dato a escribir es de 32 bits y la habilitación es de 1 bit. La ALU que se muestra en la figura 4.6 (b) tiene 3 entradas de control y su comportamiento es el descrito en la sección 3.5. Las entradas de los operandos son de 32 bits y el resultado producido también lo es. En la figura 4.7 se muestra la conexión del archivo de registros con la ALU, hasta este momento solo hemos considerado instrucciones tipo R, por lo que los datos obtenidos del archivo de registros se conectan directamente a las entradas de la ALU y el resultado producido, se dirige hacia la entrada de datos del archivo de registros. Este es el camino de los datos necesario para le ejecución de instrucciones tipo R.

Fig. 4.6 El archivo de registros y la ALU son los elementos necesarios para implementar las instrucciones

tipo-R.

Fig. 4.7 El camino de los datos para las instrucciones tipo-R.

Las siguientes instrucciones a considerar corresponden a las cargas y almacenamientos, cuyos formatos son: lw $t1, desplazamiento ($t2) y sw $t1, desplazamiento($t2). Estas instrucciones nos permiten las transferencias de memoria a registro o de registros a memoria, para calcular la dirección del dato a accesar en memoria sumando el contenido del registro base con el desplazamiento. El desplazamiento es una constante de 16 bits incluida en la instrucción. Además del archivo de registros y de la ALU, para soportar estas instrucciones necesitamos de otros elementos: una memoria de datos, la cual nos permitirá lecturas (para cargas) y escrituras (para almacenamientos) y un módulo de extensión de signo; el cual en su entrada tendrá una palabra de 16 bits y la extenderá en signo para completar una palabra de 32 bits. La extensión de signo es necesaria por que la constante incluida en la instrucción se presenta en complemento a 2, para poder accesar a los datos en direcciones posteriores o anteriores al registro base; y puesto que la ALU es de 32 bits, los dos operandos deberán tener ese tamaño. En la figura 4.8 se muestran esos dos elementos, en la memoria pueden

observarse las dos señales de control, puesto que la escritura o la lectura solo la realizan algunas instrucciones. La memoria de datos es un elemento de estado y la unidad de extensión de signo es un circuito combinacional.

Fig. 4.8 Los dos elementos necesarios para implementar las cargas y almacenamientos,

además de los elementos mostrados en la figura 4.6. En la figura 4.9 se muestra la combinación de estos elementos con el archivo de registros y la ALU para construir el camino de los datos requerido para los accesos a memoria. Se supone que la instrucción ya ha sido atrapada y se encuentra presente en el bus de la entrada. La instrucción incluye al registro base, cuyo contenido se toma del archivo de registros, y al desplazamiento que se extenderá en signo para sumarse al registro base; el resultado de la suma corresponde a la dirección de la palabra que se accesará en memoria. En el caso de una carga, se tomará la palabra de la memoria y se colocará en la entrada de datos del archivo de registros; pero si se trata de un almacenamiento, el dato leído del archivo de registros deberá escribirse en memoria. Como instrucción condicional consideraremos a la instrucción beq, esta instrucción tiene tres operandos: los dos registros que se comparan para la igualdad y una constante de 16 bits utilizada como desplazamiento para hacer brincos relativos al PC. Su forma es beq $t1, $t2, desplazamiento. Para implementar esta instrucción, se debe calcular la dirección destino del salto sumando el desplazamiento extendido en signo al PC. Hay dos detalles en la definición de las instrucciones de brincos: • El repertorio de instrucciones especifica que la base para el cálculo de la dirección

destino es la dirección siguiente a la instrucción del brinco. Dado que en el camino de los datos dedicado a buscar y capturar la instrucción, calculamos PC + 4, este valor se usará como base para obtener el destino del salto.

• También se tiene que, debido a que las instrucciones utilizan palabras de 32 bits, el desplazamiento debe corresponder a un desplazamiento de palabras y no de bytes. Para ello, una vez que se haya extendido en signo al campo del desplazamiento, será necesario multiplicarlo por 4, esto se consigue si se desplaza 2 lugares a la izquierda.

Fig. 4.9 El camino de los datos para cargas y almacenamientos, hace un acceso a registros seguido por el

cálculo de una dirección de memoria, para después leer o escribir en la memoria, y en el caso de una carga, concluir con la escritura de un registro.

Además de calcular la dirección destino del brinco, se debe determinar cual será la siguiente instrucción a ejecutarse, de acuerdo a la igualdad o desigualdad entre los registros. Si los contenidos de los registros son iguales el brinco debe realizarse, por lo que el contador del programa deberá ser sustituido por la dirección calculada. Pero si no son iguales, el brinco no se realizará por lo que se continuará con la instrucción ubicada en la dirección siguiente a la dirección del brinco. Entonces, el camino de los datos debe realizar las dos operaciones: Calcular la dirección destino del brinco y comparar los contenidos de los registros. En la figura 4.10 se muestra el camino de los datos para los brincos; con la ALU se realiza una resta entre el contenido de los dos registros, de manera que el brinco queda condicionado a la puesta en alto la bandera de zero. Con otro sumador se obtendrá la dirección destino del brinco. En la instrucción se incluye al desplazamiento en 16 bits, éste se extiende en signo y luego, para que corresponda a un desplazamiento de palabras, se desplaza a la izquierda dos lugares, lo cual equivale a multiplicar por 4. El valor resultante es el que se sumará a PC + 4, el resultado de la suma es la dirección destino del brinco. En el caso de la instrucción j, el salto es incondicional; es decir, no está sujeto al resultado de una comparación. La instrucción j tiene dos campos, un campo de 6 bits que corresponde al opcode y otro de 26 bits que indica la dirección destino del salto. Para esta instrucción también deberá considerarse que las instrucciones ocupan 4 bytes, de manera que también será necesario desplazar este campo 2 bits a la izquierda. Después del desplazamiento se tendrán 28 bits, de manera que el nuevo valor del contador del programa

se obtendrá concatenando los 4 bits más significativos del PC; de manera que este es un salto pseudo directo para todo el espacio de memoria, o directo dentro de una página de 256 Mbytes (232). La implementación de esta instrucción se incorporará una vez que se hayan implementado las demás instrucciones.

Fig. 4.10 El camino de los datos para un brinco condicional, la ALU evalúa la condición del salto y otro

sumador calcula la dirección destino del salto, con relación al valor actual del contador del programa.

4.3 Un simple esquema de implementación En esta sección se pretende realizar una implementación completa - camino de los datos y control - para las instrucciones: cargar palabra (lw), almacenar palabra (sw), brincar sobre igual (beq) y las instrucciones aritmético lógicas: add, sub, and, or y slt. Al final se incorporará la instrucción de salto (j). Construcción del camino de los datos En las figuras 4.5, 4.7, 4.9 y 4.10 se mostraron algunas piezas del camino de datos para las instrucciones individuales, ahora se combinaran todas estas piezas para tener un único camino de los datos. Debe tomarse en cuenta que se trata de una implementación que ejecutará todas las instrucciones en 1 ciclo de reloj. Esto significa que los recursos en el camino de los datos no pueden ser usados mas de una vez por instrucción, de manera que cualquier elemento que se requiera mas de una vez, deberá ser duplicado. Por lo tanto, necesitamos de una memoria de instrucciones separada de la memoria de datos. Aunque algunos elementos necesitan duplicarse, también tenemos que diferentes elementos serán compartidos por diferentes flujos de instrucciones.

Al compartir elementos, pueden requerirse múltiples conexiones a una entrada. Para ello se utilizarán multiplexores, y será el control el que determine cual de los datos fluirá a cada entrada. Primero combinaremos las instrucciones Tipo-R con las instrucciones de acceso a memoria (figuras 4.7 y 4.9). Ambas instrucciones utilizan a la ALU y el primer operando en ambos casos es el dato escrito en el registro 1, obtenido del archivo de registros, sin embargo el segundo operando difiere para las dos instrucciones: En el caso de las instrucciones tipo-R el segundo operando es el dato escrito en el registro 2, obtenido del archivo de registros. Mientras que para los accesos a memoria, el segundo operando es una constante extendida en signo. Por lo que es necesario un multiplexor en la entrada del segundo operando de la ALU. Las instrucciones tipo-R escriben el resultado en un registro y en el caso de las cargas, se obtiene un dato de memoria para ser escrito en un registro. Entonces, en la entrada de datos del archivo de registros también deberá colocarse un multiplexor por medio del cual se haga esta selección. En el caso de los almacenamientos, este multiplexor no es importante por que no hacen escritura en registro. En la figura 4.11 se muestra la combinación de ambos caminos de datos, en color naranja se muestran las señales de control, necesarias hasta el momento.

Fig. 4.11 Combinando el camino de los datos para una instrucción de acceso a memoria y el de las

instrucciones tipo-R. La parte de búsqueda y captura de la instrucción mostrada en la figura 4.4 puede fácilmente agregarse a la figura 4.11 para producir la figura 4.12, en la cual se muestra la presencia de las dos memorias, la memoria de instrucciones y la memoria de datos. Este camino de los datos requiere de un sumador además de la ALU, esto por que simultáneamente la ALU realizará la operación sobre los datos, mientras que el sumador obtendrá la dirección de la siguiente instrucción a ejecutar.

Fig. 4.12 La parte de captura de la instrucción se agrega al camino de los datos.

Para completar el camino de los datos, debemos agregar la parte necesaria para los brincos, que se muestra en la figura 4.10. Al agregar estos elementos, será necesario el uso de un multiplexor a la entrada del PC, para poder seleccionar entre PC + 4 y el resultado de haber sumado a PC + 4 una constante. En la figura 4.13 se muestra al camino de los datos obtenido hasta el momento, el cual puede ejecutar instrucciones tipo-R, cargas, almacenamientos y brincos sobre igual.

Fig. 4.13 Un camino de los datos que combina los elementos requeridos

por diferentes clases de instrucciones MIPS.

Ahora que hemos completado el camino de los datos podemos agregar la unidad de control. La unidad de control deberá tener la habilidad de generar las señales de escritura para cada elemento de estado, la selección de cada multiplexor y el control de la ALU; a partir de las entradas que definan al tipo de instrucción (opcode). Sin embargo las instrucciones aritmético-lógicas comparten el mismo opcode, de manera que para simplificar las cosas, diseñaremos por separado el control de la ALU y luego diseñaremos el resto de la unidad de control. Control de la ALU Recordemos que la ALU tiene tres entradas de control y que sólo cinco de las ocho combinaciones posibles son utilizadas. En la tabla 3.5 se definió el comportamiento de la ALU, la cual se repite en la tabla 4.1 por conveniencia.

Líneas de Control de la ALU Función 000 And 001 Or 010 Suma 110 Resta 111 Slt

Tabla 4.1 Comportamiento de la ALU La selección entre cada una de estas cinco funciones dependerá de la clase de instrucción. Para cargas y almacenamientos se requiere que la ALU realice una suma para calcular la dirección de la localidad de memoria a la que se realizará el acceso. Para instrucciones aritmético lógicas la ALU realizará una suma, resta, AND, OR o ajuste sobre menor que, dependiendo del campo de función que se encuentra en los 6 bits menos significativos en esta clase de instrucciones. Para el salto sobre igual la ALU necesita realizar una resta. Como un primer paso realizaremos una pequeña unidad de control que tenga una entrada de 2 bits a la que denominaremos ALUOp. Con esta entrada se determinará si la ALU realizará una suma (ALUOp = 00) para cargas y almacenamientos, una resta (ALUOp = 01) para brincos sobre igual o si la operación quedará determinada por el campo de función (ALUOp = 10) para instrucciones tipo-R. La salida de este Control de la ALU será de 3 bits y se conectará directamente con las líneas de control de la ALU. En la tabla 4.2 se muestra el comportamiento de la ALU basado en las entradas de dos bits (ALUOp) y en los 6 bits del campo de función. La unidad de control principal generará los valores para ALUOp. Este estilo de usar diferentes niveles de decodificación (p. Ej., la unidad de control principal genera los bits ALUOp, los cuales son usados como entradas al control de la ALU para generar las señales que controlan a la ALU) es una técnica de implementación común. El usar múltiples niveles de control reduce el tamaño del control principal, por que el

control principal ya no necesitará como entrada al campo de función, solamente al código de operación (opcode), con ello se aumenta su velocidad de respuesta considerablemente. Instrucción

(opcode) ALUOp Operación Campo de

Función Acción deseada en

la ALU Entrada de

control de la ALULW 00 Cargar palabra XXXXXX Suma 010 SW 00 Almacenar palabra XXXXXX Suma 010 BEQ 01 Saltar sobre igual XXXXXX Resta 110

Tipo-R 10 Suma (Add) 100000 Suma 010 Tipo-R 10 Resta (Sub) 100010 Resta 110 Tipo-R 10 AND 100100 AND 000 Tipo-R 10 OR 100101 OR 001 Tipo-R 10 Ajuste sobre menor

que (slt) 101010 SLT 111

Tabla 4.2 Comportamiento de la ALU en función de ALUOp y del campo de función, también se muestran las instrucciones para cada combinación.

La tabla 4.2 nos muestra que para el diseño del control de la ALU se deben considerar los 6 bits del campo de función. Sin embargo, esto nos lleva a diseñar un circuito combinacional con 8 entradas y 3 salidas. Si construimos la tabla de verdad considerando todas las combinaciones, tendremos una tabla muy grande en la que muchas de las combinaciones en realidad no importan por que no van a ocurrir. Entonces, para hacer un diseño simple (con pocas compuertas), a partir de la tabla 4.2 observaremos las condiciones necesarias y suficientes para generar cada una de las entradas de la ALU. En la tabla 4.3 se muestra a los 3 bits del control de la ALU en función de ALUOp y el campo de función; se han colocado X en aquellos valores que no son determinantes para definir la operación.

ALUOp Campo de Función Operación ALUOp1 ALUOp0 F5 F4 F3 F2 F1 F0 Sal2 Sal1 Sal0

0 0 X X X X X X 0 1 0 X 1 X X X X X X 1 1 0 1 X X X 0 0 0 0 0 1 0 1 X X X 0 0 1 0 1 1 0 1 X X X 0 1 0 0 0 0 0 1 X X X 0 1 0 1 0 0 1 1 X X X 1 0 1 0 1 1 1

Tabla 4.3 Las salidas del control de la ALU en función de ALUOp y del campo de función. En la tabla 4.3, en cuanto a las entradas ALUOp, se colocó X en la segunda fila de ALUOp1, por que es suficiente si ALUOp0 = 1 y de la 3ª a la 7ª filas con detectar el 1 de ALUOp1 es suficiente. Para el campo de Función, las columnas para F5 y F4 tiene el mismo valor, de manera que no son determinantes. Entonces, observando las condiciones mínimas para la generación de cada salida tenemos que:

Sal0 = ALUOp1 F3 + ALUOp1 F0 Sal1 = ALUOp1’ ALUOp0’ + ALUOp0 + ALUOp1 F2’ Sal2 = ALUOp0 + ALUOp1 F1

Estas ecuaciones van a funcionar en el caso de que solo se consideren estas combinaciones; ya que si se incrementan las operaciones, el campo de función introducirá nuevas combinaciones y las ecuaciones puede no cumplirse. Diseñando el control principal

Ahora que contamos con un control para la ALU, es posible realizar el control principal; para ello es conveniente repasar los formatos de las instrucciones que se están considerando: Las instrucciones tipo-R tiene el formato:

0 rs rt rd shamt funct 31-26 25-21 20-16 15-11 10-6 5-0

Para las cargas y almacenamientos el formato es:

35 o 43 rs rt dirección 31-26 25-21 20-16 15-0

Y el salto condicional tiene como formato:

4 rs rt dirección 31-26 25-21 20-16 15-0

Algunas observaciones relacionadas con los formatos y que pueden ser importantes para el diseño del hardware son: El código de operación (opcode), está siempre contenido en los bits 31-26. A este

campo lo referiremos como Op[5-0]. Los dos registros a ser leídos están siempre especificados por los campos rs y rt, en las

posiciones 25-21 y 20-16. Esto para las instrucciones tipo-R, brincos sobre igual y los almacenamientos.

El registro base para las instrucciones de cargas y almacenamientos es rs y está en los bits 25-21.

Los 16 bits de desplazamiento para brincos sobre igual, cargas y almacenamientos están siempre en las posiciones 15-0.

El registro destino está en uno de dos lugares. Para las cargas está en los bits de posición 20-16 (rt), mientras que para instrucciones tipo-R su posición es 15-11 (rd). Entonces necesitamos un multiplexor para seleccionar el campo que corresponda al registro que se escribirá de acuerdo a la operación.

Usando esta información, podemos agregar etiquetas y el multiplexor extra al camino de los datos. También podemos agregar el control de la ALU, obteniendo como resultado la figura 4.14.

Fig. 4.14 El camino de los datos mostrado en la figura 4.13 con los multiplexores necesarios para evitar colisiones y todas las líneas de control identificadas.

En la figura 4.14 se tienen 7 señales de control, mas las señales del control de la ALU (ALUOp), en la tabla 4.4 se describe el efecto de acertar o desacertar a cada una de las señales. Recordemos que acertado significa lógicamente verdadero y depende del valor necesario para la habilitación de un dispositivo, sin embargo, para los multiplexores tomaremos acertado = 1. Nombre de la señal Efecto cuando es desacertada Efecto cuando es acertada

RegDst El número del registro destino para la escritura viene del campo rt (20-16)

El número del registro destino para la escritura viene del campo rd (15-11)

RegWrite Ninguno Se escribirá un dato en el archivo de registros

ALUSrc El segundo operando de la ALU es el segundo dato leído en el archivo de registros

El segundo operando de la ALU son los 16 bits de desplazamiento tomados de la instrucción y extendidos en signo

PCSrc El PC es remplazado por PC + 4 El PC es remplazado por la suma de una dirección calculada para un brinco

MemRead Ninguno Se hace la lectura de la memoria de datos

MemWrite Ninguno Se hace la escritura en la memoria de datos

MemtoReg El valor del dato que se escribirá en el archivo de registros viene de la ALU

El valor del dato que se escribirá en el archivo de registros viene de la memoria de datos

Tabla 4.4 El efecto de cada una de las 7 señales de control. La unidad de control ajustará el valor de todas las señales dependiendo del código de operación (opcode), con excepción de la señal PCSrc. Esta señal deberá acertarse cuando se trate de un brinco condicional, sólo si el resultado de la comparación es verdadero. Por lo que a la entrada de la señal PCSrc colocaremos una AND de dos entradas, una de ellas provendrá de la bandera zero (producida por la ALU) y la otra la generará la unidad de control siempre que se trate de un brinco, a esta última señal la denominaremos branch. Por lo tanto, el control básicamente es un circuito lógico combinacional cuyas entradas corresponden a los 6 bits del opcode y sus salidas son las 7 señales de control mostradas en la tabla 4.4 mas las dos señales que requiere el control de la ALU. En la figura 4.15 se muestra al camino de los datos y el control para soportar instrucciones tipo-R, cargas y almacenamientos y brincos sobre igual. En la tabla 4.5 mostramos el valor que deberá colocarse a las señales de control, en función del opcode. Se presentan algunos casos en los que el valor de la señal no importa, por ejemplo, si no se escribirá en un registro, no importa de donde provenga el dato. Para la tabla 4.5, en relación a las memorias y al archivo de registros, se consideró que acertado equivale a 1.

Fig. 4.15 El camino de los datos con la unidad de control.

Tabla 4.5 El valor de las señales de control queda determinado por el código de operación.

Para el diseño del control, es necesario recordar los códigos de operación para cada una de las instrucciones bajo consideración, esto se muestra en la tabla 4.6.

Nombre Opcode Opcode en Binario en Decimal Op5 Op4 Op3 Op2 Op1 Op0

Tipo-R 0 0 0 0 0 0 0 lw 35 1 0 0 0 1 1 sw 43 1 0 1 0 1 1 beq 4 0 0 0 1 0 0

Tabla 4.6 Los códigos de operación en decimal y en binario. Con base en las tablas 4.5 y 4.6 se obtiene directamente el circuito del control, el cual se muestra en la figura 4.16.

R-format Iw sw beq

Op0Op1Op2Op3Op4Op5

Inputs

Outputs

RegDst

ALUSrc

MemtoReg

RegWrite

MemRead

MemWrite

Branch

ALUOp1

ALUOpO Fig. 4.16 Implementación del control.

Implementación de los Saltos A la implementación mostrada en la figura 4.15 le agregaremos el hardware necesario para soportar los saltos. El formato de la instrucción j es:

4 dirección 31-26 25-0

La diferencia entre j y beq es que la primera instrucción es incondicional, de manera que el salto siempre se realizará. Sin embargo mantienen en común el hecho de que se trata de un salto de palabras de 4 bytes, por lo que los 26 bits encontrados en la instrucción deben desplazarse a la izquierda en 2, llenando estos espacios con ceros. De manera que al realizarse el salto, el nuevo valor del contador del programa se formará por la concatenación de: Los 4 bits mas significativos del valor de PC + 4 (estos son los bits 31-28 de la

dirección secuencialmente continúa al salto). Los 26 bits del campo inmediato de la instrucción del salto.

Los bits 00dos.

Debe agregarse un multiplexor mas, por medio del cual se podrá seleccionar entre PC + 4 y el valor obtenido de la concatenación anterior. En la figura 4.17 se muestra el hardware agregado para el camino de los datos para el salto, así como la nueva señal de control para la selección del valor correcto para el PC. Por que una implementación de un ciclo de reloj no es usada Aunque la implementación mostrada en la figura 4.17 trabajará correctamente, los diseños que trabajan en un ciclo de reloj no son usados en los procesadores modernos por que son ineficientes. Una implementación de este estilo tiene un CPI igual a 1 (Ciclos por Instrucción) y puesto que no sabemos cual es la instrucción que se estará ejecutando, hasta que inicie su ejecución, todos los ciclos de reloj deberán ser del mismo tamaño. Por lo que el tamaño del ciclo de reloj estará determinado por la ruta mas larga posible en la máquina. Esta ruta ciertamente es para una instrucción de carga, la cual utiliza cinco unidades funcionales en serie: La memoria de instrucciones, el archivo de registros, la ALU, la memoria de datos y nuevamente el archivo de registros. Esta instrucción determinará el tamaño del ciclo. Las instrucciones que podrían ser rápidas, como los saltos que aunque solo ocupan la memoria de instrucciones, tardarán lo mismo que las cargas. Entonces, aunque el CPI es igual a 1, el rendimiento de esta implementación no es muy bueno dado que diferentes clases de instrucciones podrían ejecutarse en menos tiempo.

PC Readaddress

Instruction[31 - 0]

Instructionmemory

0Mux1

ReadRegister1

ReadRegister2

WriteRegister

WriteData

Readdata 1

Readdata 2

Registers

Signextend

ALUcontrol

0Mux1

ALU

Zero

ALUresult Address

Readdata

Writedata Data

Memory

1Mux0

Instruction [31-26]

Instruction [25-0] Jump Address [31-0]

PC + 4[31-28]

Instruction [25-21]

Instruction [20-16]

Instruction [15-11]

Instruction [15- 0]

Instruction [5- 0]

RegDstJumpBranchMemReadMemtoRegALUOpMemWriteALUSrcRegWrite

ShiftLeft 2

ShiftLeft 2

0Mux1

1Mux0

4

16 32

PCSrc

Fig. 4.17 El camino de los datos con la unidad de control, soporta la ejecución de instrucciones tipo-R, cargas, almacenamientos, brincos y saltos.

TAREA 8

Para los problemas del 1 al 4 de esta tarea se sugiere que se imprima la figura 4.17 para realizar lo que se pide en cada punto. 1. Suponiendo que los registros $t0 y $t1 tienen los valores 30 y 40 respectivamente, al ejecutarse la instrucción: add $t2, $t1, $t0. En la figura 4.17, resaltar las líneas que estarán activas durante la ejecución de esta instrucción y escribir el valor de cada una de las líneas activas (para las del camino de los datos usar color rojo y verde para las de control). 2. Este ejercicio es similar al anterior, pero ahora se trata de la instrucción: beq $t1, $t2, et1 y debemos suponer que tanto $t1 y $t2 tienen el dato 33, que la instrucción esta ubicada en la dirección 4000diez y que la etiqueta está ubicada 10 instrucciones antes de la que se está evaluando. 3. Al resultado mostrado en la figura 4.17, agregar el hardware necesario (camino de los datos y control) para poder soportar a la instrucción addi. 4. Esta pregunta es similar a la anterior, pero ahora se trata de soportar a la instrucción jal. 5. Se nos propone que la señal de control MemtoReg sea eliminada. Por lo que el multiplexor que tiene como entrada a MemtoReg deberá usar la señal de control MemRead ¿Trabajará el hardware con las modificaciones propuestas? ¿Por qué?