Obtenez des horloges qui donnent une broche

author-image

Par

Cet exemple de conception montre une procédure personnalisée, que vous pouvez utiliser dans les fichiers SDC, qui renvoie une liste de toutes les horloges qui alimentent une broche. La procédure peut être utile si vous devez créer des horloges générées sans connaître les autres noms d’horloge dans une conception. L’exemple de conception Simplify Design Reuse with Dynamic SDC Constraints (Simplifier la conception avec des contraintes SDC dynamiques) fournit plus de détails et un exemple d’utilisation de la procédure personnalisée décrite sur cette page.

Le code complet de la procédure se trouve en bas de la page, suivant une explication complète du fonctionnement de la procédure. Pour utiliser la get_clocks_driving_pins procédure personnalisée dans un fichier SDC, assurez-vous que la procédure a été définie, puis appelez-la comme toute autre commande SDC. Il existe deux façons simples de s’assurer que la procédure a été définie avant l’utilisation :

  • Enregistrez le code de procédure dans un fichier SDC séparé et incluez le fichier SDC dans le projet.
  • Copiez et collez le code de procédure en haut de tout fichier SDC, avant l’utilisation de la get_clocks_driving_pins procédure personnalisée.

Fichier SDC séparé

L’enregistrement du code de procédure dans un fichier SDC séparé du reste de vos contraintes permet de le réutiliser plus facilement dans d’autres projets. Si vous utilisez un fichier SDC séparé, vous devez ajouter le fichier SDC avec la procédure à la liste des fichiers du projet, et il doit apparaître au-dessus des fichiers SDC qui utilisent la procédure. L’inscription au-dessus des autres fichiers SDC garantit que le logiciel Quartus® II définit la procédure avant de l’utiliser, chaque fois que les fichiers SDC sont lus.

Copier-coller

La copie et le coller du code de procédure dans le même fichier SDC où il est utilisé entraînent un moins grand nombre de fichiers SDC dans un projet. Si vous créez un fichier SDC pour un module qui sera réutilisé par d’autres concepteurs, il peut être plus simple d’inclure toutes les contraintes et le code de prise en charge dans un seul fichier SDC. Vous devez inclure le code de procédure dans le fichier SDC avant la première utilisation de la procédure afin qu’il soit défini avant l’utilisation. En général, vous le mettez en haut du fichier pour satisfaire cette exigence.

Opération de script

Obtenir une liste de toutes les horloges d’une conception qui alimente une broche prend trois étapes principales :

  1. Obtenez toutes les horloges et créez un mappage à partir de leurs nœuds cibles vers les horloges des nœuds cibles.
  2. Obtenez une liste de nœuds avec des horloges dessus qui se trouvent sur le chemin du fanin vers la broche spécifiée.
  3. Dans cette liste de nœuds, trouvez le nœud le plus proche de la broche spécifiée et retournez les horloges sur ce nœud.

Étape 1. Obtenez toutes les horloges et créez un mappage

Le code Tcl suivant obtient toutes les horloges dans la conception et crée le mappage (avec une batterie Tcl) d’un nœud aux horloges du nœud.

catch {array unset nodes_with_clocks}
array set nodes_with_clocks [list] #

Iterate sur chaque horloge de la foreach_in_collection clock_id
[all_clocks]

    {set clock_name [get_clock_info -name $clock_id]

    # Chaque horloge est appliquée aux nœuds. Obtenez la collection des nœuds cibles
    foreach_in_collection target_id [get_clock_info -targets $clock_id] {

        # Associez le nom d’horloge à son nœud cible
        défini target_name [get_node_info -name $target_id]
        lall nodes_with_clocks($target_name) $clock_name
    }
}

Comme les horloges virtuelles n’ont pas d’objectifs, aucune cartographie n’est jamais réalisée avec une horloge virtuelle. Dans le code de procédure complet indiqué ci-dessous, les informations sur le type de nœuds cibles (registre, broche, cellule ou port) sont enregistrées pour une utilisation ultérieure.

Étape 2. Obtenez des nœuds avec des horloges sur Fanin Path

La deuxième étape consiste à trouver le sous-ensemble de nœuds avec des horloges qui se trouvent sur le chemin du ventilateur vers la broche spécifiée. Pour chaque nœud avec des horloges (se trouvant à l’étape 1), obtenez le fanin à la broche spécifiée à travers le nœud. S’il y a un fanin, le nœud se trouve sur le chemin du ventilateur jusqu’à la broche. S’il n’y a pas de fanin, le nœud n’est pas sur le chemin du fanin vers la broche.

