typedef, énumérations et packages

Donner un sens aux types, coder les états proprement et partager des déclarations sans dépendances cachées.

Nommer un format une seule fois

typedef crée un nom de type. Ce nom peut représenter un vecteur, un entier, une structure ou une énumération.

typedef logic [11:0] adc_sample_t;
typedef logic signed [23:0] accumulator_t;
 
adc_sample_t  sample_a;
adc_sample_t  sample_b;
accumulator_t sum;

Le type exprime mieux le rôle des données qu'une répétition de [11:0]. Si la résolution change, une seule déclaration doit être revue. Deux noms de type ayant la même largeur peuvent aussi rester distincts dans l'esprit du lecteur.

Des états lisibles

Une énumération associe des noms à un ensemble fini de valeurs.

typedef enum logic [1:0] {
  IDLE,
  LOAD,
  RUN,
  DONE
} state_t;
 
state_t state_q, state_d;

Le type de base logic [1:0] fixe la représentation. Les variables d'un type énuméré sont fortement typées : une affectation arbitraire peut demander un cast explicite. Cette règle évite qu'une valeur quelconque soit confondue avec un état valide.

Les méthodes comme first(), last(), next(), prev() et name() sont pratiques en simulation. Il ne faut pas supposer qu'elles sont toutes synthétisables sans vérifier l'outil.

Partager avec un package

Un package regroupe des types, constantes, fonctions et déclarations communes.

package stream_pkg;
  parameter int unsigned DATA_WIDTH = 32;
 
  typedef struct packed {
    logic                  valid;
    logic                  last;
    logic [DATA_WIDTH-1:0] data;
  } stream_word_t;
endpackage

Le contenu est utilisé avec une qualification explicite :

stream_pkg::stream_word_t word;

On peut aussi importer un nom précis :

import stream_pkg::stream_word_t;
stream_word_t word;

L'import générique import stream_pkg::*; est rapide, mais il rend moins visible l'origine des noms et peut créer des ambiguïtés. Dans une base de code partagée, les imports ciblés ou le préfixe :: facilitent souvent la lecture.

Ordre de compilation

Un package doit être analysé avant les modules qui l'utilisent. Le script de compilation ou la liste de fichiers doit donc refléter les dépendances.

Les déclarations globales placées dans $unit dépendent davantage de l'ordre et de la façon dont l'outil regroupe les fichiers. Un package nommé est plus clair et plus portable.

À retenir

• typedef donne un nom stable à un format de données.
• Une énumération limite les valeurs et rend les états lisibles.
• Le type de base d'une énumération doit être choisi consciemment.
• Un package partage types, constantes et fonctions entre modules.
• package::name et les imports ciblés rendent les dépendances visibles.

📝 Tester mes connaissances - Quiz du chapitre