Passer d'un testbench en couches aux notions UVM

Construire un environnement complet et relier ses phases, sa configuration, ses callbacks et sa création de composants aux notions qu'UVM industrialise.

Ce qu'UVM apporte au patron déjà construit

UVM, pour Universal Verification Methodology, industrialise avec une bibliothèque de classes les responsabilités vues dans l'environnement en couches : objets de données, génération de scénarios, driver, monitor, modèle, scoreboard, couverture, environnement et test.

Il ne remplace ni le plan de vérification, ni le protocole, ni le modèle de référence. Il standardise surtout la construction, la configuration, les points d'extension, la création des composants et leurs communications.

Ce chapitre est une passerelle conceptuelle. Il montre comment préparer un environnement compatible avec ces idées sans présenter un pseudo-testbench UVM incomplet. Les séquences, le séquenceur, les objections et le graphe complet des phases nécessitent l'API UVM exacte du projet et de sa version.

Correspondance avec l'environnement en couches

Environnement SystemVerilog du cours	Notion industrialisée dans UVM
transaction et méthode de copie	objet de données avec opérations communes de copie et de représentation
driver, monitor, scoreboard, environnement, test	composants dans une hiérarchie nommée
`build()`, `run()`, `wrap_up()`	sous-ensemble pédagogique d'un mécanisme de phases plus riche
interfaces virtuelles passées aux classes	ressource de configuration transmise au bon composant
appels de callbacks	points d'extension enregistrés sans dériver tout le driver
publication du monitor vers plusieurs consommateurs	communication transactionnelle vers scoreboard et couverture
choix d'une classe dérivée à la construction	factory et override de type

Les responsabilités ne changent pas. Le driver applique, le monitor observe, la prédiction reste indépendante et le test choisit le scénario sans reconstruire l'infrastructure.

// sum_if.sv
interface sum_if(input logic clk);
  timeunit 1ns;
  timeprecision 1ps;
 
  logic       rst_n     = 1'b0;
  logic       in_valid  = 1'b0;
  logic       in_ready;
  logic [7:0] a         = '0;
  logic [7:0] b         = '0;
  logic       out_valid;
  logic [8:0] sum;
 
  clocking drv_cb @(posedge clk);
    default input #1step output #0;
    output rst_n, in_valid, a, b;
    input  in_ready;
  endclocking
 
  clocking mon_cb @(posedge clk);
    default input #1step;
    input rst_n, in_valid, in_ready, a, b, out_valid, sum;
  endclocking
 
  modport drv (clocking drv_cb);
  modport mon (clocking mon_cb);
  modport dut (
    input  clk, rst_n, in_valid, a, b,
    output in_ready, out_valid, sum
  );
endinterface

// sum_dut.sv
module sum_dut(sum_if.dut bus);
  timeunit 1ns;
  timeprecision 1ps;
 
  assign bus.in_ready = 1'b1;
 
  always_ff @(posedge bus.clk or negedge bus.rst_n) begin
    if (!bus.rst_n) begin
      bus.out_valid <= 1'b0;
      bus.sum       <= '0;
    end
    else begin
      bus.out_valid <= bus.in_valid && bus.in_ready;
      if (bus.in_valid && bus.in_ready)
        bus.sum <= {1'b0, bus.a} + {1'b0, bus.b};
    end
  end
endmodule

