Vous êtes sur la page 1sur 16

Instructions Concurrentes (suite)

et Generic
Generate
Generic

Cours 4/5
Mars 2019
Instruction Generate
• Les instructions « generate » permettent de créer
de façon compacte des structures régulières,
comme les registres ou les multiplexeurs.
• Elles sont particulièrement efficaces dans des
descriptions structurelles.
• Une instruction generate permet de dupliquer un
bloc d’instructions concurrentes un certain
nombre de fois, ou de créer un tel bloc si une
condition est vérifiée.
Syntaxe
-- structure répétitive :
etiquette : for variable in debut to fin generate
Instructions concurrentes
end generate [etiquette] ;
ou :
-- structure conditionnelle :
etiquette : if condition generate
instructions concurrentes
end generate [etiquette] ;
• Library ieee;
• Use ieee.std_logic_1164.all;
• Entity ADD_4bits is
• GENERIC (n : INTEGER := 4); -- default value 4
• port( A,B: in std_logic_vector(n-1 downto 0);
• cin : in std_logic;
• S: out std_logic_vector(n-1 downto 0);
• Cout: out std_logic);
• End ADD_4bits;
architecture ARCHI of ADD_4bits is
signal C : std_logic_vector(n downto 0);
begin
C(0) <= CIN;
COUT <= C(n);
BOUCLE_ADD: 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;
end ARCHI;
entity ADD_4bit is
port ( A,B : in BIT_VECTOR (3 downto 0);
CIN : in BIT;
Y : out BIT_VECTOR (3 downto 0);
COUT : out BIT);
end ADD_4bit;
Architecture struct of ADD_4bits is
component ADD_CMP port ( a1 , b1,cin : in std_logic ;
so,cout : out std_logic ) ;
end component ;
signal C : std_logic_vector(n downto 0);
begin
C(0) <= CIN ;
COUT <= C(n) ;
BOUCLE_ADD: for I in 0 to n-1 generate
Add_i : Add_cmp port map ( A(i), B(i),C(i),S(i), C(i+1) ) ;
end generate;
end ARCHI2;
GENERIC
• Comme son nom l'indique, GENERIC est un moyen de
spécifier un paramètre générique (c'est-à-dire un
paramètre statique qui peut être facilement modifié et
adapté à différentes applications).
• Le but est de conférer au code plus de flexibilité et de
réutilisabilité.
• Une déclaration GENERIC , lorsqu'elle est employée, doit
être déclarée dans l'ENTITÉ.
• Le paramètre spécifié sera alors vraiment global (c'est-à-
dire visible pour l'ensemble de code, y compris l'ENTITE
elle-même).
• Sa syntaxe est illustrée ci-dessous.
GENERIC (parameter_name : paramr_type := param_value);
exemple
ENTITY my_entity IS
GENERIC (n : INTEGER := 8); -- default value
8
PORT (...);
END my_entity;
ARCHITECTURE my_architecture OF my_entity IS
...
END my_architecture:
More than one GENERIC parameter can be
specified in an ENTITY. For
example:
GENERIC (n: INTEGER := 8; vector: BIT_VECTOR :=
"00001111");
Additionneur –soustracteur
• On considère un circuit arithmétique simple qui
réalise les 2 opérations: (addition , soustraction).
• Un signal de contrôle , ctrl , spécifie l’opération
demandé.
ctrl opération
0 A+B
1 A-B

Le premier design suit le tableau de fonctionnement


et le code VHDL est donné par:
library ieee ;
use ieee.Std_logic_1164. all ;
Code vhdl
use ieee.Numeric_std. all ;

entity addsub is port(


a, b : in std_logic_vector (7 downto 0) ;
ctrl: in std_logic;
r : out std_logic _ vector(7 downto 0));
end addsub;
architecture direct_arch of addsub is
signal src0, src1 , res: signed(7 downto 0) ;
begin
src0 <= signed(a);
src1 <= signed(b);

res<= src0 + src1 when ctrl=‘0’ else


src0-src1;
r <= std_logic_vector(res);
end direct_arch;
Optimisation du code à travers
partage (sharing)
a+(-b) = a+ Compl à 2(b) = a+(not b +1)
architecture shared_arch of addsub is
signal src0, src1 , res: signed(7 downto 0) ;
A1 : std_logic_vector(8 downto 0);
signal cin: signed(0 downto 0); -- carry -in bit
Begin
a1<=a & ‘1’;
src0 <= signed(a1);
src1 <= signed(b) when ctrl=’0’ else
signed (not b) ;
cin <= “0” when ctrl= else
“1”;
res <= src0 + src1 + cin;
r <= std_logic_vector(sum);
end shared_arch ;
a = a7a6a5a4a3a2a1a0
b = b7b6b5b4b3b2b10

Les opérandes étendues:


a7a6a5a4a3a2a1a0 1
b7b6b5b4b3b2b1b0
architecture manual_carry_arch of addsub is
signal src0, src1, res: signed(8 downto 0);
signal b_tmp: std_logic_vector ( 7 downto 0) ;
signal cin: std_logic; -- carry - in bit
src0 <= signed(a & ‘1’);
b_tmp <= b when ctrl=>’0’ else
not b;
cin <= ‘0’ when ctrl=‘0’ else
src1 <= signed(b_tmp & cin);
res <= src0 + src1;
r <= std_logic_vector (res( 8 downto 1)) ;
end manual_carry_arch ;

Vous aimerez peut-être aussi