UC3M _ Doble Grado en Ingeniería Informática y ADE _ Estructura de computadores _ Estructura

Esta es una vista previa del archivo. Inicie sesión para ver el archivo original

EC Materiales/EC_practica1_2013-2014.pdf
 
ESTRUCTURA DE COMPUTADORES 
GRADO EN INGENIERÍA INFORMÁTICA 
 
 
 
UNIVERSIDAD CARLOS III DE MADRID 
 
 
 
Práctica 1 
Representación de la Información 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Septiembre 2013 
1 
 
Contenido 
 
 
 
OBJETIVOS DE LA PRÁCTICA ................................................................................. 2 
EJERCICIO 1. ................................................................................................................. 3 
EJERCICIO 2. ................................................................................................................. 4 
EJERCICIO 3. ................................................................................................................. 5 
EJERCICIO 4. ................................................................................................................. 6 
EJERCICIO 5. ................................................................................................................. 7 
PROCEDIMIENTO DE EVALUACIÓN DE LA PRÁCTICA .................................. 8 
PROCEDIMIENTO DE ENTREGA DE LA PRÁCTICA ......................................... 9 
NORMAS ....................................................................................................................... 10 
 
 
2 
 
Objetivos de la práctica 
El objetivo de la práctica consiste en entender el formato de representación de los 
números en el computador. Para ello se propone el desarrollo de una serie de programas 
en C que permiten trabajar con los detalles relacionados con los números enteros y los 
números en coma flotante representados en el estándar IEEE 754, que es el que se 
emplea en la mayoría de los lenguajes de programación. 
Para el desarrollo de la práctica es necesario que el alumno repase: 
 Los diferentes operadores que ofrece C para trabajar con bits. En el siguiente 
enlace se puede obtener información sobre los diferentes operadores de bit de C. 
http://en.wikipedia.org/wiki/Bitwise_operations_in_C 
 La representación de números en coma flotante según el estándar IEEE754 de 
precisión simple. 
La práctica consistirá en realizar los siguientes ejercicios 
 Ejercicio 1: analizar el ancho de los tipos de datos float, double, int y long. 
 Ejercicio 2: obtener el valor de un número binario en complemento a 2. 
 Ejercicio 3: obtener el valor de un número binario en coma flotante según el 
estándar IEEE754. 
 Ejercicio 4: Sumar dos números binarios en complemento a 2 y obtener el valor 
de la suma. 
 Ejercicio 5: obtener el siguiente número representable dado un número en coma 
flotante según el estándar IEEE754. 
http://en.wikipedia.org/wiki/Bitwise_operations_in_C
3 
 
Ejercicio 1. 
a. Escriba un programa en C que calcule la siguiente serie: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Para ello se deben utilizar números en coma flotante de precisión simple 
(variables de tipo float) y números en coma flotante de precisión doble 
(variables de tipo double). El objetivo del programa es calcular la serie e indicar 
el número de iteraciones a partir del cual el resultado que se obtiene para Sn+1 es 
igual que el obtenido para Sn. 
b. Agregue una función al anterior programa que calcule el tamaño de una variable 
de tipo entero (variable de tipo int) y una variable de tipo entero largo (variable 
de tipo long). Para ello, el alumno programará un bucle en el cual la variable 
tendrá un valor inicial de 0 e irá incrementándose. En el momento en que la 
variable se desborde y pase a tener un valor negativo, el alumno deberá imprimir 
su valor y analizarlo para obtener cuantos bits forman el ancho del tipo de datos. 
Documentación a entregar: 
 E1-Series.c. Contiene el código fuente del programa conteniendo ambas 
funciones. El programa debe contener documentación describiendo el 
funcionamiento, así como la versión y el autor o autores del mismo. Para la 
realización de esta parte se usará como base el código entregado, donde vienen 
especificados los nombres de los métodos y el retorno de los mismos. 
 Además, se responderá en un apartado específico de la memoria a las siguientes 
preguntas: 
o ¿Cuál es el valor máximo de iteraciones con precisión simple? 
o ¿Cuál es el valor máximo de iteraciones con precisión doble? 
o ¿Cuál es el tamaño en bits del tipo int? 
o ¿Cuál es el tamaño en bits del tipo long? 
o ¿Qué ocurre con la precisión si en lugar de utilizar una máquina de 32 
bits pasamos a una de 64 bits, o viceversa? Justifique su respuesta 
 
 
4 
 
Ejercicio 2. 
Escriba un programa en C denominado E2-CompToInt.c, utilizando como base el 
código fuente entregado, que dado un número binario en complemento a 2 de 8 bits 
muestre su valor decimal. Para ello se debe rellenar la función comp2ToInt que se 
encuentra dentro del código base. 
 int comp2ToInt(bit* num) 
Función que recibe como parámetro un array de bits que representan un número 
binario en complemento a dos y retorna su valor entero. 
 
Documentación a entregar: 
 E2-CompToInt.c. Programa que se entrega como código fuente con la función 
comp2ToInt implementada. Se pueden agregar al programa funciones 
adicionales si se considera oportuno. El código debe contener documentación 
describiendo su funcionamiento, así como el nombre del o de los autores. 
NOTAS: 
 Considere n=8 bits para hacer el complemento a 2. 
 Se deben respetar los nombres asignados, así como los retornos 
especificados en el programa E2-CompToInt.c que se entrega. 
 No se pueden emplear funciones del API de C. 
 
 
5 
 
Ejercicio 3. 
Escriba un programa en C denominado E3-IEEE754ToFloat.c, utilizando como plantilla 
el programa entregado junto con la documentación, que recibe un número binario que 
representa un número en coma flotante según el estándar IEEE 754 de 32 bits y retorne 
su valor. La cadena que recibe el programa puede tener separados por un espacio la 
representación del signo, la representación del exponente y la representación de la 
mantisa de la siguiente forma: 
$ ./E3-IEEE754ToFloat 1 10100001 10101110100111111000000 
También puede introducirse el número en un solo argumento: 
$ ./E3-IEEE754ToFloat 11010000110101110100111111000000 
Para ello se debe rellenar la función IEEE754ToFloat que se encuentra dentro del 
código base. 
 float IEEE754Tofloat (bit* numero) 
Función que recibe como parámetro un array de bits que representan un número 
en coma flotante según el estándar IEEE754 de precisión simple y devuelve su 
valor decimal 
Ejemplo: 
Array de bits IEEE754 Valor 
0 10000011 10011001100110011001101 +25.6 
1 10000100 10101010000000000000000 -53.25 
Además se responderá en un apartado específico de la memoria a la siguiente pregunta: 
a) Calcular el número de números representables que hay entre 8 y 9, y entre 15 y 
16. ¿Dónde hay un número mayor de números representables? Justifique su 
respuesta. 
Documentación a entregar: 
 E3-IEEE754ToFloat.c: Programa que se entrega como código fuente con la 
función IEEE754Tofloat implementada. Se pueden agregar al programa 
funciones adicionales si se considera oportuno. El código debe contener 
documentación describiendo su funcionamiento, así como el nombre del o de los 
autores. 
NOTAS: 
 Se deben respetar los nombres asignados, así como los retornos 
especificados en el programa E3-IEEE754ToFloat.c que se entrega. 
 No se pueden funciones del API de C salvo la función pow que calcula la 
potencia de un número x elevado a un número y. Ver man pow para más 
información. 
 Se deben tener en cuenta los casos particulares del estándar: NaN, ±∞ y 
números no normalizados. 
 
6 
 
Ejercicio 4. 
Escriba un programa
en C denominado E4-Add.c, utilizando como plantilla el programa 
entregado junto con la documentación, que reciba dos números binarios en 
complemento a 2 de 8 bits, realice la suma bit a bit, y una vez obtenido el resultado en 
binario, obtenga su valor decimal de la misma manera que en el ejercicio 2. Para ello se 
debe rellenar la función add que se encuentra dentro del código base. 
 int add(bit* num1, bit* num2) 
Función que recibe como parámetro dos array de bits que representan dos 
números binarios en complemento a dos y retorna el valor entero de la suma de 
ambos. 
 
Documentación a entregar: 
 E4-Add.c: Programa que se entrega como código fuente con la función add 
implementada. Se pueden agregar al programa funciones adicionales si se 
considera oportuno. El código debe contener documentación describiendo su 
funcionamiento, así como el nombre del o de los autores. 
NOTAS: 
 Si se desea emplear código o funciones desarrollados en el Ejercicio 2, estos 
deben ser copiados al programa E4-Add.c 
 Se deben respetar los nombres asignados, así como los retornos 
