arqcomp: Práctico 1 - Ejercicio 8

Buenas, unas consultas sobre las sumas que pide los valores de las flags Z, N, C y V para:

A) 2977 + 5689:

1111 1111 1111 111

+ 0x2977 = 0010 1001 0111 0111 b

0x5689 = 0101 0110 1000 1001 b

---------------- ------------------------------

0x8000 1000 0000 0000 0000 b = 0

= 8 = 0 = 0 = 0 (bit a bit)

Las flags quedarían:

Z = 1 ya que el resultado es 0 "negativo"?

N = 1 ya que el BMS = 1?

C = 0 ya que el último carry es 0? No entendí lo de que hay que fijarse los últimos dos.

V = 0 ya que no se fue de rango?

Ahora el resultado no es 8000 h, sino 0 en C2?

B) CAFE + B007 = 1 0111 1011 0000 0101 b

Z = 0 ya que el resultado es distinto de 0

N = 0 ya que el BMS dentro del rango de la representación es 0?

C = 1 ya que el último carry es 1?

V = 1 ya que hay overflow?

El resultado sería 7B05 pero debería ser 17B05 pero se va de rango?

C) F21C + 0DE4 = 1 0000 0000 0000 0000

Z = 1 ya que el resultado es 0 (sin contar el 1 que se fue de rango?)

N = 0 ya que el BMS dentro del rango de la representación es 0?

C = 1 ya que el último carry es 1?

V = 1 ya que hay overflow?

El resultado sería 0 pero debería ser 10000 pero se va de rango?

D) 5789 - 021F = 1 0101 0101 0110 1010

Z = 0 ya que el resultado es distinto de 0

N = 0 ya que el BMS dentro del rango de la representación es 0?

C = 1 ya que el último carry es 1?

V = 0 ya que no hay overflow?

El resultado sería 556A (el 1 se "desprecia o elimina)", y el resultado es el correcto?

Perdón que ya hay consultas sobre este ejercicio pero no me quedó claro.

Desde ya muchas gracias.

Saluda,

Verónica.

Re: Práctico 1 - Ejercicio 8

de Gustavo Brown - jueves, 18 de octubre de 2018, 15:34

Recordar que el ejercicio es sobre números en complemento a2. No existen "0 positivo" y "0 negativo" en complemento a2.

La flag de Z vale 1 si el resultado es 0 y vale 0 en otro caso.

La flag de N vale 1 si el resultado es negativo (que se puede ver mirando el bit más significativo del resultado, o sea si el resultado >= 0x8000 y <= 0xFFFF).

Entonces:

Para caso A (0x2977+0x5689 = 0x8000):

Z = 0 ya que el resultado no es 0

N = 1 ya que el número es negativo (BMS = 1)

C = 0 ya que el último carry es 0

V = 1 ya que el resultado se fue de rango (suma 2 positivos y el resultado da negativo)

B) CAFE + B007 = 1 0111 1011 0000 0101 b

Z = 0 ya que el resultado es distinto de 0

N = 0 ya que el BMS es 0

C = 1 ya que el último carry es 1

V = 1 ya que hay overflow (el resultado es positivo cuando ambos sumandos son negativos)

C) F21C + 0DE4 = 1 0000 0000 0000 0000

Z = 1 ya que el resultado es 0

N = 0 ya que el BMS dentro del rango de la representación es 0

C = 1 ya que el último carry es 1

V = 0 ya que no hay desbordamiento (la operacion es (-0x0DE4) + 0xDE4)

D) 5789 - 021F = 0x5789 + (-0x021F) = 0x5789 + 0xFDE1 = 0x556A 1 0101 0101 0110 1010

Z = 0 ya que el resultado es distinto de 0

N = 0 ya que el BMS es 0

C = 1 ya que el último carry es 1

V = 0 ya que no hay overflow

Notar que en esta última operación estoy haciendo siempre una suma binaria, estoy calculando el carry out y no el borrow in.

Saludos,
Gustavo

Re: Práctico 1 - Ejercicio 8

de Veronica Viviana Pintos Fernandez - jueves, 18 de octubre de 2018, 17:08

Muchas gracias Gustavo por tus respuestas!

Igualmente me quedaron algunas dudas:

C) V = 0 ya que no hay desbordamiento (la operacion es (-0x0DE4) + 0xDE4)

Esto se debe a que si se mira la representación en C2, se ve que son "opuestos"? Por qué se toma -0x0DE4 y 0xDE4 y no -0xF21C y 0xF21C? O es lo mismo?