Le code Tcl suivant itération à travers tous les nœuds avec des horloges de l’étape 1 et utilise la commande get_fanins pour déterminer si chaque nœud se trouve sur le chemin de fanin de la broche spécifiée. Si le nœud se trouve sur le chemin du fanin de la broche spécifiée, le nœud est enregistré dans la liste pin_drivers.

définissez pin_drivers [liste]

# Iterate sur tous les nœuds du mappage créé à l’étape 1 de la node_with_clocks [noms de
batterie nodes_with_clocks] { # Obtenez tous les

    fanins à la broche spécifiée à l’aide du nœud actuel
    défini fanin_col [get_fanins -clock -through $node_with_clock $pin_name]

    # S’il y a au moins un nœud fanin, le nœud actuel se trouve sur le
    chemin # fanin vers la broche spécifiée,  enregistrez-le.
    si { 0 < [get_collection_size $fanin_col] } {
        lalux pin_drivers $node_with_clocks
}

Le code de procédure complet indiqué ci-dessous utilise des informations supplémentaires sur le type de nœud pour spécifier une collection spécifique au type pour la valeur de -through dans la commande get_fanins.

Étape 3. Trouver le nœud le plus proche de la broche spécifiée

La variable pin_drivers possède maintenant une liste de tous les nœuds dont les horloges se trouvent sur le chemin du ventilateur vers la broche spécifiée. Cette étape trouve le nœud le plus proche de la broche spécifiée. Alors qu’il y a plusieurs nœuds dans la liste pin_drivers, le code prend les deux premiers nœuds de la liste et vérifie si l’un se trouve sur le chemin du ventilateur vers l’autre. S’il se trouve sur le chemin du ventilateur, le premier nœud doit être plus loin de la broche que le deuxième nœud, de sorte qu’il puisse être retiré de la liste.

{1 < [llength $pin_drivers] } {

    # Obtenez les deux premiers nœuds de la liste pin_drivers
    défini node_a [$pin_drivers 0]
    défini node_b [$pin _drivers 1]

    # Vérifiez si node_b est sur le chemin du fanin de node_a
    défini fanin_col [get_fanins -clock-through $node_b $node_a]

    # S’il y a au moins un nœud fanin,  node_b doit être plus
    loin de la broche spécifiée que node_a l’est.
    # S’il n’y a pas de nœud fanin, node_b doit être plus proche de la
    broche # spécifiée que node_a l’est.
    si {0 < [get_collection_size] } {

        # node_a est plus proche de la broche.
        # Supprimer les node_b de la liste de pin_drivers
        défini pin_drivers [lreplace $pin_drivers 1 1]

    }

        {# node_b est plus proche de la broche.
        # Supprimer node_a de la liste de pin_drivers
        défini pin_drivers [lreplace $pin_drivers 0 0]
    } } Le nœud qui reste dans pin_drivers est le nœud qui pilote la broche
spécifiée pin_drivers node_driving_pin [$pin_drivers 0]

# Recherchez les horloges du nœud dans le mappage à partir de l’étape 1 et retournez-les
$nodes_with_clocks ($node_driving_pin

Le code de procédure complet indiqué ci-dessous utilise des informations supplémentaires sur le type de nœud pour spécifier une collection spécifique au type pour la valeur de -through dans la commande get_fanins.

Code de procédure complet

Le code complet de la get_clocks_driving_pin procédure personnalisée est indiqué ci-dessous. Il inclut une vérification des erreurs et des fonctionnalités d’assistance supplémentaires qui ne sont pas décrites dans les détails ci-dessus.

proc get_clocks_feeding_pin { pin_name } {

    # Avant l’étape 1, effectuez une vérification d’erreur pour s’assurer que le numéro de pin_name
    transmis à la procédure correspond à une seule broche et une seule.
    # Retournez une erreur s’il ne correspond pas à une seule broche et une seule.
    définissez pin_col [get_pins -compatibility_mode $pin_name]
    si { 0 == [get_collection_size $pin_col] } { erreur de
        retour de code « Aucune broche ne correspond à $pin_name »
    } elseif { 1 < [get_collection_size $pin_col] } { erreur de
        retour -code " $pin_name correspond aux broches [get_collection_size $pin_col]\
            mais ne doivent correspondre qu’à une seule »
    } #
    
    Initialiser les variables utilisées dans la procédure
    capture {array unset nodes_with_clocks }
    catch {unset node_types }
    array set nodes_with_clocks [liste]
    array set node_types [list]
    défini pin_drivers [liste]
    
    # Étape 1. Obtenez toutes les horloges dans la conception et créez un mappage à partir de
    # les nœuds cibles aux horloges des nœuds cibles

    # Iterate sur chaque horloge dans le foreach_in_collection clock_id de conception
    [all_clocks] {

        définissez clock_name [get_clock_info -name $clock_id]
        défini clock_target_col [get_clock_info -targets $clock_id]
        
        # Chaque horloge est appliquée aux nœuds. Obtenez la collection des nœuds cibles
        foreach_in_collection target_id [get_clock_info -targets $clock_id] { # Associer le nom d’horloge

            à son nœud cible défini target_name
            [get_node_info -name $target_id]
            la nodes_with_clocks($target $clock_name

            ) Save the type of the target node for later use
            set target_type [get_node_info -type $target_id]
            set node_types($target_name) $target_type
    } }

    Nb. Étape 2. Obtenez une liste de nœuds avec des horloges dessus qui se trouvent sur
    le chemin # fanin vers la broche

    spécifiée # Iterate sur tous les nœuds dans le mappage créé à l’étape 1 de la node_with_clocks [noms de
    réseau nodes_with_clocks] { # Utilisez le type de

        nœud cible pour créer une collection # spécifique de type spécifique pour la valeur
        -through dans la commande get_fanins.
        switch -exact -- $node_types($node_with_clocks) {
            « pin »  {set through_col [get_pins $node_with_clocks] }
            « port » { set through_col [get_ports $node_with_clocks] }
            « cell » {set through_col [get_cells $node_with_clocks] }
            « reg »  {set through_col [get_registers $node_with_clocks] } par défaut { erreur de
            retour de code « $node_types($node_with_clocks) n’est pas géré\
                comme un type fanin par le script »
        } }

        Nb. Accédez à la broche spécifiée à l’aide du nœud
        actuel défini fanin_col [get_fanins -clock -through $through_col $pin_name]

        # S’il y a au moins un nœud fanin, le nœud actuel se trouve sur le
        chemin # fanin vers la broche spécifiée, alors enregistrez-le.
        si {0 < [get_collection_size $fanin_col] } {
            la fixend pin_drivers $node_with_clocks
        } } # avant

    l’étape 3, effectuez une vérification d’erreur pour vous assurer qu’au moins un
    des nœuds possédant des horloges est sur la voie du ventilateur vers la broche
    spécifiée.
    si {0 == [llength $pin_drivers] } {erreur de
        retour de code « Impossible de trouver aucun nœud avec les horloges qui lecteurs $pin_name »
    } # Étape
    
    3. Dans la liste des nœuds créés à l’étape 2, trouvez le nœud le
    plus proche de la broche spécifiée et retournez les horloges sur ce nœud.

    tandis que { 1 < [llength $pin_drivers] } {

        # Obtenez les deux premiers nœuds de la liste pin_drivers
        défini node_a [$pin_drivers 0] défini node_b
        [$pin_drivers 1]
        
        # Utilisez le type de nœud cible pour créer une collection # spécifique pour la valeur
        -through de la commande get_fanins.
        switch -exact -- $node_types($node_b) {
            « pin »  {set through_col [get_pins $node_b] }
            « port » {set through_col [get_ports $node_b] }
            « cell » {set through_col [get_cells $node_b] }
            « reg »  {set through_col [get_registers $node_b] } par défaut { erreur de
            retour de code « $node_types ($node_b) n’est pas traitée\
                en tant que type fanin par le script »
        } } Nb Vérifiez si node_b se trouve sur le chemin du ventilateur de

        node_a        
        définissez fanin_col [get_fanins -clock-through $through_col $node_a]

        # S’il y a au moins un nœud fanin, node_b doit être plus
        loin de la broche spécifiée que la node_a.
        # S’il n’y a pas de nœud fanin, node_b doit être plus proche de la
        broche # spécifiée que node_a l’est.
        si {0 < [get_collection_size $fanin_col] } {

            # node_a est plus proche de la broche.
            # Supprimer node_b de la liste de pin_drivers
            défini pin_drivers [lreplace $pin_drivers 1 1] } {# node_b est plus proche de

        la broche # Supprimer le node_a de la liste pin_drivers défini pin_drivers
            [lrange $pin node_b }
        Le nœud restant dans pin_drivers est le nœud à
    l’origine du jeu de
    
    broches spécifié node_driving_pin
    [$pin_drivers 0]

    # Rechercher les horloges sur le nœud dans le mappage à partir de l’étape 1 et retournez-les
    retourner $nodes_with_clocks ($node_driving_pin)
}

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.