especificados en el programa E4-Add.c que se entrega. 
 No se pueden funciones del API de C. 
 Se deberá realizar en primer lugar la suma bit a bit de los números 
binarios, y a partir del número resultante, obtener el valor decimal en un 
segundo paso. 
 En caso de desbordamiento el bit de acarreo será descartado. 
 
 
7 
 
Ejercicio 5. 
Escriba un programa en C denominado E5-NextUp.c, utilizando como plantilla el 
programa entregado junto con la documentación, que reciba un número binario que 
representa un número en coma flotante según el estándar IEEE 754 de 32 bits. devuelva 
el siguiente número representable. En caso de que el número sea 0, el método debe 
devolver el primer número no normalizado. En caso de que el número sea el mayor 
número normalizado, el programa debe devolver Infinity. Se deberá imprimir el valor 
decimal tanto del número como de su siguiente (puede utilizar para ello las funciones 
desarrolladas en el ejercicio 3). Se debe rellenar la función nextup que se encuentra 
dentro del código base. 
 void nextup(bit* num, bit* nextnum) 
Función que recibe dos parámetros. El primero es un array de bits que contiene 
el número a partir del cual se va a calcular el siguiente representable. El segundo 
es un array donde se va a almacenar el siguiente representable calculado. 
 
Documentación a entregar: 
 E5-NextUp.c: Programa que se entrega como código fuente con la función 
nextup implementada. Se pueden agregar al programa funciones adicionales si 
se considera oportuno. El código debe contener documentación describiendo su 
funcionamiento, así como el nombre del o de los autores. 
NOTAS: 
 Se deben respetar los nombres asignados, así como los retornos 
especificados en el programa E5-NextUp.c que se entrega. 
 No se pueden funciones del API de C salvo la función pow que calcula la 
potencia de un número x elevado a un número y. Ver man pow para más 
información. 
 Se deben tener en cuenta los casos particulares del estándar: NaN, ±∞ y 
números no normalizados. 
 Si se desea emplear código o funciones desarrollados en el Ejercicio 3, estos 
deben ser copiados al programa E5-NextUp.c 
 
 
8 
 
Procedimiento de evaluación de la práctica 
 
La evaluación de la práctica se va a dividir en dos partes. 
 Código (8 puntos) 
o Ejercicio 1 (1 puntos) 
o Ejercicio 2 (1.5 puntos) 
o Ejercicio 3 (1.5 puntos) 
o Ejercicio 4 (2 puntos) 
o Ejercicio 5 (2 puntos) 
 Memoria (2 puntos) 
Los ejercicios 1, 2, 3, 4 y la memoria son obligatorios. Deben entregarse para poder 
seguir la evaluación continua. 
 
9 
 
Procedimiento de entrega de la práctica 
La entrega de la práctica 1 se realizará de la siguiente manera: se habilitarán dos 
entregadores distintos, uno para los ejercicios de este cuaderno y otro para la memoria 
completa. La fecha límite de entrega es el día 25 de Octubre de 2013 a las 23:55 
horas. 
Entregador 1: Se deberá entregar un único archivo comprimido en formato zip con el 
nombre ec_p1_AAAAAAAAA_BBBBBBBBB.zip donde A…A y B…B son los NIAs 
de los integrantes del grupo. 
El archivo zip debe contener: 
 Bit-Library.c 
 Bit-Library.h 
 E1-Series.c 
 E2-CompToInt.c 
 E3-IEEE754ToFloat.c 
 E4-Add.c 
 E5-NextUp.c 
 Makefile 
Entregador 2: Se deberá entregar la memoria en un único archivo en formato pdf con 
el nombre ec_p1_AAAAAAAAA_BBBBBBBBB.pdf donde A…A y B…B son los 
NIAs de los integrantes del grupo. La memoria tendrá que contener al menos los 
siguientes apartados: 
o Portada donde figuren los autores (incluyendo nombre completo, NIA y 
dirección de correo electrónico). 
o Índice de contenidos. 
o Descripción de todos los programas C solicitados en este cuaderno de 
prácticas detallando las principales funciones implementadas. La memoria 
debe describir el comportamiento de los programas, así como las principales 
decisiones de diseño (adicionalmente se pueden incluir diagramas de flujo, 
algoritmos, etc.). 
o Las respuestas a las preguntas planteadas en los ejercicios debidamente 
justificadas. 
o Batería de pruebas utilizadas y resultados obtenidos. Se dará mayor 
puntuación a pruebas avanzadas, casos extremos, y en general a aquellas 
pruebas que garanticen el correcto funcionamiento de la práctica en todos los 
casos. Hay que tener en cuenta: 
o Que un programa compile correctamente y sin advertencias 
(warnings) no es garantía de que funcione correctamente. 
o Evite pruebas duplicadas que evalúan los mismos flujos de programa. 
La puntuación de este apartado no se mide en función del número de 
10 
 
pruebas, sino del grado de cobertura de las mismas. Es mejor pocas 
pruebas que evalúan diferentes casos a muchas pruebas que evalúan 
siempre el mismo caso. 
o Conclusiones y problemas encontrados. 
NOTA: NO DESCUIDE LA CALIDAD DE LA MEMORIA DE SU PRÁCTICA. 
Aprobar la memoria es tan imprescindible para aprobar la práctica, como el correcto 
funcionamiento de la misma. Si al evaluarse la memoria de su práctica, se considera que 
no alcanza el mínimo admisible, su práctica estará suspensa. 
La longitud de la memoria no deberá superar las 10 páginas (portada e índice 
incluidos) 
 La entrega de las prácticas ha de realizarse de forma electrónica. En AULA 
GLOBAL se habilitarán unos enlaces a través de los cuales podrá realizar la 
entrega de las prácticas. 
 
 La única versión registrada de su práctica es la última entregada. La valoración 
de esta es la única válida y definitiva. 
 
 
Normas 
1) Las prácticas que no compilen o que no se ajusten a la funcionalidad y requisitos 
planteados, obtendrán una calificación de 0. 
2) Un programa no comentado, obtendrá una calificación de 0. 
3) La entrega de la práctica se realizará a través de los entregadores habilitados. No se 
permite la entrega a través de correo electrónico sin autorización previa. 
4) Se prestará especial atención a detectar funcionalidades copiadas entre dos prácticas. 
En caso de encontrar implementaciones comunes en dos prácticas, ambas obtendrán 
una calificación de 0. 
 
EC Materiales/Examen-2A-grupo81_2014_sol (1).pdf
UNIVERSIDAD CARLOS III DE MADRID 
DEPARTAMENTO DE INFORMÁTICA 
GRADO EN INGENIERÍA INFORMÁTICA. ESTRUCTURA DE COMPUTADORES 
 18 de octubre de 2013. Grupo 81. Examen 2 
 
Para la realización del presente examen se dispondrá de 15 minutos. 
NO se podrán utilizar libros, apuntes ni calculadoras de ningún tipo. 
Responda en el espacio reservado. 
 
Grupo: Alumno:
. 
 
 
Ejercicio 1. Represente correctamente en hexadecimal usando el formato IEEE754 de 32 bits el valor 
(en decimal) -0,75. Indique brevemente los pasos de la conversión. 
 
Solución: 
 
-0,7510 = -0,112 x 2
0
 = -1,12 x 2
-1
 
 
Signo = 1 (negativo) 
Exponente = 01111110 (-1 exceso 127 = 126) 
Mantisa= 100… (con bit implícito) 
 
1 01111110 10000000000000000000000 => 1011 1111 0100 0000 0000 0000 0000 0000 
 0x B F 4 0 0 0 0 0 
 
 
 
Ejercicio 2. Considere un computador de 16 bits con las siguientes características: todas las 
instrucciones caben en una palabra, el banco de registros tiene 8 registros y el computador dispone de un 
juego de 15 instrucciones. Conteste correctamente a las siguientes cuestiones: 
 
a) Indique un posible formato para las siguientes instrucciones. 
 lw $t1, 80($t2) 
 addi $t1, $t2, 80 
 jal dirección 
b) En la última instrucción, ¿cuál será el espacio direccionable de memoria? 
 
Solución: 
 
a) lw $t1, 80($t2) 
 
CO (4 bits) Registro 1 (3 bits) Registro 2 (3 bits) Desplazamiento (6 bits) 
 
 addi $t1, $t2, 80 
 
CO (4 bits) Registro 1 (3 bits) Registro 2 (3 bits) Valor inmediato (6 bits) 
 
jal direccion 
 
CO (4 bits) Direccion (12 bits) 
 
b) Podremos direccionar desde la posición 0 de memoria hasta la posición 212-1 
 
 
 
