¡Descarga Practica 4 IC y más Ejercicios en PDF de Introducción a los Ordenadores solo en Docsity!
PRÁCTICA 4
Implementación de un multiplicador de números
naturales con la unidad de proceso general (UPG) y
una unidad de control de propósito específico.
Objetivos que se deben haber alcanzado antes de realizar la práctica
Antes de preparar esta práctica se deben haber alcanzado los objetivos específicos que se indican en la siguiente tabla. Para ello, es recomendable haber estudiado las secciones de la documentación que se indican en la primera columna de la tabla.
Secciones de la documentación a estudiar Objetivos específicos a alcanzar
Capítulo 8. Completo 8.7, 8.8, 8.9 y 8.
Estos objetivos serán evaluados en parte del informe previo que debéis entregar al inicio de la sesión de laboratorio y en la prueba previa individual que se hará al inicio de la sesión.
Objetivos que se deben alcanzar al realizar la práctica
Después de realizar esta práctica, además de haber mejorado el nivel de consecución de los objetivos necesarios para preparar la práctica (citados en la tabla anterior) el alumno será capaz de:
Diseñar e implementar dos versiones de un multiplicador de números naturales con Entradas/Salidas síncronas formado por una unidad de control de propósito específico y la UPG. En la primera versión la multiplicación tarda siempre el mismo número de ciclos mientras que en la segunda versión (denominada de terminación temprana) el número de ciclos depende del valor concreto de los bits del multiplicador. En concreto: a) Dibujar el grafo de estados de la unidad de control de propósito específico del multiplicador. b) Dibujar el esquema lógico del circuito que implementa el grafo de estados de la unidad de control del multiplicador mediante dos memorias ROM y un registro. c) Implementar en LogicWorks la unidad de control del multiplicador mediante dos memorias ROM y un registro.
Directorio de la práctica Aularios en módulo A5 y C6: Mi PC\I:\ic\Prac Aularios en el módulo D6: Mi PC\R:\Logic\Ver_4.1\Ic\Prac
1.1 Introducción
En esta práctica implementamos un multiplicador secuencial de dos números naturales codificados en binario con 16 bits. Es equivalente al diseño de propósito específico que hicimos en la práctica 3 pero ahora usando la unidad de proceso general, UPG, que hemos estudiado en clase. Como la UPG ya está diseñada, nos centramos en el diseño de la unidad de control (UC). La comunicación de este multiplicador con el subsistema que le proporciona los datos y recoge el resultado es síncrona, como en la práctica 3. Por ello, os recomendamos que para hacer esta práctica repaséis profundamente la práctica 3 de este curso, así como la documentación sobre la unidad de proceso general UPG (Etapa I de la documentación del tema 7).
1.2 La unidad de proceso general UPG
A modo de repaso de la UPG, en las siguientes figuras se muestra su estructura a nivel de bloques, la tabla que indica las operaciones que realiza la ALU en función del valor de los bits de selección OP y F de 2 y 3 bits respectivamente y por último los 33 bits que forman la palabra de control. Por razones de espacio, los 16 bits del campo N se expresan en hexadecimal con 4 dígitos. La palabra de control está
formada por los bits que cada ciclo tiene que generar la unidad de control para indicarle a la UPG qué debe hacer durante ese ciclo. Todos los conectores que entran a la UPG llegan de la UC excepto RD-IN que viene del exterior del multiplicador, de donde le llegarán los operandos. De las señales que salen de la UPG, z va a la UC para indicarle si el resultado que sale por la ALU en ese ciclo es cero o no y WR- OUT va al exterior para entregar el resultado de la multiplicación.
RD-IN
WR-OUT
In/Alu
WrD Clk
Rb/N
MUX
10
MUX
10
@A 3 3 @B
3 @D
N
X (^) Y
ALU
OP z
F 3 F OP 2 z
REGFILE
D
A
@B B
@D
@A
WrD
Unidad de Proceso General (UPG)
F OP
0 0 0 --- X CMPLT(X,Y) AND(X,Y)
0 0 1 --- Y CMPLE(X,Y) OR(X,Y)
0 1 0 --- --- --- XOR(X,Y)
0 1 1 --- --- CMPEQ(X,Y) NOT(X)
1 0 0 --- --- CMPLTU(X,Y) ADD(X,Y)
1 0 1 --- --- CMPLEU(X,Y) SUB(X,Y)
1 1 0 --- --- --- SHA(X,Y)
1 1 1 --- --- --- SHL(X,Y)
Funcionalidades de la ALU de la UPG
@A @B
Rb/N
OP F
In/Alu
@D
WrD
N ( Hexa )
b 2 b 1 b 0 b 2 b 1 b 0 b 1 b 0 b 2 b 1 b 0 b 2 b 1 b 0 D
3 D
2 D
1 D
0
x x x x x x x x x x x x x x x x x X X X X
Palabra de control de la UPG
Antes de pasar al diseño del multiplicador usando la UPG, vamos a hacer algunos ejercicios para familiarizarnos con ella y con el diseño de unidades de control específicas para controlar a la UPG.
de menor peso (los 3 bits de más peso de este dígito los codificaremos como 0, ya que no se refieren a ninguna señal binaria de la palabra de control)
Mnemotécnico Palabra de control hexadecimal AND R3, R1, R5 (^) 06C ADD R1, R2, R3 // NOT R2, R1 (^) -------------- SHAI R7, R7, - ADDI R4, R7, - OUT R5 // IN R IN R1 // ADD R2, R3, R MOVEI R3, 327 SHLI R6, R6, 1 CMPEQ -, R3, R SUBI -, R2, 1
Informe previo
Pregunta 3
¿Cómo se modifican los registros de la UPG al final del ciclo en el cual la UPG ha estado controlada por la palabra de control que se especifica para cada uno de los siguientes apartados? Cada fila de la tabla es un ejercicio independiente. Debe suponerse, para cada fila/ejercicio, que desde el inicio del ciclo que estamos considerando, el estado de la UPG (el contenido de los registros de la UPG) y el valor presente en el bus de datos de entrada de la UPG es: Ri vale i +3 para 0 ≤ i ≤ 7 RD-IN = 23. Sólo tenéis que especificar los cambios ocurridos en el estado del computador tras la llegada del flanco de reloj que indica el final del ciclo. Los registros que no se modifiquen no deben especificarse. (Los dos primeros apartados los hemos completado nosotros, como muestra).
a) AND R3, R1, R Respuesta: R3 = 0 b) ADD R1, R2, R3 // NOT R2, R Respuesta: ------- c) SHAI R7, R7, -
d) ADDI R4, R7, -
e) OUT R5 // IN R
f) MOVEI R3, 327
g) IN R1 // ADD R2, R3, R
h) SHLI R6, R6, 1
i) CMPEQ -, R3, R
j) SUBI -, R2, 1
En toda unidad de control puede considerarse que hay dos circuitos combinacionales (que se pueden implementar con dos ROM), uno para generar en cada ciclo el estado siguiente (para indicar el nodo que se ejecutará al ciclo siguiente) y otro para generar las salidas de la unidad de control (la palabra de control más algún bit de salida del procesador para sincronizar y/o validar el resultado de la operación. Hemos practicado un poco con la palabra de control, que le indica a la UPG la acción que debe realizar en cada ciclo. Ahora vamos a practicar además con la generación del estado siguiente, con el secuenciamiento (la secuencia de ejecución de los nodos del grafo). El secuenciamiento se indica mediante los arcos del grafo de estados de la unidad de control (las flechas etiquetadas entre nodos).
Informe previo
Pregunta 4
Para cada uno de los apartados siguientes, dibujad el fragmento del grafo de estados de la unidad de control de propósito específico para que la UPG realice la funcionalidad que se indica. Indicad la palabra de control en hexadecimal que genera la unidad de control para cada nodo. Indicad con una flecha la llegada al primer nodo del fragmento y con otra flecha la salida del último nodo del fragmento. Consideramos que los contenidos de los registros son números naturales codificados en binario ( unsigned integers ). El apartado a) lo damos resuelto, escribiendo al lado de cada nodo
la palabra de control con mnemotécnicos que debe generar la unidad de control cuando ejecuta el nodo. a) if (R2 ≤^ R3) R3 = R1 – 1; Respuesta:
b) if (R1 != 1) R2 = R2 + R2; else R2 = R2 + 5;
c) for (R2 = 3; R2 <= R5; R2 = R2+1) R7 = R7 + 3;
d) if (R1<3> = 1) R2 = R2 + R5; (Nota: R1<3> se refiere al bit 3 del registro R1. La acción ANDI de R3 con un valor inmediato adecuado da como resultado 0 si el bit 3 de R1 vale 0 y distinto de 0 si vale 1).
1.3 Multiplicación en la UPG
1.3.1 Repaso de la práctica 3
En la práctica 3 obtuvimos el siguiente algoritmo para multiplicar los números naturales Xu e Yu :
Algoritmo MUL
Xu ( 0 )=X u;
Wu ( 0 )= 0 ;
for (j = 0; j < n; j = j + 1) {
Mu = Xu( j)×y j;
Wu ( j+ 1 )=Wu(j)+M u;
X u ( j+ 1 )=Xu(j)× 2 ;
W u = Wu(n );
respectivamente. Las entradas de estos tres registros se han etiquetado como X ( j+ 1 ), Y( j+ 1 ) y
W( j+ 1 ) que son los vectores de bits que tendrán cada uno de los registros al ciclo siguiente del ciclo en
el que se implementa la iteración j del algoritmo de multiplicación.
Recordad que y jes el bit de peso 2 jdel vector de bits Y que codifica al multiplicador Yu. Otra forma de
escribir el algoritmo de multiplicación anterior con más detalle, y de acuerdo con la implementación
realizada en la práctica 3, consiste en especificar cómo se obtiene y j. Primero, antes de entrar en el
bucle del algoritmo, se carga Y en el registro superior derecha. Para que, en cada una de las iteraciones
j, el bit 0 (bit de peso 0 2 ) de Y( j)sea y (^) j, en cada iteración del bucle hay que desplazar a la derecha el
contenido del registro superior derecho (división entera por 2). El algoritmo que se obtiene especificando
la obtención de y jes el siguiente. Notad que la expresión Yu (j)mod 2 , que aparece en la primera línea
del cuerpo del bucle, es una forma de referirnos al bit 0 de Y( j) usando el valor del número, Yu (j),
representado por Y( j).
Algoritmo MUL (segunda versión)
Xu ( 0 )=X u;
Yu ( 0 )=Y u;
Wu = 0 ;
for (j = 0; j < n; j = j + 1) {
M u = Xu( j)×(Yu(j)mod 2 );
Wu ( j+ 1 )=Wu(j)+M u;
X u ( j+ 1 )=Xu(j)× 2 ;
Yu ( j+ 1 )=Yu(j)/ 2 ;
W u = Wu(n );
1.3.2 Enunciado del problema
Suponiendo que el vector de bits X que representa al multiplicando X use encuentra inicialmente en el
registro R6 de la UPG y que el vector de bits Y que representa al multiplicador Yu se encuentra en R7,
dibujad el grafo de la unidad de control, especificando la palabra de control con mnemotécnicos, que deje
los 16 bits de menor peso del resultado de la multiplicación de Xu por Yu en el registro R5. No hay que
detectar el caso de desbordamiento, esto es, el caso en el que el resultado de la multiplicación no puede representarse correctamente en binario con 16 bits.
1.3.3 Obtención del grafo de estados, sentencia por sentencia
Para resolver este problema vamos a utilizar el algoritmo MUL (segunda versión). De momento, y motivados por el enunciado del problema, asociamos los siguientes registros del banco de registros de la UPG con las variables del algoritmo MUL:
- R6 contiene el vector de bits X( j)(que representa al valor Xu (j))
- R7 contiene el vector de bits Y( j)(que representa al valor Yu (j))
- R5 contiene el vector de bits W (j)(que representa al valor Wu (j))
a) Sentencias anteriores al bucle
Dada esta asociación las dos primeras líneas del algoritmo MUL ( X u ( 0 )=Xue Yu ( 0 )=Yu) no necesitan
ningún nodo del grafo para su implementación. La tercera línea del algoritmo ( Wu ( 0 )= 0 ) se puede
implementar con la acción:
MOVEI R5, 0
(También puede hacerse, por ejemplo con XOR R5, R5, R5; o con SUB R5, R5, R5)
El nodo del grafo que especifica esta acción es el siguiente:
b) Implementación del bucle
En el diseño específico de la práctica 3 realizamos las 4 sentencias de cada iteración del bucle del algoritmo MUL en un solo ciclo, ya que la unidad de proceso específica fue diseñada para ello y se dispuso del hardware necesario para que pudiera actuar en paralelo (en el mismo ciclo). Ahora, en la UPG, tenemos una única ALU que sólo puede efectuar una operación por ciclo. Por ello, lo que en la práctica 3 hacíamos en un ciclo (un nodo de la unidad de control) ahora lo tendremos que hacer en varios ciclos (varios nodos de la unidad de control).
También, en la práctica 3 implementamos las 16 iteraciones del algoritmo MUL mediante una secuencia de 16 nodos del grafo de estados, uno por iteración del bucle for del algoritmo. De momento pensemos en hacer lo mismo, con la salvedad de que será una secuencia de 16 subgrafos, cada uno de ellos de varios nodos, ya que cada iteración del bucle necesita varios ciclos para ejecutarse.
Sentencias del cuerpo del bucle
Veamos ahora cómo implementamos cada una de las sentencias del cuerpo del bucle del algoritmo MUL.
Primera sentencia del cuerpo del bucle. La primera sentencia tiene cierta dificultad:
M u =Xu( j)×(Yu(j)mod 2 )
Supongamos que deseamos el valor de Mu en el registro R4, por ejemplo. En R4 debe quedar el
contenido de R6, Xu (j), si el bit de menor peso de R7, de la representación de Yu (j), es 1 y debe quedar
el valor 0 si el bit de menor peso de R7 es 0.
Podemos escribir en R4 el bit de menor peso de R7, ( Yu (j)mod 2 ), mediante la acción,
ANDI R4, R7, 1
El valor 1 (representado en binario como todo ceros excepto el bit de menor peso que vale 1) hace el papel de una máscara que sólo nos deja ver el bit 0 de R7. Así, después de ejecutar la acción ANDI, el registro R4 valdrá 1 o 0 según el bit de menor peso de R7 sea 1 o 0 respectivamente. Dicho esto, podemos comprobar que el siguiente fragmento de grafo implementa eficientemente la primera sentencia del cuerpo del bucle (carga en R4 un 0 si el bit 0 de R7 vale 0 y si no carga el valor de R6):
El resto de sentencias del cuerpo del bucle son muy fáciles de implementar en la UPG pues sólo requieren un nodo (un ciclo de reloj) para su ejecución.
Segunda sentencia del cuerpo del bucle. Con el uso de los registros que hemos establecido, la sentencia,
M u =Xu( j)×(Yu(j)mod 2 )
Wu ( j+ 1 )=Wu(j)+M u.
Como hemos usado R4 temporalmente tanto para Yu (j)mod 2 como para Mu y como sumar 0 a
Wu (j )es lo mismo que no sumarle nada, podemos implementar estas dos sentencias con 2 nodos
del grafo, en vez de con los 3 que hemos usado y sin requerir el registro temporal R4.
Completad la tabla de las palabras de control del nuevo grafo optimizado. A la izquierda os damos el original, para que os sirva de ayuda.
Con esta optimización que acabáis de hacer, completad la implementación definitiva del cuerpo del bucle con 4 nodos que se encuentra en la siguiente figura (simplemente volved a copiar los mnemotécnicos de los nodos C y D ya que los antiguos nodos N y O de la implementación con 5 nodos son iguales a los que ahora se llaman E y F en la implementación con 4 nodos).
Veamos ahora la implementación del control del bucle.
Control del bucle
En la práctica 3 implementamos una versión del algoritmo MUL con el bucle totalmente desenroscado usando un total de 16+2 nodos, uno para cada iteración del bucle más el estado inicial y final. Ahora, con la UPG, cada iteración del bucle requiere 4 nodos por lo que una implementación desenroscada requeriría al menos 64 nodos (4x16), y esto ya empieza a ser excesivo. Por ello, en esta práctica vamos a hacerlo de otra forma. En la unidad de control tendremos solamente una instancia de los 4 nodos que implementan el cuerpo del bucle de forma que la ejecución del algoritmo suponga reutilizar estos pocos nodos, pasar por ellos, 16 veces, una por iteración del bucle. Se requerirá un registro en la UPG para contar el número de iteraciones hechas. Cada vez que se ejecute una iteración la unidad de control ordenará incrementar este contador. Vamos a ver esto en detalle a continuación.
Es muy importante observar que lo que en la unidad de proceso específica de la práctica 3 se hacía en un ciclo (un nodo), ahora requiere 3 o 4 ciclos, dependiendo del valor del bit del multiplicador que se esté tratando. Al implementar la unidad de control con un bucle, reutilizando los 4 nodos del cuerpo del bucle 16 veces, se usan poco más de 4 nodos en total (muchos menos de 64) pero se necesita más tiempo de ejecución, pues a los 3 o 4 ciclos por iteración del cuerpo del bucle habrá que añadirles algún nodo extra (ciclo extra) para ordenar a la UPG que actualice el registro contador y que compruebe si se han realizado las 16 iteraciones para saber cuándo terminar.
Vamos a implementar el bucle
for (j = 0; j < n; j = j + 1) {
accionesdelcuerpodel bucle
Una forma eficiente de hacerlo, ya que sabemos que hay que ejecutar al menos 1 vez las acciones del cuerpo del bucle (de hecho se tienen que ejecutar 16 veces), consiste en usar la estructura de control do while que ejecuta el cuerpo del bucle y después pregunta si hay que volver al ejecutar otra iteración. Consiste en inicializar un registro contador con el valor 16 y decrementarlo una unidad en cada iteración. En el ciclo en el que se decrementa el registro, la unidad de control puede saber si vale cero mirando el valor del bit z que llega de la ALU. Si z = 1 ya se ha terminado y si vale 0 hay que volver a ejecutar otra vez el bucle. El grafo resultante es el siguiente:
c) Grafo completo de la Unidad de Control del algoritmo MUL
Antes de dar por terminado el grafo completo de la unidad de control decir que la última sentencia del algoritmo MUL, que se encuentra fuera del bucle, no necesita ningún nodo para su implementación, simplemente debemos saber que el resultado de la multiplicación se encuentra en el registro R5 de la UPG.
Ciclo Mnemotécnico Estado actual de los registros R2 R5 R6 R 0 MOVEI^ R5,^0 X X X X X X X X 0 0 1 1 0 1 0 1 1 MOVEI^ R2,^4 0 0 0 0 2 ANDI^ -,^ R7,^1 0 1 0 0 3 4 5 6 7 8 9
Además de rellenar la tabla, responded a las siguientes preguntas:
a) ¿Cuántos ciclos tarda en ejecutarse el algoritmo?
b) ¿Cuál es el estado de la UPG (el valor de los registros de la UPG) después de ejecutarse el algoritmo?
1.4 Un algoritmo de multiplicación con terminación temprana
Informe previo
Pregunta 8
Dibujad el grafo de estados del algoritmo de multiplicación de la pregunta 6 del informe previo modificado adecuadamente para que no tengan que ejecutarse siempre 16 iteraciones del bucle.
Cuando la representación en binario del multiplicador, Y , tenga k ceros en las posiciones de mayor
peso, debemos ahorrarnos las últimas k iteraciones del algoritmo. Esto es posible porque el resultado parcial de la multiplicación que se encuentra en R5 al final de la iteración n-1-k ya es el definitivo. Si continuáramos con el algoritmo sumaríamos un 0 a R5 en cada iteración y esto no modifica R5. Dibujad el grafo de la unidad de control para implementar este algoritmo de multiplicación que denominamos “ con terminación temprana ”. Indicad claramente las etiquetas de los nodos, la palabra de control y las etiquetas en los arcos. Una pista: Os podéis hacer dos preguntas que os ayudarán a encontrar el nuevo grafo, ¿Cómo se modifican los arcos del grafo para poder detectar la terminación temprana? Una vez hecha esta modificación preguntaos ¿Qué nodos del grafo son innecesarios ahora? Después de responder a estas preguntas veréis que el grafo resultante tiene solamente 5 nodos en vez de los 7 nodos que tiene el de la pregunta 6. Completad el grafo siguiente, añadiendo los arcos con sus etiquetas e indicando la palabra de control de cada nodo usando mnemotécnicos.
1.5 Añadiendo Entradas/Salidas síncronas
El grafo que implementa el algoritmo de multiplicación con terminación temprana usando la UPG puede incrustarse en un grafo más complejo. Cada vez que se desea multiplicar dos números, sólo hay que cargar los números en R6 y R7 antes de pasar a ejecutar el grafo que hemos diseñado y después recoger el resultado de R5.
En esta práctica vamos a usar el multiplicador en un entorno equivalente al de la práctica 3. Entramos los operandos de forma síncrona desde un teclado hexadecimal de 4 dígitos y vemos el resultado en un display hexadecimal de 4 dígitos. El circuito se muestra a continuación.
X X X X
b
b
b 0 1 2 3 b 4 5 6 7 8 9 A B b4 C D E F
b
b 0 1 2 3 b 4 5 6 7 8 9 A B b8 C D E F
b
b 0 1 2 3 b 4 5 6 7 8 9 A B b12 C D E F
b
b 0 1 2 3 b 4 5 6 7 8 9 A B C D E F
1000,1000 1000
Pulse
Ld REG
X X X X
MUX
10
0 0
MULwUPG FinMul WR-OUT
IniMul (^) RD-IN
FinMul
IniMul
W
IniMul
Clk
FinMul
RD-IN WR-OUT UPG
RD-IN WR-OUT
In/AluWrD@D@AOPFRb/N@BN
z
IniMul UC-MULwUPG FinMul
z In/AluWrD@D@AOPFRb/N@BN
En la siguiente figura mostramos el esquema interno de la unidad de control específica para la multiplicación. La hemos diseñado con dos memorias ROM, la ROM_Q+_MUL para calcular el estado siguiente, en función de las entradas a la unidad de control y del estado actual (implementa la tabla de transiciones que se obtiene del grafo de estados), y la ROM_OUT_MUL para calcular las salidas de la unidad de control en función del estado actual (tabla de salidas que se obtiene del grafo de estados). Observad que de los 4 bits (un dígito hexadecimal) de menor peso de la salida de la ROM, solamente usamos el bit de menor peso, para codificar la señal FinMul. Hemos usado un dígito en vez de un bit para codificar FinMul, para que sea más fácil escribir el contenido de la ROM en hexadecimal, aunque por esto se necesite una ROM con 3 bits más por palabra. Además hemos usado 9 dígitos hexadecimales para la palabra de control, de 33 bits, aunque no se usen los 3 bits de más peso de la ROM
z
Clk
b b b b b b b b b b b b b b b b b b b b b b
b b b b b b
Rb/N
WrD In/Alu
IniMul REG b b b0b1 b b
b b b
FinMul
3 @B
(^3) F
3 @A
3 @D
N
b b
2 OP
In In In In In
Out Out Out Out
ROM_Q+_MUL
200
In In In
Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out Out ROM_OUT_MUL
200
Informe previo
Pregunta 10
Indicad el contenido de cada una de las dos memorias ROM, para que el multiplicador funcione como se ha especificado (y de acuerdo con el grafo de 8 estados que habéis diseñado en la pregunta 9 del informe previo). Los bits de salida de las ROM que no se usan haced que sean siempre 0. Expresad el contenido de cada una de las dos ROM en hexadecimal, separando cada palabra por un espacio o un cambio de línea acordando que la primera palabra corresponde a la palabra con dirección 0, la siguiente a la de dirección 1, etc. Usad el espacio siguiente.
ROM_Q+_MUL
ROM_OUT_MUL
El circuito ProbeMxx, que se encuentra en la carpeta Prac5 y que hemos construido para vosotros, es una implementación completa del multiplicador que hemos visto aquí junto con los dispositivos para entrar datos y visualizar el resultado. El problema es que no funciona, ya que el contenido de las ROM de la unidad de control no es correcto.
Implementad en el laboratorio, usando el LogicWorks, cada una de las dos ROM que habéis diseñado en la pregunta 10 del informe previo. Para construir un dispositivo de tipo ROM tenéis que seguir los pasos
que os indica el PROM/RAM/PLA Wizard que se encuentra en la barra de herramientas del LogicWorks. Después de hacer clic en el icono tenéis que seleccionar PROM (ya que la ROM que usamos es realmente una Programmable ROM, PROM), en la siguiente ventana poner el número de líneas de dirección ( Address Lines ) y de datos ( Bits per Word ), seleccionar Enter hex data manually y por último entrar los datos del contenido de la ROM en hexadecimal, separando cada palabra con un espacio o con un return. Podéis hacer clic en Format Help para saber cómo tenéis que separar cada palabra del contenido de la ROM. Como las ROM son bastante grandes para entrar los datos manualmente es fácil cometer errores. Hay un problema, que una vez creada una ROM no se puede ver su contenido ni modificarlo. Si se quiere cambiar el contenido hay que crear otra ROM. Así si se produce un error al entrar los datos es muy difícil detectarlo y corregirlo. Podéis escribir el contenido de la ROM en un fichero tipo texto (con el bloc de notas, por ejemplo) y recortar y pegar su contenido en la ventana de entrada de datos manual.
Para que los símbolos de las ROM que creéis tengan el mismo tamaño que las que nosotros hemos puesto en el circuito de la unidad de control, tenéis que darles el mismo nombre: ROM_Q+_MUL y ROM_OUT_MUL. Si dais nombres con más caracteres, cuando tengáis que sustituir en el circuito vuestras ROM por las nuestras, no tendréis espacio suficiente y tendréis que mover componentes del circuito, cosa engorrosa. Para poder salvar la ROM tenéis que tener abierta una librería de dispositivos en el escritorio, ya que en el disco donde está LibPrac5 no podéis escribir.
Una vez creadas vuestras dos ROM, eliminad las dos ROM que se encuentran en la unidad de control del multiplicador y colocad las vuestras. Haced reset del sistema y comprobad que el multiplicador funciona correctamente.
Informe final
Pregunta 1:
Cuando estéis seguros del correcto funcionamiento del multiplicador con terminación temprana, avisad al profesor de laboratorio y pedidle que revise vuestro trabajo y firme en el informe final.
Informe final
Pregunta 2:
Indicad si realizasteis correctamente el grafo de la pregunta 9 y el contenido de las ROM de la pregunta 10 del informe previo. En caso de que haya algo incorrecto en los grafos o en el contenido de las ROM del informe previo decid el qué es incorrecto y por qué es incorrecto. Copiad aquí el grafo correcto y el contenido de las ROM correctos.
Informe previo Práctica-
Apellidos y nombre: ................................................................................................................ Grupo: .......
Apellidos y nombre: ................................................................................................................ Grupo: .......
(por orden alfabético)
Pregunta 1
@A @B
Rb/N
OP F
In/Alu
@D
WrD
N ( Hexa )
b^2 b^1 b^0 b^2 b^1 b^0 b^1 b^0 b^2 b^1 b^0 b^2 b^1 b^0 D
3 D
2 D
1 D
0
AND R3, R1, R5 0 0 1 1 0 1 1 0 0 0 0 0 0 0 1 1 1 X X X X
ADD R1, R2, R3 // NOT R2, R
SHAI R7, R7, -
ADDI R4, R7, -
OUT R5 // IN R
IN R1 // ADD R2, R3, R
MOVEI R3, 327
SHLI R6, R6, 1
CMPEQ -, R3, R
SUBI -, R2, 1
Pregunta 2
Mnemotécnico Palabra de control hexadecimal AND R3, R1, R5 (^) 06C ADD R1, R2, R3 // NOT R2, R1 (^) -------------- SHAI R7, R7, - ADDI R4, R7, - OUT R5 // IN R IN R1 // ADD R2, R3, R MOVEI R3, 327 SHLI R6, R6, 1 CMPEQ -, R3, R SUBI -, R2, 1
Pregunta 3
a) AND R3, R1, R Respuesta: R3 = 0
b) ADD R1, R2, R3 // NOT R2, R Respuesta: -------
c) SHAI R7, R7, -
d) ADDI R4, R7, -
e) OUT R5 // IN R
f) MOVEI R3, 327
g) IN R1 // ADD R2, R3, R
h) SHLI R6, R6, 1
i) CMPEQ -, R3, R
j) SUBI -, R2, 1
Pregunta 4
a) Ya está resuelto en el enunciado
b) if (R1 != 1) R2 = R2 + R2; else R2 = R2 + 5;
c) for (R2 = 3; R2 <= R5; R2 = R2+1) R7 = R7 + 3;
