Lorsque vous bouclez le timing d’une conception, il est souvent utile de savoir combien de niveaux de logique se trouvent dans les chemins défaillants. L’Analyseur de synchronisation affiche le nombre de niveaux de logique lorsque vous signalez la synchronisation d’un chemin, mais il n’existe aucun rapport par défaut qui répernumère le nombre de niveaux de logique pour un ensemble de chemins. Cet exemple de conception définit une procédure personnalisée que vous pouvez utiliser pour créer des rapports qui montrent le nombre de niveaux de logique pour les ensembles de chemins.
La procédure personnalisée prend en charge les mêmes arguments que la commande report_timing. Vous devez utiliser les mêmes options avec la procédure personnalisée que celle de la commande report_timing. La procédure personnalisée prend également en charge trois options supplémentaires : -greater_than <value>, -less_than <value> et -file <reporter>. Vous pouvez utiliser les options -greater_than et -less_than pour limiter le reporting à des chemins avec des niveaux de logique supérieurs ou inférieurs aux niveaux spécifiés. Vous pouvez utiliser l’option -file pour écrire le rapport dans un fichier.
La procédure personnalisée affiche le nombre de niveaux de logique pour les chemins avec le pire slack de synchronisation. Il n’affiche pas nécessairement les chemins dans la conception avec le plus grand nombre de niveaux de logique. Les chemins avec le plus mauvais slack de synchronisation ne sont pas toujours les chemins possédant le plus grand nombre de niveaux de logique, bien que cela soit souvent vrai.
Opération de procédure
La procédure personnalisée utilise les étapes suivantes.
- Obtenir une liste des chemins qui répondent aux critères de création de rapports
- Obtenez le nombre de niveaux de logique pour chaque chemin d’accès
- Afficher le nombre de niveaux d’informations logiques et de chemin dans un tableau
Étape 1 : Obtenir une liste de chemins
La procédure personnalisée utilise la commande get_timing_paths, qui prend en charge les mêmes arguments que la commande report_timing. Vous pouvez utiliser toutes les options de report_timing pour contrôler l’analyse de synchronisation. Par exemple, vous pouvez limiter le rapport du nombre de niveaux de logique aux chemins qui se terminent par un certain nom de registre. Le code Tcl suivant montre la définition de la procédure et transmet tous les arguments à la commande get_timing_paths.
proc report_levels_of_logic { args } {
# Pass tous les arguments directement à get_timing_paths
si {[capture {eval get_timing_paths $args} paths_col] } {
post_message -type d’erreur $paths_col
retour }
}
Étape 2 : obtenez le nombre de niveaux de logique pour chaque chemin d’accès
Utilisez une boucle pour itérer la collection de chemin dans le paths_col variable et extraire le nombre de niveaux de logique dans chaque chemin. Enregistrez des informations sur le chemin dans une structure de données matricielle Tcl qui sera utilisée pour imprimer les résultats. Les informations enregistrées correspondent au nombre de niveaux de logique, au relâchement du chemin et au nom du nœud source et de destination.
foreach_in_collection path_obj $paths_col {
Combien de niveaux de logique y a-t-il sur le chemin ?
définissez levels_of_logic [get_path_info -num_logic_levels $path_obj] # Ajoutez
les informations de chemin à une matrice.
$logic_levels_matrix add row [liste \
$levels_of_logic \
[get_path_info -slack $path_obj] \
[get_node_info -nom [get_path_info -de $path_obj]] \
[get_node_info -nom [get_path_info -à $path_obj]]
] }
Étape 3 : Afficher les informations sur le chemin d’accès dans un tableau
Enfin, affichez toutes les informations de chemin stockées dans la variable matricielle. Cet exemple utilise le package de rapport Tcl pour formater la matrice pour l’imprimer. Le code suivant ajoute une ligne de tête à la matrice, définit le style visuel du rapport, définit la cellule de programmation et affiche le rapport.
# Mettez dans la ligne d’en-tête
$logic_levels_matrix insert 0 \
[liste « Niveaux de logique », « Slack », « De » « À » ]
# Nous avons besoin d’un style défini pour imprimer le tableau des résultats capture {
::report:rm logic basicrpt }
::report::d ef fait basicrpt {{cap_rows 1}} { jeu de
données [split « [string repeat » [ colonnes];]
top set [split « [string repeat « + - " [columns]+"]
bottom set [top get]
topcapsep set [top get]
topdata set [data get]
top enable
topcapsep enable bottom enable bottom enable tcaption $cap_rows
} # Create the
report, configurez les colonnes pour avoir un espace de marquage unique, et
# imprimez la matrice avec la capture de format spécifié
{ r destroy }
::report::report r 4 style basicrpt
pour {set col 0 } { $col < [r columns]} { incr col } {
r pad $col les deux » » } post_message « Niveaux de
logique\n[r printmatrix $logic_levels_matrix] »
Procédure personnalisée
Le code de la procédure personnalisée indiquée ci-dessous comprend des options permettant d’écrire le rapport dans un fichier et de limiter les chemins signalés, sauf si le nombre de niveaux de logique est supérieur ou inférieur aux valeurs spécifiées par l’utilisateur.
Voici quelques exemples de comment vous pouvez utiliser la procédure personnalisée.
- report_levels_of_logic -setup -greater_than 10 -à [get_registers data*] -npaths 1000
- report_levels_of_logic -hold-from_clock core_50 -npaths 50 -niveaux de fichier.txt
Pour utiliser la procédure personnalisée, enregistrez le code Tcl ci-dessous dans un fichier nommé report_levels_of_logic.tcl. Utilisez ensuite la source de commande report_levels_of_logic.tcl à l’invite Tcl De l’analyseur de synchronisation. L’usage de ce fichier définit la procédure personnalisée. Vous pouvez ensuite utiliser la commande nouvellement définie report_levels_of_logic jusqu’à ce que vous quittez l’Analyseur de synchronisation.
package nécessitant un package cmdline
nécessitent struct::matrix package nécessitent un
rapport
proc report_levels_of_logic { args } {
options définies { { «
less_than.arg » « » « Limiter aux chemins avec moins de ce nombre » }
{ « greater_than.arg » « » « Limite aux chemins avec plus de ce nombre » }
{ « file.arg » » « » « Output file name » }
} array set
opts [::cmdline:::getKnownOptions args $options]
# Assurez-vous que la procédure est appelée avec certains arguments
si {[chaîne égale « » $opts(less_than)] &&> [chaîne égale « » $opts(greater_than)] } {
post_message -type d’avertissement « Vous devez spécifier une valeur numérique\
pour le retour -less_than ou -greater_than »
}
Assurez-vous que la procédure est appelée avec des valeurs d’argument numérique
si { ![ la chaîne est double $opts(less_than)] } {
avertissement de type post_message « Vous devez spécifier une valeur numérique\ pour le retour less_than »
} si {
![ la chaîne est double $opts(greater_than)] } {
avertissement de type post_message « Vous devez spécifier une valeur numérique\ pour le retour greater_than »
} Créer une matrice pour tenir des informations sur les
chemins défectueux
définis logic_levels_matrix [::struct ::matrix]
$logic_levels_matrix add columns 4
# Pass tous les arguments inconnus directement à get_timing_paths
si {capture {eval get_timing_paths $args } paths_col] } {
post_message -type d’erreur $paths_col
retour
}
# Marchez dans la liste des chemins de synchronisation, obtenir des informations
# sur les niveaux de logique
foreach_in_collection path_obj $paths_col {
# Suppose que le chemin sera signalé, sauf si le nombre de niveaux de
logique #est en dehors des limites spécifiées.
définir include_path 1
# Combien de niveaux de logique y a-t-il sur le chemin ?
définissez levels_of_logic [get_path_info -num_logic_levels $path_obj] # Si
nous avons spécifié une limite inférieure, nous ne signalons pas le chemin si les
niveaux de logique #sont supérieurs ou égaux à celui qui est inférieur
si { ! [chaîne égale « » $opts(less_than)] } {
si {$levels_of_logic >= $opts(less_than) }
{défini include_path 0
} } Si
nous avons spécifié un
lien supérieur, nous ne signalons pas le chemin si les
niveaux de logique nº sont inférieurs ou égaux à la limite supérieure
si { ! [chaîne égale « » $opts(greater_than)] } {
si {$levels_of_logic <= $opts(greater_than) }
{définir include_path 0 } }
Si le chemin
d’accès possède des niveaux de logique qui entrent dans nos limites,
Nb de rapport si {
$include_path } {
{$logic_levels_matrix add row [list
\$levels_of_logic \
[get_path_info -slack $path_obj] \
[get_node_info -name [get_path_info -from $path_obj]] \
[get_node_info -name [get_path_info -à $path_obj]]
} }
}
# Terminé en passant par tous les chemins de get_timing_paths
# S’il y a des lignes dans la matrice, les chemins correspondent aux critères.
# Nous devons imprimer le tableau avec ces informations.
si { 0 == [$logic_levels_matrix rows] } {
# Aucun chemin ne répond aux critères #
Imprimez un message rapide
post_message « Aucun chemin ne répond aux critères pour signaler les niveaux de logique »
# S’il y a une erreur qui ouvre le fichier, imprimez un message
indiquant n°1. Sinon, disons qu’il n’y a pas de chemins répondant aux critères
si { ! [chaîne égale « » $opts(fichier)] } {
si {[catch {open $opts(file) w } fh] } {
erreur de type post_message « Impossible d’ouvrir le fichier : $fh » }
d’autre
{met $fh « Aucun chemin ne répond aux critères pour signaler les niveaux de logique » capture { fermez $fh $fh } } } }
d’autre {
# Mettre dans la ligne d’en-tête
$logic_levels_matrix insert row 0 \
[liste « Niveaux de logique », « Slack » « De » « To » ]
# Nous avons besoin d’un style défini pour imprimer le tableau des résultats
à capture { :: report::rm firmware basicrpt }
::report::d ef firmware basicrpt {{cap_rows 1}} { jeu de
données [split « [string repeat » » [columns];]
top set [split « [string repeat « + - " [columns]+"]
bottom set [top get]
topcapsep set [top get]
topdata set [data get]
top enable
topcapsep enable bottom enable bottom enable tcaption $cap_rows
} # Create the
report, configurez les colonnes pour avoir un espace de marquage unique, et
# imprimez la matrice avec la capture de format spécifié
{ r destroy }
::report::report r 4 style basicrpt
pour {set col 0 } { $col < [r columns]} { incr col } {
r pad $col both » » } post_message « Niveaux de
logique\n[r printmatrix $logic_levels_matrix] »
# Enregistrez le rapport dans un fichier si un nom de fichier est spécifié si {
! [chaîne égale « » $opts(fichier)] } {si
{[capture { open $opts(file) w } fh] } { erreur de type post_message « Impossible d’ouvrir le
fichier : $fh » }
d’autre
{ met $fh « Niveaux de logique » r
printmatrix2channel $logic_levels_matrix $fh
capture { fermez $fh } } }
}