prefixand.vhd

Cadence的VHDL运算库包

-------------------------------------------------------------------------------
-- Title       : Parallel-prefix AND structure
-- Project     : VHDL Library of Arithmetic Units
-------------------------------------------------------------------------------
-- File        : PrefixAnd.vhd
-- Author      : Reto Zimmermann  <[e-mail]>
-- Company     : Integrated Systems Laboratory, ETH Zurich
-- Date        : 1997/11/04
-------------------------------------------------------------------------------
-- Copyright (c) 1998 Integrated Systems Laboratory, ETH Zurich
-------------------------------------------------------------------------------
-- Description :
-- Prefix structures of different depth (i.e. speed) for propagate calculation
-- in different arithmetic units. Compute in m levels new propagate signal
-- pairs for always larger groups of bits. Basic logic operation: AND for
-- propagate signals. 
-------------------------------------------------------------------------------

library ieee;
use ieee.std_logic_1164.all;
library arith_lib;
use arith_lib.arith_lib.all;
use arith_lib.arith_utils.all;

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

entity PrefixAnd is

  generic (width : positive := 8;	-- word width
	   speed : speedType := fast);	-- performance parameter

  port (PI : in std_logic_vector(width-1 downto 0);  -- propagate in
	PO : out std_logic_vector(width-1 downto 0));  -- propagate out

end PrefixAnd;

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

architecture Structural of PrefixAnd is 

  constant n : positive := width;	-- prefix structure width
  constant m : positive := log2ceil(width);  -- prefix structure depth

begin

  -- Sklansky parallel-prefix propagate-lookahead structure
  fastPrefix : if speed = fast generate
    local : block
      signal PT : std_logic_vector((m+1)*n-1 downto 0);
    begin
      PT(n-1 downto 0) <= PI;
      levels : for l in 1 to m generate
	groups : for k in 0 to 2**(m-l) - 1 generate
	  bits : for i in 0 to 2**(l-1) - 1 generate
	    white : if (k*2**l + i) < n generate
	      PT(l*n + k*2**l + i) <= PT((l-1)*n + k*2**l + i);
	    end generate white;
	    black : if (k*2**l + 2**(l-1) + i) < n generate
	      PT(l*n + k*2**l + 2**(l-1) + i) <= 
		PT((l-1)*n + k*2**l + 2**(l-1) + i) and
		PT((l-1)*n + k*2**l + 2**(l-1) - 1);
	    end generate black;
	  end generate bits;
	end generate groups;
      end generate levels;
      PO <= PT((m+1)*n-1 downto m*n);
    end block local;
  end generate fastPrefix;

  -- Brent-Kung parallel-prefix propagate-lookahead structure
  mediumPrefix : if speed = medium generate
    local : block
      signal PT : std_logic_vector((2*m)*n-1 downto 0);
    begin
      PT(n-1 downto 0) <= PI;
      levels1 : for l in 1 to m generate
	groups : for k in 0 to 2**(m-l) - 1 generate
	  bits : for i in 0 to 2**l - 2 generate
	    white : if (k*2**l + i) < n generate
	      PT(l*n + k*2**l + i) <= PT((l-1)*n + k*2**l + i);
	    end generate white;
	  end generate bits;
	  black : if (k*2**l + 2**l - 1) < n generate
	    PT(l*n + k*2**l + 2**l - 1) <= 
	      PT((l-1)*n + k*2**l + 2**l - 1) and
	      PT((l-1)*n + k*2**l + 2**(l-1) - 1);
	  end generate black;
	end generate groups;
      end generate levels1;
      levels2 : for l in m + 1 to 2*m - 1 generate
	bits : for i in 0 to 2**(2*m-l) - 1 generate
	  white : if i < n generate
	    PT(l*n + i) <= PT((l-1)*n + i);
	  end generate white;
	end generate bits;
	groups : for k in 1 to 2**(l-m) - 1 generate
	  empty : if l < 2*m - 1 generate
	    bits : for i in 0 to 2**(2*m-l-1) - 2 generate
	      white : if (k*2**(2*m-l) + i) < n generate
		PT(l*n + k*2**(2*m-l) + i) <= PT((l-1)*n + k*2**(2*m-l) + i);
	      end generate white;
	    end generate bits;
	  end generate empty;
	  black : if (k*2**(2*m-l) + 2**(2*m-l-1) - 1) < n generate
	    PT(l*n + k*2**(2*m-l) + 2**(2*m-l-1) - 1) <= 
	      PT((l-1)*n + k*2**(2*m-l) + 2**(2*m-l-1) - 1) and
	      PT((l-1)*n + k*2**(2*m-l) - 1);
	  end generate black;
	  bits : for i in 2**(2*m-l-1) to 2**(2*m-l) - 1 generate
	    white : if ( k*2**(2*m-l) + i) < n generate
	      PT(l*n + k*2**(2*m-l) + i) <= PT((l-1)*n + k*2**(2*m-l) + i);
	    end generate white;
	  end generate bits;	
	end generate groups;
      end generate levels2;
      PO <= PT(2*m*n-1 downto (2*m-1)*n);
    end block local;
  end generate mediumPrefix;

  -- serial-prefix propagate-lookahead structure
  slowPrefix : if speed = slow generate
    local : block
      signal PT : std_logic_vector(n-1 downto 0);
    begin
      PT(0) <= PI(0);
      bits : for i in 1 to n - 1 generate
	PT(i) <= PI(i) and PT(i-1);
      end generate bits;
      PO <= PT;
    end block local;
  end generate slowPrefix;

end Structural;

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