Lors de la conception numérique, des situations particulières sont souvent rencontrées. Les tâches et fonctions de Verilog peuvent ne plus répondre aux exigences de simulation, et il est nécessaire de personnaliser certaines tâches et fonctions système. L'interface de langage de programmation (PLI) fournit un ensemble de routines d'interface permettant d'accéder aux structures de données internes d'une conception et d'extraire des informations sur l'environnement de simulation. Les utilisateurs peuvent appeler ces routines pour personnaliser des tâches système et des fonctions système, et interagir avec les données internes de la conception et l'environnement du simulateur Verilog.
Fonctionnalités du PLI
En termes simples, le PLI Verilog fournit un ensemble de fonctions du langage C. Les concepteurs peuvent appeler ces fonctions intégrées pour écrire des programmes logiciels en C. Lors de la compilation RTL, les programmes logiciels écrits sont également intégrés à l'environnement de simulation. Pendant l'exécution de la simulation, au moyen d'appels de tâches système, les structures de données de la simulation peuvent être accédées dynamiquement. Cet accès est bidirectionnel ; non seulement les informations peuvent être lues à partir des structures de données du simulateur, mais les informations dans les structures de données peuvent également être modifiées.
Les fonctionnalités du PLI sont très puissantes, et ses utilisations ne sont limitées que par l'imagination du concepteur.
- Le PLI permet aux utilisateurs d'écrire des tâches et fonctions système personnalisées en C, et peut accomplir des opérations complexes qui ne peuvent pas être réalisées avec Verilog.
- Certains logiciels d'application, tels que les outils de lecture/écriture de fichiers et les outils de calcul de délai, peuvent également être écrits avec le PLI.
- Le PLI peut extraire des informations de conception, telles que la hiérarchie d'accès, les conditions d'interconnexion et le nombre de types spécifiques d'éléments logiques, etc.
- PLI peut être utilisé pour écrire des programmes d'affichage de sortie dédiés, tels que certains observateurs de formes d'onde dédiés, afin de générer des informations telles que les interconnexions logiques, les hiérarchies et les formes d'onde de données.
- PLI peut accomplir des tâches de surveillance fastidieuses ou des tâches de stimulus.
- PLI peut contrôler le processus de simulation, par exemple mettre en pause et quitter, pour faciliter le débogage.
- PLI peut également être étendu à des usages tels que les outils de téléchargement de programmes RAM/ROM, l'analyse de puissance, les interfaces CModel, les environnements de co-simulation...
Voici un résumé des fonctionnalités fréquemment utilisées de PLI :
- (1) Mettre en œuvre la co-simulation de modèles CModel et Verilog. Pour des systèmes relativement complexes, les développeurs doivent souvent d'abord créer un modèle fonctionnel décrit en langage C, puis le réécrire module par module en descriptions Verilog.
- (2) Générer des stimuli de test, ou effectuer directement la vérification. Pour des stimuli d'entrée avec une quantité de données relativement importante, des entrées de contrôle relativement complexes et une vérification des données dans des environnements spécifiques, l'implémentation PLI présente plus d'avantages que Verilog.
- (3) Capturer le processus et les résultats de simulation, et les restituer d'une manière facilement acceptable par les utilisateurs. Par exemple, pour certains modules d'encodage/décodage, l'utilisation d'effets d'affichage définis par l'utilisateur rend le débogage plus facile.
- (4) Co-simulation logiciel-matériel. Par exemple, si la conception contient une entité CPU, le logiciel peut être compilé en code machine et chargé dans la ROM correspondante pour la co-simulation.
Versions de PLI
Le développement de PLI a principalement connu 3 générations.
1985 - Interface TF
La première génération est appelée interface Task/Function, désignée par interface TF. L'interface TF contient un ensemble de bibliothèques de fonctions C, toutes préfixées par tf_, définies dans veriuser.h. Ces fonctions C sont généralement appelées routines TF, comprenant principalement des tâches et fonctions définies par l'utilisateur, des fonctions utilitaires, des mécanismes de rappel et une sortie d'écriture de données.
1989 - Interface ACC
La deuxième génération est appelée interface Access, désignée par interface ACC. Les fonctions de l'interface ACC sont toutes préfixées par acc_, définies dans acc_user.h. Les routines ACC sont principalement utilisées pour accéder aux divers objets décrits en Verilog et les modifier. Les fonctions de bibliothèque ACC sont une surcouche des fonctions de bibliothèque TF, et non un remplacement.
Généralement, l'interface PLI désigne spécifiquement les interfaces TF et ACC.
1995 - Interface VPI
La troisième génération est appelée Verilog Process Interface, désignée par interface VPI. Les routines VPI sont un ensemble des fonctions des routines TF et ACC, définies dans vpi_user.h.
Comparé aux routines PLI nombreuses et désordonnées, VPI apparaît particulièrement épuré. Comme PLI n'avait pas de standard unifié à sa naissance et s'est développé entièrement par la pratique, il existe près d'une centaine de fonctions de bibliothèque PLI couramment utilisées, et l'écriture de programmes nécessite pratiquement de consulter le manuel.
VPI, en revanche, est formulé selon une planification globale conforme à certains standards, intégrant de nombreuses idées orientées objet, et ses fonctions de bibliothèque sont bien plus épurées que celles de PLI. Cependant, VPI a une structure relativement complexe et n'est pas facile à prendre en main. La plus grande faiblesse de VPI reste que sa prise en charge des simulateurs n'est pas conviviale.
2003 - SystemVerilog et DPI
En tant qu'extension de Verilog, la norme SystemVerilog a été publiée en 2003, prenant en charge davantage de formes de simulation.
L'interface DPI (Direct Procee Interface) est devenue l'interface d'interaction entre les logiciels et SystemVerilog, et est actuellement la plus répandue.
En général, l'utilisation des interfaces TF et ACC de PLI suffit à répondre aux exigences de simulation. Ce chapitre ne fournit qu'une brève introduction aux interfaces TF et ACC. Quant aux autres interfaces, elles seront partagées avec tout le monde une par une lorsque cette jeune personne aura terminé ses études.
Utilisation de PLI
En écrivant des tâches système et des fonctions système, les utilisateurs peuvent étendre le langage Verilog avec PLI et des programmes C. Les noms de ces tâches et fonctions système définies par l'utilisateur doivent commencer par le signe dollar "$". À ce stade, une tâche en Verilog est équivalente à un sous-programme. Lorsqu'une tâche est appelée, le flux d'exécution du simulateur saute vers le sous-programme, et une fois la tâche terminée, le flux d'exécution revient. Les tâches Verilog ne renvoient pas de valeur, mais elles peuvent avoir des paramètres formels d'entrée, de sortie et bidirectionnels.
Les fonctions en Verilog sont identiques aux fonctions de la plupart des langages. Lorsqu'une fonction est appelée, elle exécute un ensemble d'instructions, puis renvoie une valeur à l'instruction qui l'a appelée.
Flux PLI
Le flux de base pour utiliser l'interface PLI afin de réaliser des tâches système définies par l'utilisateur est illustré ci-dessous.

