Universidad Nacional de San Luis

Facultad de Ciencias Físico Matemáticas y Naturales.

Ingeniería Electrónica con O.S.D.

Arquitectura de computadoras

Trabajo Práctico No 3
Aritmética de Computadoras

Alumno
Cortez Médici Emanuel

Profesores Responsables
Ing. Andrés Airabella
Ing. Astrid Andrada

29 de mayo de 2021
1. Realice las siguientes operaciones en binario. Exprese los
resultados obtenidos en formato decimal, asumiendo una
representación en complemento a dos.
1.a. A−B
Desarrollo de la actividad
Para poder realizar la resta, se pasa B a un complemento a 2. Para ello, se cambian
los unos por ceros y viceversa y al resultado se le suma 1.

B2 = 01011011 → 10100100 → 10100101

Luego se realiza la suma de ambos números para obtener el resultado:

11101010
+ 10100101
1 10001111

Se observa que se produce overflow, es decir necesito más bits para poder representar el
número del resultado, el cual es en este caso es 110001111. El número en formato decimal
es −28 + 27 + 23 + 22 + 21 + 20 = −113

1.b. A∗B
Desarrollo de la actividad
Primero debo obtener el valor absoluto de la multiplicación, y luego en el resultado
final decidir el signo correspondiente. Para ello, transformo A en un número positivo.
A = 11101010 → 00010101 → 00010110
Debido a que A presenta más ceros y A ∗ B = B ∗ A, se presenta la multiplicación de
B ∗ A, permitiendo una resolución más corta.

0 1 0 1 1 0 1 1
* 0 0 0 1 0 1 1 0
0 0 0 0 0 0 0 0
0 1 0 1 1 0 1 1
0 1 0 1 1 0 1 1
0 0 0 0 0 0 0 0
0 1 0 1 1 0 1 1
0 1 1 1 1 1 0 1 0 0 1 0

El resultado final, es el número 011111010010. Debido a que A es un número negativo,

el resultado es negativo, y por lo tanto, se debe pasar a complemento a 2 el resultado
obtenido.

Res = 011111010010 → 100000101101

Finalmente, el número resultante es −211 + 25 + 23 + 22 + 21 = −2002
Donde

1
 A = 11101010

B = 01011011

2. Dados los siguientes números en sistema decimal, pasarlo

a sistema binario usando IEEE 754 floating-point standard
para una palabra de 32 bits.
2.a. -254x10-4
2.b. 0,500047
Desarrollo de la actividad
Escribo el número en decimal para una mayor facilidad. −254 ∗ 10−4 = −0,0254
Con la ayuda de la tabla 1 se obtiene la mantisa y el exponente del número en binario.
Luego se calcula el valor del mismo para la conformación del número final según la norma
IEEE 754. Utilizando la siguiente formula, se obtiene el exponente según IEEE 754.

Exponente = bias + exponentedesplazado

Exponentea = 127 + (−6) = 121 → 01111001
Exponenteb = 127 + (−1) = 126 → 01111110

Finalmente los números en binarios según la norma IEE 754 quedan conformados de
la siguiente manera:

Número Signo Exponente Mantisa

−254 ∗ 10−4 1 01111001 10100000001001110101001
0,500047 0 01111110 00000000000001100010100

2
N° a convertir Binario Exponente
0,0254 0
0,051 0 0
N° a convertir Binario Exponente
0,102 0 0
0,500047 0
0,203 0 0
9,4E-05 1 1
0,406 0 0
0,000188 0 0
0,813 0 0
0,000376 0 0
0,626 1 6
0,000752 0 0
0,251 1 0
0,001504 0 0
0,502 0 0
0,003008 0 0
0,005 1 0
0,006016 0 0
0,010 0 0
0,012032 0 0
0,019 0 0
0,024064 0 0
0,038 0 0
0,048128 0 0
0,077 0 0
0,096256 0 0
0,154 0 0
0,192512 0 0
0,307 0 0
0,385024 0 0
0,614 0 0
0,770048 0 0
0,229 1 0
0,540096 1 0
0,458 0 0
0,080192 1 0
0,915 0 0
0,160384 0 0
0,830 1 0
0,320768 0 0
0,661 1 0
0,641536 0 0
0,322 1 0
0,283072 1 0
0,643 0 0
0,566144 0 0
0,286 1 0
0,132288 1 0
0,573 0 0
0,264576 0 0
0,146 1 0
0,529152 0 0
0,291 0 0
Mantisa 00000000000001100010100
0,582 0 0
0,165 1 0
Mantisa 10100000001001110101001
Cuadro 1: Cálculo de la mantisa y obtención del exponente.

