1. Outils de vérification formels
Pour la transplantation de certains circuits, il n'est généralement pas nécessaire d'effectuer une vérification par simulation sur le nouveau circuit, mais peut directement utiliser des outils EDA pour analyser si la fonction du circuit est cohérente avec le circuit d'origine.Cette méthode de vérification peut réduire considérablement la vérification temps et améliorer l'efficacité du circuit.
Le contrôle d'équivalence (Equivalence Check) est actuellement le courant dominant de la vérification formelle, qui est utilisé pour comparer la cohérence des fonctions logiques de deux circuits. Il effectue une vérification d'équivalence en prenant des points correspondants et en comparant la logique entre ces points. Il génère une structure de données et la compare avec la courbe caractéristique numérique de sortie dans les mêmes conditions de courbe caractéristique d'entrée. S'ils sont différents, cela signifie que les deux circuits comparés ne sont pas équivalents. Le processus spécifique d'utilisation de l'outil est illustré dans la figure ci-dessous. Tout d'abord, il est nécessaire de fournir à l'outil une conception originale complète et correcte, une bibliothèque de processus associée et une conception prête pour la vérification. Deuxièmement, il est nécessaire de donner des contraintes et de définir des paramètres pour le processus d'inspection, et de déterminer la plage de comparaison et points correspondants Si les résultats ne sont pas égaux, il faut diagnostiquer . Il est généralement utilisé pour comparer si la fonction logique de la netlist extraite après le code RTL et la mise en page est cohérente, si la fonction logique de la netlist avant et après l'ajout de la chaîne de numérisation est cohérente en mode de fonctionnement normal et si la fonction logique de la netlist avant et après la correction ECO Est-ce cohérent.
Pendant la phase ECO, RTL ne passe pas par le processus de synthèse complet. Lorsqu'un bogue est localisé ou qu'un nouvel ajustement doit être ajouté à la fin du processus de conception, la modification fonctionnelle de la RTL doit d'abord être confirmée puis testée pour s'assurer que la modification est comme prévu. Les modifications se font alors directement sur la netlist. Comment pouvons-nous confirmer que la netlist modifiée est conforme à la RTL ? Nous pouvons effectuer une simulation au niveau de la porte de la netlist modifiée et vérifier si la modification a atteint l'objectif souhaité. Cependant, la simulation au niveau de la porte ne peut pas fournir de garanties, et il ne peut pas être sûr à 100 % que le RTL modifié et la netlist modifiée soient équivalents.
Vous trouverez ci-dessous quelques outils de vérification d'équivalence.
| fabricant | nom de l'outil |
| Cadence | Conforme |
| Synopsis | Formalité |
| Mentor | FormalPro |
| Magma | Forme Quartz |
2. Netlist ECO
ECO est une phase de conception importante. Dans l'étape ECO, le code RTL ne peut pas être re-synthétisé, mais la netlist peut être modifiée directement. La modification et la resynthèse du code RTL peuvent être coûteuses à l'approche de l'étape finale de la conception de la puce (tape-out). Si seules des modifications mineures sont nécessaires, elles peuvent être traitées par ECO avant le ruban adhésif. Voici le processus d'ECO.
- Corrigez les erreurs sur le code RTL et vérifiez-le pour vous assurer que la puce fonctionne comme prévu.
- Avec ECO, les corrections de bogues sont effectuées directement sur la netlist. Des portes logiques peuvent être ajoutées ou modifiées pour corriger des bogues, et il y a une limite à ce qui peut être fait dans la phase ECO. Typiquement, quelques bascules et quelques portes logiques peuvent être ajoutées. S'il s'agit de quelques centaines de bascules et de quelques centaines de portes logiques, mieux vaut toutes les resynthétiser, ce qui est plus simple qu'ECO. Dans ECO, la modification de l'unité de contrôle (machine d'état) est plus facile que la modification du chemin des données.
- Une vérification d'équivalence est ensuite effectuée entre le code RTL modifié et la netlist modifiée pour s'assurer que les deux sont fonctionnellement équivalents.
Étant donné que l'ECO est exécuté directement sur la netlist, les fonctions modifiées de la netlist ne sont pas pratiques pour une analyse directe. Deux méthodes ECO typiques sont décrites ci-dessous.
Méthode 1 : modification du cône logique
Cette méthode atteint l'objectif de modifier la fonction logique et de s'adapter à la fonction RTL mise à jour en ajoutant et en réorganisant les portes logiques existantes. Cela implique d'examiner le cône de logique pilotant la bascule, d'examiner les nœuds existants et d'apporter des modifications au cône de logique, entre autres. Cela nécessite des essais et des erreurs, mais peut être modifié avec un ajout minimal de portes logiques. Cette approche doit être plus efficace lorsque le nombre de portes logiques libres à proximité de la zone modifiée est faible. Des outils tels que ECO Compiler ou Conformal LEC peuvent aider la conception à faire ECO.
Méthode 2 : Remplacer par une nouvelle logique
Lors de l'utilisation de cette méthode, il est nécessaire de concevoir un ensemble supplémentaire de circuits logiques utilisant des portes logiques, dont la sortie est connectée à une bascule existante via un sélecteur. Lorsque les conditions données sont remplies, la valeur dont nous avons besoin peut être sélectionnée via le sélecteur, et dans d'autres conditions, l'ancienne valeur peut être sélectionnée via le sélecteur. Cette méthode est plus intuitive, mais nécessite l'utilisation de plus de portes logiques. Nous utiliserons l'exemple de la méthode 2 pour analyser ci-dessous.
Exemple de description
La machine d'état lit les données d'un FIFO et les transmet au circuit de l'agent récepteur via dataout et dataout_valid. Le circuit de l'agent récepteur indique l'achèvement d'une phase de transfert de données via target_rdy. En d'autres termes, une opération de transfert de données se termine lorsque dataout_valid et target_rdy sont valides. Le contrôleur pilotera toujours dataout et dataout_valid pendant une phase de transfert de données jusqu'à ce que target_rdy soit valide. La machine d'état continue d'être dans la phase de transmission de données jusqu'à ce qu'elle lise le drapeau end_of_pkt à partir du FIFO de données. Le signal dataout_last est activé une fois le dernier transfert de données terminé. Il s'agit d'un protocole typique de transmission de données entre deux agents, et les deux agents peuvent effectuer un contrôle de flux via dataout_valid et target_rdy respectivement.
erreur
Il y a une erreur dans la conception de la machine d'état, qui ne tient pas compte du fait que la FIFO peut être temporairement vide avant la fin de la transmission du paquet (avant le signal end_of_pkt). Si le paquet n'est pas complet lorsque la FIFO de données est lue vide, la machine d'état lit une FIFO vide, ce qui entraîne une erreur.
Correction ÉCO
Dans l'état BURST_DATA, passez à un autre état WAIT_NONEMPTY et attendez que la FIFO entre dans un état non vide. Le code commenté indique le nouvel état et la logique qui doivent être ajoutés. Ici, un nouvel état doit être créé et certaines sorties doivent être modifiées. L'exemple de code est le suivant :
reg [2:0] xmitstate, xmitstate_nxt;
reg fifo_rden;
reg [15:0] dataout, dataout_nxt;
reg dataout_valid, dataout_valid_nxt;
reg dataout_last, dataout_last_nxt;
parameter IDLE = 3'b000,
DATA_AVAIL = 3'b001,
FIRST_DATA = 3'b010,
BURST_DATA = 3'b011,
LAST_DATA = 3'b100;
//新加的状态
//parameter WAIT_NONEMPTY = 3'b101;
always@(posedge clk, negedge rstb) begin
if(!rstb) begin
xmitstate <= IDLE;
dataout <= 0;
dataout_valid <= 0;
dataout_last <= 0;
end
else begin
xmitstate <= xmitstate_nxt;
dataout <= dataout_nxt;
dataout_valid <= dataout_valid_nxt;
dataout_last <= dataout_last_nxt;
end
end
always@(*) begin
xmitstate_nxt = xmitstate;
fifo_nxt = 1'b0;
dataout_nxt = dataout;
dataout_valid_nxt = 1'b0;
dataout_last_nxt = 1'b0;
case(xmistate)
IDLE: begin
if(start_xmit)
xmitstate_nxt = DATA_AVAIL;
end
DATA_AVAIL: begin
if(!fifo_empty) begin
xmitstate = FIRST_DATA;
fifo_rden = 1'b1;
end
end
FIRST_DATA: begin
data_out_nxt = fifo_rddata;
dataout_valid_nxt = 1'b1;
if(end_of_pkt) begin
xmitstate_nxt = LAST_DATA;
dataout_last_nxt = 1'b1;
end
else begin
xmitstate_nxt = BURST_DATA;
fifo_rden = 1'b1;
end
end
BURST_DATA: begin
if(target_rdy) begin
data_out_nxt = fifo_rddata;
dataout_valid_nxt = 1'b1;
if(end_of_pkt) begin
xmitstate_nxt = LAST_DATA;
dataout_last_nxt = 1'b1;
end
//else if(fifo_empty)
// xmitstate_nxt = WAIT_NONEMPTY;
else
fifo_rden = 1'b1;
end
else begin
dataout_nxt = data_out;
dataout_valid_nxt = 1'b1;
end
end
LAST_DATA: begin
if(target_rdy)
xmitstate_nxt = IDLE;
else begin
dataout_nxt = dataout;
dataout_valid_nxt = 1'b1;
dataout_last_nxt = 1'b1;
end
end
/*新加的状态
WAIT_NONEMPTY: begin
if(target_rdy) begin
if(!fifo_empty) begin
xmitstate_nxt = FIRST_DATA;
fifo_rden = 1'b1;
end
else
xmitstate_nxt = DATA_AVAIL;
end
else
dataout_valid_nxt = 1'b1;
dataout_nxt = dataout;
end
*/
endcase
endÉCO
Pour le code RTL nouvellement ajouté lors de la correction des erreurs, xmistate_nxt[2:0], dataout_valid_nxt et fifo_rden doivent être modifiés. Ensuite, nous devons nous attaquer à la logique xmistate_nxt[2:0], qui est probablement la plus difficile des trois.
première condition de couverture
if((xmitstate == BURST_DATA) && target_rdy && !end_of_pkt && fifo_empty)
xmitstate_nxt = WAIT_NONEMPTY
即
if((xmitstate == 3'b011) && target_rdy && !end_of_pkt && fifo_empty)
xmitstate_nxt = 3'b101deuxième condition de couverture
if((xmitstate == WAIT_NONEMPTY) && target_rdy && !fifo_empty)
xmitstate_nxt = FIRST_DATA;
即
if((xmitstate == 3'b101) && target_rdy && !fifo_empty)
xmitstate_nxt = 3'b010;La troisième condition de couverture
if((xmitstate == WAIT_NONEMPTY) && target_rdy && fifo_empty)
xmitstate_nxt = DATA_AVAIL;
即
if((xmitstate == 3'b101) && target_rdy && fifo_empty)
xmitstate_nxt = 3'b001;La figure ci-dessous montre l'ECO pour xmitstate[2], et la méthode ECO pour les deux autres bits est similaire. Bien sûr, dans l'ECO réel, le circuit logique peut être encore optimisé en fonction des portes logiques qui peuvent être sélectionnées dans la bibliothèque de cellules. Pendant ECO, l'entrée qui entre initialement dans la bascule xmitstate[2] est coupée et connectée à un sélecteur composé d'une porte OU et d'une porte ET. En contrôlant le sélecteur, il est possible de sélectionner la branche logique nouvellement ajoutée ou la branche logique d'origine. Les trois conditions de couverture ci-dessus ne peuvent pas toutes être satisfaites en même temps, et on peut constater que dans les deuxième et troisième conditions de couverture, xmitstate[2] est à la fois 0, et (xmitstate == 3'b101) && target_rdy peut couvrir les deux d'eux en même temps. Il en résulte que seules deux conditions de couverture A et B apparaissent dans l'ECO.
ECO expliqué
Aux points A et B du diagramme, il existe deux conditions de couverture. Nous voulons que l'entrée de xmitstate[2] soit 1 lorsque la première condition de remplacement (point A) est vraie. Lorsque A est 1, la sortie de la porte OU OR-A est 1, et la deuxième condition de couverture est fausse à ce moment, c'est-à-dire que le point B est 1, et la sortie de la porte ET ET-B est également 1. Nous voulons que l'entrée de xmitstate[2] soit 0, lorsque la deuxième ou la troisième condition est vraie. Dans ce cas, le point B est 0 et la sortie de AND-B est également 0. C'est ce à quoi nous nous attendrions dans les deuxième et troisième conditions de couverture.
En résumé, nous avons pu obtenir 1 dans la première condition de couverture et 0 dans les deuxième et troisième conditions. Les valeurs logiques obtenues dans ces conditions ne dépendent pas des conditions d'origine, puisque ces conditions sont à l'avant du cône logique. Lorsqu'aucune des conditions de remplacement n'est vraie, le point B est 1 et le point A est 0, ce qui fait passer le point C (la valeur d'origine) à l'entrée de la bascule.
Le contenu ci-dessus provient de "Verilog Advanced Digital System Design Technology and Example Analysis" et "SOC Design Method and Implementation"