Ce qui suit utilise la tâche système simple $hello_example comme exemple d'explication. Lorsque cette tâche système est appelée, elle affiche une ligne de chaîne "Hello Example!".
Écriture de tâches système avec PLI
Le programme d'impression décrit en langage C est présenté ci-dessous, et le fichier est nomméhello_example.c 。
Pour illustrer le flux général d'utilisation de PLI, ce programme n'appelle pas de routines TF/ACC.
Exemple
int hello_example(){
printf("Hello Example! \n");
}
Connexion du PLI au simulateur
En prenant l'utilisation de VCS comme exemple, compilez ou créez les fichiers liés à C nécessaires pendant la compilation VCS.
Effectuez une compilation simple du fichier hello_example.c ci-dessus et générez le fichier hello_example.o. Faites attention au chemin relatif.
gcc -c ../tb/hello_example.c
Créez un fichier de table de liaison reconnaissable par VCS, nommé hello_example.tab, avec le contenu suivant.
$hello_example call=hello_example
Appel de tâches système en Verilog
En Verilog, appelez $hello_example sous la forme d'un appel de tâche système, décrit comme suit.
Exemple
module test ;
initial begin
#10 ;
$hello_example;
end
initial begin
forever begin
#100;
if ($time >= 10000) $finish ;
end
end
endmodule
Compilation et simulation Verilog
Compilez le RTL et les fichiers intermédiaires PLI écrits. Lorsqu'il est indiqué que le fichier de table dans la bibliothèque PLI doit être lié, le paramètre "-P" doit être utilisé pour le spécifier. Par exemple, dans cette simulation, le paramètre suivant doit être ajouté à la ligne de commande VCS (faites attention au chemin relatif) :
-P ../tb/hello_example.tab hello_example.o
Les informations imprimées sont visibles dans les résultats de simulation, comme le montre la capture d'écran ci-dessous.

Téléchargement du code source de ce chapitre
Téléchargement