Livelli di logica dei report

author-image

di

Quando si sta chiudendo la tempistica di un progetto, è spesso utile sapere quanti livelli di logica sono nei percorsi in errore. L'analizzatore di tempi mostra il numero di livelli di logica quando si segnala la tempistica per un percorso, ma non esiste un report predefinito che elenca il numero di livelli di logica per un insieme di percorsi. Questo esempio di progettazione definisce una procedura personalizzata che è possibile utilizzare per creare report che mostrano il numero di livelli di logica per set di percorsi.

La procedura personalizzata supporta gli stessi argomenti del comando report_timing. È necessario utilizzare le stesse opzioni con la procedura personalizzata che si farebbe con il comando report_timing. La procedura personalizzata supporta inoltre tre opzioni aggiuntive: -greater_than <value>, -less_than <value> e -file <report file>. È possibile utilizzare le opzioni -greater_than e -less_than per limitare la segnalazione a percorsi con livelli di logica superiori o inferiori. È possibile utilizzare l'opzione -file per scrivere il report in un file.

La procedura personalizzata visualizza i numeri di livelli di logica per i percorsi con il peggior margine di temporizzazione. Non visualizza necessariamente i percorsi nella progettazione con il maggior numero di livelli di logica. I percorsi con il rallentamento della tempistica peggiore non sono sempre i percorsi con il maggior numero di livelli di logica, anche se ciò è spesso vero.

Funzionamento della procedura

La procedura personalizzata utilizza i seguenti passaggi.

  1. Ottieni un elenco di percorsi che soddisfano i criteri di reporting
  2. Ottieni il numero di livelli di logica per ciascun percorso
  3. Visualizzare il numero di livelli di informazioni sulla logica e sul percorso in un grafico

Passaggio 1: ottenere un elenco di percorsi

La procedura personalizzata utilizza il comando get_timing_paths, che supporta gli stessi argomenti del comando report_timing. È possibile utilizzare qualsiasi opzione per report_timing per controllare l'analisi dei tempi. Ad esempio, è possibile limitare il report del numero di livelli di logica ai percorsi che terminano con un determinato nome di registro. Il seguente codice Tcl mostra la definizione della procedura e passa tutti gli argomenti al comando get_timing_paths.

proc report_levels_of_logic { args } {
    
    # Passa tutti gli argomenti direttamente a get_timing_paths se {
    [catch { eval get_timing_paths $args } paths_col] } {
        errore di tipo post_message $paths_col
        return }
}

Passaggio 2: ottenere il numero di livelli di logica per ogni percorso

Utilizzare un ciclo per iterare la raccolta di percorsi nella variabile paths_col ed estrarre il numero di livelli di logica in ciascun percorso. Salvare le informazioni sul percorso in una struttura di dati della matrice Tcl che verrà utilizzata per stampare i risultati. Le informazioni salvate sono il numero di livelli di logica, il margine di flessibilità del percorso e i nomi dei nodi di origine e di destinazione.

foreach_in_collection path_obj $paths_col {

        # Quanti livelli di logica ci sono nel percorso?
        set levels_of_logic [get_path_info -num_logic_levels $path_obj] # Aggiungi
        
        le informazioni sul percorso a una matrice.
        $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 -to $path_obj]]
    ] }

Passaggio 3: visualizzare le informazioni sul percorso in un grafico

Infine, visualizzare tutte le informazioni sul percorso memorizzate nella variabile matrice. Questo esempio utilizza il pacchetto del report Tcl per formattare la matrice per stamparla. Il seguente codice aggiunge una riga di intestazione alla matrice, definisce lo stile visivo del report, imposta il riempimento delle celle e visualizza il report.