3
3. Convertir los siguientes números escritos en binario de
punto flotante a decimal.
10101111 01011101 11011100 00000000
00001111 11011000 10110000 00011000
Desarrollo de la actividad
Se procede a identificar las partes de los números previamente mencionados. Esto se
muestra en la tabla

Signo Exponente Mantisa

1 01011110 10111011101110000000000
0 00011111 10110001011000000011000

Expdesplazado = exponente − bias

Expa = 94 − 127 = −33 → 01111001
Expb = 31 − 127 = −96 → 01111110

La mantisa se obtiene sumando cada dígito del número ponderado desde 2−1 hasta
2−23 . Se obtiene así los valores:

M antisaa = 10111011101110000000000 → 0,733276367

M antisab = 10110001011000000011000 → 0,692873954

Finalmente usando la fórmula:

N umero = (−1)s ∗ (1 + mantisa) ∗ 2exp d

A = (−1)1 ∗ (1 + 0,733276367) ∗ 2−33 = −2,017799261 ∗ 10( − 10)
B = (−1)0 ∗ (1 + 0,692873954) ∗ 2−96 = −2,136707329 ∗ 10( − 29)

4. Realizar las siguientes operaciones aritméticas

A = 562, 359

B = −0, 97123

Primero se convierten los números decimales a binarios, obteniendo así la tabla 2.

Número Signo Exponente Mantisa

562,359 0 10001000 00011001001011011111001
−0,97123 1 01111110 11110001010001010000111
Cuadro 2: Números convertidos a binarios

4
4.a. A/B
Se analiza primeramente el exponente de ambos números para obtener el exponente
que tendrá el resultado. Se obtiene que el exponente del resultado será igual a 10.

01111110 → 10000010
10001000 + 10000010 = 00001010
00001010 → 10

Se divide la mantisa de A con la mantisa de B, habiendoles agregado ya el uno al

principio, obteniendo así el siguiente resultado:

M antisaA 100011001001011011111001
= = 0100011001001011011111001
M antisaB 111110001010001010000111
Con dicha mantisa se define una nueva mantisa para el resultado, junto con un despla-
zamiento del exponente. Esto es:

MN = 1,000110010010110111110010
expN = 127 + 10 + (−1) = 136 → 10001000

El signo se determina haciendo un xor entre los signos de los dividendos. En este caso
el signo es 1. Luego el resultado de la división queda conformado en la tabla 3

Número Signo Exponente Mantisa

A 562,359 0 10001000 00011001001011011111001
B −0,97123 1 01111110 11110001010001010000111
Resultado −579,0173285 1 10001000 00110010010110111110010
Cuadro 3: Resultado de la división

4.b. A−B
Debido a que B es de signo negativo, en realidad se puede realizar una suma entre las
mantisas. Se tiene que el resultado tendrá un exponente de 10, esto se averigua al realizar
la resta entre los exponentes de ambos números como se hizo previamente. Se procede a
normalizar la mantisa de menor valor para poder realizar una suma entre los números.
Teniendo en cuenta que B es diez veces menor que A, se corre B 10 lugares, y se toman
los bits más significativos.

A = 100011001001011011111001
B = 000000000011111000101000 | 1010000111
Resultado = 100011001101010100100001

Luego el número resultante es:

5
 Número Signo Exponente Mantisa
A 562,359 0 10001000 00011001001011011111001
B −0,97123 1 01111110 11110001010001010000111
Resultado 563,33023 0 10001000 00011001101010100100001
Cuadro 4: Resultado de la resta

4.c. A∗B
Se realiza la suma entre los exponentes, restando el bias correspondiente para obtener
el exponente del resultado:
ExponenteA − 127 + ExponenteB − 127 = 9 + (−1) = 8
Por lo tanto, el exponente con bias será: 8 + 127 = 135
Se multiplican las mantisas, obteniendo así el resultado.

