Matériel vs logiciel : comment Verilog pense différemment de C ou Python

Le temps logiciel vs le temps matériel

Dans un programme, le temps avance une instruction à la fois. Le CPU termine la ligne 1, puis exécute la ligne 2. Si tu veux que deux choses se passent en même temps, tu utilises des threads, de l'async, ou une deuxième machine.

Dans le matériel, tout se passe en même temps. Un circuit ne prend pas son tour. L'additionneur additionne en permanence, le multiplexeur sélectionne en permanence, le flip-flop surveille l'horloge en permanence. Il n'y a pas de compteur de programme. Il n'y a pas de « ligne en cours ».

Verilog doit décrire ce monde en texte. La façon dont il s'y prend est la source de toutes les confusions dans ce chapitre.

Deux couches de concurrence

Quand tu lis un module Verilog, tu regardes deux choses différentes en même temps :

1. La description statique du circuit. Wires, registres, instances de portes, instances de sous-modules, assignations continues. Tout ça existe simultanément. L'ordre dans le fichier n'a pas d'importance.
2. Les blocs procéduraux - initial et always - qui ressemblent à de petits programmes que le simulateur déroule. À l'intérieur de l'un de ces blocs, les instructions s'exécutent dans un certain ordre. Mais plusieurs blocs always peuvent être actifs en même temps, chacun dans son propre fil de temps simulé.

module example(input wire a, input wire b, output wire y, output wire z);
    assign y = a & b;        // existe à tout instant
    assign z = a | b;        // existe aussi à tout instant, en parallèle

    always @(posedge a) begin
        // un autre réacteur « always-on » qui se réveille
        // à chaque front montant de `a`
    end
endmodule

Les deux lignes assign ne forment pas une séquence. Elles décrivent deux morceaux de logique combinatoire que l'outil de synthèse peut placer côte à côte. Le bloc always est une troisième chose qui se passe en parallèle.

Ce que « signal » veut dire

En logiciel, une variable retient une valeur jusqu'à ce que tu la changes. En Verilog, un signal retient une valeur en permanence - et à chaque instant elle dépend de ce qui le pilote.

Un wire est piloté depuis l'extérieur (un assign, le port de sortie d'un sous-module, une connexion inout). Un reg est piloté depuis l'intérieur d'un bloc procédural. Les deux ont une valeur à tout instant. Il n'existe rien qui ressemble à « non initialisé » au sens où C l'entend - les signaux sont soit pilotés à une valeur définie, soit à l'inconnu spécial x, soit à la haute impédance z. On couvre les deux derniers dans Valeurs X et Z.

Les horloges changent tout

Dès que tu introduis une horloge, le temps commence à compter. Un flip-flop est un minuscule morceau de matériel qui capture la valeur de son entrée sur le front montant (ou descendant) d'une horloge et la maintient jusqu'au front suivant. C'est l'horloge qui te permet de construire des compteurs, des machines à états, des pipelines - tout ce qui a de la mémoire.

module reg_demo(input wire clk, input wire d, output reg q);
    // q capture d à chaque front montant de l'horloge.
    always @(posedge clk) begin
        q <= d;
    end
endmodule

module test;
    reg clk = 0;
    reg d   = 0;
    wire q;

    reg_demo dut(.clk(clk), .d(d), .q(q));

    always #5 clk = ~clk;

    initial begin
        #2  d = 1; $display("t=%0t d=%b q=%b", $time, d, q);
        #10 d = 0; $display("t=%0t d=%b q=%b", $time, d, q);
        #10 $display("t=%0t d=%b q=%b", $time, d, q);
        #1  $finish;
    end
endmodule

Remarque q <= d plutôt que q = d. C'est une assignation non-blocking - le pilier de la logique cadencée. Elle dit « au prochain front d'horloge, planifie que q devienne ce que d est maintenant ». On creuse les règles dans Blocking vs Non-blocking ; pour l'instant, retiens que l'assignation ne fait pas semblant d'être une instruction logicielle.

RTL : le modèle mental Register Transfer

La majorité du Verilog synthétisable est écrite dans un style appelé Register Transfer Level, ou RTL. L'idée est simple :

• Décide quel état ton circuit a besoin de tenir (les registres).
• Pour chaque registre, décris deux choses : ce qui le reset, et la logique combinatoire qui calcule sa prochaine valeur.
• Connecte les sorties de la logique combinatoire aux entrées des registres et tu as un circuit fonctionnel.

always @(posedge clk) begin
    if (reset) state <= IDLE;
    else       state <= next_state;
end

always @(*) begin
    case (state)
        IDLE:   next_state = start ? RUNNING : IDLE;
        RUNNING: next_state = done  ? IDLE    : RUNNING;
        default: next_state = IDLE;
    endcase
end

C'est une machine à deux états. Le premier bloc always est cadencé - c'est un flip-flop. Le second est purement combinatoire - c'est juste une équation. Presque toutes les machines à états, compteurs et pipelines que tu écriras suivent cette forme.

Les habitudes qui te bloquent

Si tu viens du logiciel, voici une courte liste d'habitudes à laisser de côté :

• « Les variables se mettent à jour quand je les assigne. » Pas sur un front d'horloge - une assignation non-blocking planifie la mise à jour pour la fin du pas de temps.
• « Les instructions s'exécutent du haut vers le bas. » En dehors des blocs procéduraux, non. À l'intérieur d'un bloc cadencé, plus ou moins - mais blocking vs non-blocking change le sens de « dans l'ordre ».
• « J'alloue ça quand j'en aurai besoin. » Le matériel n'alloue pas. Chaque registre et chaque porte doit exister au moment de la synthèse. La taille de chaque vecteur est fixe.
• « Cette boucle est rapide - ce n'est qu'une opération. » Une boucle for en Verilog synthétisable est déroulée en matériel parallèle. Une boucle de 64 itérations devient 64 copies du corps, pas une instruction CPU qui tourne 64 fois.

Tu n'apprends pas à écrire un programme. Tu apprends à décrire un circuit. L'instinct de lire du haut vers le bas est exactement le mauvais et il faut un certain temps pour le rééduquer.

La suite

Les prochains documents te guident à travers l'installation d'une toolchain locale (optionnel - l'éditeur en ligne suffit), puis l'écriture de ton premier module from scratch. On reviendra sur le contraste matériel-vs-logiciel chaque fois que quelque chose paraîtra bizarre, parce que la majorité des parties « bizarres » ont la même cause racine : ce n'est pas du logiciel.