Mots-clés : bloc séquentiel, bloc parallèle, bloc imbriqué, bloc nommé, disable
Les blocs d'instructions Verilog fournissent un mécanisme permettant de regrouper deux instructions ou plus dans une structure syntaxiquement équivalente à une seule instruction. Il existe principalement deux types : les blocs séquentiels et les blocs parallèles.
Bloc séquentiel
Un bloc séquentiel est représenté par les mots-clés begin et end.
Les instructions d'un bloc séquentiel sont exécutées une par une. Bien sûr, les affectations non bloquantes font exception.
Le délai de chaque instruction dans un bloc séquentiel est toujours lié au temps d'exécution de l'instruction qui la précède.
Dans les simulations précédant cette section, les affectations bloquantes dans les blocs initial sont toutes des instances de blocs séquentiels.
Bloc parallèle
Un bloc parallèle est représenté par les mots-clés fork et join.
Les instructions dans un bloc parallèle sont exécutées en parallèle, même s'il s'agit d'affectations bloquantes.
Le délai de chaque instruction dans un bloc parallèle est lié au moment où l'instruction du bloc commence son exécution.
La différence entre les blocs séquentiels et les blocs parallèles est évidente ; la simulation suivante l'illustre.
Le code de simulation est le suivant :
Exemple
module test ;
reg [3:0] ai_sequen, bi_sequen ;
reg [3:0] ai_paral, bi_paral ;
reg [3:0] ai_nonblk, bi_nonblk ;
//============================================================//
//(1)Bloc séquentiel
initial begin
#5 ai_sequen = 4'd5 ; //à 5ns
#5 bi_sequen = 4'd8 ; //à 10ns
end
//(2) bloc fork
initial fork
#5 ai_paral = 4'd5 ; //à 5ns
#5 bi_paral = 4'd8 ; //à 5ns
join
//(3)bloc non bloquant
initial fork
#5 ai_nonblk <= 4'd5 ; //à 5ns
#5 bi_nonblk <= 4'd8 ; //à 5ns
join
endmodule
Les résultats de simulation sont les suivants :
Comme le montre la figure, le bloc séquentiel s'exécute séquentiellement, et à 10ns, le signal bi_sequen ne reçoit qu'une valeur de 8.Dans le bloc parallèle, les affectations de ai_paral et bi_paral sont exécutées simultanément, donc les deux sont affectées à 5ns.
Les affectations non bloquantes peuvent également produire le même effet d'affectation qu'un bloc parallèle.

Bloc imbriqué
Les blocs séquentiels et les blocs parallèles peuvent également être imbriqués.
Le code de simulation est le suivant :
Exemple
module test ;
reg [3:0] ai_sequen2, bi_sequen2 ;
reg [3:0] ai_paral2, bi_paral2 ;
initial begin
ai_sequen2 = 4'd5 ; //à 0ns
fork
#10 ai_paral2 = 4'd5 ; //à 10ns
#15 bi_paral2 = 4'd8 ; //à 15ns
join
#20 bi_sequen2 = 4'd8 ; //à 35ns
end
endmodule
Les résultats de simulation sont les suivants :
Les instructions dans le bloc parallèle sont exécutées en parallèle, donc les signaux ai_paral2 et bi_paral2 sont affectés à 10ns et 15ns respectivement. Le temps d'exécution le plus long dans le bloc parallèle est de 15ns, donc le signal bi_sequen2 dans le bloc séquentiel est affecté à 35ns.

Bloc nommé
Nous pouvons nommer les structures d'instructions de bloc.
Les variables locales peuvent être déclarées dans un bloc nommé, et il est possible d'accéder aux variables via des références de nom hiérarchique.
Le code de simulation est le suivant :
Exemple
module test;
initial begin: example //Nommez le bloc nommé example ; le point-virgule ne peut pas être omis
integer i ; //Cette variable peut être utilisée par d'autres modules via test.example.i
i = 0 ;
forever begin
#10 i = i + 10 ;
end
end
reg stop_flag ;
initial stop_flag = 1'b0 ;
always begin : detect_stop
if ( test.example.i == 100) begin //i est incrémenté 10 fois, c.-à-d. que la simulation s'arrête à 100ns
$display("Vous pouvez maintenant arrêter la simulation !!!");
stop_flag = 1'b1 ;
end
#10 ;
end
endmodule
Les résultats de simulation sont les suivants :
Un bloc nommé peut aussi être désactivé, représenté par le mot-clé disable.
disable peut terminer l'exécution d'un bloc nommé et peut être utilisé pour sortir d'une boucle, gérer les erreurs, etc.
Il est similaire à break en langage C, mais break ne peut sortir que de la boucle courante, tandis que disable peut désactiver n'importe quel bloc nommé de la conception.
Le code de simulation est le suivant :
Exemple
module test;
initial begin: example_d //Nommer le bloc nommé example_d
entier i_d ;
i_d = 0 ;
while(i_d<=100) begin: example_d2
# 10 ;
if (i_d >= 50) begin //Arrêter l'incrémentation après 5 incréments
disable example_d3.clk_gen ;//Arrêter le bloc externe : clk_gen
disable example_d2 ; //Arrêter le bloc courant : example_d2
end
i_d = i_d + 10 ;
end
end
reg clk ;
initial begin: example_d3
while (1) begin: clk_gen //Module de génération d'horloge
clk=1 ; #10 ;
clk=0 ; #10 ;
end
end
endmodule
Les résultats de simulation sont les suivants :
Comme on peut le voir sur la figure, le signal i_d cesse d'être incrémenté après avoir atteint 50, et l'horloge clk n'est plus générée par la suite.
On peut voir que disable sort du bloc while courant.
Il convient de noter que lorsque disable est utilisé dans un bloc always ou forever, il ne peut sortir que de l'itération courante ; la prochaine fois, l'instruction s'exécutera toujours dans le bloc always ou forever. Comme les blocs always et les blocs forever s'exécutent en continu, disable à ce stade est quelque peu similaire à la fonction continue du langage C.
Téléchargement du code source
Téléchargement
