Caractéristiques fonctionnelles
Les sous-programmes TF (tâche/fonction) sont principalement utilisés pour le transfert de données dans les deux sens à la frontière entre Verilog et les programmes C utilisateur.
Les sous-programmes TF ont toujours le préfixe tf_ et sont définis dans le fichier d'en-tête veriuser.h. Par conséquent, lorsque vous écrivez des tâches ou fonctions système en C, vous devez ajouter #include "veriuser.h" au fichier C.
Les sous-programmes TF peuvent être répartis dans les utilisations suivantes :
- Obtention des informations sur les tâches système
- Obtention d'informations sur la liste des paramètres
- Obtention des valeurs des paramètres
- Renvoi des valeurs des paramètres aux tâches système
- Surveillance des changements de valeurs des paramètres
- Obtention du temps de simulation et des informations sur les événements planifiés
- Opérations arithmétiques
- Affichage des informations
- Gestion et maintenance des tâches
- Autres tâches telles que la suspension, l'arrêt, la sauvegarde et la restauration
Pour une liste complète des sous-routines TF et de leurs instructions d'utilisation simples, reportez-vous à la section suivante."8.3 Liste des sous-routines TF"。
Exemples de sous-routines TF
La bibliothèque de sous-routines PLI contient un grand nombre de fonctions. Les expliquer une par une nécessiterait beaucoup d'espace. Par conséquent, il est recommandé d'étudier attentivement les sous-routines individuelles uniquement lorsque c'est nécessaire. Ci-dessous figurent des exemples de quelques sous-routines TF, illustrant principalement le flux de base de la conception de tâches système Verilog à l'aide de sous-routines TF.
Exigences de conception
Parfois, pour réduire la taille du fichier objet après la compilation du fichier en langage C, ou pour produire des informations de débogage dans un certain format, la fonction d'impression du logiciel peut ne pas utiliser la fonction printf intégrée à C, ni la fonction io_printf des sous-routines TF. À la place, elle utilise l'interface PLI et les fonctions d'affichage système Verilog ($display ou $write) pour implémenter une fonction d'impression logicielle définie par l'utilisateur.
Cette conception implémente une fonction d'impression logicielle nommée print_my, avec un format de sortie de "chaîne + entier".
Analyse de conception
La fonction d'impression logicielle définie par l'utilisateur print_my n'est qu'une enveloppe peu attrayante servant à transmettre les informations d'impression aux variables de paramètres formels du logiciel. Pour transmettre les informations d'impression à Verilog, une tâche système construite avec des sous-routines TF est également nécessaire, nommée $send_my().
Il convient de noter que les tâches système implémentées avec des sous-routines TF doivent généralement être appelées dans le code Verilog. Le fait que le logiciel appelle directement cette "tâche système" équivaut à appeler une fonction logicielle, et n'a aucun lien direct avec les descriptions des variables associées dans le code Verilog. Par conséquent, appeler directement la "fonction logicielle" send_my dans la fonction logicielle print_my n'a pas de sens. Il est nécessaire d'ajouter certains comportements logiciels spécifiques dans print_my pour déclencher l'appel de la tâche système $send_my par Verilog.
Si le système numérique contient un CPU, vous pouvez utiliser la méthode consistant à écrire sur le bus ou dans la mémoire via le logiciel, puis à surveiller les variables de signal pertinentes dans le testbench. Cette conception est relativement petite en échelle, donc une autre méthode peut être utilisée : Verilog continue d'exécuter la tâche système $send_my, et une variable globale est définie dans la fonction logicielle print_my pour contrôler s'il faut effectuer le transfert d'informations et l'impression.