Ejercicio 3. Considere el siguiente fragmento: 
 
.data 
 .align 2 
 v1: .word 1, 2, 1, 3, 2, 1, 2, 3, 0 
 
a) ¿Para qué sirve align? ¿Es necesario en la definición anterior? 
 
b) Codifique correctamente en ensamblador una subrutina denominada cuenta1 que cuente el 
número de números en el vector pasado por parámetro en $a0. Dicho vector está compuesto por 
una secuencia de números que terminan con el valor 0 (cero). 
Si es necesario, añada el código necesario para el uso de pila, si no lo es justifique por qué. 
 
c) Codifique correctamente una subrutina main que llame a la subrutina anterior usando el vector de 
enteros v1 con n elementos, tal y como está definido anteriormente. 
 
Solución: 
 
a) La instrucción align sirve para indicar la alineación de los elementos dentro de memoria, en este caso 
al poner align 2 estamos indicando que el siguiente elemento estará alineado a 2
2
, es decir, cualquier 
acceso a un elemento de memoria, se hará sobre una dirección alineada en memoria (múltiplos de 4). 
Es necesario puesto que la siguiente variable es un entero. 
 
b) y c) Una posible solución sería: 
 
.text 
.globl main 
 
cuenta1: li $v0 0 
 move $t0 $a0 
 bucle: lw $t1 ($t0) 
 beqz $t1 fin 
 add $v0 $v0 1 
 add $t0 $t0 4 
 b bucle 
 fin: jr $ra 
 
 main: # cuenta1(v1,n) 
 la $a0 v1 
 jal cuenta1 
 # exit 
 li $v0 10 
 syscall 
 
 No es necesario marco de pila puesto que cuenta1 es rutina terminal y solo modifica los $t.. y $v.. 
 En main no se utiliza los $t.. por lo que no es necesario salvaguardarlos. 
EC Materiales/InstruccionesFormato.pdf
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
Ej. El formato de instrucción de un procesador de una dirección tiene 6 bits para el código de operación y 
10 para la dirección del operando. Suponiendo que una instrucción de bifurcación, con direccionamiento 
relativo al contador de programa, almacenada en la posición 530 (en decimal), origina un salto a la 
posición 620 (en decimal). Si el código de operación de la instrucción de salto es 110011, ¿cuál es la 
codificación en binario de dicha instrucción? 
 
 Procesador de una dirección. 
 6 bits para el código de operación. 
 10 bits para la dirección de un operando. 
 Instrucción de bifurcación, con direccionamiento relativo al contador del programa, almacenada 
en la dirección DIR10=530 origina un salto a la posición DIR10=620. 
 El código de operación de la instrucción es 110011 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION : 
De acuerdo con el enunciado se tiene el siguiente formato de instrucción: 
COP 6 bits OPERANDO 10bits 
 
Una instrucción de bifurcación con direccionamiento relativo al contador de programa CP, se puede 
expresar de la siguiente forma: 
COP 6 bits DESPLAZAMIENTO 10bits 
 
Donde la dirección del operando se obtiene a partir de: 
Direccion final= PC + desplazamiento 
Sustituyendo los datos del enunciado se tiene: 
620 = 530 + desplazamiento 
 luego el desplazamiento es 90 
Si se pasa a binario el desplazamiento se tiene: 
Desplazamiento=90=64+16+8+2=2
6
+2
4
+2
3
+2 
Desplazamiento2=1011010 
En el enunciado nos dan el código de operación de la instrucción 110011 y acabamos de calcular el 
desplazamiento, que expresado sobre un tamaño de 10 bits toma la forma: 0001011010. Luego la 
instrucción pedida es: 
COP Operando 
110011 0001011010 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
Ej. Dado un procesador de 16 bits conectado a una memoria direccionada por bytes. El tamaño de la 
memoria principal viene determinado por el conjunto de posiciones direccionables en una palabra. El 
banco de registros incluye los registros de propósito general visibles al usuario (R0-R15).El juego de 
instrucciones esta formado por 180 instrucciones de máquina. 
Las direcciones y valores inmediatos son enteros de 16 bits 
Indique un formato posible de instrucciones 
a) LOAD R, inm carga en el registro R el valor inmediato inm 
b) STORE R,dir almacena el contenido de R en la dirección de memoria dir 
c) ADDI R1, R2, inm suma el contenido de R2 con el valor inm y deja el resultado en R1 
 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
a) LOAD R,inm 
 
Juego de instrucción 180 => necesarios 8 bits para su codificación 
16 registros de propósito general => 4 bits 
Dirección de memoria 16 bits (posiciones direccionables en una palabra y esta es de 16 bits) 
Valor inmediato => 16 bits 
 
No es suficiente una única palabra para representar la instrucción 
Palabra 1 
COP 8 bits R1 4 bits Sin uso 4 bits 
 
Palabra 2 
Inm 16 bits 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
b) STORE R1, dir 
Palabra 1 
COP 8 bits R1 4 bits Sin uso 4 bits 
 
Palabra 2 
Inm 16 bits 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
c) ADDI R1,R2,inm 
Palabra 1 
COP 8 bits R1 4 bits R2 4 bits 
 
Palabra 2 
inm 16 bits 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
 
Ej Partiendo de un procesador de 16 bits con un juego de 60 instrucciones máquina, se dispone de 
memoria direccionada a byte con un tamaño de 64KB.El banco de registros consta de 8 registros de 
propósito general. Diseñe el formato de la una instrucción que permita sumar dos registros y 
almacenar su resultado en una dirección de memoria. 
ADD R1 R2 MEM 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
 Al tener un juego de 60 instrucciones necesitamos al menos 6 bits para codificar su código de 
operación, en este caso ADD 
 Se disponen de 8 registros, luego serán necesarios tres bits para identificar cada uno de estos. En 
la instrucción aparecen dos registros de ahí que necesites 6 bits para su codificación. 
 La memoria permite direccionar hasta 64kb, lo que equivale a 16 bits 
 La palabra tiene un tamaño de 16 bits, por lo que la instrucción ocupará dos palabras, en la 
primera se codifica la operación y los 2 registros , quedan 4 bits sin utilizar y en la segunda la 
dirección con un tamaño de 16 bits con todos los bits utilizados 
 
ESTRUCTURA
DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
Ej. Partiendo de un computador con las siguientes características 
 Banco de registros de 32 registros de uso general de 32 bits 
 Operador con 40 operaciones aritméticas y lógicas 
 Bus de datos de 32 bits 
 Bus de dirección de 32 bits 
 Memoria con ancho de palabra de 32 bits y direccionamiento a nivel de byte 
 Juego de 1100 instrucciones 
El computador dispone de la siguiente instrucción 
POP despl($reg) 
Dicha instrucción saca de la pila el dato que se encuentra en la cima y lo almacena en la dirección de 
memoria indicada por su operando.Se utiliza un direccionamiento relativo al registro base. EL 
desplazamiento debe poder expresar saltos positivos y negativos de hasta 1 MB. 
Indicar el formato de la instrucción POP 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
A) El computador posee un juego de 1100 instrucciones, de ahí que sean necesarios 11 bits para la 
identificación del código de operación 
B) El numero de registros de uso general son 32 , empleando para ello 5 bits para la identificación 
de cada operando 
C) El desplazamiento de 1MB requiere 20bits (ver tabla correspondencia KB, MB,GB etc…), 
destacar que al ser posible realizar desplazamiento positivos y negativos es necesario indicar este 
hecho con un bit adicional que señalara el signo positivo o negativo del desplazamiento 
D) El tamaño de palabra es de 32 bits, al sumar los bits necesarios en los operandos y código de 
operación vemos necesario el uso de 2 palabras 
 
Palabra 1 
COP 11 bits R1 5bits sin uso 16 bits 
 
Palabra 2 
Desplazamiento 21 bits Sin uso 11 bits 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
Ej. Una arquitectura con tamaño de 20 bits , tanto palabra como registro, con 8 registros y un juego 
de 120 instrucciones. Todas las instrucciones presentan el siguiente formato y orden en caso de estar 
presentes todos los operadores 
COP DIR DESTINO DIR ORIGEN DESPLZ VALOR INMEDIATO 
 
En el caso de existir desplazamiento o valor inmediato en la instrucción será necesario 
maximizar su tamaño evitando bits sin asignar. En el caso de existir bits sin asignar se utilizaran 
los menos significativos (a la derecha) 
Asigne el formato adecuado para las siguientes instrucciones. 
a)ADDI Sumar de un valor inmediato sobre registro 
b) ADDR Suma en operación registro a registro 
c) ADDM Suma con direccionamiento absoluto en operaciones registro-memoria 
d)ADDRB suma con direccionamiento relativo a registro base 
e)ADDPC suma con direccionamiento relativo a contador de programa 
f)¿Cual es la dirección máxima direccionable? 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
 