// sum_tb_pkg.sv - à compiler après sum_if.sv
package sum_tb_pkg;
  timeunit 1ns;
  timeprecision 1ps;
 
  typedef virtual sum_if.drv sum_drv_vif_t;
  typedef virtual sum_if.mon sum_mon_vif_t;
 
  class sum_item;
    randc logic [7:0] a;
    rand  logic [7:0] b;
    rand  int unsigned idle_cycles;
          logic [8:0] sum;
 
    constraint legal_idle { idle_cycles inside {[0:3]}; }
 
    function sum_item copy();
      sum_item result;
      result = new();
      result.a           = a;
      result.b           = b;
      result.idle_cycles = idle_cycles;
      result.sum         = sum;
      return result;
    endfunction
  endclass
 
  class sum_config;
    int unsigned transaction_count = 80;
    time         timeout           = 20us;
  endclass
 
  class sum_generator;
    sum_item blueprint;
    mailbox #(sum_item) outbox;
    int unsigned generated_count;
    bit done;
 
    function new(mailbox #(sum_item) outbox);
      this.outbox = outbox;
      blueprint   = new();
    endfunction
 
    task run(int unsigned count);
      sum_item item;
      generated_count = 0;
      done = 0;
 
      repeat (count) begin
        if (!blueprint.randomize())
          $fatal(1, "[GENERATOR] randomization failed");
        item = blueprint.copy();
        outbox.put(item);
        generated_count++;
      end
      done = 1;
    endtask
  endclass
 
  class sum_driver_callback;
    virtual task pre_drive(sum_item item);
    endtask
  endclass
 
  class sum_driver;
    sum_drv_vif_t vif;
    mailbox #(sum_item) inbox;
    sum_driver_callback callbacks[$];
    int unsigned driven_count;
 
    function new(sum_drv_vif_t vif,
                 mailbox #(sum_item) inbox);
      this.vif   = vif;
      this.inbox = inbox;
    endfunction
 
    function void add_callback(sum_driver_callback callback);
      callbacks.push_back(callback);
    endfunction
 
    task run();
      sum_item item;
      vif.drv_cb.in_valid <= 1'b0;
 
      forever begin
        inbox.get(item);
        foreach (callbacks[i])
          callbacks[i].pre_drive(item);
 
        repeat (item.idle_cycles) @vif.drv_cb;
        vif.drv_cb.a        <= item.a;
        vif.drv_cb.b        <= item.b;
        vif.drv_cb.in_valid <= 1'b1;
        do @vif.drv_cb;
        while (vif.drv_cb.in_ready !== 1'b1);
        vif.drv_cb.in_valid <= 1'b0;
        driven_count++;
      end
    endtask
  endclass
 
  class sum_input_monitor;
    sum_mon_vif_t vif;
    mailbox #(sum_item) to_reference;
    mailbox #(sum_item) to_coverage;
    int unsigned accepted_count;
 
    function new(sum_mon_vif_t vif,
                 mailbox #(sum_item) to_reference,
                 mailbox #(sum_item) to_coverage);
      this.vif          = vif;
      this.to_reference = to_reference;
      this.to_coverage  = to_coverage;
    endfunction
 
    task run();
      sum_item observed;
      forever begin
        @vif.mon_cb;
        if (vif.mon_cb.rst_n     === 1'b1 &&
            vif.mon_cb.in_valid  === 1'b1 &&
            vif.mon_cb.in_ready  === 1'b1) begin
          observed = new();
          observed.a = vif.mon_cb.a;
          observed.b = vif.mon_cb.b;
          to_reference.put(observed.copy());
          to_coverage.put(observed.copy());
          accepted_count++;
        end
      end
    endtask
  endclass
 
  class sum_output_monitor;
    sum_mon_vif_t vif;
    mailbox #(sum_item) to_scoreboard;
    int unsigned observed_count;
 
    function new(sum_mon_vif_t vif,
                 mailbox #(sum_item) to_scoreboard);
      this.vif           = vif;
      this.to_scoreboard = to_scoreboard;
    endfunction
 
    task run();
      sum_item observed;
      forever begin
        @vif.mon_cb;
        if (vif.mon_cb.rst_n    === 1'b1 &&
            vif.mon_cb.out_valid === 1'b1) begin
          observed = new();
          observed.sum = vif.mon_cb.sum;
          to_scoreboard.put(observed);
          observed_count++;
        end
      end
    endtask
  endclass
 
  class sum_reference_model;
    mailbox #(sum_item) inbox;
    mailbox #(sum_item) expected_out;
    int unsigned predicted_count;
 
    function new(mailbox #(sum_item) inbox,
                 mailbox #(sum_item) expected_out);
      this.inbox        = inbox;
      this.expected_out = expected_out;
    endfunction
 
    task run();
      sum_item input_item;
      sum_item expected;
      forever begin
        inbox.get(input_item);
        expected = input_item.copy();
        expected.sum = {1'b0, input_item.a} +
                       {1'b0, input_item.b};
        expected_out.put(expected);
        predicted_count++;
      end
    endtask
  endclass
 
  class sum_scoreboard;
    mailbox #(sum_item) expected_in;
    mailbox #(sum_item) actual_in;
    int unsigned expected_count;
    int unsigned observed_count;
    int unsigned compared_count;
    int unsigned errors;
 
    function new(mailbox #(sum_item) expected_in,
                 mailbox #(sum_item) actual_in);
      this.expected_in = expected_in;
      this.actual_in   = actual_in;
    endfunction
 
    task run();
      sum_item expected;
      sum_item actual;
      forever begin
        expected_in.get(expected);
        expected_count++;
        actual_in.get(actual);
        observed_count++;
        compared_count++;
 
        if (actual.sum !== expected.sum) begin
          errors++;
          $error("[SCOREBOARD] a=%0h b=%0h expected=%0h actual=%0h time=%0t",
                 expected.a, expected.b,
                 expected.sum, actual.sum, $time);
        end
      end
    endtask
 
    task wrap_up(int unsigned requested,
                 int unsigned generated,
                 int unsigned driven,
                 int unsigned accepted,
                 int unsigned predicted,
                 int unsigned output_observed,
                 int unsigned covered,
                 real coverage_percent);
      if (generated       != requested ||
          driven          != requested ||
          accepted        != requested ||
          predicted       != requested ||
          output_observed != requested ||
          expected_count  != requested ||
          observed_count  != requested ||
          compared_count  != requested ||
          covered         != requested) begin
        errors++;
        $error("[COUNTS] req=%0d gen=%0d drv=%0d in=%0d pred=%0d out=%0d exp=%0d obs=%0d cmp=%0d cov=%0d",
               requested, generated, driven, accepted, predicted,
               output_observed, expected_count, observed_count,
               compared_count, covered);
      end
 
      if (expected_in.num() != 0 || actual_in.num() != 0) begin
        errors++;
        $error("[LEFTOVERS] expected=%0d actual=%0d",
               expected_in.num(), actual_in.num());
      end
 
      if (compared_count == 0) begin
        errors++;
        $error("[SCOREBOARD] no comparison was performed");
      end
 
      if (errors == 0)
        $display("PASS: %0d comparisons, coverage=%0.2f%%",
                 compared_count, coverage_percent);
      else
        $fatal(1, "FAIL: %0d error(s)", errors);
    endtask
  endclass
 
  class sum_coverage;
    mailbox #(sum_item) inbox;
    sum_item current;
    int unsigned sampled_count;
 
    covergroup operands_cg;
      option.per_instance = 1;
      a_cp: coverpoint current.a {
        bins zero = {0};
        bins low  = {[1:127]};
        bins high = {[128:254]};
        bins max  = {255};
      }
      b_cp: coverpoint current.b {
        bins zero = {0};
        bins low  = {[1:127]};
        bins high = {[128:254]};
        bins max  = {255};
      }
      operands_cross: cross a_cp, b_cp;
    endgroup
 
    function new(mailbox #(sum_item) inbox);
      this.inbox = inbox;
      operands_cg = new();
    endfunction
 
    task run();
      forever begin
        inbox.get(current);
        operands_cg.sample();
        sampled_count++;
      end
    endtask
 
    function real percentage();
      return operands_cg.get_inst_coverage();
    endfunction
  endclass

// Suite de sum_tb_pkg.sv, avant endpackage
  class sum_environment;
    sum_drv_vif_t drv_vif;
    sum_mon_vif_t mon_vif;
    sum_config cfg;
 
    mailbox #(sum_item) generated_mb;
    mailbox #(sum_item) accepted_for_model_mb;
    mailbox #(sum_item) accepted_for_coverage_mb;
    mailbox #(sum_item) expected_mb;
    mailbox #(sum_item) actual_mb;
 
    sum_generator       generator;
    sum_driver          driver;
    sum_input_monitor   input_monitor;
    sum_output_monitor  output_monitor;
    sum_reference_model reference_model;
    sum_scoreboard      scoreboard;
    sum_coverage        coverage;
 
    function new(sum_drv_vif_t drv_vif,
                 sum_mon_vif_t mon_vif,
                 sum_config cfg);
      this.drv_vif = drv_vif;
      this.mon_vif = mon_vif;
      this.cfg     = cfg;
    endfunction
 
    function void build();
      generated_mb             = new();
      accepted_for_model_mb    = new();
      accepted_for_coverage_mb = new();
      expected_mb              = new();
      actual_mb                = new();
 
      generator       = new(generated_mb);
      driver          = new(drv_vif, generated_mb);
      input_monitor   = new(mon_vif,
                            accepted_for_model_mb,
                            accepted_for_coverage_mb);
      output_monitor  = new(mon_vif, actual_mb);
      reference_model = new(accepted_for_model_mb, expected_mb);
      scoreboard      = new(expected_mb, actual_mb);
      coverage        = new(accepted_for_coverage_mb);
    endfunction
 
    task reset();
      drv_vif.drv_cb.rst_n    <= 1'b0;
      drv_vif.drv_cb.in_valid <= 1'b0;
      drv_vif.drv_cb.a        <= '0;
      drv_vif.drv_cb.b        <= '0;
      repeat (3) @drv_vif.drv_cb;
      drv_vif.drv_cb.rst_n <= 1'b1;
      @drv_vif.drv_cb;
    endtask
 
    task run();
      bit completed = 0;
      bit timed_out = 0;
 
      fork : run_phase
        begin : component_threads
          fork
            generator.run(cfg.transaction_count);
            driver.run();
            input_monitor.run();
            output_monitor.run();
            reference_model.run();
            scoreboard.run();
            coverage.run();
          join
        end
 
        begin : completion_thread
          wait (generator.done);
          wait (driver.driven_count == generator.generated_count);
          wait (input_monitor.accepted_count == driver.driven_count);
          wait (reference_model.predicted_count ==
                input_monitor.accepted_count);
          wait (coverage.sampled_count ==
                input_monitor.accepted_count);
          wait (output_monitor.observed_count >=
                input_monitor.accepted_count);
          wait (scoreboard.compared_count ==
                input_monitor.accepted_count);
          repeat (2) @mon_vif.mon_cb;
          completed = 1;
        end
 
        begin : watchdog_thread
          #(cfg.timeout);
          if (!completed)
            timed_out = 1;
        end
      join_any
 
      disable run_phase;
      if (timed_out)
        $fatal(1,
          "TIMEOUT: gen=%0d drv=%0d in=%0d pred=%0d out=%0d cmp=%0d",
          generator.generated_count,
          driver.driven_count,
          input_monitor.accepted_count,
          reference_model.predicted_count,
          output_monitor.observed_count,
          scoreboard.compared_count);
    endtask
 
    task wrap_up();
      scoreboard.wrap_up(
        cfg.transaction_count,
        generator.generated_count,
        driver.driven_count,
        input_monitor.accepted_count,
        reference_model.predicted_count,
        output_monitor.observed_count,
        coverage.sampled_count,
        coverage.percentage()
      );
    endtask
  endclass
 
  class force_corner_callback extends sum_driver_callback;
    int unsigned seen;
 
    virtual task pre_drive(sum_item item);
      seen++;
      if ((seen % 10) == 0) begin
        item.a = 8'h00;
        item.b = 8'hff;
      end
    endtask
  endclass
 
  class sum_test;
    sum_config cfg;
    sum_environment environment;
    force_corner_callback corner_callback;
 
    function new(sum_drv_vif_t drv_vif,
                 sum_mon_vif_t mon_vif);
      cfg = new();
      cfg.transaction_count = 80;
      cfg.timeout = 20us;
      environment = new(drv_vif, mon_vif, cfg);
    endfunction
 
    task run();
      environment.build();
      corner_callback = new();
      environment.driver.add_callback(corner_callback);
      environment.reset();
      environment.run();
      environment.wrap_up();
    endtask
  endclass
endpackage

// tb_top.sv - à compiler en dernier
program automatic sum_test_program(sum_if.drv drv_bus,
                                   sum_if.mon mon_bus);
  timeunit 1ns;
  timeprecision 1ps;
 
  import sum_tb_pkg::*;
 
  initial begin
    sum_test test;
 
    test = new(drv_bus, mon_bus);
    test.run();
    $finish;
  end
endprogram
 
module tb_top;
  timeunit 1ns;
  timeprecision 1ps;
 
  logic clk = 1'b0;
  always #5ns clk = ~clk;
 
  sum_if bus(clk);
  sum_dut dut(bus);
  sum_test_program test_program(bus, bus);
endmodule

Élément exécutable	Responsabilité conservée lors de la migration
`sum_item`	objet transactionnel copiable et randomisable
`sum_generator`	production du scénario ; UVM sépare ensuite séquence et arbitrage
`sum_driver`	conversion transaction vers signaux à travers une interface virtuelle
monitors	observation passive et publication des transactions acceptées
`sum_reference_model`	prédiction indépendante du RTL
`sum_scoreboard`	appariement, comparaison, restes et verdict
`sum_coverage`	mesure séparée, déclenchée après observation réelle
`sum_environment`	construction, connexion, exécution, vidange et bilan
`sum_test`	choix du scénario, de la configuration et des extensions

Passer d'un testbench en couches aux notions UVM

Ce qu'UVM apporte au patron déjà construit

Correspondance avec l'environnement en couches

Phases : raisonner avant de mémoriser des noms

Exemple complet : un environnement inspiré d'UVM

1. Frontière signal et DUT

2. Objets, transactors, modèle, scoreboard et couverture

3. Environnement, test et top

4. Lire cet exemple avec le vocabulaire UVM

5. Prouver que l'environnement détecte de vraies fautes

Configuration : distribuer sans variables globales

Factory : remplacer un type sans modifier ses créateurs

Callbacks et publication

Garder le test au-dessus de l'environnement

Chemin de migration concret

À retenir