D) 5789 - 021F = 0x5789 + (-0x021F) = 0x5789 + 0xFDE1 = 0x556A 1 0101 0101 0110 1010

Si hago la suma en hexadecimal de 0x5789 + 0xFDE1 = 0x1556A. El 1 se desprecia ya que se va de rango? Es lo mismo que sucede con la suma en C2 con el último carry = 1?

Por qué se dice que no hay overflow para este caso si el resultado debería ser mayor (0x1556A)? O se debe interpretar que el resultado de 5789 - 021F (cuenta original) es 0x556A? Para decir si hay overflow o no se deben ver los operando en C2 y no qué resultado darían en hexadecimal?

Saluda,

Verónica.

Re: Práctico 1 - Ejercicio 8

de Gustavo Brown - lunes, 22 de octubre de 2018, 15:23

Sobre C). Mi respuesta va en la línea de mostrar que no debe haber desbordamiento porque estás sumando 2 números opuestos. También es cierto que si tomaras el opuesto de 0xDE4 = -0XF21C llegarías a la misma conclusión.

O sea, 0xF21C + 0x0DE4 = 0xF21C - (-0x0DE4) = 0xF21C - 0xF21C = 0 y se ve directamente de la ecuación que no debe haber desbordamiento porque la suma original era sobre 2 números opuestos.

Sobre D). El 1 ese se va porque estás operando con números de 16 bits (4 nibbles). O sea el resultado de 0x5789-0x021F es 0x556A.

No hay overflow porque, más allá de la regla de cálculo UltimoCarry XOR PenúltimoCarry = 0, el resultado de la operación (truncado a 16 bits) es correcto si se interpreta en complemento A2. El resultado de la suma no depende de la base en que operes.

Lo de mirar los ultimos 2 carrys de la suma binaria es una regla de cálculo. .

Saludos,
Gustavo

Re: Práctico 1 - Ejercicio 8

de Veronica Viviana Pintos Fernandez - jueves, 18 de octubre de 2018, 18:43

Agrego a lo anterior, si me podes explicar lo de carry out y borrow in.

Muchas gracias!

Re: Práctico 1 - Ejercicio 8

de Gustavo Brown - lunes, 22 de octubre de 2018, 16:29

Verónica,

Cuando hablamos de una suma el carry out es el acarreo del último bit en la suma.

El borrow out vendría a ser la contraparte para el caso de la resta e indica si "le pedí prestado un uno a la izquierda" en el bit más significativo.

Ahora bien (y esto no es parte del práctico 1 sino de temás más avanzados en el curso) desde el punto de vista práctico (por ejemplo de implementación de una ALU para una CPU), hay dos variantes en el cálculo y uso de las flags para la resta y todo esta un poco atado al uso que se le va a dar a la ALU en la implementación de una CPU.

Primero que nada conviene aclarar que en general en una CPU hay 2 instrucciones distintas para la suma de dos operandos A y B. Una de ellas computa A+B y otra computa A+B+CarryIn. Ésta segunda operación sirve para encadenar sumas y en este caso el CarryIn es la flag de Carry de la CPU.

Por otro lado una CPU en general también tiene 2 variantes para la resta: una que tiene en cuenta el borrow in (y sirve para encadenar restas) y otra que no lo tiene. Pero en general las CPUs no tienen una flag de Borrow sino que usan la misma flag de Carry para esto. Y por aca es donde aparecen las 2 variantes para el cálculo y uso de la flag en el caso de la resta:

- En una variante la resta de A-B puede verse como la suma de A y el opuesto de B, o sea A + (-B) y se calcula el carry out tal cual lo vimos en la suma. Con este algoritmo si A=1 y B=1 el carry queda en 1 aunque claramente si hago la resta binaria no le tengo que pedir nada en el último bit.

- En la otra variante podemos ver la resta como si la hiciésemos directamente en binario A - B y en ese caso la flag de carry queda en 1 si le "pedí prestado" un 1 en el digito más significativo. En ese caso si A=1 y B=1 la flag de carry queda en 0 porque no le pedí nada en el último bit.

Luego la variante de la instrucción de la resta que sirve para encadenar restas (A-B-BorrowIn) opera teniendo en cuenta cómo se calculó la flag de carry en la resta (cual de las 2 variantes).

Saludos,
Gustavo

Re: Práctico 1 - Ejercicio 8

de Veronica Viviana Pintos Fernandez - martes, 23 de octubre de 2018, 23:14

Muchas gracias Gustavo por ambas respuestas. Las de las partes C y D me quedaron claras la del carry y borrow no mucho, cito unos ejemplos:

