read_sdc.h File Reference

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

Go to the source code of this file.

Functions
void	read_sdc (t_timing_inf timing_inf)
void	free_sdc_related_structs (void)
void	free_override_constraint (t_override_constraint *&constraint_array, int num_constraints)

Variables
t_timing_constraints *	g_sdc

Function Documentation

void free_override_constraint	(	t_override_constraint *&	constraint_array,
		int	num_constraints
	)

Definition at line 1297 of file read_sdc.c.

                                                                                              {
    int i, j;

    if (!constraint_array) return;

    for (i = 0; i < num_constraints; i++) {
        for (j = 0; j < constraint_array[i].num_source; j++) {
            free(constraint_array[i].source_list[j]);
            constraint_array[i].source_list[j] = NULL;
        }
        for (j = 0; j < constraint_array[i].num_sink; j++) {
            free(constraint_array[i].sink_list[j]);
            constraint_array[i].sink_list[j] = NULL;
        }
        free(constraint_array[i].source_list);
        free(constraint_array[i].sink_list);
    }
    free(constraint_array);
    constraint_array = NULL;
}

Here is the caller graph for this function:

void free_sdc_related_structs

(

void

)

Definition at line 1280 of file read_sdc.c.

                                    {
    if (!g_sdc) return;

    free_override_constraint(g_sdc->cc_constraints, g_sdc->num_cc_constraints); 
    /* Should already have been freed in process_constraints() */

    free_override_constraint(g_sdc->cf_constraints, g_sdc->num_cf_constraints);
    free_override_constraint(g_sdc->fc_constraints, g_sdc->num_fc_constraints);
    free_override_constraint(g_sdc->ff_constraints, g_sdc->num_ff_constraints);
    free_io_constraint(g_sdc->constrained_inputs, g_sdc->num_constrained_inputs);
    free_io_constraint(g_sdc->constrained_outputs, g_sdc->num_constrained_outputs);
    free_clock_constraint(g_sdc->constrained_clocks, g_sdc->num_constrained_clocks);
    free_matrix(g_sdc->domain_constraint, 0, g_sdc->num_constrained_clocks - 1, 0, sizeof(float));
    free(g_sdc);
    g_sdc = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void read_sdc

(

t_timing_inf

timing_inf

)

Definition at line 115 of file read_sdc.c.

                                       {

    char buf[BUFSIZE];
    int source_clock_domain, sink_clock_domain, iinput, ioutput, icc, isource, isink;
    boolean found; 
    
    /* Make sure we haven't called this subroutine before. */
    assert(!g_sdc);

    /* Allocate container structure for SDC constraints. */
    g_sdc = (t_timing_constraints *) my_calloc(1, sizeof(t_timing_constraints));
    
    /* Reset file line number. */
    file_line_number = 0;

    /* If no SDC file is included or specified, or timing analysis is off,
    use default behaviour of cutting paths between domains and optimizing each clock separately */

    if (!timing_inf.timing_analysis_enabled) {
        vpr_printf(TIO_MESSAGE_INFO, "\n");
        vpr_printf(TIO_MESSAGE_INFO, "Timing analysis off; using default timing constraints.\n");
        use_default_timing_constraints();
        return;
    }
    
    if ((sdc = fopen(timing_inf.SDCFile, "r")) == NULL) {
        vpr_printf(TIO_MESSAGE_INFO, "\n");
        vpr_printf(TIO_MESSAGE_INFO, "SDC file '%s' blank or not found.\n", timing_inf.SDCFile);
        use_default_timing_constraints();
        return;
    }
    
    /* Now we have an SDC file. */

    /* Count how many clocks and I/Os are in the netlist. 
    Store the names of each clock and each I/O in netlist_clocks and netlist_ios. 
    The only purpose of these two lists is to compare clock names in the SDC file against them.
    As a result, they will be freed after the SDC file is parsed. */
    alloc_and_load_netlist_clocks_and_ios();

    /* Parse the file line-by-line. */
    found = FALSE;
    while (my_fgets(buf, BUFSIZE, sdc) != NULL) { 
        if (get_sdc_tok(buf)) {
            found = TRUE;
        }
    }
    if (!found) { /* blank file or only comments found */
        vpr_printf(TIO_MESSAGE_INFO, "\n");
        vpr_printf(TIO_MESSAGE_INFO, "SDC file '%s' blank or not found.\n", timing_inf.SDCFile);
        use_default_timing_constraints();
        free(netlist_clocks);
        free(netlist_ios);
        return;
    }
    
    fclose(sdc);

    /* Make sure that all virtual clocks referenced in g_sdc->constrained_inputs and g_sdc->constrained_outputs have been constrained. */
    for (iinput = 0; iinput < g_sdc->num_constrained_inputs; iinput++) {
        if ((find_constrained_clock(g_sdc->constrained_inputs[iinput].clock_name)) == -1) {
            vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Input %s is associated with an unconstrained clock %s.\n", 
                    g_sdc->constrained_inputs[iinput].file_line_number,
                    g_sdc->constrained_inputs[iinput].name, 
                    g_sdc->constrained_inputs[iinput].clock_name);
            exit(1);
        }
    }

    for (ioutput = 0; ioutput < g_sdc->num_constrained_outputs; ioutput++) {
        if ((find_constrained_clock(g_sdc->constrained_outputs[ioutput].clock_name)) == -1) {
            vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Output %s is associated with an unconstrained clock %s.\n", 
                    g_sdc->constrained_inputs[iinput].file_line_number,
                    g_sdc->constrained_outputs[ioutput].name, 
                    g_sdc->constrained_outputs[ioutput].clock_name);
            exit(1);
        }
    }

    /* Make sure that all clocks referenced in g_sdc->cc_constraints have been constrained. */
    for (icc = 0; icc < g_sdc->num_cc_constraints; icc++) {
        for (isource = 0; isource < g_sdc->cc_constraints[icc].num_source; isource++) {
            if ((find_constrained_clock(g_sdc->cc_constraints[icc].source_list[isource])) == -1) {
                vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Token %s is not a constrained clock.\n", 
                        g_sdc->cc_constraints[icc].file_line_number,
                        g_sdc->cc_constraints[icc].source_list[isource]);
                exit(1);
            }
        }
        for (isink = 0; isink < g_sdc->cc_constraints[icc].num_sink; isink++) {
            if ((find_constrained_clock(g_sdc->cc_constraints[icc].sink_list[isink])) == -1) {
                vpr_printf(TIO_MESSAGE_ERROR, "[SDC line %d] Token %s is not a constrained clock.\n",
                        g_sdc->cc_constraints[icc].file_line_number, 
                        g_sdc->cc_constraints[icc].sink_list[isink]);
                exit(1);
            }
        }
    }

    /* Allocate matrix of timing constraints [0..g_sdc->num_constrained_clocks-1][0..g_sdc->num_constrained_clocks-1] and initialize to 0 */
    g_sdc->domain_constraint = (float **) alloc_matrix(0, g_sdc->num_constrained_clocks-1, 0, g_sdc->num_constrained_clocks-1, sizeof(float));
    
    /* Based on the information from sdc_clocks, calculate constraints for all paths except ones with an override constraint. */
    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 ((icc = find_cc_constraint(g_sdc->constrained_clocks[source_clock_domain].name, g_sdc->constrained_clocks[sink_clock_domain].name)) != -1) {
                if (g_sdc->cc_constraints[icc].num_multicycles == 0) {
                    /* There's a special constraint from set_false_path, set_clock_groups 
                    -exclusive or set_max_delay which overrides the default constraint. */
                    g_sdc->domain_constraint[source_clock_domain][sink_clock_domain] = g_sdc->cc_constraints[icc].constraint;
                } else {
                    /* There's a special constraint from set_multicycle_path which overrides the default constraint. 
                    This constraint = default constraint (obtained via edge counting) + (num_multicycles - 1) * period of sink clock domain. */
                    g_sdc->domain_constraint[source_clock_domain][sink_clock_domain] = 
                        calculate_constraint(sdc_clocks[source_clock_domain], sdc_clocks[sink_clock_domain]) 
                        + (g_sdc->cc_constraints[icc].num_multicycles - 1) * sdc_clocks[sink_clock_domain].period;
                }
            } else {
                /* There's no special override constraint. */
                /* Calculate the constraint between clock domains by finding the smallest positive 
                difference between a posedge in the source domain and one in the sink domain. */
                g_sdc->domain_constraint[source_clock_domain][sink_clock_domain] = 
                    calculate_constraint(sdc_clocks[source_clock_domain], sdc_clocks[sink_clock_domain]);
            }
        }
    }

    vpr_printf(TIO_MESSAGE_INFO, "\n");
    vpr_printf(TIO_MESSAGE_INFO, "SDC file '%s' parsed successfully.\n",
                 timing_inf.SDCFile ); 
    vpr_printf(TIO_MESSAGE_INFO, "%d clocks (including virtual clocks), %d inputs and %d outputs were constrained.\n", 
                 g_sdc->num_constrained_clocks, g_sdc->num_constrained_inputs, g_sdc->num_constrained_outputs);
    vpr_printf(TIO_MESSAGE_INFO, "\n");
    
    /* Since all the information we need is stored in g_sdc->domain_constraint, g_sdc->constrained_clocks, 
    and constrained_ios, free other data structures used in this routine */
    free(sdc_clocks);
    free(netlist_clocks);
    free(netlist_ios);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

t_timing_constraints* g_sdc

Definition at line 65 of file read_sdc.c.