a)ADDI Sumar de un valor inmediato sobre registro 
 
Siendo 120 el juego de instrucción utilizaremos al menos 7 bits para identificar cada operación 
El juego de registros es de 8, siendo por lo tanto necesarios 3 bits para identificar cada operador 
El resto de bits serán asignados al valor inmediato 
 
COP 7 bits DIR DESTINO 3 bits VALOR INMEDIATO 10bits 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
 
b) ADDR Suma en operación registro a registro 
AL igual que el caso anterior utilizaremos 7 bits para el código de operación , y 3 para cada uno 
de los 2 operadores que utilizaremos. El resto de bits 7, quedaran sin uso 
COP 7 bits DIR DESTINO 3 bits DIR ORIGEN 3 
bits 
0000000 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
 
c) ADDM Suma con direccionamiento absoluto en operaciones registro-memoria 
COP 7 bits DIR DESTINO 3 bits DIRECCION ABSOLUTA 10 bits 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
 
d)ADDRB suma con direccionamiento relativo a registro base 
COP 7 bits DIR DESTINO 3 bits REG DIR BASE 3 bits DESPL 7 bits 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
 
e)ADDPC suma con direccionamiento relativo a contador de programa 
COP 7 bits DIR DESTINO 3 bits DESPL 10 bits 
No es necesario conocer el valor del PC al ser implícito a la propia instrucción 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
 
f) ¿Cual es la dirección máxima direccionable? 
Son 10 bits luego 1024 posiciones 
 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
Ej. Dado un procesador de 16 bits que dispone de un banco de 6 registros y un espacio de 
direccionamiento de 64KB. La memoria se direcciona por bytes y requiere tres ciclos para las 
operaciones de lectura y escritura. La unidad ALU es capaz de realizar 20 operaciones 
aritméticas-lógicas . Asumiendo un código de operación fijo, diseñar el formato de instrucción 
que permita construir un juego de instrucciones con : 
a) 40 instrucciones aritmético-lógicas 
b) 5 direcciones de direccionamiento absoluto 
c) 5 direcciones de direccionamiento relativo a registro base con un desplazamiento 
máximo de 128 bytes 
d) 2 instrucciones de direccionamiento indirecto 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
Existen 52 instrucciones diferentes con lo que serán necesarios al menos 6 bits para codificar 
los diferentes códigos de operación 
Además existen 6 registros siendo necesarios a su vez 3 bits para su codificación 
El conjunto de direcciones de memoria puede ser representado mediante 16 bits (espacio 
direccionamiento 64Kb) 
Las operaciones que impliquen direccionamiento relativo a registro base requieren 7 bits, 
siendo 128 el desplazamiento máximo 
a) Operaciones aritmético-lógicas 
COP 6 bits R1 3 bits R2 3 bits R3 3 bits Sin uso 1 bit 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
Existen 52 instrucciones diferentes con lo que serán necesarios al menos 6 bits para codificar 
los diferentes códigos de operación 
Además existen 6 registros siendo necesarios a su vez 3 bits para su codificación 
El conjunto de direcciones de memoria puede ser representado mediante 16 bits (espacio 
direccionamiento 64Kb) 
Las operaciones que impliquen direccionamiento relativo a registro base requieren 7 bits, 
siendo 128 el desplazamiento máximo 
 
b) Direccionamiento absoluto 
COP 6 bits Sin uso 10 bits 
 
Dirección absoluto 16 bits 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
Existen 52 instrucciones diferentes con lo que serán necesarios al menos 6 bits para codificar 
los diferentes códigos de operación 
Además existen 6 registros siendo necesarios a su vez 3 bits para su codificación 
El conjunto de direcciones de memoria puede ser representado mediante 16 bits (espacio 
direccionamiento 64Kb) 
Las operaciones que impliquen direccionamiento relativo a registro base requieren 7 bits, 
siendo 128 el desplazamiento máximo 
 
c) Direccionamiento relativo 
COP 6 bits R1 3 bits Desplazamiento 7 bits 
 
 
 
ESTRUCTURA DE COMPUTADORES COLMENAREJO 
2013-2014 Ejercicios Viernes 
 
SOLUCION 
Existen 52 instrucciones diferentes con lo que serán necesarios al menos 6 bits para codificar 
los diferentes códigos de operación 
Además existen 6 registros siendo necesarios a su vez 3 bits para su codificación 
El conjunto de direcciones de memoria puede ser representado mediante 16 bits (espacio 
direccionamiento 64Kb) 
Las operaciones que impliquen direccionamiento relativo a registro base requieren 7 bits, 
siendo 128 el desplazamiento máximo 
 
d) Direccionamiento indirecto 
Similar al direccionamiento
absoluto 
COP 6 bits Sin uso 10 bits 
 
Dirección indirecta 16 bits 
 
EC Materiales/EC_practica3_2013-2014.pdf
 
 
 
ESTRUCTURA DE COMPUTADORES 
GRADO EN INGENIERÍA INFORMÁTICA 
 
 
 
UNIVERSIDAD CARLOS III DE MADRID 
 
 
 
Práctica 3 
Ensamblador de MIPS: Paso de 
parámetros entre subrutinas 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Noviembre 2013 
 
 
 
1. Objetivos de la práctica 
El objetivo de esta práctica es que el alumno se familiarice con la programación en 
ensamblador y el convenio de paso de parámetros a subrutinas en el ensamblador del 
MIPS32. 
Para alcanzar este objetivo el estudiante realizará la codificación en lenguaje 
ensamblador de una serie de funciones de las que se proporciona su código fuente en 
lenguaje C. 
Otro objetivo de la práctica es el trabajo en grupo, para ello, los alumnos deben 
repartirse las tareas y las funciones a desarrollar y posteriormente describir este reparto 
en el Ejercicio 4 
 
NOTA: Las subrutinas pedidas deben seguir OBLIGATORIAMENTE 
el nombre indicado en las siguientes secciones. Se ha de tener en cuenta 
que un nombre con mayúsculas es diferente de otro con minúsculas. 
Por ejemplo, los siguientes nombres corresponden a subrutinas 
diferentes: 
imprimir_entero, Imprimir_Entero, imprimir_ENTERO, etc. 
Observe que los nombres de función que se piden en esta práctica 
tienen todas sus letras en MINÚSCULAS. 
 
 
 
 
2. Convenio de paso de parámetros entre rutinas 
Operaciones básicas: apilar y desapilar 
Apilar 
sub $sp, $sp, 4 
sw $REG, ($sp) 
 
 
Desapilar 
lw $REG, ($sp) 
add $sp, $sp, 4 
 
 
La pila crece hacia direcciones de memoria más bajas. 
$p apunta al último dato en la pila. (OJO con esto: al último dato, NO al primer hueco 
libre). 
Convenio de uso de registros 
 Parámetros no flotantes: $a0, $a1, $a2, $a3, ---- si hay más de 4, el resto en la 
pila ---- 
 Parámetros flotantes: $f12, $f13, $f14, $f15, ---- si hay más de 4, el resto en la 
pila ---- 
 Parámetros flotantes doble precisión: $f12, $f14, ---- si hay más de 2, el resto 
en la pila ---- 
 Resultados no flotantes: $v0, $v1, ---- si hay más de 2, el resto en la pila ---- 
 Resultados flotantes: $f0, ---- si hay más de 1, el resto en la pila ---- 
Siempre que se pueda se deben usar registros, ya que es más rápido que usar la pila. 
Paso de parámetros con tipos de datos no básicos 
 Cadenas de caracteres: se pasa la dirección de comienzo de la cadena. 
 Arrays unidimensionales: se pasa la dirección de comienzo del array y el 
número de elementos 
 Arrays bidimensionales (solo en la práctica): se pasa la dirección de comienzo 
del array, el número de filas, y el número de columnas. 
Rutina A que llama a rutina B (B, terminal) 
Rutina A  Antes de llamar a B 
nueva cima 
 
 
cima 
nuevo $sp $sp 
cima 
 
 
REG 
(nueva cima) 
$sp nuevo $sp 
 
 
 
o Apilar $a que vaya a 
utilizar 
o Apilar $t que quiera 
conservar 
o Apilar $ra 
o Pasar parámetros en $a 
o Apilar (si no caben en 
regs) resto de parámetros 
de B 
 Llamar a B 
o jal B <Pasa a ejecutarse 
B> 
 Después de llamar a B 
