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

`timescale 1ns/1ns
 
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

`timescale      1ns/1ns
 
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

`timescale 1ns/1ns
 
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

`timescale 1ns/1ns
 
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