# Inserire la riga di intestazione
        $logic_levels_matrix inserire la riga 0 \
            [elenco "Livelli di logica" "Slack" "Da" "A"]
    
        # Abbiamo bisogno di uno stile definito per stampare la tabella dei risultati catch {
        ::report::rmstyle basicrpt }
        ::report::d efstyle basicrpt {{cap_rows 1}} { set di
            dati        [split "[string repeat " "   [colonne]];"]         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, impostate le colonne per avere uno spazio di riempimento e
        # stampate la matrice con il formato specificato
        catch { r destroy }
        ::report::report r 4 style basicrpt
        per { set col 0 } { $col < [r columns]} { incr col } {
            r pad $col entrambi " " } post_message
        "Livelli di logica\n[r printmatrix $logic_levels_matrix]"

Procedura personalizzata

Il codice per la procedura personalizzata elencata di seguito include opzioni per scrivere il report in un file e per limitare i percorsi segnalati, a meno che il numero di livelli di logica non sia maggiore o inferiore ai valori specificati dall'utente.

Questi sono alcuni esempi di come è possibile utilizzare la procedura personalizzata.

  • report_levels_of_logic -setup -greater_than da 10 a [get_registers data*] -npaths 1000
  • report_levels_of_logic -hold -from_clock core_50 -npaths 50 -file levels.txt

Per utilizzare la procedura personalizzata, salvare il codice Tcl riportato di seguito in un file denominato report_levels_of_logic.tcl. Quindi utilizzare l'origine del comando report_levels_of_logic.tcl al prompt Tcl di Timing Analyzer. L'appurcing del file definisce la procedura personalizzata. È quindi possibile utilizzare il comando appena definito report_levels_of_logic fino a uscire da Timing Analyzer.

package require cmdline
package require struct::matrix
package require report proc report_levels_of_logic {

args } { set options {
        { "less_than.arg" "" "Limit to paths with less than this number" }
        { "greater_than.arg" "" "Limit to paths with greater than this number" }
        { "file.arg" "" "Output file name" }
        
    } } array set
    opta [::cmdline::getKnownOptions args $options]

    # Assicurarsi che la procedura venga chiamata con alcuni argomenti
    if { [string equal "" $opts(less_than)] && [string equal "" $opts(greater_than)] } {
        post_message -type warning "È necessario specificare un valore numerico\
            per -less_than o -greater_than"
        return } # Assicurarsi che la procedura venga chiamata con valori di argomento
    
    numerico
    se { ![ string è double $opts(less_than)] } {
        avviso di tipo post_message "È necessario specificare un valore numerico\
            per -less_than"
        return } if {
    ![ string è double $opts(greater_than)] } {
        avviso di tipo post_message "È necessario specificare un valore numerico\
            per -greater_than"
        return } # Crea una matrice per contenere informazioni sui percorsi non riusciti
    impostati logic_levels_matrix [::struct::matrix]
    $logic_levels_matrix aggiungi le colonne 4

    # Passa tutti gli argomenti sconosciuti direttamente a get_timing_paths
    se { [catch { eval get_timing_paths $args } paths_col] } {
        errore post_message -type $paths_col
        return
    }
    
    # Scorrere l'elenco dei percorsi di temporizzazione, ottenere informazioni
    # sui livelli di logica
    foreach_in_collection path_obj $paths_col {
    
        # Assumere che il percorso venga segnalato, a meno che il numero di livelli di logica #non sia al di
        fuori dei limiti specificati.
        set include_path 1
        
        # Quanti livelli di logica ci sono nel percorso?
        set levels_of_logic [get_path_info -num_logic_levels $path_obj] # Se
        
        è stato specificato un limite inferiore, non viene segnalato il percorso se i
        livelli di logica #sono maggiori o uguali al limite inferiore
        se { ! [stringa uguale a "" $opts(less_than)] } {
            se { $levels_of_logic >= $opts(less_than) } { set
                include_path 0 }
            } # Se è stato specificato un
        limite
        
        superiore, non viene indicato il percorso se i
        livelli di logica # sono inferiori o uguali al limite superiore se {
        ! [stringa uguale a "" $opts(greater_than)] } {
            se { $levels_of_logic <= $opts(greater_than) } { impostare include_path
                0 } }
            # Se il percorso ha livelli di
        logica che rientrano nei nostri
        
        limiti, # report
        su di esso se {
        $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 -to $path_obj]]
        ] }
    }
    # Finito di scorrere tutti i percorsi da get_timing_paths
    
    # Se ci sono righe nella matrice, i percorsi corrispondono ai criteri.
    # Dobbiamo stampare la tabella con le informazioni.
    if { 0 == [$logic_levels_matrix rows] } {
    
        # Nessun percorso soddisfa i criteri # Stampa un messaggio rapido post_message
        "Nessun percorso soddisfa i criteri per segnalare i livelli di logica"
        
        # Se c'è un errore nell'apertura del file, stampa un messaggio che dice
        # che. In caso contrario, dire che non ci sono percorsi che soddisfano i criteri
        se { ! [stringa uguale a "" $opts(file)] } {
            se { [catch { open $opts(file) w } fh] } {
                errore di tipo post_message "Impossibile aprire il file: $fh"
            } else { mette $fh
                "Nessun percorso soddisfa i criteri per segnalare i livelli di logica"
                catch { chiudi $fh } } } } } else {
            # Inserire la riga di
    
        intestazione
        $logic_levels_matrix insert row 0 \
            [elenco "Livelli di logica" "Slack" "Da" "A"]
    
        # Abbiamo bisogno di uno stile definito per stampare la tabella dei risultati catch {
        :: report::rmstyle basicrpt }
        ::report::d efstyle basicrpt {{cap_rows 1}} {
            set di dati        [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, impostate le colonne per avere uno spazio di riempimento e
        # stampate la matrice con il formato specificato
        catch { r destroy }
        ::report::report r 4 style basicrpt
        per { set col 0 } { $col < [r columns]} { incr col } {
            r pad $col sia " " } post_message
        "Livelli di logica\n[r printmatrix $logic_levels_matrix]"
        
        # Salvare il report in un file se viene specificato un nome di file se {
        ! [stringa uguale "" $opts(file)] } {
            if { [catch { open $opts(file) w } fh] } {
                errore di tipo post_message "Impossibile aprire il file: $fh"
            } else { mette $fh
                "Livelli di logica"
                r printmatrix2channel $logic_levels_matrix $fh
                catch { chiudi $fh } } } }
}

Il contenuto di questa pagina è il risultato della combinazione tra la traduzione umana e quella automatica del contenuto originale in lingua inglese. Questo contenuto è fornito soltanto a titolo di informazione generale e non ha pretese di completezza o accuratezza. In presenza di contraddizioni tra la versione in lingua inglese di questa pagina e la sua traduzione, fa fede la versione inglese. Visualizza la versione in lingua inglese di questa pagina.