net_delay.h File Reference

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

Go to the source code of this file.

Functions
float **	alloc_net_delay (t_chunk *chunk_list_ptr, struct s_net *nets, int n_nets)
void	free_net_delay (float **net_delay, t_chunk *chunk_list_ptr)
void	load_net_delay_from_routing (float **net_delay, struct s_net *nets, int n_nets)
void	load_constant_net_delay (float **net_delay, float delay_value, struct s_net *nets, int n_nets)

Function Documentation

float** alloc_net_delay	(	t_chunk *	chunk_list_ptr,
		struct s_net *	nets,
		int	n_nets
	)

Definition at line 103 of file net_delay.c.

                   {

    /* Allocates space for the net_delay data structure                          *
     * [0..num_nets-1][1..num_pins-1].  I chunk the data to save space on large  *
     * problems.                                                                 */

    float **net_delay; /* [0..num_nets-1][1..num_pins-1] */
    float *tmp_ptr;
    int inet;

    net_delay = (float **) my_malloc(n_nets * sizeof(float *));

    for (inet = 0; inet < n_nets; inet++) {
        tmp_ptr = (float *) my_chunk_malloc(
                ((nets[inet].num_sinks + 1) - 1) * sizeof(float),
                chunk_list_ptr);

        net_delay[inet] = tmp_ptr - 1; /* [1..num_pins-1] */
    }

    return (net_delay);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void free_net_delay	(	float **	net_delay,
		t_chunk *	chunk_list_ptr
	)

Definition at line 127 of file net_delay.c.

                                {

    /* Frees the net_delay structure.  Assumes it was chunk allocated.          */

    free(net_delay);
    free_chunk_memory(chunk_list_ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void load_constant_net_delay	(	float **	net_delay,
		float	delay_value,
		struct s_net *	nets,
		int	n_nets
	)

Definition at line 175 of file net_delay.c.

                                        {

    /* Loads the net_delay array with delay_value for every source - sink        *
     * connection that is not on a global resource, and with 0. for every source *
     * - sink connection on a global net.  (This can be used to allow timing     *
     * analysis before routing is done with a constant net delay model).         */

    int inet;

    for (inet = 0; inet < n_nets; inet++) {
        if (nets[inet].is_global) {
            load_one_constant_net_delay(net_delay, inet, nets, 0.);
        } else {
            load_one_constant_net_delay(net_delay, inet, nets, delay_value);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void load_net_delay_from_routing	(	float **	net_delay,
		struct s_net *	nets,
		int	n_nets
	)

Definition at line 136 of file net_delay.c.

                    {

    /* This routine loads net_delay[0..num_nets-1][1..num_pins-1].  Each entry   *
     * is the Elmore delay from the net source to the appropriate sink.  Both    *
     * the rr_graph and the routing traceback must be completely constructed     *
     * before this routine is called, and the net_delay array must have been     *
     * allocated.                                                                */

    t_rc_node *rc_node_free_list, *rc_root;
    t_linked_rc_edge *rc_edge_free_list;
    int inet;
    t_linked_rc_ptr *rr_node_to_rc_node; /* [0..num_rr_nodes-1]  */

    rr_node_to_rc_node = (t_linked_rc_ptr *) my_calloc(num_rr_nodes,
            sizeof(t_linked_rc_ptr));

    rc_node_free_list = NULL;
    rc_edge_free_list = NULL;

    for (inet = 0; inet < n_nets; inet++) {
        if (nets[inet].is_global) {
            load_one_constant_net_delay(net_delay, inet, nets, 0.);
        } else {
            rc_root = alloc_and_load_rc_tree(inet, &rc_node_free_list,
                    &rc_edge_free_list, rr_node_to_rc_node);
            load_rc_tree_C(rc_root);
            load_rc_tree_T(rc_root, 0.);
            load_one_net_delay(net_delay, inet, nets, rr_node_to_rc_node);
            free_rc_tree(rc_root, &rc_node_free_list, &rc_edge_free_list);
            reset_rr_node_to_rc_node(rr_node_to_rc_node, inet);
        }
    }

    free_rc_node_free_list(rc_node_free_list);
    free_rc_edge_free_list(rc_edge_free_list);
    free(rr_node_to_rc_node);
}

Here is the call graph for this function:

Here is the caller graph for this function: