path_delay.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DO_NOT_ANALYSE   -1
#define	SLACK_DEFINITION   'R'

Functions
t_slack *	alloc_and_load_timing_graph (t_timing_inf timing_inf)
t_slack *	alloc_and_load_pre_packing_timing_graph (float block_delay, float inter_cluster_net_delay, t_model *models, t_timing_inf timing_inf)
t_linked_int *	allocate_and_load_critical_path (void)
void	load_timing_graph_net_delays (float **net_delay)
void	do_timing_analysis (t_slack *slacks, boolean is_prepacked, boolean do_lut_input_balancing, boolean is_final_analysis)
void	free_timing_graph (t_slack *slack)
void	free_timing_stats (void)
void	print_timing_graph (const char *fname)
void	print_lut_remapping (const char *fname)
void	print_slack (float **slack, boolean slack_is_normalized, const char *fname)
void	print_criticality (t_slack *slacks, boolean criticality_is_normalized, const char *fname)
void	print_net_delay (float **net_delay, const char *fname)
void	print_clustering_timing_info (const char *fname)
boolean	has_valid_normalized_T_arr (int inode)
void	print_timing_stats (void)
float	get_critical_path_delay (void)
void	print_critical_path (const char *fname)
void	get_tnode_block_and_output_net (int inode, int *iblk_ptr, int *inet_ptr)
void	do_constant_net_delay_timing_analysis (t_timing_inf timing_inf, float constant_net_delay_value)
void	print_timing_graph_as_blif (const char *fname, t_model *models)

Variables
int	num_tnodes
t_tnode *	tnode

Macro Definition Documentation

#define DO_NOT_ANALYSE   -1

Definition at line 4 of file path_delay.h.

#define SLACK_DEFINITION   'R'

Definition at line 8 of file path_delay.h.

Function Documentation

t_slack* alloc_and_load_pre_packing_timing_graph	(	float	block_delay,
		float	inter_cluster_net_delay,
		t_model *	models,
		t_timing_inf	timing_inf
	)

Definition at line 288 of file path_delay.c.

                                                                                 {

    /* This routine builds the graph used for timing analysis.  Every technology-
     * mapped netlist pin is a timing node (tnode).  The connectivity between pins is *
     * represented by timing edges (tedges).  All delay is marked on edges, not *
     * on nodes.  Returns two arrays that will store slack values:               *
     * slack and criticality ([0..num_nets-1][1..num_pins]).           */

    /*  For pads, only the first two pin locations are used (input to pad is first,
     * output of pad is second).  For CLBs, all OPEN pins on the cb have their 
     * mapping set to OPEN so I won't use it by mistake.                          */
    
    int num_sinks;
    t_slack * slacks = NULL;
    boolean do_process_constraints = FALSE;
    
    if (tedge_ch.chunk_ptr_head != NULL) {
        vpr_printf(TIO_MESSAGE_ERROR, "in alloc_and_load_timing_graph: An old timing graph still exists.\n");
        exit(1);
    }

    num_timing_nets = num_logical_nets;
    timing_nets = vpack_net;

    alloc_and_load_tnodes_from_prepacked_netlist(block_delay,
            inter_cluster_net_delay);

    num_sinks = alloc_and_load_timing_graph_levels();

    slacks = alloc_slacks();

    check_timing_graph(num_sinks);

    if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_PRE_PACKING_TIMING_GRAPH_AS_BLIF)) {
        print_timing_graph_as_blif(getEchoFileName(E_ECHO_PRE_PACKING_TIMING_GRAPH_AS_BLIF), models);
    }
    
    if (g_sdc == NULL) {
        /* the SDC timing constraints only need to be read in once; *
         * if they haven't been already, do it now                  */
        read_sdc(timing_inf);
        do_process_constraints = TRUE;
    }
    
    load_clock_domain_and_clock_and_io_delay(TRUE); 

    if (do_process_constraints) 
        process_constraints();
    
    if (f_timing_stats == NULL)
        alloc_timing_stats();

    return slacks;
}

Here is the call graph for this function:

Here is the caller graph for this function:

t_slack* alloc_and_load_timing_graph

(

t_timing_inf

timing_inf

)

Definition at line 239 of file path_delay.c.

                                                               {

    /* This routine builds the graph used for timing analysis.  Every cb pin is a 
     * timing node (tnode).  The connectivity between pins is                   *
     * represented by timing edges (tedges).  All delay is marked on edges, not *
     * on nodes.  Returns two arrays that will store slack values:              *
     * slack and criticality ([0..num_nets-1][1..num_pins]).           */

    /*  For pads, only the first two pin locations are used (input to pad is first,
     * output of pad is second).  For CLBs, all OPEN pins on the cb have their 
     * mapping set to OPEN so I won't use it by mistake.                          */

    int num_sinks;
    t_slack * slacks = NULL;
    boolean do_process_constraints = FALSE;

    if (tedge_ch.chunk_ptr_head != NULL) {
        vpr_printf(TIO_MESSAGE_ERROR, "in alloc_and_load_timing_graph: An old timing graph still exists.\n");
        exit(1);
    }
    num_timing_nets = num_nets;
    timing_nets = clb_net;

    alloc_and_load_tnodes(timing_inf);

    num_sinks = alloc_and_load_timing_graph_levels();

    check_timing_graph(num_sinks);

    slacks = alloc_slacks();

    if (g_sdc == NULL) {
        /* the SDC timing constraints only need to be read in once; *
         * if they haven't been already, do it now                  */
        read_sdc(timing_inf);
        do_process_constraints = TRUE;
    }
    
    load_clock_domain_and_clock_and_io_delay(FALSE); 

    if (do_process_constraints) 
        process_constraints();
    
    if (f_timing_stats == NULL)
        alloc_timing_stats();

    return slacks;
}

Here is the call graph for this function:

Here is the caller graph for this function:

t_linked_int* allocate_and_load_critical_path

(

void

)

Definition at line 2522 of file path_delay.c.

                                                     {

    /* Finds the critical path and returns a list of the tnodes on the critical *
     * path in a linked list, from the path SOURCE to the path SINK.            */

    t_linked_int *critical_path_head, *curr_crit_node, *prev_crit_node;
    int inode, iedge, to_node, num_at_level_zero, i, j, crit_node = OPEN, num_edges;
    int source_clock_domain = UNDEFINED, sink_clock_domain = UNDEFINED;
    float min_slack = HUGE_POSITIVE_FLOAT, slack;
    t_tedge *tedge;

    /* If there's only one clock, we can use the arrival and required times 
    currently on the timing graph to find the critical path. If there are multiple 
    clocks, however, the values currently on the timing graph correspond to the 
    last constraint (pair of clock domains) analysed, which may not be the constraint 
    with the critical path. In this case, we have to find the constraint with the 
    least slack and redo the timing analysis for this constraint so we get the right
    values onto the timing graph. */

    if (g_sdc->num_constrained_clocks > 1) {
        /* The critical path belongs to the source and sink clock domains 
        with the least slack. Find these clock domains now. */

        for (i = 0; i < g_sdc->num_constrained_clocks; i++) {
            for (j = 0; j < g_sdc->num_constrained_clocks; j++) {
                if (min_slack > f_timing_stats->least_slack[i][j]) {
                    min_slack = f_timing_stats->least_slack[i][j];
                    source_clock_domain = i;
                    sink_clock_domain = j;
                }
            }
        }

        /* Do a timing analysis for this clock domain pair only. 
        Set is_prepacked to FALSE since we don't care about the clusterer's normalized values. 
        Set is_final_analysis to FALSE to get actual, rather than relaxed, slacks.
        Set max critical input/output paths to NULL since they aren't used unless is_prepacked is TRUE. */
        do_timing_analysis_for_constraint(source_clock_domain, sink_clock_domain, FALSE, FALSE, (long*)NULL, (long*)NULL);
    }

    /* Start at the source (level-0) tnode with the least slack (T_req-T_arr). 
    This will form the head of our linked list of tnodes on the critical path. */
    min_slack = HUGE_POSITIVE_FLOAT;
    num_at_level_zero = tnodes_at_level[0].nelem;
    for (i = 0; i < num_at_level_zero; i++) { 
        inode = tnodes_at_level[0].list[i];
        if (has_valid_T_arr(inode) && has_valid_T_req(inode)) { /* Valid arrival and required times */
            slack = tnode[inode].T_req - tnode[inode].T_arr;
            if (slack < min_slack) {
                crit_node = inode;
                min_slack = slack;
            }
        }
    }
    critical_path_head = (t_linked_int *) my_malloc(sizeof(t_linked_int));
    critical_path_head->data = crit_node;
    assert(crit_node != OPEN);
    prev_crit_node = critical_path_head;
    num_edges = tnode[crit_node].num_edges;

    /* Keep adding the tnode in this tnode's fanout which has the least slack
    to our critical path linked list, then jump to that tnode and repeat, until
    we hit a tnode with no edges, which is the sink of the critical path. */
    while (num_edges != 0) { 
        curr_crit_node = (t_linked_int *) my_malloc(sizeof(t_linked_int));
        prev_crit_node->next = curr_crit_node;
        tedge = tnode[crit_node].out_edges;
        min_slack = HUGE_POSITIVE_FLOAT;

        for (iedge = 0; iedge < num_edges; iedge++) {
            to_node = tedge[iedge].to_node;
            if (has_valid_T_arr(to_node) && has_valid_T_req(to_node)) { /* Valid arrival and required times */
                slack = tnode[to_node].T_req - tnode[to_node].T_arr;
                if (slack < min_slack) {
                    crit_node = to_node;
                    min_slack = slack;
                }
            }
        }

        curr_crit_node->data = crit_node;
        prev_crit_node = curr_crit_node;
        num_edges = tnode[crit_node].num_edges;
    }

    prev_crit_node->next = NULL;
    return (critical_path_head);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void do_constant_net_delay_timing_analysis	(	t_timing_inf	timing_inf,
		float	constant_net_delay_value
	)

Definition at line 2636 of file path_delay.c.

                                        {

    /* Does a timing analysis (simple) where it assumes that each net has a      *
     * constant delay value.  Used only when operation == TIMING_ANALYSIS_ONLY.  */

    /*struct s_linked_vptr *net_delay_chunk_list_head;*/

    t_chunk net_delay_ch = {NULL, 0, NULL};
    t_slack * slacks = NULL;
    float **net_delay = NULL;
    
    slacks = alloc_and_load_timing_graph(timing_inf);
    net_delay = alloc_net_delay(&net_delay_ch, timing_nets,
            num_timing_nets);

    load_constant_net_delay(net_delay, constant_net_delay_value, timing_nets,
            num_timing_nets);
    load_timing_graph_net_delays(net_delay);
    
    do_timing_analysis(slacks, FALSE, FALSE, TRUE);

    if (getEchoEnabled()) {
        if(isEchoFileEnabled(E_ECHO_CRITICAL_PATH))
            print_critical_path("critical_path.echo");
        if(isEchoFileEnabled(E_ECHO_TIMING_GRAPH))
            print_timing_graph(getEchoFileName(E_ECHO_TIMING_GRAPH));
        if(isEchoFileEnabled(E_ECHO_SLACK))
            print_slack(slacks->slack, TRUE, getEchoFileName(E_ECHO_SLACK));
        if(isEchoFileEnabled(E_ECHO_CRITICALITY))
            print_criticality(slacks, TRUE, getEchoFileName(E_ECHO_CRITICALITY));
        if(isEchoFileEnabled(E_ECHO_NET_DELAY))
            print_net_delay(net_delay, getEchoFileName(E_ECHO_NET_DELAY));
    }

    print_timing_stats();

    free_timing_graph(slacks);
    free_net_delay(net_delay, &net_delay_ch);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void do_timing_analysis	(	t_slack *	slacks,
		boolean	is_prepacked,
		boolean	do_lut_input_balancing,
		boolean	is_final_analysis
	)

Definition at line 1613 of file path_delay.c.

                                                                                                                           {

/*  Performs timing analysis on the circuit.  Before this routine is called, t_slack * slacks 
    must have been allocated, and the circuit must have been converted into a timing graph.
    The nodes of the timing graph represent pins and the edges between them represent delays 
    and m dependencies from one pin to another.  Most elements are modeled as a pair of nodes so
    that the delay through the element can be marked on the edge between them (e.g.
    TN_INPAD_SOURCE->TN_INPAD_OPIN, TN_OUTPAD_IPIN->TN_OUTPAD_SINK, TN_PRIMITIVE_OPIN->
    TN_PRIMITIVE_OPIN, etc.).
    
    The timing graph nodes are stored as an array, tnode [0..num_tnodes - 1]. Each tnode 
    includes an array of all edges, tedge, which fan out from it. Each tedge includes the
    index of the node on its far end (in the tnode array), and the delay to that node.

    The timing graph has sources at each TN_FF_SOURCE (Q output), TN_INPAD_SOURCE (input I/O pad)
    and TN_CONSTANT_GEN_SOURCE (constant 1 or 0 generator) node and sinks at TN_FF_SINK (D input) 
    and TN_OUTPAD_SINK (output I/O pad) nodes. Two traversals, one forward (sources to sinks)
    and one backward, are performed for each valid constraint (one which is not DO_NOT_ANALYSE) 
    between a source and a sink clock domain in the matrix g_sdc->domain_constraint 
    [0..g_sdc->num_constrained_clocks - 1][0..g_sdc->num_constrained_clocks - 1]. This matrix has been 
    pruned so that all domain pairs with no paths between them have been set to DO_NOT_ANALYSE.
    
    During the traversal pair for each constraint, all nodes in the fanout of sources on the
    source clock domain are assigned a T_arr, the arrival time of the last input signal to the node.
    All nodes in the fanin of sinks on the sink clock domain are assigned a T_req, the required 
    arrival time of the last input signal to the node if the critical path for this constraint is 
    not to be lengthened.  Nodes which receive both a valid T_arr and T_req are flagged with 
    used_on_this_traversal, and nodes which are used on at least one traversal pair are flagged 
    with has_valid_slack so that later functions know the slack is valid.

    After each traversal pair, a slack is calculated for each sink pin on each net (or equivalently, 
    each connection or tedge fanning out from that net's driver tnode). Slack is calculated as:
        T_req (dest node) - T_arr (source node) - Tdel (edge)
    and represents the amount of delay which could be added to this connection before the critical 
    path delay for this constraint would worsen.  Edges on the critical path have a slack of 0.  
    Slacks which are never used are set to HUGE_POSITIVE_FLOAT.
    
    The optimizers actually use a metric called timing_criticality.  Timing criticality is defined 
    as 1 - slack / criticality_denom, where the normalization factor criticality_denom is the max
    of all arrival times in the constraint and the constraint itself (T_req-relaxed slacks) or
    all arrival times and constraints in the design (shifted slacks).  See below for a further 
    discussion of these two regimes.  Timing criticality is always between 0 (not critical) and 1
    (very critical).  Unlike slack, which is set to HUGE_POSITIVE_FLOAT for unanalysed connections,
    timing criticality is 0 for these, meaning no special check has to be made for which connections
    have been analysed.

    If path counting is on (PATH_COUNTING is defined in vpr_types.h), the optimizers use a weighted
    sum of timing_criticality and path_criticality, the latter of which is an estimate of the 
    importance of the number of paths using a particular connection.  As a path's timing_criticality
    decreases, it will become exponentially less important to the path_criticality of any connection
    which this path uses.  Path criticality also goes from 0 (not critical or unanalysed) to 1.

    Slack and criticalities are only calculated if both the driver of the net and the sink pin were
    used_on_this_traversal, and are only overwritten if lower than previously-obtained values. 
    The optimizers actually use criticality rather than slack, but slack is useful for human 
    designers and so we calculate it only if we need to print it.
    
    This routine outputs slack and criticality to t_slack * slacks. It also stores least slack and
    critical path delay per constraint [0..g_sdc->num_constrained_clocks - 1][0..g_sdc->num_constrained_clocks - 1] 
    in the file-scope variable f_timing_stats. 

    Is_prepacked flags whether to calculate normalized costs for the clusterer (normalized_slack, 
    normalized_Tarr, normalized_total_critical_paths). Setting this to FALSE saves time in post-
    packed timing analyses.

    Do_lut_input_balancing flags whether to rebalance LUT inputs.  LUT rebalancing takes advantage of 
    the fact that different LUT inputs often have different delays. Since we can freely permute which 
    LUT inputs are used by just changing the logic in the LUT, these LUT permutations can be performed 
    late into the routing stage of the flow. 
    
    Is_final_analysis flags whether this is the final, analysis pass.  If it is, the analyser will 
    compute actual slacks instead of relaxed ones. We "relax" slacks by setting the required time to 
    the maximum arrival time for tight constraints so that no slacks are negative (which confuses 
    the optimizers). This is called "T_req-relaxed" slack.  However, human designers want to see 
    actual slack values, so we report those in the final analysis.  The alternative way of making 
    slacks positive is shifting them upwards by the value of the largest negative slack, after 
    all traversals are complete ("shifted slacks"), which can be enabled by changing SLACK_DEFINITION 
    from 'R' to 'S' in path_delay.h.

    To do: flip-flop to flip-flop and flip-flop to clock domain constraints (set_false_path, set_max_delay,
    and especially set_multicycle_path). All the info for these constraints is contained in g_sdc->fc_constraints and 
    g_sdc->ff_constraints, but graph traversals are not included yet. Probably, an entire traversal will be needed for
    each constraint. Clock domain to flip-flop constraints are coded but not tested, and are done within 
    existing traversals. */

    int i, j, source_clock_domain, sink_clock_domain, inode, inet, ipin;

#if defined PATH_COUNTING || SLACK_DEFINITION == 'S'
    int iedge, num_edges;
#endif

#ifdef PATH_COUNTING
    float max_path_criticality = HUGE_NEGATIVE_FLOAT /* used to normalize path_criticalities */;
#endif

    boolean update_slack = (boolean) (is_final_analysis || getEchoEnabled());
                                 /* Only update slack values if we need to print it, i.e.
                                 for the final output file (is_final_analysis) or echo files. */

    float criticality_denom; /* (SLACK_DEFINITION == 'R' only) For a particular constraint, the maximum of 
                             the constraint and all arrival times for the constraint's traversal. Used to 
                             normalize the clusterer's normalized_slack and, more importantly, criticality. */

    long max_critical_output_paths, max_critical_input_paths;
    t_pb *pb;

#if SLACK_DEFINITION == 'S'
    float smallest_slack_in_design = HUGE_POSITIVE_FLOAT;
    /* Shift all slacks upwards by this number if it is negative. */

    float criticality_denom_global = HUGE_NEGATIVE_FLOAT;
    /* Denominator of criticality for shifted - max of all arrival times and all constraints. */
#endif

    /* Reset LUT input rebalancing. */
    for (inode = 0; inode < num_tnodes; inode++) {
        if (tnode[inode].type == TN_PRIMITIVE_OPIN && tnode[inode].pb_graph_pin != NULL) {
            pb = block[tnode[inode].block].pb->rr_node_to_pb_mapping[tnode[inode].pb_graph_pin->pin_count_in_cluster];
            if (pb != NULL && pb->lut_pin_remap != NULL) {
                /* this is a LUT primitive, do pin swapping */
                assert(pb->pb_graph_node->pb_type->num_output_pins == 1 && pb->pb_graph_node->pb_type->num_clock_pins == 0); /* ensure LUT properties are valid */
                assert(pb->pb_graph_node->num_input_ports == 1);
                /* If all input pins are known, perform LUT input delay rebalancing, do nothing otherwise */
                for (i = 0; i < pb->pb_graph_node->num_input_pins[0]; i++) {
                    pb->lut_pin_remap[i] = OPEN;
                }
            }
        }
    }

    /* Reset all values which need to be reset once per 
    timing analysis, rather than once per traversal pair. */

    /* Reset slack and criticality */
    for (inet = 0; inet < num_timing_nets; inet++) {
        for (ipin = 1; ipin <= timing_nets[inet].num_sinks; ipin++) {
            slacks->slack[inet][ipin]              = HUGE_POSITIVE_FLOAT; 
            slacks->timing_criticality[inet][ipin] = 0.; 
#ifdef PATH_COUNTING
            slacks->path_criticality[inet][ipin] = 0.;
#endif
        }
    }

    /* Reset f_timing_stats. */
    for (i = 0; i < g_sdc->num_constrained_clocks; i++) {   
        for (j = 0; j < g_sdc->num_constrained_clocks; j++) {
            f_timing_stats->cpd[i][j]         = HUGE_NEGATIVE_FLOAT;
            f_timing_stats->least_slack[i][j] = HUGE_POSITIVE_FLOAT;
        }
    }

#ifndef PATH_COUNTING
    /* Reset normalized values for clusterer. */
    if (is_prepacked) { 
        for (inode = 0; inode < num_tnodes; inode++) {          
            tnode[inode].prepacked_data->normalized_slack = HUGE_POSITIVE_FLOAT;
            tnode[inode].prepacked_data->normalized_T_arr = HUGE_NEGATIVE_FLOAT;
            tnode[inode].prepacked_data->normalized_total_critical_paths = HUGE_NEGATIVE_FLOAT;
        }
    }
#endif

    if (do_lut_input_balancing) {
        do_lut_rebalancing();
    }

    /* For each valid constraint (pair of source and sink clock domains), we do one 
    forward and one backward topological traversal to find arrival and required times,
    in do_timing_analysis_for_constraint. If path counting is on, we then do another, 
    simpler traversal to find forward and backward weights, relying on the largest 
    required time we found from the first traversal.  After each constraint's traversals,
    we update the slacks, timing criticalities and (if necessary) path criticalities or
    normalized costs used by the clusterer. */

    for (source_clock_domain = 0; source_clock_domain < g_sdc->num_constrained_clocks; source_clock_domain++) {
        for (sink_clock_domain = 0; sink_clock_domain < g_sdc->num_constrained_clocks; sink_clock_domain++) {
            if (g_sdc->domain_constraint[source_clock_domain][sink_clock_domain] > NEGATIVE_EPSILON) { /* i.e. != DO_NOT_ANALYSE */

                /* Perform the forward and backward traversal for this constraint. */
                criticality_denom = do_timing_analysis_for_constraint(source_clock_domain, sink_clock_domain, 
                    is_prepacked, is_final_analysis, &max_critical_input_paths, &max_critical_output_paths);
#ifdef PATH_COUNTING
                /* Weight the importance of each net, used in slack calculation. */
                do_path_counting(criticality_denom);
#endif

                /* Update the slack and criticality for each edge of each net which was  
                analysed on the most recent traversal and has a lower (slack) or 
                higher (criticality) value than before. */
                update_slacks(slacks, source_clock_domain, sink_clock_domain, criticality_denom, update_slack);

#ifndef PATH_COUNTING
                /* Update the normalized costs used by the clusterer. */
                if (is_prepacked) {
                    update_normalized_costs(criticality_denom, max_critical_input_paths, max_critical_output_paths);
                }
#endif

#if SLACK_DEFINITION == 'S'
                /* Set criticality_denom_global to the max of criticality_denom over all traversals. */
                criticality_denom_global = std::max(criticality_denom_global, criticality_denom);
#endif
            }
        }
    } 

#ifdef PATH_COUNTING
    /* Normalize path criticalities by the largest value in the 
    circuit. Otherwise, path criticalities would be unbounded. */

    for (inet = 0; inet < num_timing_nets; inet++) {
        num_edges = timing_nets[inet].num_sinks;
        for (iedge = 0; iedge < num_edges; iedge++) {
            max_path_criticality = std::max(max_path_criticality, slacks->path_criticality[inet][iedge + 1]);
        }
    }

    for (inet = 0; inet < num_timing_nets; inet++) {
        num_edges = timing_nets[inet].num_sinks;
        for (iedge = 0; iedge < num_edges; iedge++) {
            slacks->path_criticality[inet][iedge + 1] /= max_path_criticality;
        }
    }

#endif

#if SLACK_DEFINITION == 'S'
    if (!is_final_analysis) {

        /* Find the smallest slack in the design. */
        for (i = 0; i < g_sdc->num_constrained_clocks; i++) {
            for (j = 0; j < g_sdc->num_constrained_clocks; j++) {
                smallest_slack_in_design = std::min(smallest_slack_in_design, f_timing_stats->least_slack[i][j]);
            }
        }

        /* Increase all slacks by the value of the smallest slack in the design, if it's negative. */
        if (smallest_slack_in_design < 0) {
            for (inet = 0; inet < num_timing_nets; inet++) {
                num_edges = timing_nets[inet].num_sinks;
                for (iedge = 0; iedge < num_edges; iedge++) {
                    slacks->slack[inet][iedge + 1] -= smallest_slack_in_design; 
                    /* Remember, smallest_slack_in_design is negative, so we're INCREASING all the slacks. */
                    /* Note that if slack was equal to HUGE_POSITIVE_FLOAT, it will still be equal to more than this, 
                    so it will still be ignored when we calculate criticalities. */
                }
            }
        }
    }

    /* We can now calculate criticalities, only after we normalize slacks. */
    for (inet = 0; inet < num_timing_nets; inet++) {
        num_edges = timing_nets[inet].num_sinks;
        for (iedge = 0; iedge < num_edges; iedge++) {
            if (slacks->slack[inet][iedge + 1] < HUGE_POSITIVE_FLOAT - 1) { /* if the slack is valid */
                slacks->timing_criticality[inet][iedge + 1] = 1 - slacks->slack[inet][iedge + 1]/criticality_denom_global; 
            }
            /* otherwise, criticality remains 0, as it was initialized */
        }
    }       
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void free_timing_graph

(

t_slack *

slack

)

Definition at line 390 of file path_delay.c.

                                         {

    int inode;

    if (tedge_ch.chunk_ptr_head == NULL) {
        vpr_printf(TIO_MESSAGE_ERROR, "in free_timing_graph: No timing graph to free.\n");
        exit(1);
    }

    free_chunk_memory(&tedge_ch);

    if (tnode[0].prepacked_data) {
        /* If we allocated prepacked_data for the first node, 
        it must be allocated for all other nodes too. */
        for (inode = 0; inode < num_tnodes; inode++) {
            free(tnode[inode].prepacked_data);
        }
    }
    free(tnode);
    free(f_net_to_driver_tnode);
    free_ivec_vector(tnodes_at_level, 0, num_tnode_levels - 1);

    free(slacks->slack);
    free(slacks->timing_criticality);
#ifdef PATH_COUNTING
    free(slacks->path_criticality);
#endif
    free(slacks);
    
    tnode = NULL;
    num_tnodes = 0;
    f_net_to_driver_tnode = NULL;
    tnodes_at_level = NULL;
    num_tnode_levels = 0;
    slacks = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void free_timing_stats

(

void

)

Definition at line 427 of file path_delay.c.

                             {
    int i;
    if(f_timing_stats != NULL) {
        for (i = 0; i < g_sdc->num_constrained_clocks; i++) {
            free(f_timing_stats->cpd[i]);
            free(f_timing_stats->least_slack[i]);
        }
        free(f_timing_stats->cpd);
        free(f_timing_stats->least_slack);
        free(f_timing_stats);
    }
    f_timing_stats = NULL;
}

Here is the caller graph for this function:

float get_critical_path_delay

(

void

)

Definition at line 3060 of file path_delay.c.

                                    {
    /* Finds the critical path delay, which is the minimum clock period required to meet the constraint
    corresponding to the pair of source and sink clock domains with the least slack in the design. */
    
    int source_clock_domain, sink_clock_domain;
    float least_slack_in_design = HUGE_POSITIVE_FLOAT, critical_path_delay = UNDEFINED;

    if (!g_sdc) return UNDEFINED; /* If timing analysis is off, for instance. */

    for (source_clock_domain = 0; source_clock_domain < g_sdc->num_constrained_clocks; source_clock_domain++) {
        for (sink_clock_domain = 0; sink_clock_domain < g_sdc->num_constrained_clocks; sink_clock_domain++) {
            if (least_slack_in_design > f_timing_stats->least_slack[source_clock_domain][sink_clock_domain]) {
                least_slack_in_design = f_timing_stats->least_slack[source_clock_domain][sink_clock_domain];
                critical_path_delay = f_timing_stats->cpd[source_clock_domain][sink_clock_domain];
            }
        }
    }

    return critical_path_delay * 1e9; /* Convert to nanoseconds */
}

Here is the caller graph for this function:

void get_tnode_block_and_output_net	(	int	inode,
		int *	iblk_ptr,
		int *	inet_ptr
	)

Definition at line 2611 of file path_delay.c.

                                                                             {

    /* Returns the index of the block that this tnode is part of.  If the tnode *
     * is a TN_CB_OPIN or TN_INPAD_OPIN (i.e. if it drives a net), the net index is  *
     * returned via inet_ptr.  Otherwise inet_ptr points at OPEN.               */

    int inet, ipin, iblk;
    e_tnode_type tnode_type;

    iblk = tnode[inode].block;
    tnode_type = tnode[inode].type;

    if (tnode_type == TN_CB_OPIN) {
        ipin = tnode[inode].pb_graph_pin->pin_count_in_cluster;
        inet = block[iblk].pb->rr_graph[ipin].net_num;
        assert(inet != OPEN);
        inet = vpack_to_clb_net_mapping[inet];
    } else {
        inet = OPEN;
    }

    *iblk_ptr = iblk;
    *inet_ptr = inet;
}

Here is the caller graph for this function:

boolean has_valid_normalized_T_arr

(

int

inode

)

Definition at line 3054 of file path_delay.c.

                                              {
    /* Has this tnode's normalized_T_arr been changed from its original value of HUGE_NEGATIVE_FLOAT? */
    return (boolean) (tnode[inode].prepacked_data->normalized_T_arr > HUGE_NEGATIVE_FLOAT + 1);
}

Here is the caller graph for this function:

void load_timing_graph_net_delays

(

float **

net_delay

)

Definition at line 368 of file path_delay.c.

                                                     {

    /* Sets the delays of the inter-CLB nets to the values specified by          *
     * net_delay[0..num_nets-1][1..num_pins-1].  These net delays should have    *
     * been allocated and loaded with the net_delay routines.  This routine      *
     * marks the corresponding edges in the timing graph with the proper delay.  */

    int inet, ipin, inode;
    t_tedge *tedge;

    for (inet = 0; inet < num_timing_nets; inet++) {
        inode = f_net_to_driver_tnode[inet];
        tedge = tnode[inode].out_edges;

        /* Note that the edges of a tnode corresponding to a CLB or INPAD opin must  *
         * be in the same order as the pins of the net driven by the tnode.          */

        for (ipin = 1; ipin < (timing_nets[inet].num_sinks + 1); ipin++)
            tedge[ipin - 1].Tdel = net_delay[inet][ipin];
    }
}

Here is the caller graph for this function:

void print_clustering_timing_info

(

const char *

fname

)

Definition at line 696 of file path_delay.c.

                                                     {
    /* Print information from tnodes which is used by the clusterer. */
    int inode;
    FILE *fp;

    fp = my_fopen(fname, "w", 0);

    fprintf(fp, "inode  ");
    if (g_sdc->num_constrained_clocks <= 1) {
        /* These values are from the last constraint analysed, 
        so they're not meaningful unless there was only one constraint. */
        fprintf(fp, "Critical input paths  Critical output paths  ");
    }
    fprintf(fp, "Normalized slack  Normalized Tarr  Normalized total crit paths\n");
    for (inode = 0; inode < num_tnodes; inode++) {
        fprintf(fp, "%d\t", inode);
        /* Only print normalized values for tnodes which have valid normalized values. (If normalized_T_arr is valid, the others will be too.) */
        if (has_valid_normalized_T_arr(inode)) {
            if (g_sdc->num_constrained_clocks <= 1) {
                fprintf(fp, "%ld\t\t\t%ld\t\t\t", tnode[inode].prepacked_data->num_critical_input_paths, tnode[inode].prepacked_data->num_critical_output_paths); 
            }
            fprintf(fp, "%f\t%f\t%f\n", tnode[inode].prepacked_data->normalized_slack, tnode[inode].prepacked_data->normalized_T_arr, tnode[inode].prepacked_data->normalized_total_critical_paths);
        } else {
            if (g_sdc->num_constrained_clocks <= 1) {
                fprintf(fp, "--\t\t\t--\t\t\t"); 
            }
            fprintf(fp, "--\t\t--\t\t--\n");
        }
    }

    fclose(fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_critical_path

(

const char *

fname

)

Definition at line 2458 of file path_delay.c.

                                            {

    /* Prints the critical path to a file. */

    t_linked_int *critical_path_head, *critical_path_node;
    FILE *fp;
    int non_global_nets_on_crit_path, global_nets_on_crit_path;
    int tnodes_on_crit_path, inode, iblk, inet;
    e_tnode_type type;
    float total_net_delay, total_logic_delay, Tdel;

    critical_path_head = allocate_and_load_critical_path();
    critical_path_node = critical_path_head;

    fp = my_fopen(fname, "w", 0);

    non_global_nets_on_crit_path = 0;
    global_nets_on_crit_path = 0;
    tnodes_on_crit_path = 0;
    total_net_delay = 0.;
    total_logic_delay = 0.;

    while (critical_path_node != NULL) {
        Tdel = print_critical_path_node(fp, critical_path_node);
        inode = critical_path_node->data;
        type = tnode[inode].type;
        tnodes_on_crit_path++;

        if (type == TN_CB_OPIN) {
            get_tnode_block_and_output_net(inode, &iblk, &inet);

            if (!timing_nets[inet].is_global)
                non_global_nets_on_crit_path++;
            else
                global_nets_on_crit_path++;

            total_net_delay += Tdel;
        } else {
            total_logic_delay += Tdel;
        }

        critical_path_node = critical_path_node->next;
    }

    fprintf(fp, "\nTnodes on critical path: %d  Non-global nets on critical path: %d."
            "\n", tnodes_on_crit_path, non_global_nets_on_crit_path);
    fprintf(fp, "Global nets on critical path: %d.\n", global_nets_on_crit_path);
    fprintf(fp, "Total logic delay: %g (s)  Total net delay: %g (s)\n",
            total_logic_delay, total_net_delay);

    vpr_printf(TIO_MESSAGE_INFO, "Nets on critical path: %d normal, %d global.\n",
            non_global_nets_on_crit_path, global_nets_on_crit_path);

    vpr_printf(TIO_MESSAGE_INFO, "Total logic delay: %g (s), total net delay: %g (s)\n",
            total_logic_delay, total_net_delay);

    /* Make sure total_logic_delay and total_net_delay add 
    up to critical path delay,within 5 decimal places. */
    assert(total_logic_delay + total_net_delay - get_critical_path_delay()/1e9 < 1e-5);

    fclose(fp);
    free_int_list(&critical_path_head);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_criticality	(	t_slack *	slacks,
		boolean	criticality_is_normalized,
		const char *	fname
	)

Definition at line 559 of file path_delay.c.

                                                                                               {

    /* Prints timing criticalities (and path criticalities if enabled) into a file. */

    int inet, iedge, driver_tnode, num_edges;
    t_tedge * tedge;
    FILE *fp;

    fp = my_fopen(fname, "w", 0);

    if (criticality_is_normalized) {
        fprintf(fp, "Timing criticalities have been normalized to be non-negative by "
                    "relaxing the required times to the maximum arrival time.\n\n");
    }

    print_global_criticality_stats(fp, slacks->timing_criticality, "timing criticality", "Timing criticalities");
#ifdef PATH_COUNTING
    print_global_criticality_stats(fp, slacks->path_criticality, "path criticality", "Path criticalities");
#endif

    /* Finally, print all the criticalities, organized by net. */
    fprintf(fp, "\n\nNet #\tDriver_tnode\t to_node\tTiming criticality"
#ifdef PATH_COUNTING
        "\tPath criticality"
#endif
        "\n");

    for (inet = 0; inet < num_timing_nets; inet++) {
        driver_tnode = f_net_to_driver_tnode[inet];
        num_edges = tnode[driver_tnode].num_edges;
        tedge = tnode[driver_tnode].out_edges;

        fprintf(fp, "\n%5d\t%5d\t\t%5d\t\t%.6f", inet, driver_tnode, tedge[0].to_node, slacks->timing_criticality[inet][1]);
#ifdef PATH_COUNTING
        fprintf(fp, "\t\t%g", slacks->path_criticality[inet][1]);
#endif
        for (iedge = 1; iedge < num_edges; iedge++) { /* newline and indent subsequent edges after the first */
            fprintf(fp, "\n\t\t\t%5d\t\t%.6f", tedge[iedge].to_node, slacks->timing_criticality[inet][iedge+1]);
#ifdef PATH_COUNTING
            fprintf(fp, "\t\t%g", slacks->path_criticality[inet][iedge+1]);
#endif
        }
    }

    fclose(fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_lut_remapping

(

const char *

fname

)

Definition at line 2430 of file path_delay.c.

                                            {
    FILE *fp;
    int inode, i;
    t_pb *pb;
    

    fp = my_fopen(fname, "w", 0);
    fprintf(fp, "# LUT_Name\tinput_pin_mapping\n");

    for (inode = 0; inode < num_tnodes; inode++) {      
        /* Print LUT input rebalancing */
        if (tnode[inode].type == TN_PRIMITIVE_OPIN && tnode[inode].pb_graph_pin != NULL) {
            pb = block[tnode[inode].block].pb->rr_node_to_pb_mapping[tnode[inode].pb_graph_pin->pin_count_in_cluster];
            if (pb != NULL && pb->lut_pin_remap != NULL) {
                assert(pb->pb_graph_node->pb_type->num_output_pins == 1 && pb->pb_graph_node->pb_type->num_clock_pins == 0); /* ensure LUT properties are valid */
                assert(pb->pb_graph_node->num_input_ports == 1);
                fprintf(fp, "%s", pb->name);
                for (i = 0; i < pb->pb_graph_node->num_input_pins[0]; i++) {
                    fprintf(fp, "\t%d", pb->lut_pin_remap[i]);
                }
                fprintf(fp, "\n");
            }
        }
    }

    fclose(fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_net_delay	(	float **	net_delay,
		const char *	fname
	)

Definition at line 670 of file path_delay.c.

                                                           {

    /* Prints the net delays into a file. */

    int inet, iedge, driver_tnode, num_edges;
    t_tedge * tedge;
    FILE *fp;

    fp = my_fopen(fname, "w", 0);

    fprintf(fp, "Net #\tDriver_tnode\tto_node\tDelay\n\n");

    for (inet = 0; inet < num_timing_nets; inet++) {
        driver_tnode = f_net_to_driver_tnode[inet];
        num_edges = tnode[driver_tnode].num_edges;
        tedge = tnode[driver_tnode].out_edges;
        fprintf(fp, "%5d\t%5d\t\t%5d\t%g\n", inet, driver_tnode, tedge[0].to_node, net_delay[inet][1]);
        for (iedge = 1; iedge < num_edges; iedge++) { /* newline and indent subsequent edges after the first */
            fprintf(fp, "\t\t\t%5d\t%g\n", tedge[iedge].to_node, net_delay[inet][iedge+1]);
        }
    }

    fclose(fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_slack	(	float **	slack,
		boolean	slack_is_normalized,
		const char *	fname
	)

Definition at line 441 of file path_delay.c.

                                                                                 {

    /* Prints slacks into a file. */

    int inet, iedge, ibucket, driver_tnode, num_edges, num_unused_slacks = 0;
    t_tedge * tedge;
    FILE *fp;
    float max_slack = HUGE_NEGATIVE_FLOAT, min_slack = HUGE_POSITIVE_FLOAT, 
        total_slack = 0, total_negative_slack = 0, bucket_size, slk;
    int slacks_in_bucket[NUM_BUCKETS]; 

    fp = my_fopen(fname, "w", 0);

    if (slack_is_normalized) {
        fprintf(fp, "The following slacks have been normalized to be non-negative by "
                    "relaxing the required times to the maximum arrival time.\n\n");
    }

    /* Go through slack once to get the largest and smallest slack, both for reporting and 
       so that we can delimit the buckets. Also calculate the total negative slack in the design. */
    for (inet = 0; inet < num_timing_nets; inet++) {
        num_edges = timing_nets[inet].num_sinks;
        for (iedge = 0; iedge < num_edges; iedge++) { 
            slk = slack[inet][iedge + 1];
            if (slk < HUGE_POSITIVE_FLOAT - 1) { /* if slack was analysed */
                max_slack = std::max(max_slack, slk);
                min_slack = std::min(min_slack, slk);
                total_slack += slk;
                if (slk < NEGATIVE_EPSILON) { 
                    total_negative_slack -= slk; /* By convention, we'll have total_negative_slack be a positive number. */
                }
            } else { /* slack was never analysed */
                num_unused_slacks++;
            }
        }
    }

    if (max_slack > HUGE_NEGATIVE_FLOAT + 1) {
        fprintf(fp, "Largest slack in design: %g\n", max_slack);
    } else {
        fprintf(fp, "Largest slack in design: --\n");
    }
    
    if (min_slack < HUGE_POSITIVE_FLOAT - 1) {
        fprintf(fp, "Smallest slack in design: %g\n", min_slack);
    } else {
        fprintf(fp, "Smallest slack in design: --\n");
    }

    fprintf(fp, "Total slack in design: %g\n", total_slack);
    fprintf(fp, "Total negative slack: %g\n", total_negative_slack);

    if (max_slack - min_slack > EPSILON) { /* Only sort the slacks into buckets if not all slacks are the same (if they are identical, no need to sort). */
        /* Initialize slacks_in_bucket, an array counting how many slacks are within certain linearly-spaced ranges (buckets). */
        for (ibucket = 0; ibucket < NUM_BUCKETS; ibucket++) {
            slacks_in_bucket[ibucket] = 0;
        }

        /* The size of each bucket is the range of slacks, divided by the number of buckets. */
        bucket_size = (max_slack - min_slack)/NUM_BUCKETS;

        /* Now, pass through again, incrementing the number of slacks in the nth bucket 
            for each slack between (min_slack + n*bucket_size) and (min_slack + (n+1)*bucket_size). */

        for (inet = 0; inet < num_timing_nets; inet++) {
            num_edges = timing_nets[inet].num_sinks;
            for (iedge = 0; iedge < num_edges; iedge++) { 
                slk = slack[inet][iedge + 1];
                if (slk < HUGE_POSITIVE_FLOAT - 1) {
                    /* We have to watch out for the special case where slack = max_slack, in which case ibucket = NUM_BUCKETS and we go out of bounds of the array. */
                    ibucket = std::min(NUM_BUCKETS - 1, (int) ((slk - min_slack)/bucket_size));
                    assert(ibucket >= 0 && ibucket < NUM_BUCKETS);
                    slacks_in_bucket[ibucket]++;
                }
            }
        }

        /* Now print how many slacks are in each bucket. */
        fprintf(fp, "\n\nRange\t\t");
        for (ibucket = 0; ibucket < NUM_BUCKETS; ibucket++) {
            fprintf(fp, "%.1e to ", min_slack);
            min_slack += bucket_size;
            fprintf(fp, "%.1e\t", min_slack);
        }
        fprintf(fp, "Not analysed");
        fprintf(fp, "\nSlacks in range\t\t");
        for (ibucket = 0; ibucket < NUM_BUCKETS; ibucket++) {
            fprintf(fp, "%d\t\t\t", slacks_in_bucket[ibucket]);
        }
        fprintf(fp, "%d", num_unused_slacks);
    }

    /* Finally, print all the slacks, organized by net. */
    fprintf(fp, "\n\nNet #\tDriver_tnode\tto_node\tSlack\n\n");

    for (inet = 0; inet < num_timing_nets; inet++) {
        driver_tnode = f_net_to_driver_tnode[inet];
        num_edges = tnode[driver_tnode].num_edges;
        tedge = tnode[driver_tnode].out_edges;
        slk = slack[inet][1];
        if (slk < HUGE_POSITIVE_FLOAT - 1) {
            fprintf(fp, "%5d\t%5d\t\t%5d\t%g\n", inet, driver_tnode, tedge[0].to_node, slk);
        } else { /* Slack is meaningless, so replace with --. */
            fprintf(fp, "%5d\t%5d\t\t%5d\t--\n", inet, driver_tnode, tedge[0].to_node);
        }
        for (iedge = 1; iedge < num_edges; iedge++) { /* newline and indent subsequent edges after the first */
            slk = slack[inet][iedge+1];
            if (slk < HUGE_POSITIVE_FLOAT - 1) {
                fprintf(fp, "\t\t\t%5d\t%g\n", tedge[iedge].to_node, slk);
            } else { /* Slack is meaningless, so replace with --. */
                fprintf(fp, "\t\t\t%5d\t--\n", tedge[iedge].to_node);
            }
        }
    }

    fclose(fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_timing_graph

(

const char *

fname

)

Definition at line 1388 of file path_delay.c.

                                           {

    /* Prints the timing graph into a file. */

    FILE *fp;
    int inode, iedge, ilevel, i;
    t_tedge *tedge;
    e_tnode_type itype;
    const char *tnode_type_names[] = {  "TN_INPAD_SOURCE", "TN_INPAD_OPIN", "TN_OUTPAD_IPIN",

            "TN_OUTPAD_SINK", "TN_CB_IPIN", "TN_CB_OPIN", "TN_INTERMEDIATE_NODE",
            "TN_PRIMITIVE_IPIN", "TN_PRIMITIVE_OPIN", "TN_FF_IPIN", "TN_FF_OPIN", "TN_FF_SINK",
            "TN_FF_SOURCE", "TN_FF_CLOCK", "TN_CONSTANT_GEN_SOURCE" };

    fp = my_fopen(fname, "w", 0);

    fprintf(fp, "num_tnodes: %d\n", num_tnodes);
    fprintf(fp, "Node #\tType\t\tipin\tiblk\tDomain\tSkew\tI/O Delay\t# edges\t"
            "to_node     Tdel\n\n");

    for (inode = 0; inode < num_tnodes; inode++) {
        fprintf(fp, "%d\t", inode);

        itype = tnode[inode].type;
        fprintf(fp, "%-15.15s\t", tnode_type_names[itype]);

        if (tnode[inode].pb_graph_pin != NULL) {
            fprintf(fp, "%d\t%d\t",
                    tnode[inode].pb_graph_pin->pin_count_in_cluster,
                    tnode[inode].block);
        } else {
            fprintf(fp, "\t%d\t", tnode[inode].block);
        }

        if (itype == TN_FF_CLOCK || itype == TN_FF_SOURCE || itype == TN_FF_SINK) {
            fprintf(fp, "%d\t%.3e\t\t", tnode[inode].clock_domain, tnode[inode].clock_delay);
        } else if (itype == TN_INPAD_SOURCE) {
            fprintf(fp, "%d\t\t%.3e\t", tnode[inode].clock_domain, tnode[inode].out_edges[0].Tdel);
        } else if (itype == TN_OUTPAD_SINK) {
            assert(tnode[inode-1].type == TN_OUTPAD_IPIN); /* Outpad ipins should be one prior in the tnode array */
            fprintf(fp, "%d\t\t%.3e\t", tnode[inode].clock_domain, tnode[inode-1].out_edges[0].Tdel);
        } else {
            fprintf(fp, "\t\t\t\t");
        }

        fprintf(fp, "%d", tnode[inode].num_edges);

        /* Print all edges after edge 0 on separate lines */
        tedge = tnode[inode].out_edges;
        if (tnode[inode].num_edges > 0) {
            fprintf(fp, "\t%4d\t%7.3g", tedge[0].to_node, tedge[0].Tdel);
            for (iedge = 1; iedge < tnode[inode].num_edges; iedge++) {
                fprintf(fp, "\n\t\t\t\t\t\t\t\t\t\t%4d\t%7.3g", tedge[iedge].to_node, tedge[iedge].Tdel);
            }
        }
        fprintf(fp, "\n");
    }

    fprintf(fp, "\n\nnum_tnode_levels: %d\n", num_tnode_levels);

    for (ilevel = 0; ilevel < num_tnode_levels; ilevel++) {
        fprintf(fp, "\n\nLevel: %d  Num_nodes: %d\nNodes:", ilevel,
                tnodes_at_level[ilevel].nelem);
        for (i = 0; i < tnodes_at_level[ilevel].nelem; i++)
            fprintf(fp, "\t%d", tnodes_at_level[ilevel].list[i]);
    }

    fprintf(fp, "\n");
    fprintf(fp, "\n\nNet #\tNet_to_driver_tnode\n");

    for (i = 0; i < num_nets; i++)
        fprintf(fp, "%4d\t%6d\n", i, f_net_to_driver_tnode[i]);

    if (g_sdc->num_constrained_clocks == 1) {
        /* Arrival and required times, and forward and backward weights, will be meaningless for multiclock
        designs, since the values currently on the graph will only correspond to the most recent traversal. */
        fprintf(fp, "\n\nNode #\t\tT_arr\t\tT_req"
#ifdef PATH_COUNTING
            "\tForward weight\tBackward weight"
#endif
            "\n\n");

        for (inode = 0; inode < num_tnodes; inode++) {
            if (tnode[inode].T_arr > HUGE_NEGATIVE_FLOAT + 1) {
                fprintf(fp, "%d\t%12g", inode, tnode[inode].T_arr);
            } else {
                fprintf(fp, "%d\t\t   -", inode);
            }
            if (tnode[inode].T_req < HUGE_POSITIVE_FLOAT - 1) {
                fprintf(fp, "\t%12g", tnode[inode].T_req);
            } else {
                fprintf(fp, "\t\t   -");
            }
#ifdef PATH_COUNTING
            fprintf(fp, "\t%12g\t%12g\n", tnode[inode].forward_weight, tnode[inode].backward_weight);
#endif
        }
    }

    fclose(fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_timing_graph_as_blif	(	const char *	fname,
		t_model *	models
	)

Definition at line 3360 of file path_delay.c.

                                                                     {
    struct s_model_ports *port;
    struct s_linked_vptr *p_io_removed;
    /* Prints out the critical path to a file.  */

    FILE *fp;
    int i, j;

    fp = my_fopen(fname, "w", 0);

    fprintf(fp, ".model %s\n", blif_circuit_name);

    fprintf(fp, ".inputs ");
    for (i = 0; i < num_logical_blocks; i++) {
        if (logical_block[i].type == VPACK_INPAD) {
            fprintf(fp, "\\\n%s ", logical_block[i].name);
        }
    }
    p_io_removed = circuit_p_io_removed;
    while (p_io_removed) {
        fprintf(fp, "\\\n%s ", (char *) p_io_removed->data_vptr);
        p_io_removed = p_io_removed->next;
    }

    fprintf(fp, "\n");

    fprintf(fp, ".outputs ");
    for (i = 0; i < num_logical_blocks; i++) {
        if (logical_block[i].type == VPACK_OUTPAD) {
            /* Outputs have a "out:" prepended to them, must remove */
            fprintf(fp, "\\\n%s ", &logical_block[i].name[4]);
        }
    }
    fprintf(fp, "\n");
    fprintf(fp, ".names unconn\n");
    fprintf(fp, " 0\n\n");

    /* Print out primitives */
    for (i = 0; i < num_logical_blocks; i++) {
        print_primitive_as_blif (fp, i);
    }

    /* Print out tnode connections */
    for (i = 0; i < num_tnodes; i++) {
        if (tnode[i].type != TN_PRIMITIVE_IPIN && tnode[i].type != TN_FF_SOURCE
                && tnode[i].type != TN_INPAD_SOURCE
                && tnode[i].type != TN_OUTPAD_IPIN) {
            for (j = 0; j < tnode[i].num_edges; j++) {
                fprintf(fp, ".names tnode_%d tnode_%d\n", i,
                    tnode[i].out_edges[j].to_node);
                fprintf(fp, "1 1\n\n");
            }
        }
    }

    fprintf(fp, ".end\n\n");

    /* Print out .subckt models */
    while (models) {
        fprintf(fp, ".model %s\n", models->name);
        fprintf(fp, ".inputs ");
        port = models->inputs;
        while (port) {
            if (port->size > 1) {
                for (j = 0; j < port->size; j++) {
                    fprintf(fp, "%s[%d] ", port->name, j);
                }
            } else {
                fprintf(fp, "%s ", port->name);
            }
            port = port->next;
        }
        fprintf(fp, "\n");
        fprintf(fp, ".outputs ");
        port = models->outputs;
        while (port) {
            if (port->size > 1) {
                for (j = 0; j < port->size; j++) {
                    fprintf(fp, "%s[%d] ", port->name, j);
                }
            } else {
                fprintf(fp, "%s ", port->name);
            }
            port = port->next;
        }
        fprintf(fp, "\n.blackbox\n.end\n\n");
        fprintf(fp, "\n\n");
        models = models->next;
    }
    fclose(fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_timing_stats

(

void

)

Definition at line 3081 of file path_delay.c.

                              {

    /* Prints critical path delay/fmax, least slack in design, and, for multiple-clock designs, 
    minimum required clock period to meet each constraint, least slack per constraint,
    geometric average clock frequency, and fanout-weighted geometric average clock frequency. */

    int source_clock_domain, sink_clock_domain, clock_domain, fanout, total_fanout = 0, 
        num_netlist_clocks_with_intra_domain_paths = 0;
    float geomean_period = 1., least_slack_in_design = HUGE_POSITIVE_FLOAT, critical_path_delay = UNDEFINED;
    double fanout_weighted_geomean_period = 1.;
    boolean found;

    /* Find critical path delay. If the pb_max_internal_delay is greater than this, it becomes
     the limiting factor on critical path delay, so print that instead, with a special message. */
    
    for (source_clock_domain = 0; source_clock_domain < g_sdc->num_constrained_clocks; source_clock_domain++) {
        for (sink_clock_domain = 0; sink_clock_domain < g_sdc->num_constrained_clocks; sink_clock_domain++) {
            if (least_slack_in_design > f_timing_stats->least_slack[source_clock_domain][sink_clock_domain]) {
                least_slack_in_design = f_timing_stats->least_slack[source_clock_domain][sink_clock_domain];
                critical_path_delay = f_timing_stats->cpd[source_clock_domain][sink_clock_domain];
            }
        }
    }

    if (pb_max_internal_delay != UNDEFINED && pb_max_internal_delay > critical_path_delay) {
        critical_path_delay = pb_max_internal_delay;
        vpr_printf(TIO_MESSAGE_INFO, "Final critical path: %g ns\n", 1e9 * critical_path_delay);
        vpr_printf(TIO_MESSAGE_INFO, "\t(capped by fmax of block type %s)\n", pbtype_max_internal_delay->name);
        
    } else {
        vpr_printf(TIO_MESSAGE_INFO, "Final critical path: %g ns\n", 1e9 * critical_path_delay);
    }

    if (g_sdc->num_constrained_clocks <= 1) {
        /* Although critical path delay is always well-defined, it doesn't make sense to talk about fmax for multi-clock circuits */
        vpr_printf(TIO_MESSAGE_INFO, "f_max: %g MHz\n", 1e-6 / critical_path_delay);
    }
    
    /* Also print the least slack in the design */
    vpr_printf(TIO_MESSAGE_INFO, "\n");
    vpr_printf(TIO_MESSAGE_INFO, "Least slack in design: %g ns\n", 1e9 * least_slack_in_design);
    vpr_printf(TIO_MESSAGE_INFO, "\n");

    if (g_sdc->num_constrained_clocks > 1) { /* Multiple-clock design */

        /* Print minimum possible clock period to meet each constraint. Convert to nanoseconds. */

        vpr_printf(TIO_MESSAGE_INFO, "Minimum possible clock period to meet each constraint (including skew effects):\n");
        for (source_clock_domain = 0; source_clock_domain < g_sdc->num_constrained_clocks; source_clock_domain++) {
            /* Print the intra-domain constraint if it was analysed. */
            if (g_sdc->domain_constraint[source_clock_domain][source_clock_domain] > NEGATIVE_EPSILON) { 
                vpr_printf(TIO_MESSAGE_INFO, "%s to %s: %g ns (%g MHz)\n", 
                        g_sdc->constrained_clocks[source_clock_domain].name,
                        g_sdc->constrained_clocks[source_clock_domain].name, 
                        1e9 * f_timing_stats->cpd[source_clock_domain][source_clock_domain],
                        1e-6 / f_timing_stats->cpd[source_clock_domain][source_clock_domain]);
            } else {
                vpr_printf(TIO_MESSAGE_INFO, "%s to %s: --\n", 
                        g_sdc->constrained_clocks[source_clock_domain].name,
                        g_sdc->constrained_clocks[source_clock_domain].name);
            }
            /* Then, print all other constraints on separate lines, indented. We re-print 
            the source clock domain's name so there's no ambiguity when parsing. */
            for (sink_clock_domain = 0; sink_clock_domain < g_sdc->num_constrained_clocks; sink_clock_domain++) {
                if (source_clock_domain == sink_clock_domain) continue; /* already done that */
                if (g_sdc->domain_constraint[source_clock_domain][sink_clock_domain] > NEGATIVE_EPSILON) { 
                    /* If this domain pair was analysed */
                    vpr_printf(TIO_MESSAGE_INFO, "\t%s to %s: %g ns (%g MHz)\n", 
                            g_sdc->constrained_clocks[source_clock_domain].name,
                            g_sdc->constrained_clocks[sink_clock_domain].name, 
                            1e9 * f_timing_stats->cpd[source_clock_domain][sink_clock_domain],
                            1e-6 / f_timing_stats->cpd[source_clock_domain][sink_clock_domain]);
                } else {
                    vpr_printf(TIO_MESSAGE_INFO, "\t%s to %s: --\n", 
                            g_sdc->constrained_clocks[source_clock_domain].name,
                            g_sdc->constrained_clocks[sink_clock_domain].name);
                }
            }
        }

        /* Print least slack per constraint. */

        vpr_printf(TIO_MESSAGE_INFO, "\n");
        vpr_printf(TIO_MESSAGE_INFO, "Least slack per constraint:\n");
        for (source_clock_domain = 0; source_clock_domain < g_sdc->num_constrained_clocks; source_clock_domain++) {
            /* Print the intra-domain slack if valid. */
            if (f_timing_stats->least_slack[source_clock_domain][source_clock_domain] < HUGE_POSITIVE_FLOAT - 1) {
                vpr_printf(TIO_MESSAGE_INFO, "%s to %s: %g ns\n", 
                        g_sdc->constrained_clocks[source_clock_domain].name, 
                        g_sdc->constrained_clocks[source_clock_domain].name, 
                        1e9 * f_timing_stats->least_slack[source_clock_domain][source_clock_domain]);
            } else {
                vpr_printf(TIO_MESSAGE_INFO, "%s to %s: --\n", 
                        g_sdc->constrained_clocks[source_clock_domain].name,
                        g_sdc->constrained_clocks[source_clock_domain].name);
            }
            /* Then, print all other slacks on separate lines. */
            for (sink_clock_domain = 0; sink_clock_domain < g_sdc->num_constrained_clocks; sink_clock_domain++) {
                if (source_clock_domain == sink_clock_domain) continue; /* already done that */
                if (f_timing_stats->least_slack[source_clock_domain][sink_clock_domain] < HUGE_POSITIVE_FLOAT - 1) {
                    /* If this domain pair was analysed and has a valid slack */
                    vpr_printf(TIO_MESSAGE_INFO, "\t%s to %s: %g ns\n", 
                            g_sdc->constrained_clocks[source_clock_domain].name,
                            g_sdc->constrained_clocks[sink_clock_domain].name, 
                            1e9 * f_timing_stats->least_slack[source_clock_domain][sink_clock_domain]);
                } else {
                    vpr_printf(TIO_MESSAGE_INFO, "\t%s to %s: --\n", 
                            g_sdc->constrained_clocks[source_clock_domain].name,
                            g_sdc->constrained_clocks[sink_clock_domain].name);
                }
            }
        }
    
        /* Calculate geometric mean f_max (fanout-weighted and unweighted) from the diagonal (intra-domain) entries of critical_path_delay, 
        excluding domains without intra-domain paths (for which the timing constraint is DO_NOT_ANALYSE) and virtual clocks. */
        found = FALSE;
        for (clock_domain = 0; clock_domain < g_sdc->num_constrained_clocks; clock_domain++) {
            if (g_sdc->domain_constraint[clock_domain][clock_domain] > NEGATIVE_EPSILON && g_sdc->constrained_clocks[clock_domain].is_netlist_clock) {
                geomean_period *= f_timing_stats->cpd[clock_domain][clock_domain];
                fanout = g_sdc->constrained_clocks[clock_domain].fanout;
                fanout_weighted_geomean_period *= pow((double) f_timing_stats->cpd[clock_domain][clock_domain], fanout);
                total_fanout += fanout;
                num_netlist_clocks_with_intra_domain_paths++;
                found = TRUE;
            }
        }
        if (found) { /* Only print these if we found at least one clock domain with intra-domain paths. */
            geomean_period = pow(geomean_period, (float) 1/num_netlist_clocks_with_intra_domain_paths);
            fanout_weighted_geomean_period = pow(fanout_weighted_geomean_period, (double) 1/total_fanout);
            /* Convert to MHz */
            vpr_printf(TIO_MESSAGE_INFO, "\n");
            vpr_printf(TIO_MESSAGE_INFO, "Geometric mean intra-domain period: %g ns (%g MHz)\n", 
                    1e9 * geomean_period, 1e-6 / geomean_period);
            vpr_printf(TIO_MESSAGE_INFO, "Fanout-weighted geomean intra-domain period: %g ns (%g MHz)\n", 
                    1e9 * fanout_weighted_geomean_period, 1e-6 / fanout_weighted_geomean_period);
        }

        vpr_printf(TIO_MESSAGE_INFO, "\n");
    }
}

Here is the caller graph for this function:

Variable Documentation

int num_tnodes

Definition at line 144 of file path_delay.c.

t_tnode* tnode

Definition at line 143 of file path_delay.c.