Gei 431 Architecture des ordinateurs II – Frédéric Mailhot Le VHDL De nos jours, les circuits...

Gei

431

Architecture des ordinateurs II – Frédéric Mailhot

Le VHDL

De nos jours, les circuits numériques de haute performance sont habituellement créés à partir de descriptions en langages de haut niveau.

Nous allons maintenant parler de l’un de ces langages, le VHDL

© 2001 Frédéric Mailhot Université de Sherbrooke

Le

VH

DL

Le VHDL: Qu’est-ce que c’est, et à quoi cela sert-il?

• VHDL: VHSIC Hardware Description Language

• VHSIC: Very High Speed Integrated Circuit (projet de grande envergure du DoD (Departement of Defense) Américain, mis en place dans les années ’80

• Principe de base: Définir un langage de description de matériel qui puisse être utilisé pour simuler du matériel numérique

• Extension: Utilisation du même langage pour la synthèse automatique de circuits


Le

VH

DL

VHDL: Est-ce le seul HDL?

• Il existe plusieurs autres langages de description de matériel, entre autres: Verilog (Très populaire aux États-Unis, utilisé aussi en

Europe, au Japon et au Canada)

UDL/1 (Utilisé à un certain moment au Japon)

Estérel (langage académique – Français)

HardwareC (langage académique – Stanford)

• Verilog est plus simple que le VHDL, mais est un peu moins utilisé


Le

VH

DL

« Design Flow » moderne

Design fonctionnel

Design « Register Transfer Level »

Design Logique

Design « Physique »

Simulation comportermentale

Simulation RTLValidation

Simulation logiqueVérificationSimulation de fautes

Analyse des délaisAnalyse du circuit« Design Rule Checking »


Le

VH

DL

Concepts de base

• Description du système: Structurale Comportementale (behavioral)

• Événements

• Délais de propagation

• Concurrence

• Timing: Synchrone Asynchrone

• Signaux: Forme Valeur Partage

• Simulation d’événements discrets


Le

VH

DL

Pourquoi utiliser des langages HDL?

• Pour accélérer la conception de circuits (raison économique)

• Pour permettre la conception de circuits très complexes (150 millions de portes logiques d’ici 5 ans)

• Pour pouvoir représenter les systèmes numériques selon les différents axes d’abstraction


Le

VH

DL

Pourquoi mettre en marché plus rapidement?

Temps

Rev

enus

Délai

Aug

men

tatio

n du

mar

ché

Déclin du m

arché

Revenus maximum

Pertes de revenus


Le

VH

DL

Le « Y » de Gadjsky

Comportemental Structural

Physique

Transistors

Portes

Registres

Processeurs

Cellules

Modules

Circuits

Printed Circuit Board

Algorithmes

Register transfer

Expressions Booléennes

Fonctions de transfert


Le

VH

DL

Valeur des signaux

• À la base, tout système numérique est constitué de signaux binaires. VHDL supporte le ‘bit’ au plus bas niveau.

• Valeur possible du bit: 0 ou 1

• Est-ce suffisant?


Le

VH

DL

Valeur des signaux

Valeur Interprétation

0 0 - Forcé

1 1 - Forcé

U Uninitialized (non-initialisé)

X Inconnu - Forcé

Z Haute impédance

W Inconnu - Faible

L 0 - Faible

H 1 - Faible

- Don’t Care

Standard IEEE 1164:


Le

VH

DL

Premier concept de base: les entités (entity)

• Première étape de définition de matériel: définir l’interface

• Comment: à l’aide de la déclaration « entity »


Le

VH

DL

Les « entity »

• L’interface externe du circuit ci-haut est spécifiée par la déclaration « entity » suivante:

entity half_adder is

port(a, b: in bit;

sum, carry: out bit);

end half_adder;

ab

sum

carry


Le

VH

DL

Exemple d’entity: multiplexeur de bus

entity mux is

port (I0, I1 : in std_ulogic_vector (7 downto 0);

I2, I3: in std_ulogic_vector (7 downto 0);

Sel: in std_ulogic_vector (1 downto 0);

z : out std_ulogic_vector (7 downto 0));

end mux;


Le

VH

DL

Exemple d’entity: Flip-flop

entity D_ff is

port (D,Clk, S, R: in std_ulogic;

Q, Qbar: out std_ulogic);

end D_ff;


Le

VH

DL

Deuxième concept de base: les énoncés concurrents

• Il faut être capable de définir la fonctionnalité de notre système, qui représente ce que le matériel devra effectuer

• Puisqu’on parle de matériel, tout ce qui est décrit va « s’exécuter » en parallèle

• Pour décrire la fonctionnalité d’un système, on utilise la déclaration « architecture », qui implicitement contient des énoncés concurrents


Le

VH

DL

Exemple d’architecture: un demi-additionneur

library IEEE;

use IEEE.std_logic_1164.all;


port(a, b: in bit;


end half_adder;

architecture comportement_concurrent of half_adder is

begin

sum <= (a xor b) after 5 ns;

carry <= (a and b) after 5 ns;

end comportement_concurrent;


Le

VH

DL

Signaux à source multiples

• Qu’arrive-t-il si un signal est produit par plus d’une source (e.g. élément d’un bus)?

• Qu’arrive-t-il si les différentes sources ne déterminent pas la même valeur?

• On utilise une fonction de « résolution » pour traiter ces cas

• Dans la librairie IEEE, le type « std_logic » du standard 1164 est résolu


Le

VH

DL

Assignations conditionnelles

• On peut utiliser une assignation conditionnelle pour définir la valeur d’un signal:

library IEEE;


entity mux4 is

port (In0, In1, In2, In3: in std_logic_vector (7 downto 0);

S0, S1: in std_logic;

z: out std_logic_vector (7 downto 0));

end mux4;

architecture comportemental of mux4 is

begin

z <= In0 after 5 ns when S0 = ‘0’ and S1 = ‘0’ else

In1 after 5 ns when S0 = ‘0’ and S1 = ‘1’ else



‘00000000’ after 5 ns;

end comportemental;


Le

VH

DL

Utilisation de sélecteurs

• Lorsqu’il y a un grand nombre de possibilités qui sont toutes énumérées, on peut utiliser un sélecteur


Le

VH

DL

Utilisation de sélecteurs – exemple

library IEEE;


entity memoire is

port (addr1,addr2: in std_logic_vector (2 downto 0);

mem1: out std_logic_vector (31 downto 0));

end memoire;

architecture comportemental of memoire is

signal reg0, reg1, reg2, reg3: std_logic_vector (31 downto 0):= to_stdlogicvector(x’’1234AB’’);

signal reg4, reg5, reg6, reg7: std_logic_vector (31 downto 0):= to_stdlogicvector(x’’5678FF’’);

begin

with addr1 select

mem1 <= reg0 after 5 ns when ‘‘000’’;

reg1 after 5 ns when ‘‘001’’;



reg4 after 5 ns when others;

end comportemental;


Le

VH

DL

Les délais

• VHDL permet de modéliser différents types de délais, qui sont utiles lors des simulations: Délais d’inertie (inertial delay): représentent la durée minimum

d’une entrée pour que son effet puisse être observé à la sortie. Utile pour tenir compte du temps de montée/descente

• E.g.: sum <= reject 2 ns inertial (a xor b) after 5 ns;

Délais de transport: représentent le délai encouru par les interconnections. Utile pour tenir compte des délais RC dans les longs fils

• E.g.: sum <= transport (a xor b) after 5 ns;

Délais « delta »: utilisés à l’interne par les simulateurs pour ordonner l’arrivée des signaux


Le

VH

DL

Les délais: exemple

library IEEE;



port(a, b: in std_logic;

sum, carry: out std_logic);

end half_adder;

architecture delai_transport of half_adder is

signal s1, s2: std_logic := ‘0’;

begin

s1 <= (a xor b) after 2 ns;

s2 <= (a and b) after 2 ns;

sum <= transport s1 after 4 ns;

carry <= transport s2 after 4 ns;

end delai_transport;

ab

sum

carrys2

s1

sum

carry

b

a

s1

s2

2 4 6 8 10 12Temps (ns)

inertie

transport


Le

VH

DL

Les délais: exemple

library IEEE;


entity circuit is


z: out std_logic);

end circuit;

architecture circ of circuit is

signal s1, s2, s3, s4: std_logic;

begin

s1 <= not a;

s2 <= not b;

s3 <= not ( s1 and b);

s4 <= not (s2 and a);

z <= not (s3 and s4);

end circ;

s1

s2

b

a

s3

z

2 4 6 8 10 12Temps (ns)

a

b

z

s2

s1 s3

s4

s4


Le

VH

DL

Les délais: exemple a

b

z

s2

s1 s3

s4

s1

s2

b

a

s3

z

2 4 6 8 10 12Temps (ns)

s4

b

s2

s3

z

2 2 3 4 Temps (ns)


Le

VH

DL

Modélisation de comportement

• Pour décrire des systèmes plus complexes qu’un petit groupe de simples portes logiques, nous devons ajouter un nouveau concept: le processus (process)

• Le «process » a une liste de dépendance (dependency list). Lorsqu’un ou plusieurs signaux de la liste sont modifiés, le process est enclenché


Le

VH

DL

Les processus: exemple

library IEEE;


use IEEE.std_logic_arith.all;

entity mem is

port(addr: in std_logic_vector (31 downto 0);

wr_data: in std_logic_vector (31 downto 0);

Mem_wr, Mem_rd: in std_logic;

rd_data: out std_logic_vector (31 downto 0);

end mem;

architecture comport of mem istype memo_arr is array(0 to 3) of std_logic_vector

(31 downto 0);

begin memo_proc: process ( addr, wr_data)

variable data_memo: memo_arr := (to_stdlogicvector(X’’00000000’’),

to_stdlogicvector(X’’00000000’’),

to_stdlogicvector(X’’00000000’’),

to_stdlogicvector(X’’00000000’’));

variable addr_int: integer;

begin

addr_int := to_integer(addr (1 downto 0));

if (Mem_wr = ‘1’ then

data_memo(addr_int) := wr_data;

elsif Mem_rd = ‘1’ then

rd_data <= data_memo(addr_int);

end if;

end process memo_proc;

end comport;


Le

VH

DL

If, Case, For et While

• À l’intérieur d’un « process », on peut utiliser des « if » et/ou des « case ». L’exécution est alors séquentielle

• De même, on peut utiliser des boucles pour contrôler l’exécution. Les « for » sont à bornes fixes, alors que les « while » ne le sont pas.


Le

VH

DL

If, case: exemple

library IEEE;



port(a, b: in bit;


end half_adder;

architecture proc_add of half_adder is

begin

sum_proc: process (a, b)

begin

if (a = b) then

sum <= ‘0’ after 5 ns;

else

sum <= (a or b) after 5 ns;

end if;

end process sum_proc;

carry_proc: process (a, b)

begin

case a is

when ‘0’ =>

carry <= a after 5 ns;

when ‘1’ =>

carry <= b after 5 ns;

when others =>

carry <= ‘X’ after 5 ns;

end case;

end process carry_proc;

end proc_add;


Le

VH

DL

For loop: exemple

library IEEE;


use IEEE.std_logic_arith.all;

entity mult32 is

port(mult1: in std_logic_vector (31 downto 0);

mult2: in std_logic_vector (31 downto 0);

prod: out std_logic_vector (63 downto 0));

end mult32;

architecture comp_mult of mult32 is

constant delai_module: Time:= 10 ns;

begin

mult_proc: process (mult1, mult2)

variable prod_reg : std_logic_vector (63 downto 0) := to_stdlogicvector(X’’0000000000000000’’);

variable mult_reg : std_logic_vector (31 downto 0) := to_stdlogicvector(X’’00000000’’);

begin

mult_reg := mult1;

prod_reg (63 downto 0) :=

to_ stdlogicvector(X’’00000000’’) & mult2;

for index in 1 to 32 loop

if prod_reg(0) = ‘1’ then

prod_reg(63 downto 32) :=

prod_reg(63 downto 32)

+ mult_reg(31 downto 0);

end if;

prod_reg(63 downto 0) :=

‘0’ & prod_reg (63 downto 1);

end loop;

prod <= prod_reg after delai_module;

end process mult_proc;

end comp_mult;


Le

VH

DL

Communication entre processus

• Les signaux sont globaux: il est possible à un processus d’accéder (lire et/ou écrire) un signal d’un autre processus

• La communication entre processus se fait donc à l’aide de signaux

• Note: on parle ici de processus qui font partie d’une même architecture…

• Exemple: additionneur 1-bit


Le

VH

DL

Exemple de communication entre processus: additionneur 1-bit

Demi-additionneurHA1

Demi-additionneurHA2

Somme

C_out

In1

In2

C_in

Demi-additionneur

s1

s3

s2

OR1


Le

VH

DL

Exemple de communication entre processus: additionneur 1-bit

library IEEE;


entity add_1_bit is

port(In1, In2, C_in: in std_logic;

Somme, C_out: out std_logic);

end add_1_bit;

architecture comp_add of add_1_bit is

signal s1, s2, s3: std_logic;

constant delai: Time:= 5 ns;

begin

HA1: process(In1, In2)

begin

s1 <= (In1 xor In2) after delai;

s3 <= (In1 and In2) after delai;

end process HA1;

HA2: process(s1, C_in)

begin

Somme <= (s1 xor C_in) after delai;

s2 <= (s1 and C_in) after delai;

end process HA2;

OR1: process(s2, s3)

begin

C_out <= (s2 or s3) after delai;

end process OR1;

end comp_add;


Le

VH

DL

L’instruction « wait »

• Il est possible de définir un « process » sans liste de dépendance. Chaque « process » est toujours exécuté au moins une fois, au début

• En ajoutant des énoncés « wait », il devient possible d’indiquer que le « process » sera réveillé à un certain endroit, selon une certaine condition: wait for time

wait on signal

wait until condition


Le

VH

DL

Les attributs dans VHDL

• Il existe un certain nombre d’attributs avec le VHDL, qui permettent d’utiliser de l’information sur l’état des signaux ou sur leur définition: Var’event : Changement sur Var

Var’active : Assignation sur Var (peut être la même valeur

Var’last_event : Retourne le temps depuis le dernier

événement

Var’last_value : Retourne la valeur précédente de Var


Le

VH

DL

Exemple de wait et d’attributs: flip-flop

library IEEE;


entity dff is

port(D, Clk: in std_logic;

Q, QN: out std_logic);

end dff;

architecture comp_dff of dff is


begin

One_ff: process

begin

wait until (Clk’event and Clk = ‘1’);

Q <= D after delai;

QN <= not D after delai;

end process One_ff;

end comp_dff;


Le

VH

DL

Exemple de wait et d’attributs: flip-flop asynchrone

library IEEE;


entity async_dff is

port(D, Clk, S, R: in std_logic;

Q, QN: out std_logic);

end async_dff;

architecture comp_adff of async_dff is


begin

One_aff: process(R, S, Clk)

begin

if (R = ‘1’) then

Q <= ‘0’ after delai;

QN <= ‘1’ after delai;

elsif (S = ‘1’) then

Q <= ‘1’ after delai;

QN <= ‘0’ after delai;

elsif (Clk’event and Clk = ‘1’) then

Q <= D after delai;

QN <= not D after delai;

end if;

end process One_aff;

end comp_adff;


Le

VH

DL

Exemple de registre

library IEEE;


entity registre is

port(D: in std_logic_vector (31 downto 0);

Cl, enable, Clk : in std_logic;

Q : out std_logic_vector (31 downto 0));

end registre;

architecture comp_reg of registre is


begin

Reg_proc: process(Cl, Clk)

begin

if (Cl = ‘1’) then

Q <= X’’00000000’’ after delai;

elsif (Clk’event and Clk = ‘1’) then

if (enable = ‘1’) then

Q <= D after delai;

end if;

end if;

end process Reg_proc;

end comp_reg;


Le

VH

DL

Génération d’une horloge

• À l’aide du VHDL, il est facile de générer un signal d’horloge périodique:

library IEEE;


entity horloge is

port(Clk : out std_logic);

end horloge;

architeture comp_horloge of horloge is

begin

proc_horloge: process

Clk <= ‘0’, ‘1’ after 5 ns;

wait for 10 ns;

end process proc_horloge;

end comp_horloge;


Le

VH

DL Les process: ils peuvent

ne pas faire ce que vous pensez…

library IEEE;


entity circuit is


z: out std_logic);

end circuit;



begin

process(a, b)

begin

s1 <= not a;

s2 <= not b;




end process;

end circ;

a

b

z

s2

s1 s3

s4

library IEEE;


entity circuit is


z: out std_logic);

end circuit;



begin

s1 <= not a;

s2 <= not b;




end circ;


Le

VH

DL Les process: ils peuvent

ne pas faire ce que vous pensez…

a

b

z

s2

s1 s3

s4

s1

s2

b

a

s3

z

2 4 6 8 10 12Temps (ns)

s4

s1

s2

b

a

s3

z

2 4 6 8 10 12Temps (ns)

s4


Le

VH

DL

Représentation hiérarchique

• On peut utiliser VHDL de façon hiérarchique et ainsi simplifier la description d’une machine complexe.


Le

VH

DL

Exemple de représentation hiérarchique: un additionneur: portes XOR et AND

library IEEE;


entity one_xor is

port(In1, In2 : in std_logic;

Z: out std_logic);

end one_xor;

architecture comp_xor of one_xor is


begin

z <= (In1 xor In2) after delai;

end comp_xor;

library IEEE;


entity one_and is


Z: out std_logic);

end one_and;

architecture comp_and of one_and is


begin

z <= (In1 and In2) after delai;

end comp_and;


Le

VH

DL

Exemple de représentation hiérarchique: un additionneur: porte OU

library IEEE;


entity one_or is


Z: out std_logic);

end one_or;

architecture comp_or of one_or is


begin

z <= (In1 or In2) after delai;

end comp_or;


Le

VH

DL

Exemple de représentation hiérarchique: un additionneur: demi-additionneur

library IEEE;


entity one_half_adder is


sum, c_out: out std_logic);