Suma:

A) B)

1 0 0 <- acarreo -> 0 1 0

1 1 0 0 1 0

+ 1 0 1 + 0 1 1

----------- ------------

1 0 1 1 1 0 1

El carry out (acarreo del último bit en la suma) = 1 (A) / 0 (B)?

El carry (flag C) es también 1 (A) y 0 (B). Carry (asecas) = Carry.

Si es así no me queda clara la diferencia entre Carry in y Carry out.

Resta:

A) B)

0 0 1 <- acarreo -> 0 1 1

1 1 0 1 1 0

- 0 0 1 - 0 1 1

----------- ------------

1 0 1 0 1 1

El borrow in (le pedí prestado un uno a la izquierda en el bit más significativo) = 0 (A) y 1 (B)?

Borrow out existe?

Re: Práctico 1 - Ejercicio 8

de Gustavo Brown - miércoles, 24 de octubre de 2018, 12:42

Sobre el caso de la suma:

En esas sumas los bit de Carry son efectivamente 1 para el ejemplo de la izquierda y 0 para el de la derecha.

Si esa suma fuese el resultado de una instrucción en una CPU típica el bit de carry de las flags de dicha CPU quedaria con 1 (ejemplo de la izquierda) y 0 (ejemplo de la derecha).

Luego en esta CPU podrias tener una instrucción (llamémosle ADC, "add with carry ") que toma en cuenta el bit de carry de las flags y lo usa como entrada de CarryIn de la ALU (o sea que calcula A+B+Carry)

Sobre el caso de la resta, primero una aclaración mirando mi respuesta anterior. En la ALU el bit de salida que indica que el bit más significativo le pide prestado 1 se llamaría "Borrow out" y no "Borrow in" como había puesto en el mensaje anterior.

Luego en tus ejemplos para la resta estas marcando en negrita el penúltimo bit, no el último que es el que tendrias que mirar.

Si la ALU calcula la resta con el algoritmo de la resta, el bit de "Carry out" pasa a llamarse "Borrow out" y vale 1 si le pediste 1 en el último bit y 0 en caso contrario. Entonces en tu ejemplo A) el "Borrow out" valdría 0 porque el ultimo bit resta 1-0

En el caso B) también vale 0 porque el ultimo bit no requiere pedir a la izquierda.

O sea, con tu diagrama seria así (marcado en negrita el Borrow out")

A)                                      B)                           
 0 0 1              <- acarreo ->          0 1 1                        
   1 1 0                                     1 1 0                          
-  0 0 1                                  -  0 1 1                       
-----------                              ------------                      
   1 0 1                                     0 1 1

Si la resta A-B se computase como A + (-B) usando el algoritmo de la suma entonces en tu diagrama quedaría:


A)                                      B)                           
 1 1 0              <- acarreo ->          1 0 0                        
   1 1 0                                     1 1 0                          
+  1 1 1   (-001=111)                    +   1 0 1   (-011=101)          
-----------                              ------------                      
   1 0 1                                     0 1 1

Notar que el resultado es el mismo, pero el bit de carry es el opuesto al de borrow.

Saludos,
Gustavo

Re: Práctico 1 - Ejercicio 8

de Veronica Viviana Pintos Fernandez - miércoles, 24 de octubre de 2018, 22:33

Entonces, "resumiendo" serían las siguientes definiciones:

Carry out - es el acarreo del último bit en la suma
Carry in - no existe
Borrow out - es el bit de préstamo en la suma al bit más significativo
Borrow in - no existe

Me perdí en el ejemplo de la resta, de donde sale por ejemplo que el opuesto de 111 es -001.

Desde ya muchas gracias y perdón tantas preguntas, tenía abandonada la materia y estoy empezando a preparar el examen.

Saludos, Verónica.

Re: Práctico 1 - Ejercicio 8

de Gustavo Brown - viernes, 26 de octubre de 2018, 12:08

Verónica,

En una ALU tipica CarryIn/BorrowIn existen pero no son salidas sino entradas y sirven para encadenar sumas/restas. En el teórico podés ver ejemplos de cómo encadenar sumadores completos.

Sobre tu otra duda, en este hilo los ejemplos que pusiste son de números en complemento A2 de 3 bits. En ese formato 111 no es el opuesto de -1 sino que es la representación de -1 en complemento A2 de 3 bits:

-1 = -(001) = 111

En la última igualdad apliqué el complemento A2 para quitar el signo de - de la expresión.

Saludos,
Gustavo