Niveaux de logique de rapport

author-image

Par

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.

  1. Obtenir une liste des chemins qui répondent aux critères de création de rapports
  2. Obtenez le nombre de niveaux de logique pour chaque chemin d’accès
  3. 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 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] } {
        erreur de type post_message $paths_col
        de 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.

#Put dans la ligne d’en-tête
        $logic_levels_matrix insert 0 \
            [liste « Niveaux de logique », « Slack » « De » « To"]
    
        # Nous avons besoin d’un style défini pour imprimer le tableau des résultats
        attrapent { ::report:rm logic basicrpt }
        ::report::d ef fait 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    tcaption $cap_rows
        } # Create the
        
        report, configurez les colonnes pour avoir un espace de gravure unique, et
        #print out the matrix with the specified format
        catch { r destroy }
        ::report::report r 4 style basicrpt
        pour {set col 0 } { $col < [r columns]} { incr col } {
            r pad $col both » » } post_message « Levels of
        logic\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 } } }
    }

Le contenu de cette page est une combinaison de traduction humaine et informatique du contenu original en anglais. Ce contenu vous est fourni pour votre commodité et à titre informatif seulement et ne saurait être totalement exact ou complet. En cas de contradiction entre la version anglaise de cette page et la traduction, c'est la version anglaise qui prévaut. Afficher la version anglaise de cette page.