end one_half_adder;

architecture comp_ha of one_half_adder is

component xor_gate

port (In_1, In2: in std_logic;

z: out std_logic);

end component;

component and_gate


z: out std_logic);

end component;

for XOR1: xor_gate use entity work.one_xor(comp_xor);

for AND1: and_gate use entity work.one_and(comp_and);

begin

XOR1:xor_gate port map(In1, In2, sum);

AND1:and_gate port map(In1, In2, c_out);

end comp_ha;


Le

VH

DL

Exemple de représentation hiérarchique: un additionneur: l’ensemble

library IEEE;


entity one_adder is

port(In1, In2, C_in : in std_logic;


end one_adder;

architecture comp_add of one_adder is

component half_addr



end component;

component or_gate


z: out std_logic);

end component;

for HA1: half_addr use entity work.one_half_adder(comp_ha);

for HA2: half_addr use entity work.one_half_adder(comp_ha);

for OR1: or_gate use entity work.one_or(comp_or);

signal s1, s2, s3: std_logic;

begin

HA1:half_addr port map(In1, In2, s1, s3);

HA2:half_addr port map(s1, C_in, sum, s2);

OR1:or_gate port map(s2, s3, c_out);

end comp_add;

Gei 431 Architecture des ordinateurs II – Frédéric Mailhot Le VHDL De nos jours, les circuits...

Documents

Transcript of Gei 431 Architecture des ordinateurs II – Frédéric Mailhot Le VHDL De nos jours, les circuits...