Discussion :

[Iradrille]

Hello,

Je débute en VHDL, et plusieurs trucs me posent problèmes, notament quel formalisme utiliser dans quelle situation. Pour citer l'introduction au VHDL de Developpez

Trois grands formalismes coexistent pour décrire les architectures :
flot de données : on écrit explicitement les fonctions booléennes que l'on veut voir implémentées (à réserver aux plus petits circuits pour des raisons de lisibilité) ; c'est lui qu'on a utilisé pour implémenter le demi-additionneur ;
structurel : on décrit le circuit comme une série de boîtes noires interconnectées au moyen de signaux (utilisé pour des circuits moyens ou grands) ; on procèdera de cette manière pour synthétiser un additionneur complet à l'aide de deux demi-additionneurs ;
comportemental : de manière très semblable à un langage de programmation informatique, on précise le fonctionnement voulu à l'aide d'une suite d'instructions de contrôles plus ou moins évoluées (conditions, boucles, etc.), dans un process.

Par exemple l'article prend l'exemple d'un additionneur sur 1 bit, on pourrait aussi le définir comme ça (pas vraiment sur de la syntaxe - code non testé - mais vous voyez l'idée)

Code vhdl :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
 
entity adder is
	generic(REG_SIZE : integer);
	port(clk : in std_logic;
		i0 : in unsigned(REG_SIZE-1 downto 0);
		i1 : in unsigned(REG_SIZE-1 downto 0);
		o : out unsigned(REG_SIZE-1 downto 0); -- = i0 + i1
		c : out std_logic); -- retenue
end adder;
 
architecture adder_bhv of adder is
begin
	P0: process(clk)
	variable tmp : unsigned(REG_SIZE downto 0);
	begin
		if(rising_edge(clk)) then
			tmp := ('0' & i0) + ('0' & i1);
			o <= tmp(REG_SIZE-1 downto 0);
			c <= tmp(REG_SIZE);
		end if;
	end process;
end adder_bhv;

C'est beaucoup plus simple (pas forcément pour 1 bit, mais pour 8+ bits ça simplifie grandement les choses).

Qu'est ce que ça change exactement ? Le circuit généré sera-t-il le même ?
Peut-on voir ça comme l'inline assembly dans un programme C ou C++ : permettre d'implémenter certaines choses d'une manière plus optimisé que ce que le compilo est capable de faire ?

