INSTITUTO POLITÉCNICO

NACIONAL

ESCUELA SUPERIOR DE CÓMPUTO

Arquitectura de computadoras

Integrantes:

Mendoza Rodriguez Israel

3CV12

Ripple carry adder

Fecha de Entrega 30 de noviembre de 2022

1
Ripple carry adder

Un sumador con propagación de acarreo, también denominado sumador de

acarreo serie, es aquel constituido por varios sumadores completos en los cuales
el acarreo de salida se conecta a la entrada de acarreo del sumador siguiente. Sin
embargo, puede observarse que el primero de los sumadores puede ser
reemplazado por un semisumador suponiendo que el acarreo de entrada Cin es
cero.

El esquema de un sumador de acarreo serie es sencillo, lo que implica un corto

tiempo de diseño; sin embargo, el sumador es relativamente lento ya que cada
etapa debe esperar que se calcule un acarreo de entrada de la etapa previa.

Ilustración 1 Circuito de ripple carry adder

Ilustración 2 Circuito Ripple carry adder desglosado.

Primeramente, se realiza el código en vhdl y queda de la siguiente manera.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity carry_ripple_Adder is
GENERIC (n : INTEGER := 4);
Port ( a : in STD_LOGIC_VECTOR (n-1 downto 0);
b : in STD_LOGIC_VECTOR (n-1 downto 0);

2
 cin : in STD_LOGIC;
s : out STD_LOGIC_VECTOR (n-1 downto 0);
cout : out STD_LOGIC);
end carry_ripple_Adder;
architecture Behavioral of carry_ripple_Adder is

SIGNAL c: STD_LOGIC_VECTOR (n DOWNTO 0);

begin
c(0) <= cin;
G1: FOR i IN 0 TO n-1 GENERATE
s(i) <= a(i) XOR b(i) XOR c(i);
c(i+1) <= (a(i) AND b(i)) OR (a(i) AND c(i)) OR (b(i) AND
c(i));
END GENERATE;
cout <= c(n);
end Behavioral;

Simulación

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
ENTITY tb_carry_ripple_Adder IS

END tb_carry_ripple_Adder;

ARCHITECTURE behavior OF tb_carry_ripple_Adder IS

-- Component Declaration for the Unit Under Test (UUT)

COMPONENT carry_ripple_Adder
PORT(
a : IN std_logic_vector(3 downto 0);
b : IN std_logic_vector(3 downto 0);
cin : IN std_logic;
s : OUT std_logic_vector(3 downto 0);
cout : OUT std_logic
);

END COMPONENT;
--Inputs
signal a : std_logic_vector(3 downto 0) := (others => '0');
signal b : std_logic_vector(3 downto 0) := (others => '0');
signal cin : std_logic := '0';

--Outputs
signal s : std_logic_vector(3 downto 0);
signal cout : std_logic;

-- No clocks detected in port list. Replace <clock> below with

-- appropriate port name
-- constant <clock>_period : time := 10 ns;

BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: carry_ripple_Adder PORT MAP (
a => a,

3
b => b,
cin => cin,
s => s,
cout => cout
);

-- Clock process definitions

-- <clock>_process :process
-- begin
-- <clock> <= '0';
-- wait for <clock>_period/2;
-- <clock> <= '1';
-- wait for <clock>_period/2;
-- end process;
-- Stimulus process

stim_proc: process

begin

a <= "0000";
b <= "0000";
cin <= '0';
-- hold reset state for 100 ns.
wait for 100 ns;
a <= "0001";
b <= "0001";
wait for 100 ns;
a <= "0010";
b <= "0010";
wait for 100 ns;
a <= "0100";
b <= "0100";
wait for 100 ns;
a <= "0100";
b <= "0100";
cin <= '1';

wait for 100 ns;

a <= "0101";
b <= "0101";
cin <= '1';
wait;
end process;
END;

4
 Ilustración 3 RTL del sumador Ripple carry adder.

A continuación, observamos la simulación del Ripple Carry Adder (Ilustración

3) y analizando los resultados vemos que funciona correctamente.
1. En la primera suma tenemos que A= 0000 , B=0000 y cin = 0, y como
podemos ver la Ilustración 4 . El primer resultado es correcto.

𝑆 = 0000 + 0000 = 0000

C4=0 ya que no se genera acarreo

2. En la segunda suma tenemos que A= 0001 , B=0001 y cin= 0 y cómo

podemos ver la Ilustración 4 . El segundo resultado es correcto.

𝑆 = 0001 + 0001 = 0010

C4=0 ya que no se genera acarreo

3. En nuestra tercera prueba tenemos A=0100 , B =0100 y cin=0 y cómo

podemos ver la Ilustración 4 . El tercer resultado es correcto.

𝑆 = 0100 − 0100 = 1000

4. En nuestra cuarta prueba tenemos A=0100 , B =0100 y cin=1 y cómo

podemos ver la Ilustración 4 . El cuarto resultado es correcto.

𝑆 = 0100 − 0100 = 1001

Ilustración 4 Simulación sumador ripple carry adder.

5
Entonces se puede observar que en cuestión de funcionamiento la
implementación y funcionamiento de nuestro sumador es correcta. Ahora
continuamos con una análisis o comparación de tiempos.

Comparación entre sumador Ripple carry adder vs Carry Look Ahead

Adder.

En el Ripple carry adder

• Cada sumador completo tiene que esperar su traslado desde su sumador
completo de etapa anterior.
• Por lo tanto, el sumador completo 𝑛𝑡ℎ tiene que esperar hasta que todos los
sumadores completos (𝑛 − 1) hayan completado sus operaciones.
• Esto provoca un retraso y hace que el sumador de acarreo de ondulación
sea extremadamente lento.
• La situación empeora cuando el valor de n se vuelve muy grande.

En Carry Look Ahead Adder.

• Carry Look Ahead Adder es una versión mejorada del ripple carry
sumador.
• Genera el arrastre de cada sumador completo simultáneamente sin causar
ningún retraso.
• La complejidad temporal del sumador anticipado de acarreo = Θ (logn).

Conclusión

Como podemos observar el sumado implementada con el método de Ripper carry

es mucho menos eficientes en cuestión de tiempo, ya que entre más bits se quieran
suma la complejidad ira aumentando, ya que el acarreo depende de la salida de la
finalización de cada sumador completo, mientras que el sumador el Carry Look
Ahead realiza la suma y el acarreo al mismo tiempo. También anteriormente
hemos realizado un sumador de 4 bits pero estos son muy parecidos al Ripper
carry.
Entonces en conclusión observamos que todos los sumadores son correctos en
funcionamiento, entonces debemos priorizar que se busca el tiempo de ejecución
o la facilidad de la implementación.