Créer un testbench SystemVerilog de A à Z

Construire un testbench exécutable : instancier le DUT, produire horloge et reset, appliquer les scénarios, contrôler les sorties et terminer avec un verdict fiable.

Le résultat attendu

Un testbench est du code de simulation qui place le design à vérifier, le DUT (Design Under Test), dans des situations choisies. Il doit produire un verdict sans obliger à inspecter chaque forme d'onde.

À la fin de ce chapitre, le testbench saura :

instancier et connecter le DUT ;
générer l'horloge et le reset ;
appliquer des stimuli au bon moment ;
calculer ou mémoriser les résultats attendus ;
comparer automatiquement attendu et observé ;
détecter un blocage et terminer avec PASS ou FAIL.

Le fichier du testbench porte généralement un nom comme pulse_counter_tb.sv. Il n'est pas synthétisable et ne devient pas du matériel dans le FPGA.

Environnement de test SystemVerilog avec scénarios, driver, interface, DUT, monitor, modèle de référence et scoreboard

Le chemin cyan applique les stimuli au DUT. Le chemin violet reconstruit ce qui s'est réellement produit. Le chemin vert calcule le résultat attendu indépendamment, puis le scoreboard confronte les deux chemins.

Partir du contrat, pas du code interne

L'exemple vérifie un compteur 4 bits nommé pulse_counter. Son contrat est volontairement court :

Port	Rôle
`i_clk`	le compteur agit au front montant
`i_rst_n`	reset asynchrone actif à 0

module pulse_counter_tb;
  timeunit 1ns;
  timeprecision 1ps;
 
  localparam time CLK_PERIOD = 10ns;
 
  logic       clk     = 1'b0;
  logic       rst_n   = 1'b0;
  logic       enable  = 1'b0;
  logic [3:0] count;
 
  pulse_counter dut (
    .i_clk    (clk),
    .i_rst_n  (rst_n),
    .i_enable (enable),
    .o_count  (count)
  );
 
  always #(CLK_PERIOD / 2) clk = ~clk;
endmodule

module pulse_counter_tb;
  timeunit 1ns;
  timeprecision 1ps;
 
  localparam time CLK_PERIOD = 10ns;
 
  logic       clk     = 1'b0;
  logic       rst_n   = 1'b0;
  logic       enable  = 1'b0;
  logic [3:0] count;
 
  int unsigned checks = 0;
  int unsigned errors = 0;
 
  pulse_counter dut (
    .i_clk    (clk),
    .i_rst_n  (rst_n),
    .i_enable (enable),
    .o_count  (count)
  );
 
  always #(CLK_PERIOD / 2) clk = ~clk;
 
  task automatic check_count(
    input logic [3:0] expected,
    input string      case_name
  );
    checks++;
 
    count_matches_a: assert (count === expected) begin
      // Réussite : le compteur de contrôles suffit.
    end else begin
      errors++;
      $error("%s: count=%h, attendu=%h, temps=%0t",
             case_name, count, expected, $time);
    end
  endtask
 
  // Le premier appel a lieu sur un front descendant. Chaque appel revient
  // sur le front descendant suivant, prêt pour le scénario suivant.
  task automatic step_and_check(
    input logic       next_enable,
    input logic [3:0] expected,
    input string      case_name
  );
    enable <= next_enable;
    @(negedge clk);
    check_count(expected, case_name);
  endtask
 
  initial begin : test_sequence
    logic [3:0] expected;
 
    expected = '0;
 
    // Le premier front montant se produit pendant le reset.
    @(negedge clk);
    check_count('0, "reset initial");
    rst_n <= 1'b1;
 
    // Trois incréments consécutifs.
    repeat (3) begin
      expected++;
      step_and_check(1'b1, expected, "comptage actif");
    end
 
    // enable=0 doit conserver la valeur.
    step_and_check(1'b0, expected, "maintien");
 
    // Treize incréments depuis 3 doivent traverser 15 et revenir à 0.
    repeat (13) begin
      expected++;
      step_and_check(
        1'b1,
        expected,
        $sformatf("test du modulo, attendu=%0d", expected)
      );
    end
 
    // Vérifier aussi le reset après une période d'activité.
    repeat (3) begin
      expected++;
      step_and_check(1'b1, expected, "préparation du reset en activité");
    end
 
    rst_n  <= 1'b0;
    enable <= 1'b1;
    @(negedge clk);
    expected = '0;
    check_count(expected, "reset en activité");
    rst_n <= 1'b1;
    enable <= 1'b0;
 
    if (checks == 0)
      $fatal(1, "FAIL: aucun contrôle exécuté");
 
    if (errors == 0) begin
      $display("PASS: %0d contrôles", checks);
      $finish;
    end
 
    $fatal(1, "FAIL: %0d erreur(s) sur %0d contrôles", errors, checks);
  end
 
  initial begin : watchdog
    #(30 * CLK_PERIOD);
    $fatal(1, "FAIL: timeout à %0t", $time);
  end
endmodule

interface counter_if(input logic clk);
  logic       rst_n;
  logic       enable;
  logic [3:0] count;
 
  clocking tb_cb @(negedge clk);
    default input #1step output #0;
    output rst_n, enable;
    input  count;
  endclocking
 
  modport dut (
    input  clk, rst_n, enable,
    output count
  );
 
  modport tb (clocking tb_cb);
endinterface

task automatic check_add(
  input logic [7:0] lhs,
  input logic [7:0] rhs
);
  logic [8:0] expected;
 
  a = lhs;
  b = rhs;
  expected = {1'b0, lhs} + {1'b0, rhs};
  #1ns;
 
  assert (sum === expected)
    else $error("a=%0d b=%0d sum=%0d attendu=%0d",
                lhs, rhs, sum, expected);
endtask

Créer un testbench SystemVerilog de A à Z

Le résultat attendu

Partir du contrat, pas du code interne

La structure minimale

Un testbench complet et auto-vérifiant

Pourquoi séparer les fronts

Comparer les quatre états

Factoriser le protocole avec des tâches

Passer à un clocking block

Séparer le banc physique du scénario temporel

Adapter le patron à un DUT combinatoire

Timeout, bilan et formes d'onde

Compiler et lancer

Checklist avant de faire confiance au test

À retenir