Caractéristiques fonctionnelles
Les principales fonctions réalisées par les sous-programmes ACC sont :
- Lecture d'informations sur des objets spécifiques à partir des structures de données internes
- Écriture d'informations sur des objets spécifiques dans les structures de données internes
Les types d'objets sur lesquels les sous-programmes ACC peuvent opérer sont :
- Instances de module, ports de module, chemins de module à module et chemins entre modules
- Modules de niveau supérieur
- Instances de primitive et ports de primitive
- Types de variables tels que wire, reg, parameter, integer, time, real, etc.
- Contrôles de temporisation
- Événements nommés
Les principales caractéristiques des sous-programmes ACC sont :
- Tous sont préfixés par acc_
- Au début, acc_initialize() doit être appelée pour initialiser l'environnement
- À la sortie, acc_close() doit être appelée
- Lors de l'utilisation de fonctions de la bibliothèque ACC, le fichier d'en-tête acc_user.h doit être inclus
- Le concept de handles est utilisé pour accéder aux objets. Un handle est un type de données prédéfini pointant vers un objet spécifique dans la conception. Une fois un handle obtenu, toutes les informations sur l'objet peuvent être consultées. Cela est similaire au concept de handle de fichier en langage C. Les handles sont déclarés avec le mot-clé handle.
Les principaux types de sous-programmes ACC sont :
- Sous-programmes handle (handle) : retournent un handle vers un objet de la conception, toujours préfixés par acc_handle_.
- Sous-programmes next (next) : retournent un handle vers l'objet suivant dans un ensemble spécifique d'objets de la conception, toujours préfixés par acc_next_, et prennent l'objet référencé comme paramètre.
- Sous-programmes de liaison de changement de valeur (VCL) : peuvent ajouter et supprimer des objets de la liste des objets surveillés pour les changements de valeur, toujours préfixés par acc_vcl_, et n'ont aucune valeur de retour.
- Sous-programmes de récupération (fetch) : peuvent extraire des informations d'attribut telles que les chemins hiérarchiques, toujours préfixés par acc_fetch_.
- Sous-programmes divers (miscellaneous) : utilisés pour effectuer diverses opérations diverses liées aux sous-programmes d'accès. Par exemple, acc_initialize() et acc_close() sont tous deux des sous-programmes divers.
- Sous-programmes de modification (modify) : peuvent modifier des structures de données internes.
Pour la liste complète des sous-programmes ACC et leurs brèves instructions d'utilisation, reportez-vous à la section suivante"8.5 Liste des sous-programmes ACC"。
Exemples de sous-programmes ACC
Ci-dessous se trouvent des exemples d'utilisation pour seulement certains sous-programmes ACC, illustrant principalement le processus de base de conception de tâches système Verilog à l'aide de sous-programmes ACC.
Exigences de conception
Cette fois, concevez une tâche système qui surveille un compteur.
D'une part, la tâche système surveille la valeur d'un compteur en Verilog ; d'autre part, après avoir détecté l'horloge de comptage en Verilog, elle effectue également un comptage logiciel et compare les valeurs de comptage logicielle et matérielle pour vérifier l'exactitude de la logique matérielle. En même temps, lorsque le compteur atteint une valeur spécifique, elle affiche les valeurs de certaines variables de signal.
Cette approche de conception est également un scénario courant pour les interfaces PLI. Le logiciel implémente une fonction logique, appelée CModel. Ensuite, le matériel implémente également la même fonction logique en utilisant Verilog. Grâce au programme d'interface PLI, les programmes logiciels et matériels peuvent s'exécuter simultanément et comparer les résultats pour vérifier l'exactitude de la conception de la logique matérielle.
Analyse de conception
Dans la partie interface PLI, un sous-programme Value Change Link est utilisé pour surveiller l'horloge. Dès qu'un front montant de l'horloge arrive, une fonction logicielle est appelée pour effectuer un comptage logiciel et comparer les valeurs de comptage logicielle et matérielle.
Conception logicielle
Le code de conception logicielle est le suivant, avec des détails expliqués dans les commentaires. Enregistrez-le dans le fichier monitor_gyc.c.
Exemple
handle hand_rstn, hand_clk, hand_cnt, hand_cout ;
int cnt_soft = 0 ; //Valeur du compteur logiciel
int cout_soft = 0 ; //Bit de débordement du compteur logiciel
//Fonction de comptage et de comparaison logicielle
void act_monitor(){
p_acc_value value ; //Déclarer la variable de structure définie dans ACC
//Lire la valeur d'une variable de signal dans Verilog, de type chaîne
char *rstn_rtl_str = acc_fetch_value(hand_rstn, "%d", value);
char *clk_rtl_str = acc_fetch_value(hand_clk, "%d", value);
char *cnt_rtl_str = acc_fetch_value(hand_cnt, "%d", value);
char *cout_rtl_str = acc_fetch_value(hand_cout, "%d", value);
//Convertir une chaîne en entier
int rstn_rtl = atoi(rstn_rtl_str) ;
int clk_rtl = atoi(clk_rtl_str) ;
int cnt_rtl = atoi(cnt_rtl_str) ;
int cout_rtl = atoi(cout_rtl_str) ;
//Compteur logiciel
//Réinitialisation
if (!rstn_rtl) {
cnt_soft = 0 ;
cout_soft = 0 ;
io_printf("---iii--- Réinitialiser l'état ! \n");
}
//Fonctionnement normal
else if (rstn_rtl && clk_rtl) {
if (cnt_soft == 9) {
cnt_soft = 0 ; //Compter 10
}
else {
cnt_soft = cnt_soft + 1 ; //Compter
}
}
cout_soft = cnt_soft == 9 ? 1 : 0 ; //Retenue
//Comparer les comptages logiciels et matériels lorsque l'horloge est basse ; c'est un moment relativement sûr
if (!clk_rtl && rstn_rtl) {
if ((cnt_soft != cnt_rtl) || (cout_soft != cout_rtl)) {
io_printf("--Err--- compteur rtl : %d, et compteur logiciel : %d\n", cnt_rtl, cnt_soft);
io_printf("--Err--- rtl cout : %d, et soft cout : %d\n", io_rtl, cout_soft);
}
//S'il n'y a pas d'erreur dans la comparaison entre le logiciel et le matériel, afficher les valeurs d'état des signaux lorsqu'un cycle de comptage est terminé
else if (cnt_soft == 9) {
io("--Monitor--- rtl et soft cnt : %d\n", cnt_soft);
io_printf("--Monitor--- rtl et soft cout : %d\n", cout_soft);
}
}
}
//Interface PLI, surveillance des changements d'horloge
void my_monitor() {
acc_initialize(); //Une initialisation est requise
//Obtenir la variable de handle du premier paramètre de la tâche système my_monitor
hand_rstn = acc_handle_tfarg(1);
hand_clk = acc_handle_tfarg(2);
hand_cnt = acc_handle_tfarg(3);
hand_cout = acc_handle_tfarg(4);
//"#define VCL_VERILOG_LOGIC 2" dans acc_user.h
//Indique que le mécanisme de rappel VCL doit signaler
//Lorsque hand_clk change, appelez la fonction act_monitor
acc_vcl_add(hand_clk, act_monitor, null, vcl_verilog_logic);
acc_close(); //Fermer la tâche
}
Conception matérielle
La description Verilog d'un compteur décimal est la suivante. Enregistrez-la dans le fichier counter10.v.
Exemple
input rstn,
input clk,
output [3:0] cnt,
output cout);
reg [3:0] cnt_temp ;
always@(posedge clk or negedge rstn) begin
if (! rstn) begin
cnt_temp <= 4'b0 ;
end
else if (cnt_temp==4'd9) begin
cnt_temp <=4'b000;
end
else begin
cnt_temp <= cnt_temp + 1'b1 ;
end
end
assign cout = (cnt_temp==4'd9) ;
assign cnt = cnt_temp ;
endmodule
testbench
La description du banc de test est la suivante. Enregistrez-la dans le fichier test.v.
Exemple
module test ;
reg rstn, clk ;
wire [3:0] cnt ;
wire cout ;
initial begin
rstn = 0 ;
clk = 0 ;
#19.8;
rstn = 1 ;
end
always #5 clk = ~clk ;
counter10 u_cnt(
.rstn (rstn),
.clk (clk),
.cnt (cnt),
.cout (cout));
initial begin
$my_monitor(test.rstn, test.clk, test.cnt, test.cout);
end
initial begin
forever begin
#100;
if ($time >= 300) $finish ;
end
end
endmodule
Compilation et simulation
Sous Linux, utilisez la commande suivante pour compiler monitor_gyc.c et produire le fichier monitor_gyc.o. Faites attention au chemin relatif.
gcc -I ${VCS_HOME}/include -c ../tb/monitor_gyc.cLors de la compilation avec VCS, vous devez créer un fichier de liaison que VCS peut reconnaître. Nommez le fichier pli_gyc.tab, avec le contenu suivant.
$my_monitor est le nom de la tâche système appelée dans Verilog ;
call=my_monitor signifie l'appel de la fonction my_monitor() dans le programme C ;
acc=rw:* définit les attributs de la tâche système. rw indique que les données internes peuvent être lues et écrites. Après le deux-points, on peut déclarer le module ou la région de signal sur lesquels la tâche système agit. ":*" signifie qu'elle peut agir sur tous les modules.
$my_monitor call=my_monitor acc=rw:*
Ajoutez la ligne de paramètre suivante lors de la compilation avec VCS.
-P ../tb/pli_gyc.tab
Le journal des résultats de simulation est le suivant.
D'après le journal, on peut voir que la comparaison des comptages logiciels et matériels est correcte, et que l'état après que le compteur a terminé un cycle de comptage est également normal.

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