fsddddddeICC-133 FUNDAMENTOS SISTEMAS

COMPUTACIONALES
Examen Midterm – Parte #1

Nombre Matrícula

P1 P2 P3 P4 P5 P6 P7 P8 P9 TOTAL

Punto 1 (8 puntos)
Para el siguiente problema asuma lo siguiente:
• Estamos corriendo el código en una máquina de 6 bits que usa complemento a dos para los
números con signo.
• Los enteros tipo short son codificados usando 3 bits.
• Cada vez que un short se convierte a int, se realiza una extensión de signo.
• El desplazamiento a la derecha para el tipo int es aritmético.
Llene los espacios en blanco de la tabla de más abajo. Las siguientes definiciones son usadas en la tabla:
short sy = -3; int y = sy; int x = -13;
unsigned ux = x;

Expresión Representation Decimal Representación Binaria

Cero 0 00 0000
- -3 11 1101

- 18 01 0010

- -1 11 1111

ux 51 11 0011

y -3 111 101

x >> 2 -4 11 1100

TMax 31 01 1111

TMin -32 10 0000

TMin + TMax -1 11 1111

Problema 2

(10 puntos)
Considere el siguiente formato de punto flotante de 8 bits basado en el estándar IEEE 754.
• Hay un signo de bit en el bit más significativo.
• Los próximos tres (3) bits son el exponente. El sesgado (bias) del exponente es 2 3-1 = 3.
• Los últimos cuatro (4) bits son la parte fraccionaria.
• La representación codifica números de la forma V = (-1) s x M x 2E, donde M es el significando y E
es el exponente sesgado.
Las reglas son parecidas al estándar IEEE (números normalizados, no normalizados, infinito, NAN, etc.).
LLENE los espacios en blanco. Aquí están las instrucciones para cada campo.
• Binary: la representación binaria de cada número.
• M: el valor del significando. Este debe ser un numero de la forma x/y, donde x es un entero y y
es una potencia entera de dos.
• E: El valor entero del exponente.
• Value: El valor numérico representado.

(4 puntos).
La siguiente rutina en C esta supuesta a tomar un entero sin signo de 8 bits, e imprimir con conteo
regresivo a partir del valor del mismo hasta el valor de cero (incluyéndolo ese valor), pero el código no
parece funcionar correctamente.
void regresive_count(unsigned char counter)
{
// Iterate until zero inclusive
while (counter >= 0)
{
// Print counter value
Problema 3

printf("Counter = %u\n", counter);

if (counter == 0) {
break;
}

// Decrement counter
counter = counter – 1;
}
}

Se pide contestar las siguientes preguntas:

a. ¿Qué imprime el código realmente cuando se invoca con el valor 4? (1 punto)
4,3,2,1,0,255,254,253, etc. De esta forma realiza un bucle infinito, volviendo desde 0 a 255 hasta
bajar a cero y volver a repetirse.

b. Analizando el código, ¿a qué se debe el funcionamiento incorrecto? (1 punto)

Una vez analizamos el código ; Me percate que cuando la variable (counter = 0) esta en binario seria
00000000 entonces al decir (counter – 1 = 11111111) pero como la variable es tipo unsigned (Sin
signo) esta toma el valor sin signo más alto de 8 bits que es 255.

c. Provea una implementación correcta de la misma para cualquier valor del parámetro de entrada sin
signo de 8 bits. (2 puntos)
Para este punto:
• No puede cambiar el prototipo de la función, es decir ni el nombre ni el nombre ni tipo de
parámetro de entrada.
• Puede crear variables nuevas con el tipo y tamaño que desee.
• Puede usar las estructuras de control de flujo que desee.
• Puede implementar la función desde cero.
void regresive_count(unsigned char counter)
{
while(counter >= 0){
printf("%u \n",counter);

if(counter == 0){
break;
};
counter = counter - 1;
}
};
(4 puntos).
A usted se le pide que cree una rutina que toma una dirección de cache y la divida en sus tres partes tag,
set y block. Si las direcciones se representan por un entero sin signo de 32 bits, y para este cache
Problema 4

especifico los bits de set s son 5 bits y los de bloque b son 6 bits. (El número de bits del tag t esta dado
de forma implícita.
Complete la siguiente función para descomponer la dirección virtual en sus componentes individuales:

#include <stdint.h>

void parse_address(uint32_t address, uint32_t* tag, uint32_t* set,

uint32_t* block)
{
// Get address components

*tag =

X = 000000...

x-1 = 111111...

x>>11

x<<11

*set =

X = 000000...

x-1 = 111111...

x>>27

x<<5

x>>6

*block =

x = 000000...

x-1 = 111111...

x>>26

}
Punto 5 (3 puntos)

Suponga que se le ha asignado la tarea de crear código para multiplicar una variable entera x (con signo)
por varios factores constantes K. Para ser eficiente, usted solo quiere usar las operaciones +, -, <<. Para
los siguientes valores de K, escribe expresiones de C que realicen las multiplicaciones, usando como
mucho tres (3) operaciones de las descritas anteriormente.
a) K = 17:

K=16 x + x=(x ≪ 4 + x)

b) K = −7:

K= x−8 x=(x−x ≪3)

c) K = 60:

K=64 x−4 x=(x ≪6−x ≪ 2)

d) K = −112:

K=16 x −128 x=(x ≪ 4−x ≪7)

2,4,8,16,32,64,128,256