o Desapilar parámetros de 
B (si hay) 
o Desapilar $ra 
o Desapilar $t (si se 
apilaron) 
o Desapilar $a 
 
 
 
 
 
 
 
 
 
 
 
 
Rutina B 
 Apilar registros (diferentes de $t 
y $v) que se vayan a modificar 
(p.ej. $s) 
 Acceder a los parámetros de la 
pila (sin desapilar) 
 <Ejecutar su código> 
 Desapilar registros que se hayan 
utilizado al principio (p. ej $s) 
 Retornar (jr $ra) 
 
 
 
 
 
Grado de Ingeniería en Informática Estructura de Computadores (2013-2014) 
Universidad Carlos III de Madrid 5 
 
Rutina A que llama a rutina C que a su vez llama a rutina B 
A y B igual que antes, pero A invocando a C en lugar de a B (A  C  B) 
C debe realizar los pasos del convenio de A y de B. 
Rutina C 
 Apilar registros (diferentes de $t y $v) que se vayan a modificar (p.ej. $s) 
 Acceder a los parámetros de la pila (sin desapilar) 
 <Ejecutar su código> 
 Apilar $a que vaya a utilizar 
 Apilar $t que quiera conservar 
 Apilar $ra 
 Pasar parámetros en $a 
 Apilar (si no caben en regs) resto de parámetros de B 
 Llamar a B (jal B) 
 Desapilar parámetros de B (si hay) 
 Desapilar $ra 
 Desapilar $t 
 Desapilar $a 
 <Seguir ejecutando su código> 
 Desapilar registros que se hayan utilizado al principio (p. ej $s) 
 Retornar a A (jr $ra) 
 
Grado de Ingeniería en Informática Estructura de Computadores (2013-2014) 
Universidad Carlos III de Madrid 6 
 
3. Ejercicios a desarrollar 
Recuerde que las rutinas implementadas tienen que seguir el convenio 
de paso de parámetros que se ha indicado anteriormente. En caso 
contrario, la práctica tendrá la calificación de 0. 
 
Ejercicio 1 
Implementar un programa matrix.s que contenga las siguientes subrutinas. En el 
material de apoyo de la práctica 3, que puede descargar en Aula Global 2, se dispone del 
fichero matrix.s, del que debe partir el alumno. 
 
El código que se muestra presenta dos operaciones de acceso a una matriz, get y set. En 
el caso de la función set, se devolverá un 0 si el cambio ha podido realizarse y un -1 en 
caso contrario. La función get devolverá dos enteros. El primero es el valor al que se 
quería acceder, y el segundo un código de finalización. Si la ejecución es correcta, se 
devolverá el valor solicitado y un 0. Si la ejecución es incorrecta, se devolverá un 0 y un 
-1 para indicar que el resultado no es válido. 
NOTA: el programa debe funcionar independientemente de los datos 
declarados en la zona de .data. 
 
Grado de Ingeniería en Informática Estructura de Computadores (2013-2014) 
Universidad Carlos III de Madrid 7 
 
Ejercicio 2 
Implementar un programa operations.s que contenga las siguientes subrutinas. En el 
material de apoyo de la práctica 3 se dispone del fichero operations.s, del que debe 
partir el alumno. 
 
 
Las subrutinas a desarrollar son sumar y multiplicar, que deberán realizar la suma y 
multiplicación de dos matrices respectivamente, dadas sus dimensiones. Los parámetros 
y valores de retorno deben seguir el orden que se muestra en la imagen anterior. 
Para desarrollar este programa deberá utilizar reserva dinámica de memoria, que se 
corresponde con la llamada al sistema 9. El resultado equivalente en ensamblador 
deberá ser la dirección de comienzo de la matriz resultado. 
Grado de Ingeniería en Informática Estructura de Computadores (2013-2014) 
Universidad Carlos III de Madrid 8 
 
También deberá emplear las subrutinas get y set del ejercicio anterior en el acceso a las 
matrices. 
NOTA: el programa debe funcionar independientemente de los datos 
declarados en la zona de .data. 
 
Grado de Ingeniería en Informática Estructura de Computadores (2013-2014) 
Universidad Carlos III de Madrid 9 
 
Ejercicio 3 
Implementar un programa axpy.s que contenga la subrutina descrita a continuación. En 
el material de apoyo de la práctica 3 se dispone del fichero axpy.s, del que debe partir el 
alumno. 
Se desea desarrollar una subrutina que realice la operación , donde A, X e Y 
son matrices. Se deberán utilizar las funciones desarrolladas previamente para la 
realización del ejercicio. Un ejemplo de código es el siguiente: 
 
La salida en este caso será: 
 
11 11 11 11 
22 22 22 22 
33 33 33 33 
44 44 44 44 
 
NOTA: el programa debe funcionar independientemente de los datos 
declarados en la zona de .data. 
 
 
Grado de Ingeniería en Informática Estructura de Computadores (2013-2014) 
Universidad Carlos III de Madrid 10 
 
Ejercicio 4 
En este ejercicio se solicita la
creación de un plan de trabajo detallado. Los alumnos 
deberán detallar como mínimo los siguientes puntos: 
 Reparto de tareas entre los miembros del grupo, tanto si se ha realizado a nivel 
de ejercicio o por funciones. 
 Planificación del tiempo de trabajo. 
 Comunicación entre los miembros del grupo (reuniones semanales, trabajo en 
mismo lugar…) 
 Herramientas utilizadas para la comunicación entre los miembros y envío del 
trabajo. 
 Método de unión de trabajo. 
 Plan de pruebas. 
 Evaluación del resultado de la planificación. 
NOTA: es obligatorio la realización de este ejercicio para aprobar la 
práctica, será evaluado como APTO o NO APTO. 
Grado de Ingeniería en Informática Estructura de Computadores (2013-2014) 
Universidad Carlos III de Madrid 11 
 
Ejercicio 5 
Implementar un programa axpy_flat.s que desarrolle un comportamiento equivalente al 
de axpy.s (con todas las subrutinas) SIN utilizar la pila para guardar ningún dato. Puede 
reservar espacio en la zona de datos o en memoria dinámica. En el material de apoyo de 
la práctica 3 se dispone del fichero axpy_flat.s, del que debe partir el alumno. 
Adicionalmente, deberá incluir en la memoria una comparación entre ambas versiones, 
detallando el número de registros utilizados, el número de líneas totales de la aplicación 
y el tamaño total utilizado en la zona de datos (si la cantidad varía en función del 
tamaño de las matrices, indíquelo de forma genérica). 
 
NOTA: el programa debe funcionar independientemente de los datos 
declarados en la zona de .data. 
 
Grado de Ingeniería en Informática Estructura de Computadores (2013-2014) 
Universidad Carlos III de Madrid 12 
 
Procedimiento de evaluación de la práctica 
La evaluación de la práctica se va a dividir en tres partes. 
 Parte Obligatoria (8 puntos) 
En esta parte se incluyen los ejercicios 2 y 3 de la práctica, así como la memoria 
de la misma. El reparto de puntuación dentro de la entrega obligatoria será el 
siguiente: 
o Ejercicio 1 (2 puntos) 
o Ejercicio 2 (3 puntos) 
o Ejercicio 3 (2 puntos) 
o Ejercicio 4 (APTO o NO APTO) 
No descuide la calidad de este ejercicio, un NO APTO en él supone un 
suspenso en la práctica 
o Memoria (1 punto) 
 Parte Opcional (2 puntos) 
El ejercicio 5 es de realización opcional. El reparto de puntuación dentro de esta 
entrega opcional será el siguiente: 
o Ejercicio 5 (1.5 puntos) 
o Memoria (0.5 puntos) 
Procedimiento de entrega 
La entrega de la práctica 3 se realizará de la siguiente manera: 
 La fecha de entrega de estos ejercicios podrá consultarse en Aula Global, en los 
entregadores habilitados a los efectos. 
 Entregador 1: Se deberá entregar un único archivo comprimido en formato zip 
con el nombre: 
ec_p3_AAAAAAAAA_BBBBBBBBB.zip 
donde A…A y B…B son los NIAs de los integrantes del grupo. El archivo zip 
debe contener: 
 matrix.s 
 operations.s 
 axpi.s 
 axpi_flat.s 
 
 
Grado de Ingeniería en Informática Estructura de Computadores (2013-2014) 
Universidad Carlos III de Madrid 13 
 
 Entregador 2: Se deberá entregar un único archivo pdf con el nombre: 
ec_p3_AAAAAAAAA_BBBBBBBBB.pdf 
donde A…A y B…B son los NIAs de los integrantes del grupo. La memoria 
debe contener al menos los siguientes apartados: 
 