Il est possible de vérifier la logique d'un circuit avec des test benchs, mais est-il possible de vérifier que les timings soient correct ? Ça dépend du matériel sur lequel est implémenté le circuit je suppose, mais est-il possible de simuler ça ?
(J'utilise actuellement GHDL + GTKWave)

Question différente, y à t'il de bonnes références sur Internet, ou de bons bouquins pour se lancer la dedans ?
Apparemment ce livre est bon, quelqu'un peut confirmer / infirmer ?

Et dernière question : le VHDL permet de définir des choses qu'on peut simuler mais pas implémenter sur un FPGA ou un ASIC, comment savoir si du code est implémentable ou pas ?

[mith06]

Bonjour voila une série de questions intelligentes!!

Voila comment je vois les chose:
-Toujours écrire le code pour qu'il soit le plus lisible possible
-Etrangement code lisible est une efficace (pas le plus efficace mais suffisamment efficace)
-Croire que tu es est plus fort que le synthétiseur revient à croire que tu es plus fort que Chuck Norris....
-Ne pas écrire une seule ligne que l'on ne comprend pas.
-Ne jamais mettre rien d'autre dans la liste de sensibilité d'un process que l'horloge et le reset (si asynchrone)


Voici comment j'aurais fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
library IEEE;
    use IEEE.std_logic_1164.all;
    use IEEE.numeric_std.all;
    use IEEE.std_logic_unsigned.all;
 
entity UNSIGNED_ADDER is
    generic
    (
        DATA_WIDTH  : natural range 1 to 64 := 18
    );
    port
    (
        RST     : in std_logic;
        CLK     : in std_logic;
        --  
        ND      : in std_logic;     --assert DIN_A or DIN_B
        DIN_A   : in std_logic_vector(DATA_WIDTH-1 downto 0);
        DIN_B   : in std_logic_vector(DATA_WIDTH-1 downto 0);
        --  
        DRY     : out std_logic;    --assert DOUT
        DOUT    : out std_logic_vector(DATA_WIDTH downto 0)
    );
end entity ADDER;
 
architecture RTL of ADDER is
 
begin
    add_prcs : process(RST,CLK)
    begin
        if(RST = '1')then       --asynchronous reset
            DRY     <= '0';
            DOUT    <= (others => '0');
        elsif(rising_edge(CLK))then
            DRY     <= ND;      --1 cycle latency
            CE:if(ND = '1')then --Clock enable
                DOUT    <=  std_logic_vector(
                                resize(unsigned(DIN_A),DATA_WIDTH+1) + 
                                resize(unsigned(DIN_B),DATA_WIDTH+1));
            end if CE;
        end if;
    end process add_prcs;
end architecture RTL;

Mais si je veux utiliser une addition j'utilise '+' je ne vais pas instancier un additionneur. Par contre si je veux une multiplication je vais instancier un multiplieur...

Qu'est ce que ça change exactement ?

Rien

Le circuit généré sera-t-il le même ?

Oui, la "carry chain" utilisée sera plus ou moins longue.

Peut-on voir ça comme l'inline assembly dans un programme C ou C++ : permettre d'implémenter certaines choses d'une manière plus optimisé que ce que le compilo est capable de faire ?

Certainement pas. Le seul point commun que je vois entre le VHDL et des langages de programmation ce sont les mots "code source" sinon tous le reste est différent.

Il est possible de vérifier la logique d'un circuit avec des test benchs, mais est-il possible de vérifier que les timings soient correct ? Ça dépend du matériel sur lequel est implémenté le circuit je suppose, mais est-il possible de simuler ça ?

Oui, une foi que le synthétiseur a fait sont travail de placement et de routage il peut te fournir un fichier de simulation qui correspond à ce qu'il a produit.
Maintenant une question: Le synthétiseur te dits que toutes les contraintes de timing sont respectées, que fais-tu si la simulation te dit le contraire?

Question différente, y à t'il de bonnes références sur Internet, ou de bons bouquins pour se lancer la dedans ?

Certainement, mais la plupart des codes que j'ai vu sont piètre qualité...
J'avais pris des livres chez DUNO qui étaient pas mal....

Et dernière question : le VHDL permet de définir des choses qu'on peut simuler mais pas implémenter sur un FPGA ou un ASIC, comment savoir si du code est implémentable ou pas ?

Ça saute aux yeux avec l'expérience:
-liste de mot clef non synthétisable ,wait, until, time, asser(condition) report "String "severity error, real, les fichier un général,la division, la plus part des boucle...
-les design de type court-circuit

-bonne pratique:
-process(RST,CLK) ou process(CLK) ET PAS AUTRE CHOSE!!!
-éviter les variables dans les process
-éviter les boucle dans les process
-éviter les signaux de type integer
-std_logic, std_logic_vector, signed et unsigned sont tes amis
-Utiliser + et - pour l'addition et la soustraction, pour * / instancier un composant
-Pour les FPGA NE PAS HESITER A PIPELINER LE DESIGN

[Iradrille]

Oui, une foi que le synthétiseur a fait sont travail de placement et de routage il peut te fournir un fichier de simulation qui correspond à ce qu'il a produit.
Maintenant une question: Le synthétiseur te dits que toutes les contraintes de timing sont respectées, que fais-tu si la simulation te dit le contraire?

J'aurais tendance à croire n'importe quel soft qui me dise que mon truc marche pas, et je chercherai l'erreur.

-Pour les FPGA NE PAS HESITER A PIPELINER LE DESIGN

Par ça, tu entends ce genre de choses ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
entity foo is
	port(clk : in std_logic;
		i : in std_logic;
		o : out std_logic);
end foo;
 
architecture foo_bhv of foo is
begin
	signal DELAY1, DELAY2 : std_logic;
	P0: process(clk)
	begin
		if(rising_edge(clk)) then
			DELAY1 <= i; -- 1er front montant
			DELAY2 <= DELAY1; -- 2eme front montant
			o <= DELAY2; -- 3eme front montant
		end if;
	end process;
end foo_bhv;

Pour une entrée donnée, la sortie serait disponible 3 fronts montants plus tard (bon bien sur, c'est inutile ici).

En tout cas merci pour ta réponse j'y vois un peu plus clair.

[mith06]

J'aurais tendance à croire n'importe quel soft qui me dise que mon truc marche pas, et je chercherai l'erreur.

Je connais le monde du FPGA pas de l'ASIC
Je n'ai jamais fait tourné une simulation post synthèse ou pire poste post routage.
Le faire revient à estimer que l'outil de synthèse/placement/routage est bugué (Il ne l'est pas).
Par contre faire tourner des simulations avec de synthétiser le code c'est 60% du métier.

Quand un truc marche en simulation mais pas sur cible, c'est que soit le design est soit mal testé, ou mal contraint (fichier .ucf Xilinx, exemple timing sur les DDR3).
Si tu ne trouve pas le problème en simulation ChipScope te sauvera la vie (Xilinx).