Classes, héritage et polymorphisme

Modéliser des transactions de test, comprendre les handles et étendre un comportement sans recopier l'environnement.

Un objet de test, pas un circuit

Une classe décrit des données et les méthodes qui les manipulent. Elle est allouée dynamiquement et n'est normalement pas synthétisable. Dans un testbench, une classe représente souvent une transaction, un générateur ou un composant de contrôle.

class bus_transaction;
  rand bit        write;
  rand bit [15:0] address;
  rand bit [31:0] data;
 
  function new(bit [15:0] address = '0);
    this.address = address;
  endfunction
 
  virtual function void display();
    $display("write=%0b address=%04h data=%08h",
             write, address, data);
  endfunction
endclass

La déclaration de classe définit un type. L'objet n'existe qu'après new :

bus_transaction tr;
tr = new(16'h0100);
tr.display();

tr est un handle, comparable à une référence. Copier tr vers un autre handle ne copie pas automatiquement l'objet. Les deux handles désignent alors la même instance.

Hériter pour une vraie différence

Une classe dérivée reprend les champs et méthodes de sa classe de base.

class error_transaction extends bus_transaction;
  bit inject_parity_error;
 
  function new();
    super.new();
    inject_parity_error = 1'b1;
  endfunction
 
  virtual function void display();
    super.display();
    $display("inject_parity_error=%0b", inject_parity_error);
  endfunction
endclass

L'héritage convient lorsque la classe dérivée reste bien une forme de la classe de base. Il ne faut pas créer une hiérarchie profonde uniquement pour partager quelques lignes de code.

Polymorphisme et méthodes virtuelles

Un handle de type base peut désigner un objet dérivé :

bus_transaction base_handle;
error_transaction error_tr = new();
 
base_handle = error_tr;
base_handle.display();

Comme display est virtual, l'appel utilise la version de error_transaction. Cela permet à un générateur ou un driver de travailler avec un type de base tout en acceptant des variantes.

Sans virtual, la méthode choisie dépendrait du type du handle, pas du type réel de l'objet.

Copie et durée de vie

Une affectation de handle est une copie superficielle de la référence. Pour obtenir deux objets indépendants, il faut créer le second et copier les champs, souvent avec une méthode dédiée.

Les objets sont libérés lorsqu'aucun handle ne les référence plus. Les références circulaires et les handles conservés inutilement compliquent le débogage d'un environnement long.

À retenir

• Une variable de classe est un handle et l'objet est créé par new.
• Copier un handle ne duplique pas l'objet.
• L'héritage représente une spécialisation réelle du type de base.
• Une méthode virtual permet au type réel de l'objet de choisir l'implémentation.
• Les classes servent au testbench, pas au RTL synthétisable courant.

📝 Tester mes connaissances - Quiz du chapitre