o Portada donde figuren los autores (incluyendo nombre completo, NIA y 
dirección de correo electrónico) 
o Índice de contenidos. 
o Descripción de los programas solicitados. 
o Respuesta al ejercicio 4. 
o Batería de pruebas utilizadas y resultados obtenidos. 
o Conclusiones y problemas encontrados. 
 
NOTA: NO DESCUIDE LA CALIDAD DE LA MEMORIA DE SU PRÁCTICA. 
Aprobar la memoria es tan imprescindible para aprobar la práctica, como el correcto 
funcionamiento de la misma. Si al evaluarse la memoria de su práctica, se considera que 
no alcanza el mínimo admisible, su práctica estará suspensa. 
La longitud de la memoria no deberá superar las 20 páginas (portada e índice 
incluidos). 
 La entrega de las prácticas ha de realizarse de forma electrónica. En AULA 
GLOBAL se habilitarán unos enlaces a través de los cuales podrá realizar la 
entrega de las prácticas. 
 La única versión registrada de su práctica es la última entregada. La valoración 
de esta es la única válida y definitiva. 
 
 
Normas 
1. Las prácticas que no compilen o que no se ajusten a la funcionalidad y requisitos 
planteados, obtendrán una calificación de 0. 
2. Un programa no comentado, obtendrá una calificación de 0. 
3. La entrega de la práctica se realizará a través de los entregadores habilitados. No 
se permite la entrega a través de correo electrónico sin autorización previa. 
4. Se prestará especial atención a detectar funcionalidades copiadas entre dos 
prácticas. En caso de encontrar implementaciones comunes en dos prácticas, 
ambas obtendrán una calificación de 0. 
 
 
EC Materiales/EC_practica2_2013-2014.pdf
http://spimsimulator.sourceforge.net/
EC Materiales/Enunciado-2.pdf
Ejercicio 1 Sumar dos números 7 y 5 y mostrar por pantalla 
 .data 
 msg: .asciiz "Suma de dos numeros" 
 resultado: .asciiz "Resultado es : " 
 retorno: .asciiz "\n" 
 
 .text 
 .globl main 
 main: li $v0, 4 # syscall 4 (print_str) 
 la $a0, msg # argument: cadena string 
 syscall # llamada al sistema 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: cadena string 
 syscall # llamada al sistema 
 
 li $t1, 5 #carga de la constante 5 en el registro 
 li $t2, 7 #carga de la constante 7 en el registro 
 add $t1 ,$t1, $t2 #suma de los valores de los registros 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, resultado # argument: string 
 syscall # llamada al sistema 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 1 # syscall 4 (print_int) 
 move $a0, $t1 # copiamos el registro en $a0 
 syscall # print the string 
 
 jr $ra # devolucion llamada punto siguiente invocacion 
 
 
Ejercicio2. Solicite uno de los dos números y súmelos. Mostrar por pantalla el resultado 
 .data 
 msg: .asciiz "Sumar a 7 el numero:" 
 resultado: .asciiz "Resultado es : " 
 retorno: .asciiz "\n" 
 
 .text 
 .globl main 
 main: li $v0, 4 # syscall 4 (print_str) 
 la $a0, msg # argument: string 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 #Tomar por pantalla un valor entero 
 li $v0,5 #syscall 5 (read_int) 
 syscall 
 move $t1, $v0 
 
 li $t2, 7 
 add $t1 ,$t1, $t2 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, resultado # argument: string 
 syscall # print the string 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 1 # syscall 4 (print_int) 
 move $a0, $t1 # Copiamos valor en el registro esperado 
 syscall # print the string 
 
 jr $ra # Devolucion llamada 
 
Ejercicio 3 . Crear un programa que permita listar los elementos de un array. 
.data 
 msg: .asciiz "Listado array" 
 resultado: .asciiz "Valores almacenados son : " 
 retorno: .asciiz "\n" 
 arr: .word 100,200,300,400 
 indice: .word 1 
 .text 
 .globl main 
 main: li $v0, 4 # syscall 4 (print_str) 
 la $a0, msg # argument: string 
 syscall # print
the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 li $v0, 1 # syscall 4 (print_int) 
 lw $t3,arr($zero) 
 move $a0,$t3 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 li $v0, 1 # syscall 4 (print_int) 
 li $t2, 1 # argument: 1 
 mul $t2,$t2,4 
 lw $t3,arr($t2) 
 move $a0,$t3 #Copiar registro 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 li $v0, 1 # syscall 4 (print_int) 
 li $t2, 2 # argument: 2 
 mul $t2,$t2,4 
 lw $t3,arr($t2) 
 move $a0,$t3 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 li $v0, 1 # syscall 4 (print_int) 
 li $t2, 3 # argument: 3 
 mul $t2,$t2,4 
 lw $t3,arr($t2) 
 move $a0,$t3 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 1 # syscall 4 (print_int) 
 
 li $t2, 4 # argument: 4 
 mul $t2,$t2,4 
 lw $t3,arr($t2) 
 move $a0,$t3 
 syscall # print the string 
 jr $ra # Devolucion llamada a punto invocacion 
 
Ejercicio 4 . Multiplicar dos números positivos recogidos por pantalla.Si uno de los 
números es negativo no hacer nada y mostrar mensaje por pantalla. 
Multiplicamos los dos valores leidos desde el terminal del teclado 
 
 .data 
 msg: .asciiz "Multiplicacion 2 numeros por teclado" 
 valor1: .asciiz "Leer valor 1" 
 valor2: .asciiz "Leer valor 2" 
 resultado: .asciiz "Resultado es : " 
 retorno: .asciiz "\n" 
 
 .text 
 .globl main 
 main: li $v0, 4 # syscall 4 (print_str) 
 la $a0, msg # argument: string 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, valor1 # argument: string 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 #tomar por pantalla un valor entero 
 li $v0,5 #syscall 5 (read_int) 
 syscall 
 move $t1, $v0 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, valor2 # argument: string 
 syscall # print the string 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 
 #tomar por pantalla segundo entero 
 li $v0,5 #syscall 5 (read_int) 
 syscall 
 move $t2, $v0 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, resultado # argument: string 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 mul $t2,$t1,$t2 #multiplicamos dos enteros 
 li $v0, 1 # syscall 4 (print_int) 
 
 move $a0,$t2 
 syscall # print the string 
 
 jr $ra # Devolucion llamada 
 
Añadimos al código las comprobaciones oportunas sobre los valores recogidos y verificamos 
que sean mayores que cero. 
 .data 
 msg: .asciiz "Multiplicacion 2 numeros por teclado" 
 valor1: .asciiz "Leer valor 1" 
 valor2: .asciiz "Leer valor 2" 
 resultado: .asciiz "Resultado es : " 
 serror: .asciiz "Valor incorrecto !! " 
 retorno: .asciiz "\n" 
 
 .text 
 .globl main 
 main: li $v0, 4 # syscall 4 (print_str) 
 la $a0, msg # argument: string 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, valor1 # argument: string 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 #tomar por pantalla un valor entero 
 li $v0,5 #syscall 5 (read_int) 
 syscall 
 move $t1, $v0 
 bltz $t1,error 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, valor2 # argument: string 
 syscall # print the string 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 
 #tomar por pantalla segundo entero 
 li $v0,5 #syscall 5 (read_int) 
 syscall 
 move $t2, $v0 
 bltz $t2,error 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, resultado # argument: string 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 mul $t2,$t1,$t2 #multiplicamos dos enteros 
 li $v0, 1 # syscall 4 (print_int) 
 
 move $a0,$t2 
 syscall # print the string 
 b final 
 
 error: 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, serror # argument: string 
 syscall # print the string 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 final: 
 jr $ra # Devolucion llamada 
 
Ejercicio 5 En un determinado array de valores, identifique el mayor valor y muéstrelo 
por pantalla. 
 
 .data 
 msg: .asciiz "Listado array" 
 resultado: .asciiz "Valores almacenados son : " 
 maximo: .asciiz "Valor maximo es : " 
 retorno: .asciiz "\n" 
 arr: .word 10,200,30,40 
 indice: .word 1 
 .text 
 .globl main 
 main: li $v0, 4 # syscall 4 (print_str) 
 la $a0, msg # argument: string 
 syscall # print the string 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 1 # syscall 4 (print_int) 
 
 lw $t3,arr($zero) 
 move $t0,$t3 
 move $a0,$t3 
 syscall # print the string 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 1 # syscall 4 (print_int) 
 
 li $t2, 1 # argument: 1 
 mul $t2,$t2,4 
 lw $t3,arr($t2) 
 move $a0,$t3 
 syscall # print the string 
 
 bgt $t3,$t0,update1 
 b after1 
 update1: 
 move $t0,$t3 
 after1: 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 1 # syscall 4 (print_int) 
 
 li $t2, 2 # argument: 2 
 mul $t2,$t2,4 
 lw $t3,arr($t2) 
 move $a0,$t3 
 syscall # print the string 
 
 bgt $t3,$t0,update2 
 b after2 
 update2: 
 move $t0,$t3 
 after2:
li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 1 # syscall 4 (print_int) 
 
 li $t2, 3 # argument: 3 
 mul $t2,$t2,4 
 lw $t3,arr($t2) 
 move $a0,$t3 
 syscall # print the string 
 
 bgt $t3,$t0,update3 
 b after3 
 update3: 
 move $t0,$t3 
 after3: 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 1 # syscall 4 (print_int) 
 
 li $t2, 4 # argument: 4 
 mul $t2,$t2,4 
 lw $t3,arr($t2) 
 move $a0,$t3 
 syscall # print the string 
 
 bgt $t3,$t0,update4 
 b fin 
 update4: 
 move $t0,$t3 
 fin: 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, retorno # argument: string 
 syscall # print the string 
 
 li $v0, 4 # syscall 4 (print_str) 
 la $a0, maximo # argument: string 
 syscall # print the string 
 
 li $v0, 1 # syscall 4 (print_int) 
 
 move $a0,$t0 
 syscall # print the string 
 
 jr $ra 
 
Optimizar el código mostrado mediante el uso de un número menor de saltos y etiquetas 
 
 
 
 
 
Ejercicio 6 Crear un sistema de selección de butacas. El usuario podrá escoger el tipo de 
butaca a partir de una lista de posibles opciones 
 
# Ejercicio Seleccion 
.data 
 # Incluimos el salto de linea en la propia cadena 
 # a diferencia ejemplos anteriores que era independiente 
 opciones: .asciiz "Leer opcion 1-Fumador 2-No Fumador 3-VIP -Resto \n" 
 fumador: .asciiz "Asiento Fumador\n" 
 Nofumador: .asciiz "Asiento no fumador\n" 
 vip: .asciiz "Acceso VIP\n" 
 otros: .asciiz "Otros\n" 
 
.text 
.globl main 
main: 
 li $v0, 4 
 la $a0,opciones 
 syscall 
 
 #tomar por pantalla un valor entero 
 li $v0,5 #syscall 5 (read_character) 
 syscall 
 move $t1, $v0 
 
opcionUno: bne $t1, 1, opcionDos 
 la $a0, fumador 
 b fin 
opcionDos: bne $t1, 2, opcionTres 
 la $a0, Nofumador 
 b fin 
opcionTres: bne $t1, 3, opcionResto 
 la $a0, vip 
 b fin 
opcionResto: la $a0, otros 
 
 fin: li $v0, 4 
 syscall 
 li $v0, 10 #terminar ejecucion del programa 
 syscall 
EC Materiales/EC_practica4_2013-2014.pdf
ESTRUCTURA DE COMPUTADORES
GRADO EN INGENIERÍA INFORMÁTICA
UNIVERSIDAD CARLOS III DE MADRID
Práctica 4
Noviembre 2013
Contenido
 OBJETIVOS DE LA PRÁCTICA.............................................................................3
 DESCRIPCIÓN...........................................................................................................3
 EJERCICIO 1 .............................................................................................................4
 EJERCICIO 2..............................................................................................................5
 PROCEDIMIENTO DE EVALUACIÓN DE LA PRÁCTICA..............................6
 PROCEDIMIENTO DE ENTREGA........................................................................7
Objetivos de la práctica
El propósito de esta práctica es que el estudiante entienda el efecto de la memoria
caché en el rendimiento de un ordenador. Para ello, analizará cómo funciona una
memoria caché y cuáles son sus valores característicos.
Descripción
El alumno deberá analizar cuáles son los valores específicos de diferentes parámetros
para la caché del ordenador en el que se realiza la práctica. Para ello, se usará
programa calibrator disponible en Aula Global. Para obtener información adicional
del programa, consultar:
http://homepages.cwi.nl/~manegold/Calibrator/
Este programa permite extraer información del siguiente tipo:
- El número de niveles de caché.
- El tamaño de cada nivel de caché.
- El tamaño de cada línea.
Para ejecutar el programa, una vez descargado, se debe ejecutar el siguiente comando:
./calibrator MHz size filename
donde:
- MHz
o especifica la frecuencia de reloj en MHz
- size
o especifica el tamaño de la memoria usada en el análisis. Debe ser un
valor inferior al tamaño de la memoria principal, y superior que el
tamaño máximo esperado de la caché. El valor de size se expresa en
bytes, y se pueden usar los siguientes sufijos:
 k  kilo = 1024 bytes (Ej: 100k)
 M  Mega = 10242 bytes (Ej: 10M)
 G  Giga = 10243 bytes (Ej: 1G)
- filename
o es el nombre del fichero donde se almacenan los resultados del análisis
http://homepages.cwi.nl/~manegold/Calibrator/
Ejercicio 1 
La práctica se realizará en un computador con sistema operativo Windows. Para poder
ejecutar el programa anterior, el alumno deberá determinar y encontrar en primer
lugar la frecuencia de reloj del procesador y el tamaño de la memoria principal
instalada.
Para ejecutar el programa calibrator, el estudiante debe averiguar previamente la
frecuencia del reloj y el tamaño de la memoria principal.
A continuación se deben responder a las siguientes 6 preguntas:
1. ¿Cuál es la frecuencia de reloj en Mhz de la máquina en la que se realiza la
práctica? ¿Cómo lo ha obtenido?
2. ¿Cuál es el tamaño en GB de la memoria principal de la máquina en la que se
realiza la práctica? ¿Cómo lo ha obtenido?
3. ¿Cuántos niveles de caché tiene la máquina?
4. Para cada nivel de caché, indicar su tamaño en KB o MB.
5. Especificar cuál es el tamaño de línea de cada nivel.
6. Indicar el número de líneas de cada nivel de caché. Justifique su respuesta.
Ejercicio 2
El objetivo de esta segunda parte es que el alumno aprenda a determinar la tasa de
fallos que se produce en la ejecución de un programa. 
Considere el siguiente código:
int array [4194304];
int stride = 4;
for ( j = 0; j <= stride; j++)
{
for (i = j; i < array.length ; i = i + stride)
{
array[i] = 28;
}
}
Dadas las siguientes configuraciones de cache de datos:
[1] L1 de 32KB con un tamaño de línea de 64B
L2 de 256KB con un tamaño de línea de 64B
[2] L1 de 32KB con un tamaño de línea de 64B
L2 de 256KB con un tamaño de línea de 128B
[3] L1 de 32KB con un tamaño de línea de 64B
L2 de 256KB con un tamaño de línea de 64B
L3 de 4MB con un tamaño de línea de 64B
Tenga en cuenta que todas las caches son asociativas por conjuntos, con 8 vías en
L1 y L2, y 16 vías en L3. La política de reemplazo es LRU.
Usando estas configuraciones conteste a las siguientes preguntas de forma justificada:
1. El número de accesos a memoria debidos a la lectura/escritura del array
que se realizan.
2. Se deberá indicar de forma razonada el número de fallos de caché que se
produce en cada nivel, así como los pasos seguidos para calcularlos. De
nuevo, considere solamente los fallos producidos por el acceso al array.
Procedimiento de evaluación de la práctica
La evaluación de la práctica se va a realizar de la siguiente forma:
• Ejercicio 1 (3 puntos)
o Ejercicio 1.1 (0.5 puntos)
o Ejercicio 1.2 (0.5 puntos)
o Ejercicio 1.3 (0.5 puntos)
o Ejercicio 1.4 (0.5 puntos)
o Ejercicio 1.5 (0.5 puntos)
o Ejercicio 1.6 (0.5 puntos)
• Ejercicio 2 (6 puntos)
o Ejercicio 2.1 (3 puntos)
o Ejercicio 2.2 (3 puntos)
• Memoria (1 punto)
 
