Subversion Repositories parallel_search_for_maximum_weight

library ieee;

use ieee.std_logic_1164.all;

use work.basic_size.all;

use work.basic_component.all;

entity Ripple is

GENERIC (cells :  Natural:=8);

port(

        left_op :       IN std_logic_vector (cells -1  DOWNTO 0);

        right_op :      IN std_logic_vector (cells -1  DOWNTO 0);

        choose_cur : out std_logic;

        found_cur : out std_logic;

        choose_sel :    OUT std_logic_vector (cells -1  DOWNTO 0));

end entity Ripple;

architecture behav of Ripple  is

SIGNAL  found_i:         std_logic_vector (cells+1  DOWNTO 0);

SIGNAL  choose_i:        std_logic_vector (cells+1  DOWNTO 0);

SIGNAL  a:       std_logic_vector (cells  DOWNTO 0);

SIGNAL  b:       std_logic_vector (cells  DOWNTO 0);

SIGNAL  sel_out:         std_logic_vector (cells  DOWNTO 0);

begin

   choose_i(2*((cells+1 )/ 2)) <= '0';

   found_i (2*((cells+1 )/ 2))  <= '0';

--rename inputs

 re_g:IF (cells mod 2) =0 GENERATE

    a(cells-1   DOWNTO 0)  <= left_op;

    b(cells-1   DOWNTO 0)  <= right_op;

END GENERATE re_g;

 --PADDING with zero's

--- PADDING ODD to EVEN

pad_gen : IF (cells mod 2) /=0 GENERATE

     a  <= left_op  & '0';

     b  <= right_op & '0';

END GENERATE pad_gen;

-- Start based on the number of Bits if Even or Odd

-- Sure not equal zero 

--even_cell :

 g_ripple : FOR i In ((cells+1)/2 )  downto 1 generate

        BEGIN

         carry_cell_NOR_Inst : carry_cell_NOR    PORT MAP (

                        a =>a(2*i-1), b=>b(2*i-1),

                        choose_prev =>choose_i(2*i ),

                        found_prev  =>found_i(2*i ),

                        choose_cur_bar =>choose_i(2*i-1 ),

                        found_cur_bar  =>found_i(2*i -1 ));

                        --Result Muxing

                        sel_out(2*i-1)  <= NOT choose_i(2*i-1);

        carry_cell_NAND_Inst : carry_cell_NAND PORT MAP(

                        a =>a(2*i -2), b=>b(2*i -2),

                        choose_prev_bar =>choose_i(2*i-1),

                        found_prev_bar  =>found_i(2*i -1 ),

                        choose_cur =>choose_i(2*i  - 2),

                        found_cur  =>found_i(2*i  - 2));

                        sel_out (2*i  - 2)  <= choose_i(2*i  - 2);

        end generate g_ripple;

  choose_sel <= sel_out(2*((cells+1)/2)-1  DOWNTO (cells mod 2));

  choose_cur <=choose_i(cells mod 2) ;

  found_cur <=  found_i(cells mod 2);

end behav;