MA ∗ MB = 0100010001000101110000010 = 1,00010001000101110000010 + 21
expN = 8 + 1 + 127 = 136 → 10001000

Finalmente el signo del número es el resultado de un or excluyente entre ambos números,

dando en este caso 1. Luego, el número resultante es:

Número Signo Exponente Mantisa

A 562,359 0 10001000 00011001001011011111001
B −0,97123 1 01111110 11110001010001010000111
Resultado −546,18 1 10001000 00010001000101110000010
Cuadro 5: Resultado de la multiplicación

5. Realice la implementación, en VHDL, de dos multiplica-

dores de 8 bits: uno combinacional (usando el operador de
multiplicación) y otro secuencial. Realizar lo siguiente:
Desarrollo de la actividad
Se procede a mostrar el código realizado en VHDL, tanto del multiplicador combina-
cional, así como tambien del multiplicador secuencial. Para compilarlo se utilizó el software
GHDL de código abierto.
l i b r a r y IEEE ;
use IEEE .STD_LOGIC_1164.ALL;
use IEEE .NUMERIC_STD.ALL;
entity m u l t i p l i c a d o r i s
Port ( m u l t i p l i c a n d o : in STD_LOGIC_VECTOR ( 7 downto 0 ) ;
m u l t i p l i c a d o : in STD_LOGIC_VECTOR ( 7 downto 0 ) ;
s a l i d a : out STD_LOGIC_VECTOR ( 1 5 downto 0 ) ) ;
end m u l t i p l i c a d o r ;
architecture B e h a v i o r a l of m u l t i p l i c a d o r i s
begin
s a l i d a <= STD_LOGIC_VECTOR( signed ( m u l t i p l i c a d o ) ∗ signed ( m u l t i p l i c a n d o ) ) ;
end B e h a v i o r a l ;

Listing 1: Multiplicador combinacional en VHDL

6
 l i b r a r y IEEE ;
use IEEE .STD_LOGIC_1164.ALL;
use IEEE .NUMERIC_STD.ALL;
entity m u l t i p l i c a d o r i s
Port (
m u l t i p l i c a n d o : in STD_LOGIC_VECTOR ( 7 downto 0 ) ;
m u l t i p l i c a d o : in STD_LOGIC_VECTOR ( 7 downto 0 ) ;
s a l i d a : out STD_LOGIC_VECTOR ( 1 5 downto 0 )
);
end m u l t i p l i c a d o r ;
architecture B e h a v i o r a l of m u l t i p l i c a d o r i s
begin
process ( m u l t i p l i c a d o , m u l t i p l i c a n d o )
variable i : integer range 0 to 7 ;
variable A: STD_LOGIC_VECTOR ( 1 5 downto 0 ) ;
variable B : STD_LOGIC_VECTOR ( 7 downto 0 ) ;
variable aux : STD_LOGIC_VECTOR ( 1 5 downto 0 ) ;
begin
A( 7 downto 0 ) := STD_LOGIC_VECTOR( signed ( m u l t i p l i c a n d o ) ) ;
A( 1 5 downto 8 ) := " 00000000 " ;
B := STD_LOGIC_VECTOR( signed ( m u l t i p l i c a d o ) ) ;
aux := " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " ;
i f (A( 7 )=' 1 ' ) then
f o r i in 0 to 7 loop
i f (A( i )=' 1 ' ) then
A( i ) := ' 0 ' ;
else
A( i ) := ' 1 ' ;
end i f ;
end loop ;
A := STD_LOGIC_VECTOR( signed (A) +1) ;
end i f ;
i f (B( 7 )=' 1 ' ) then
f o r i in 0 to 7 loop
i f (B( i )=' 1 ' ) then
B( i ) := ' 0 ' ;
else
B( i ) := ' 1 ' ;
end i f ;
end loop ;
B := STD_LOGIC_VECTOR( signed (B) +1) ;
end i f ;
f o r i in 0 to 7 loop
i f (B( 0 ) = ' 1 ' ) then
aux := STD_LOGIC_VECTOR( signed (A)+signed ( aux ) ) ;
A := STD_LOGIC_VECTOR( s h i f t _ l e f t ( signed (A) , 1 ) ) ;
else
A := STD_LOGIC_VECTOR( s h i f t _ l e f t ( signed (A) , 1 ) ) ;
end i f ;
B :=STD_LOGIC_VECTOR( s h i f t _ r i g h t ( signed (B) , 1 ) ) ;
end loop ;
i f ( ( m u l t i p l i c a n d o ( 7 ) xor m u l t i p l i c a d o ( 7 ) ) = ' 1 ' ) then
f o r i in 0 to 15 loop
i f ( aux ( i )=' 1 ' ) then
aux ( i ) := ' 0 ' ;
else
aux ( i ) := ' 1 ' ;
end i f ;
end loop ;
end i f ;
aux := STD_LOGIC_VECTOR( signed ( aux ) +1) ;
s a l i d a <= STD_LOGIC_VECTOR( signed ( aux ) ) ;
end process ;
end B e h a v i o r a l ;