Procedimiento de entrega
La entrega de la práctica 4 se realizará de la siguiente manera: los ejercicios de este
cuaderno y la memoria completa podrá entregarse hasta el día 13 de Diciembre de
2013 a las 23:55 horas.
Entregador: Se deberá entregar la memoria en un único archivo en formato pdf con el
nombre ec_p4_AAAAAAAAA_BBBBBBBBB.pdf donde A…A y B…B son los NIAs
de los integrantes del grupo. La memoria tendrá que contener al menos los siguientes
apartados: 
o Portada donde figuren los autores (incluyendo nombre completo, NIA y
dirección de correo electrónico)
o Índice de contenidos.
o Respuestas a las preguntas planteadas en los ejercicios debidamente
justificadas.
o Conclusiones y problemas encontrados. 
NOTA: NO DESCUIDE LA CALIDAD DE LA MEMORIA DE SU PRÁCTICA.
Aprobar la memoria es tan imprescindible para aprobar la práctica, como el correcto
funcionamiento de la misma. Si al evaluarse la memoria de su práctica, se considera
que no alcanza el mínimo admisible, su práctica estará suspensa.
La longitud de la memoria no deberá superar las 15 páginas (portada e índice
incluidos)
 La entrega de las prácticas ha de realizarse de forma electrónica. En AULA
GLOBAL se habilitarán unos enlaces a través de los cuales podrá realizar la
entrega de las prácticas.
 La única versión registrada de su práctica es la última entregada. La
valoración de esta es la única válida y definitiva.
Normas
1) La entrega de la práctica se realizará a través de los entregadores habilitados. No
se permite la entrega a través de correo electrónico sin autorización previa.
2) Se prestará especial atención a detectar funcionalidades copiadas entre dos
prácticas. En caso de encontrar implementaciones comunes en dos prácticas,
ambas obtendrán una calificación de 0.
		Objetivos de la práctica
		Descripción
		Ejercicio 1
		Ejercicio 2
		Procedimiento de evaluación de la práctica
		Procedimiento de entrega
EC Materiales/Ejercicios clase2 practicas.pdf
Coma Flotante 
Prácticas 
Estructura de Computadores 2013/14 
• Ejercicio 1. Represente en el estándar IEEE 
754 de simple precisión los números 14 y 3.5 
 
Estructura de Computadores 2013/14 
• Número 14 
• 14 en binario=1110 
• Normalizado 1,110 x 23 
• Exponente = 3 +127=130 en binario 10000010 
 
 
S Exponente Mantisa 
0 10000010 11000000000000000000000 
Estructura de Computadores 2013/14 
• Número 3.5 
• 3.5 en binario =11,1 
• Normalizado 1,11 x 21 
• Exponente =1 + 127=128 
 
 S Exponente Mantisa 
0 10000000 11000000000000000000000 
Estructura de Computadores 2013/14 
• Ejercicio 2. Realice la suma de los números 
anteriores, 14 y 3.5, representados en el 
estándar IEEE 754 
 
Estructura de Computadores 2013/14 
• Analizar exponentes de ambos numeros y alinear en caso necesario 
– 130 frente a 128 es decir una diferencia de -2 
• Alineamos la mantisa del segundo número 3.5 desplazando la coma 
dos posiciones 
• 1,11000000000000000000000 desplazamos dos posiciones y 
obtenemos 0,0111 
• Sumamos 
 1,11 + 
 0,0111 
10,0011 
• Normalizamos 1,00011 x 21 y obtenemos un nuevo exponente el 
cual sumaremos al exponente 130.Finalmente obtenemos un 
exponente de 131 
 
 
S Exponente Mantisa 
0 10000011 00011000000000000000000 
Estructura de Computadores 2013/14 
• Ejercicio 3. Realice el producto de los números 
anteriores, 14 y 3.5, representados en el 
estándar IEEE754 
Estructura de Computadores 2013/14 
• 14 normalizado 1,110 x 23 
• 3.5 normalizado 1,11 x 21 
 
 1,110 
X 1,11 
 111 
 111 
 111 
1,10001 
 
Sumamos los exponentes 2 (3+1) y obtenemos 
1,10001 x 24 
 
 
 
S Exponente Mantisa 
0 10000100 10001000000000000000000 
Estructura de Computadores 2013/14 
• Ejercicio 4. Represente los números 14 y 3,5 
utilizando la representación en coma flotante 
de 16 bits 
 
 S 1 bit Exponente 5 bits Mantisa 10 bits 
Estructura de Computadores 2013/14 
• Exceso 15 = 2n-1-1= 25-1-1 
• 1410=1110 
• 1,110 x 23 Exponente 15+3=18 
 
 
0 10010 1100000000 
Estructura de Computadores 2013/14 
• 3.510=11,1 
• 1,11 x 21 Exponente 15+1=16 
 
 
0 10000 1100000000 
Estructura de Computadores 2013/14 
• Ejercicio 5. Indicar el valor decimal de los 
siguientes números hexadecimales que siguen 
el formato de coma flotante IEEE 754 
 0xFF800000 
 
Estructura de Computadores 2013/14 
• Ejercicio 5. Indicar el valor decimal de los 
siguientes números hexadecimales que siguen 
el formato de coma flotante IEEE 754 
 0xFF800000 
1 11111111 00000000000000000000000 
Infinito (Consultar casos especiales y tener en cuenta 
el signo) 
 
Estructura de Computadores 2013/14 
• Ejercicio 5. Indicar el valor decimal de los 
siguientes números hexadecimales que siguen 
el formato de coma flotante IEEE 754 
 0x7F804000 
 
Estructura de Computadores 2013/14 
• Ejercicio 5. Indicar el valor decimal de los 
siguientes números hexadecimales que siguen 
el formato de coma flotante IEEE 754 
0x7F804000 
0 11111111 00000000100000000000000 
NaN Non is a Number (ver casos especiales) 
 
Estructura de Computadores 2013/14 
• Ejercicio 5. Indicar el valor decimal de los 
siguientes números hexadecimales que siguen 
el formato de coma flotante IEEE 754 
 0xC7B00000 
 
Estructura de Computadores 2013/14 
• Ejercicio 5. Indicar el valor decimal de los 
siguientes números hexadecimales que siguen 
el formato de coma flotante IEEE 754 
0xC7B00000 
1 10001111 01100000000000000000000 
 
Estructura de Computadores 2013/14 
• Ejercicio 6 Representar el numero 
A = 0,11010001 * 210100 según el IEEE-754 de 
simple precisión. Traslade el resultado 
obtenido a una representación hexadecimal. 
 
Estructura de Computadores 2013/14 
• A = 0,11010001 * 210100 = 1,1010001 * 210011 
• El exponente más el sesgo(127) vale: 
 00010011 (19) 
+ 01111111 (127) 
 10010010 (146) 
 
 
 
Valor hexadecimal 0x49510000 
 
0 10010010 10100010000000000000000 
Estructura de Computadores 2013/14 
• Ejercicio 6. Realice la siguiente suma 
4C740000 y 49840017 
• A=4C740000 y B=49840017 
 
 
Estructura de Computadores 2013/14 
• A → 0 10011000 11101000000000000000000 
Mantisa A = 1’11101000000000000000000 
Exponente A = 10011000 = 152 
• B → 0 10010011 00001000000000000010111 
Mantisa B= 1’00001000000000000010111 
Exponente B = 10010011 = 147 
 
Estructura de Computadores 2013/14 
• Alinear mantisas: Expa- Expb = 5 → desplazar 
Mantisa de B 5 lugares a la derecha 
• Mantisa B= 
0’0000100001000000000000010111 
Estructura de Computadores 2013/14 
• Sumar las mantisas 
M = Mantisa A + Mantisa B = 
1’1111000001000000000000010111 
 
Se normaliza en caso de ser necesario 
Estructura de Computadores 2013/14 
• Resultado 
 0 10011000 11110000010000000000001 
 
Estructura de Computadores 2013/14 
• Ejercicio 7 Realice la siguiente operación de 
resta entre los siguientes números en coma 
flotante 
Numero A 
 
Numero B 
 
0 01111110 10101000000000000000000 
0 10001001 10000111110010000000000 
Estructura de Computadores 2013/14 
• Comparar exponentes y alinear en caso de ser 
distintos 
Exponente A = 126 
Exponente B = 137 
Desplazamos el numero B en 11 posiciones hasta alinear 
con el exponente del número B 
 
 
Mantisa=1, 10101000000000000000000 
Mantisa desplazada 11 posiciones obtenemos= 
0,0000000000110101000000 
 
0 01111110 10101000000000000000000 
Estructura de Computadores 2013/14 
• Una aplicación del complemento a 2 es 
facilitar la operación de resta, 
complementando a 2 el sustraendo 
C2 de 1000111110010000000000 = C1 + 1 
C1 es = 011100000110111111111111 
 
 C1 
+ 1 
1110000011100000000000 
 
Estructura de Computadores 2013/14 
• Sumamos estos números 
Signo Mantisa 
0 00000000000110101000000 
1 01110000011100000000000 
 
Donde vemos que el resultado es un número 
negativo