Practica realizada por: Jorge Oliva.
Sean las siguientes instrucciones:
Sean las siguientes instrucciones:
a) ADD $t0, $t1, $t2
b) ADDI $s0, $s1, 0x0011
c) ORI $t0, $t2, 0x00A1
d) SLL $t0, $t0, 0x0002
e) SLR $t1, $t0, 0x0002
f) LUI $s0,0x0011
g) SW $t4, 0x0111
h) SLT $t1, $t2, $t0
i) J 0x000001A
j) JR $S0
1. Codificar las instrucciones en hexadecimal, tal como quedarían en memoria.
Antes de empezar a realizar la codificación, debemos saber que los valores de $t0, $t1, $t2, $t4, $s0 y $s1 podemos consultarlos en la siguiente tabla de registros:
En cada una de las instrucciones que codificaremos a continuación deberemos acudir a la tabla citada anteriormente, además de fijarnos en el formato que debemos seguir en cada una de ellas, que encontramos en el tema anterior. Dicho formato nos indicará en cada instrucción (ADD; ADDI, etc) la forma de codificarlo, especificándonos el orden de los registros ($t0, $t1, etc) así como el número de bits con los que se deben expresar. Esto será lo único que cambie entre la codificación de una instrucción y otra, ya que el resto de pasos se realizará siempre de la misma forma independientemente de la instrucción de la que se trate (Veremos esto a continuación con la realización de los ejercicios, detallando más el primero de ellos que el resto)
a) ADD $t0, $t1, $t2
Para codificar la instrucción en hexadecimal seguiremos el formato mencionado arriba. Deberemos buscar en el tema anterior el que corresponda con la instrucción que queramos codificar, en este caso ADD.
Vemos que identifica $t0 con rd, $t1 con rs y $t2 con rt. Tendremos en cuanta esa nomenclatura ya que justo abajo aparece el orden que debe seguirse: 0, Rs, Rt, Rd, 0 y 0x20.
En primer lugar deberemos consultar en la tabla de registros que pusimos al principio los valores de $t0, $t1 y $t2, que son 8, 9 y 10 respectivamente.
A continuación pasamos a binario cada uno de ellos y los colocamos con el orden y el número de bits que nos indica. En este paso debemos tener en cuenta a la hora de realizar la conversión que 0x20 está en hexadecimal.
Quedaría de la siguiente forma:
000000|01001|01010|01000|00000|100000
Tras esto, agrupamos los números del resultado anterior de 4 en 4:
0000, 0001, 0010, 1010, 0100, 0000, 0010, 0000
Y finalmente pasamos todo a hexadecimal, quedando el siguiente resultado:
Resultado = 0 1 2 A 4 0 2 0
El resto de ejercicios se realizan de la misma forma, y solo cambia el formato del principio. Todo lo demás (el paso a binario, agrupar de 4 en 4, etc) no cambia, por lo que los realizare sin extenderme tanto en dar detalles:
b) ADDI $s0, $s1, 0x0011
Pasamos a binario:
001000|10001|10000|0000000000010001
Agrupamos en grupos de 4 y lo pasamos a hexadecimal:
0010, 0010, 0011, 0000, 0000, 0000, 0001, 0001
Resultado = 2 2 3 0 0 0 1 1
c) ORI $t0, $t2, 0x00A1
Pasamos a binario:
001101|01010|01000|0000000010100001
Agrupamos en grupos de 4 y pasamos a hexadecimal:
0011, 0101, 0100, 1000, 0000, 0000, 1010, 0001
Resultado = 3 5 4 8 0 0 A 1
d) SLL $t0, $t0, 0x0002
Pasamos a binario:
000000|00000|01000|01000|00010|000000
Agrupamos en grupos de 4 y pasamos a hexadecimal:
0000, 0000, 0000, 1000, 0100, 0000, 1000, 0000
Resultado = 0 0 0 8 4 0 8 0
e) SLR $t1, $t0, 0x0002
Pasamos a binario:
000000|01000|00000|01001|00000|000010
Agrupamos en grupos de 4 y pasamos a hexadecimal:
0000, 0001, 0000, 0000, 0100, 1000, 0000, 0010
Resultado = 0 1 0 0 4 8 0 2
f) LUI $s0, 0x0011
Pasamos a binario:
001111|00000|10000|0000000000010001
Agrupamos en grupos de 4 y pasamos a hexadecimal:
0011, 1100, 0001, 0000, 0000, 0000, 0001, 0001
Resultado = 3 C 1 0 0 0 1 1
g) SW $t4, 0x0111
Pasamos a binario:
101011|00000|01100|0000000100010001
Agrupamos en grupos de 4 y pasamos a hexadecimal:
1010, 1100, 0000, 1100, 0000, 0001, 0001, 0001
Resultado = A C 0 C 0 1 1 1
h) SLT $t1, $t2, $t0
Pasamos a binario:
000000|01010|01000|01001|00000|101010
Agrupamos en grupos de 4 y pasamos a hexadecimal:
0000, 0001, 0100, 1000, 0100, 1000, 0010, 1010
Resultado = 0148482A
i) J 0x000001A
Pasamos a binario:
000010|00000000000000000000011010
Agrupamos en grupos de 4 y pasamos a hexadecimal:
0000, 1000, 0000, 0000, 0000, 0000, 0001, 1010
Resultado = 0800001A
j) JR $S0
Pasamos a binario:
000000|10000|000000000000000|001000
Agrupamos en grupos de 4 y pasamos a hexadecimal:
0000, 0010, 0000, 0000, 0000, 0000, 0000, 1000
Resultado = 02000008
2. Utilizando la CPU descrita en clase teórica y el lenguaje de transferencia de registro, realizar la secuencia de transferencias y acciones.
En este segundo ejercicio realizaremos la secuencia de transferencia de registro, para la cual deberemos seguir el siguiente esquema de la CPU:
Para referirnos a cada una de las secuencias utilizaremos la nomenclatura C seguida del número de dicha secuencia (Ej: C1, C2, C3…)
En la realización del ejercicio observaremos que las secuencias C1, C2 y C3 son comunes en todos ellos, no cambian nunca, ya que se trata de la fase de lectura de instrucciones. Lo mismo ocurre con C4, que se corresponde con la fase de decodificación.
A partir de ahí cambia según el ejercicio, ya que cada instrucción genera distintas señales dependiendo de su función.
Tras esta aclaración pasemos a los ejercicios:
a) ADD $t0, $t1, $t2
C1: MAR ß PC
C2: PC ß PC + 4 | MBR ß MP
C3: RI ß MBR
C4: Decodificación
C5: R8 ($t0) = R9 ($t1) + R10 ($t2)
Para este primer ejercicio daremos una breve aclaración del significado de las sentencias, para ayudar a entender mejor que está sucediendo realmente en cada una de ellas:
En primer lugar, en la sentencia C1 hemos guardado la dirección de memoria a la que se accede (PC) en el registro MAR. Posteriormente en la secuencia C2 incrementamos la dirección de memoria en 4 y cargamos el contenido de la memoria principal (MP) en el registro MBR.
Tras eso cargamos el contenido de MBR en RI, el registro de instrucciones, para así poder operar con los datos (C3).
En C4 tiene lugar la fase de decodificación como mencionamos arriba, y finalmente en C5 se realiza la operación correspondiente a ADD.
En el resto de ejercicios se realizan instrucciones similares, por lo que no daremos detalles sobre ellas y nos limitaremos a mostrar directamente el resultado:
b) ADDI $s0, $s1, 0x0011
C1: MAR ß PC
C2: PC ß PC + 4 | MBR ß MP
C3: RI ß MBR
C4: Decodificación
C5: RT1 ß MBR
C6: R16 ($s0) =R17 ($s1) + RT1 (0x0011)
c) ORI $t0, $t2, 0x00A1
C1: MAR ß PC
C2: PC ß PC + 4 | MBR ß MP
C3: RI ß MBR
C4: Decodificación
C5: RT1 ß MBR
C6: R8 ($t0) = R10 ($t2) OR RT1 (0x00A1)
d) SLL $t0, $t0, 0x0002
C1: MAR ß PC
C2: PC ß PC + 4 | MBR ß MP
C3: RI ß MBR
C4: Decodificación
C5: RT1 ß MBR
C6: R8 ($t0) = Desplazamiento Izq. (R8 ($t0), RT1 (=0x0002))
e) SLR $t1, $t0, 0x0002
C1: MAR ß PC
C2: PC ß PC + 4 | MBR ß MP
C3: RI ß MBR
C4: Decodificación
C5: RT1 ß MBR
C6: R9 ($t1) = Desplazamiento Der. (R8 ($t0), RT1 (=0x0002))
f) LUI $s0, 0x0011
C1: MAR ß PC
C2: PC ß PC + 4 | MBR ß MP
C3: RI ß MBR
C4: Decodificación
C5: RT1 ß MBR
g) SW $t4, 0x0111
C1: MAR ß PC
C2: PC ß PC + 4 | MBR ß MP
C3: RI ß MBR
C4: Decodificación
C5: MAR ß RI
C6: MBR ß R12 ($t4)
C7: MP ß MBR
h) SLT $t1, $t2, $t0
C1: MAR ß PC
C2: PC ß PC + 4 | MBR ß MP
C3: RI ß MBR
C4: Decodificación
C5: MAR ß RI
i) J 0x000001A
C1: MAR ß PC
C2: PC ß PC + 4 | MBR ß MP
C3: RI ß MBR
C4: Decodificación
j) JR $S0
C1: MAR ß PC
C2: PC ß PC + 4 | MBR ß MP
C3: RI ß MBR
C4: Decodificación
Como podréis ver en los ejercicios anteriores, las secuencias C1, C2 y C3 son comunes en todos, ya que se trata de la fase de lectura de instrucciones. Lo mismo ocurre con C4, que es la fase de decodificación.
3. Comprobar que todo lo anterior se ha realizado de forma correcta mediante el simulador que se adjunta para la práctica. Se introducirá el código de instrucción en la memoria de manera que sea posible realizar todas las fases de la instrucción.
Este último ejercicio consiste en, como en indica el enunciado, comprobar que todo lo anterior se ha realizado de forma correcta, para lo cual realizaremos la simulación con el Logisim, y comprobaremos las señales que se deben activar en el circuito que nos dan hecho para la realización de dicha práctica.
Aquí podéis ver el circuito del que hablamos:
Para saber las señales que se deben activar nos fijaremos en las operaciones y direccionamientos que queremos realizar en la secuencia de transferencia de acciones y miraremos el circuito.
Haremos un ejemplo con el primer ejercicio (ADD), para ver las señales que se activan en él. Pondremos las secuencias a la izquierda y a la derecha las señales que se activan:
a) ADD $t0, $t1, $t2
Señales que se activan:
C1: MAR ß PC T4, C1
C2: PC ß PC + 4 | MBR ß MP C4, TD, L, C2
C3: RI ß MBR T3 y C7
C4: Decodificación
C5: R8 ($t0) = R9 ($t1) + R10 ($t2)
Haríamos lo mismo con el resto de ejercicios, comprobando las señales que se activan con el Logisim.