Listing 2: Multiplicador secuencial en VHDL

7
5.a. Verificar el funcionamiento de cada multiplicador mediante la ope-
ración del punto 1.b
Se procede a realizar el siguiente testbench en VHDL.
LIBRARY i e e e ;
USE i e e e . std_logic_1164 .ALL;
USE i e e e . numeric_std .ALL;

ENTITY t e s t B IS
END t e s t B ;

ARCHITECTURE b e h a v i o r OF t e s t B IS

−− Component D e c l a r a t i o n f o r t h e Unit Under Test (UUT)

COMPONENT m u l t i p l i c a d o r
PORT(
m u l t i p l i c a n d o : IN std_logic_vector ( 7 downto 0 ) ;
m u l t i p l i c a d o : IN std_logic_vector ( 7 downto 0 ) ;
s a l i d a : OUT std_logic_vector ( 1 5 downto 0 )

);
END COMPONENT;

−−I n p u t s
s i g n a l m u l t i p l i c a n d o : std_logic_vector ( 7 downto 0 ) := ( others => ' 0 ' ) ;
s i g n a l m u l t i p l i c a d o : std_logic_vector ( 7 downto 0 ) := ( others => ' 0 ' ) ;

−−Outputs
s i g n a l s a l i d a : std_logic_vector ( 1 5 downto 0 ) ;

−− Clock p e r i o d d e f i n i t i o n s
constant c l k _ p e r i o d : time := 10 ns ;

BEGIN

−− I n s t a n t i a t e t h e Unit Under Test (UUT)

uut : m u l t i p l i c a d o r PORT MAP (
m u l t i p l i c a n d o => m u l t i p l i c a n d o ,
m u l t i p l i c a d o => m u l t i p l i c a d o ,
s a l i d a => s a l i d a

);
−− S t i m u l u s p r o c e s s
stim_proc : process
begin
multiplicando<= " 11101010 " ;
mult iplicad o<= " 01011011 " ;
wait f o r 50 ns ;
wait ;
end process ;

END;

Listing 3: Testbench para los multiplicadores en VHDL

Se comprueba el correcto funcionamiento del código analizando las salidas de un test-

bench con el programa GTKWave. En la figura 1 se obtiene el mismo resultado de la
multiplicación del punto 1.b utilizando el multiplicador combinacional.
En la figura 2 se muestra el resultado implementando el multiplicador secuencial.

8
 Figura 1: Resultado del testbench para el sistema combinacional.

Figura 2: Resultado del testbench para el sistema secuencial.

5.b. Analizar la máxima frecuencia de operación de cada implementa-

ción. Analizar el uso de recursos de cada implementación.
No se pudo analizar el uso de recursos de cada implementación, ya que con el software
utilizado no se puede obtener un diseño en compuertas y flip-flops del mismo. Tampoco
permite elegir el modelo de FPGA a utilizar y determinar así la latencia de las compuertas,

9
para poder asi estimar el tiempo de ejecución.

5.c. Indicar cuál implementación es más rápida para realizar la opera-

ción, justificando la respuesta en función del uso de recursos.
La implementación más rápida es la combinacional, esto se debe principalmente a que
no necesita de flip-flops para su implementación, y el tiempo que demorará en cambiar
la salida dependerá de una lógica combiancional de 2 etapas. Por otro lado, en la lógica
secuencial, la salida dependerá de los flips-flops y del clock utilizado, ralentizando así el
cambio a la salida.

10