Conception logicielle
Le code de conception logicielle est le suivant, avec les détails expliqués dans les commentaires. Enregistrez-le dans le fichier print_gyc.c.
Exemple
// chaîne à imprimer, données entières, indicateur de démarrage d'impression logicielle
char *str_mes ;
unsigned int int_mes ;
int flags = 0;
//===== définir print_my() utilisé en C ======
void print_my(char * str_send, unsigned int int_send){
str_mes = str_send ;
int_mes = int_send ;
indicateurs = 1 ;
}
// données de type caractère des codes ASCII correspondant à la chaîne à imprimer, longueur de caractères d'origine limitée à 100
// par exemple, le caractère "1" correspond au code ASCII 0x31, dont les données de type caractère sont 0x33, 0x31
char str_mes_format[200] ;
// lorsque les sous-programmes TF transmettent des données de type chaîne, ils ne peuvent transmettre que des données au format de base correspondant
// par exemple, "0xc0de1234" peut être transmis, mais "www.example.com" ne peut pas l'être
// par conséquent, les données de chaîne d'origine doivent être converties en données de type caractère des codes ASCII correspondants
void byte2hexstr(char* str, char* dest, int len)
{
char tmp;
int i ;
char stb[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
for (i = 0; i < len; i++){
tmp = str[i];
dest[i * 2] = stb[tmp >> 4];
dest[i * 2 + 1] = stb[tmp & 15];
}
return;
}
//===== définir PLI : send_my() =======
void send_my(){
int i = 0 ;
// détecter les indicateurs de début d'impression du logiciel flags
// et la tâche système $send_my est appelée par Verilog avec 3 paramètres passés en entrée
if (flags && tf_nump()==3) {
// convertir les données de chaîne à imprimer en type chaîne correspondant à l'ASCII
byte2hexstr(str_mes, str_mes_format, 100);
// transmettre les données de type caractère hexadécimal au 2e paramètre de la tâche système send_my
// la longueur est de 1600 bits, correspondant à 100 caractères et 200 données de type caractère ASCII
tf_strdelputp(2, 1600, 'H', str_mes_format, 0, 0);
// transmettre les données entières au 3e paramètre
tf_putp(3, int_mes);
// transmettre l'indicateur de début d'impression matériel au 1er paramètre
tf_putp(1, 1) ;
indicateurs = 0 ;
}
}
Conception matérielle
D'après les tests de simulation, les données transmises du logiciel à Verilog sont stockées dans un registre de 1600 bits de large, comme le montre la figure ci-dessous.

Lorsque le registre contient des données normales, il commence à stocker les données de caractères normales à partir du 799e bit (la moitié de la largeur du registre). Les bits de poids faible restants stockent "NULL" (correspondant à la donnée 0) et les données système par défaut. Les longueurs de ces deux parties de données varient selon la longueur des données normales stockées.
Lorsque le registre ne contient aucune donnée normale, il utilise plus de 800 bits de longueur de registre pour stocker "NULL" (correspondant à la donnée 0). La largeur restante stocke les données système par défaut.
Sur la base des caractéristiques ci-dessus, les données de chaîne de caractères normales peuvent être détectées sans imprimer toutes les données du registre, ce qui évite une grande quantité d'espaces vides dans la sortie imprimée susceptibles de nuire à l'apparence.
La conception du code Verilog matériel est la suivante, avec les détails spécifiques expliqués dans les commentaires. Enregistrez-le dans le fichier test.v.
Exemple
module test ;
reg [1599:0] str_my ;
reg [31:0] int_my ;
reg flag_my ;
// vérifier en continu l'indicateur d'impression matériel flagh pour déterminer s'il faut imprimer
entier i = 1599;
entier j = 1599;
reg [7:0] str_tmp ; // registre de stockage des données de chaîne de caractères
initial begin
flagh = 0 ;
forever begin
#20 ;
// appeler la tâche système et transmettre des données du logiciel vers le matériel (Verilog)
$send_my(flagh, str_my, int_my);
if (flagh) begin // commencer l'impression des informations
#1 ;
// la largeur du registre a de la redondance ; imprimer tout produirait beaucoup d'espaces
// ici, les bits de registre inutilisés sont détectés et supprimés de l'impression
for(i=1599; i>=0; i= i-8) begin
if (str_my[i -: 8] != 0)
break ;
end
// généralement, la moitié de la largeur du registre est utilisée pour stocker des données de chaîne
// donc lorsque le transfert de chaîne est correct, les données commencent à partir de str_my
$display("--DEBUG--- Numéro de données valide : %d", i);
// s'il n'y a pas de données de chaîne, str_my ne sera pas complètement vide non plus
// mais str_my[799 -: 8] n'aura pas de données
if (i<=791) begin
$display("--ERR--- VEUILLEZ SAISIR DES INFORMATIONS DE CHAÎNE VALIDES !!!");
$display("--ERR--- Numéro de données par défaut : %d", i);
$display("--ERR--- Structure de données de chaîne : %h", str_my);
end
else begin
$write("---YYY---");
for(j=i; j>=0; j= j-8) begin
str_tmp = str_my[j -: 8] ;
// arrêter l'affichage lorsqu'un caractère nul est détecté à nouveau
if (str_tmp == "") begin
break ;
end
// afficher caractère par caractère
else begin
$write("%s", str_tmp);
end
end
// afficher les données entières
$write("%h \n", int_my);
end
/* $display ne prend pas en charge l'accès aux variables dans les sélections de parties de vecteur de registre
// donc la description suivante est incorrecte ; vous pouvez uniquement utiliser $write de manière répétée pour imprimer
else begin
$display("--YYY--- %s%h", str_my[i : j], int_my);
end
*/
flagh = 0 ;
end
end
end
// arrêter la simulation
initial begin
forever begin
#10000;
if ($time >= 300) $finish ;
end
end
endmodule
Invocation logicielle
Comme la partie logicielle de cette conception ne peut pas s'exécuter activement, une tâche système Verilog supplémentaire conçue avec des sous-routines TF est ajoutée. Lorsque cette tâche système est exécutée dans le banc de test, elle peut appeler la fonction print_my dans le programme logiciel.
Ajoutez le code C suivant au fichier print_gyc.c :
if (tf_getp(1) == 1) // si la valeur du premier paramètre de la fonction système est 1
print_my("C'est le premier affichage réussi : ", 0x20170714);
else if (tf_getp(1) == 2) // si la valeur du deuxième paramètre de la fonction système est 2
print_my("2e : ", 0x09070602);
else
print_my("", 0x1); // si les données de chaîne ne sont pas transmises, signaler une erreur
}
Ajoutez le code Verilog suivant au fichier test.v :
initial begin
#100 ;
$call_c_print(1);
#100 ;
$call_c_print(2);
#100 ;
$call_c_print(3);
end
Compilation et simulation
Sous Linux, utilisez la commande suivante pour compiler print_gyc.c et générer le fichier print_gyc.o. Faites attention aux chemins relatifs.
gcc -I ${VCS_HOME}/include -c ../tb/print_gyc.cLors de la compilation avec VCS, vous devez créer un fichier de table de liaison que VCS peut reconnaître, nommé pli_gyc.tab, avec le contenu suivant.
$send_my et $call_c_print sont les noms des tâches système appelées par Verilog ;
call=my_monitor, call=call_c_print, etc., indiquent des appels à des fonctions dans le programme C ;
$send_my call=send_my $call_c_print call=call_c_print
Ajoutez la ligne de paramètre suivante lors de la compilation avec VCS.
-P ../tb/pli_gyc.tab
Les résultats de la simulation sont les suivants.
Comme on peut le voir sur la figure, la sortie imprimée est normale, sans espaces blancs supplémentaires.
Lorsqu'il n'y a pas de données de chaîne dans les informations imprimées, une erreur est signalée, avec quelques informations de débogage en sortie.
Vous pouvez modifier certains paramètres dans le banc de test pour déboguer et en apprendre davantage sur les formats de stockage de données.

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