Subversion Repositories xmatchpro

--This library is free software; you can redistribute it and/or

--modify it under the terms of the GNU Lesser General Public

--License as published by the Free Software Foundation; either

--version 2.1 of the License, or (at your option) any later version.

--This library is distributed in the hope that it will be useful,

--but WITHOUT ANY WARRANTY; without even the implied warranty of

--MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

--Lesser General Public License for more details.

--You should have received a copy of the GNU Lesser General Public

--License along with this library; if not, write to the Free Software

--Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

-- e_mail : j.l.nunez-yanez@byacom.co.uk

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

--  ENTITY       = PC_GENERATE   --

--  version      = 2.0           --

--  last update  = 3/8/99        --

--  author       = Jose Nunez    --

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

-- FUNCTION

-- generate the phased binary code for a given location ond table size (next free location)

-- PIN LIST

-- NFL_M_ONE  = next free location minus one in the dictionary

-- MATCH_LOC  = match location

-- MISS       = indicates that a miss occurred (active low), i.e MATCH_LOC is invalid

-- TABLE_FULL = signal to indicate that the table is full (active LOW)

-- CODE       = output phased binary code

-- LENGTH     = length of the output code

library ieee,dzx;

use ieee.std_logic_1164.all;

use dzx.bit_arith.all;

use dzx.bit_utils.all;

entity PC_GENERATE is

port

(

    NFL_M_ONE : in bit_vector(3 downto 0);

        MATCH_LOC : in bit_vector(3 downto 0);

        MISS : in bit;

        TABLE_FULL : in bit;

        CODE : out bit_vector(4 downto 0);

        LENGTH : out bit_vector(2 downto 0)

);

end PC_GENERATE;

architecture PHASED2 of PC_GENERATE is

signal K : bit_vector(3 downto 0);

signal K_MINUS_ONE : bit_vector(3 downto 0);

signal TWO_K_M_ROW : bit_vector(3 downto 0);

signal LESS_THAN : bit;

signal CODE_A : bit_vector(3 downto 0);

signal CODE_B : bit_vector(3 downto 0);

signal CODE_Y : bit_vector(3 downto 0);

signal CODE_SHIFTED : bit_vector(3 downto 0);

signal LENGTH_A : bit_vector(2 downto 0);

signal LENGTH_B : bit_vector(2 downto 0);

signal LENGTH_Y : bit_vector(2 downto 0);

signal SUM : bit_vector(3 downto 0);

begin

OR_TREE : process(NFL_M_ONE)

variable TEMP_K : bit_vector(3 downto 0);

begin

TEMP_K := "0000";

for I in 3 downto 0 loop

    for J in 3 downto I loop

        TEMP_K(I) := TEMP_K(I) or NFL_M_ONE(J);

    end loop;

end loop;

K <= TEMP_K;

K_MINUS_ONE <= '0' & TEMP_K(3 downto 1);

end process OR_TREE;

COMPARE : process (TWO_K_M_ROW , MATCH_LOC)

begin

if (MATCH_LOC < TWO_K_M_ROW) then

    LESS_THAN <= '0';

else

    LESS_THAN <= '1';

end if;

end process COMPARE;

CONVA : process(K_MINUS_ONE)

begin

case K_MINUS_ONE  is

    when "1111" => LENGTH_A <= "101";

    when "0111" => LENGTH_A <= "100";

    when "0011" => LENGTH_A <= "011";

    when "0001" => LENGTH_A <= "010";

    when "0000" => LENGTH_A <= "001";

    when others    => LENGTH_A <= "000";

end case;

end process CONVA;

CONVB : process(K)

begin

case K  is

    when "1111" => LENGTH_B <= "101";

        when "0111" => LENGTH_B <= "100";

        when "0011" => LENGTH_B <= "011";

    when "0001" => LENGTH_B <= "010";

    when "0000" => LENGTH_B <= "001";

    when others    => LENGTH_B <= "000";

end case;

end process CONVB;

MUXES_ONE : process ( LESS_THAN , TABLE_FULL , CODE_A , CODE_B , LENGTH_A , LENGTH_B, MATCH_LOC )

begin

if (TABLE_FULL = '0') then

        CODE_Y <= MATCH_LOC;

        LENGTH_Y <= "101";

else

        if (LESS_THAN = '0') then

                CODE_Y <= CODE_A;

                LENGTH_Y <= LENGTH_A;

        else

                CODE_Y <= CODE_B;

                LENGTH_Y <= LENGTH_B;

        end if;

end if;

end process MUXES_ONE;

MUXES_TWO : process ( MISS , CODE_SHIFTED , LENGTH_Y )

begin

if (MISS = '1') then

    CODE <= '1' & "0000";

    LENGTH <= "001";

else

    CODE <= '0' & CODE_SHIFTED;

    LENGTH <= LENGTH_Y;

end if;

end process MUXES_TWO;

SHIFT_CODE : process ( CODE_Y , LENGTH_Y)

begin

case LENGTH_Y is

    when "001" => CODE_SHIFTED <= "0000";

    when "010" => CODE_SHIFTED <= CODE_Y(0) & "000";

    when "011" => CODE_SHIFTED <= CODE_Y(1 downto 0) & "00";

    when "100" => CODE_SHIFTED <= CODE_Y(2 downto 0) & "0";

    when "101" => CODE_SHIFTED <= CODE_Y(3 downto 0);

    when others => CODE_SHIFTED <= "0000";

end case;

end process SHIFT_CODE;

TWO_K_M_ROW <= K and not(NFL_M_ONE);

SUM <= TWO_K_M_ROW + MATCH_LOC;

CODE_A <= MATCH_LOC and K_MINUS_ONE;

CODE_B <= SUM and K;

end PHASED2; -- end of architecture