SRC/route_tree_timing.h File Reference

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

Go to the source code of this file.

Data Structures
struct	s_linked_rt_edge
struct	s_rt_node
Typedefs
typedef struct s_linked_rt_edge	t_linked_rt_edge
typedef struct s_rt_node	t_rt_node
Functions
void	alloc_route_tree_timing_structs (void)
void	free_route_tree_timing_structs (void)
t_rt_node *	init_route_tree_to_source (int inet)
void	free_route_tree (t_rt_node *rt_node)
t_rt_node *	update_route_tree (struct s_heap *hptr)
void	update_net_delays_from_route_tree (float *net_delay, t_rt_node **rt_node_of_sink, int inet)

---

Typedef Documentation

typedef struct s_linked_rt_edge t_linked_rt_edge

Definition at line 10 of file route_tree_timing.h.

typedef struct s_rt_node t_rt_node

Definition at line 37 of file route_tree_timing.h.

---

Function Documentation

void alloc_route_tree_timing_structs

(

void

)

Definition at line 61 of file route_tree_timing.c.

{

/* Allocates any structures needed to build the routing trees. */

    if(rr_node_to_rt_node != NULL || rt_node_free_list != NULL ||
       rt_node_free_list != NULL)
        {
            printf("Error in alloc_route_tree_timing_structs: old structures "
                   "already exist.\n");
            exit(1);
        }

    rr_node_to_rt_node = (t_rt_node **) my_malloc(num_rr_nodes *
                                                  sizeof(t_rt_node *));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void free_route_tree

(

t_rt_node *

rt_node

)

Definition at line 529 of file route_tree_timing.c.

{

/* Puts the rt_nodes and edges in the tree rooted at rt_node back on the    *
 * free lists.  Recursive, depth-first post-order traversal.                */

    t_rt_node *child_node;
    t_linked_rt_edge *rt_edge, *next_edge;

    rt_edge = rt_node->u.child_list;

    while(rt_edge != NULL)
        {                       /* For all children */
            child_node = rt_edge->child;
            free_route_tree(child_node);
            next_edge = rt_edge->next;
            free_linked_rt_edge(rt_edge);
            rt_edge = next_edge;
        }

    free_rt_node(rt_node);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void free_route_tree_timing_structs

(

void

)

Definition at line 80 of file route_tree_timing.c.

{

/* Frees the structures needed to build routing trees, and really frees      *
 * (i.e. calls free) all the data on the free lists.                         */

    t_rt_node *rt_node, *next_node;
    t_linked_rt_edge *rt_edge, *next_edge;

    free(rr_node_to_rt_node);
    rr_node_to_rt_node = NULL;

    rt_node = rt_node_free_list;

    while(rt_node != NULL)
        {
            next_node = rt_node->u.next;
            free(rt_node);
            rt_node = next_node;
        }

    rt_node_free_list = NULL;

    rt_edge = rt_edge_free_list;

    while(rt_edge != NULL)
        {
            next_edge = rt_edge->next;
            free(rt_edge);
            rt_edge = next_edge;
        }

    rt_edge_free_list = NULL;
}

Here is the caller graph for this function:

t_rt_node* init_route_tree_to_source

(

int

inet

)

Definition at line 188 of file route_tree_timing.c.

{

/* Initializes the routing tree to just the net source, and returns the root *
 * node of the rt_tree (which is just the net source).                       */

    t_rt_node *rt_root;
    int inode;

    rt_root = alloc_rt_node();
    rt_root->u.child_list = NULL;
    rt_root->parent_node = NULL;
    rt_root->parent_switch = OPEN;
    rt_root->re_expand = TRUE;

    inode = net_rr_terminals[inet][0];  /* Net source */

    rt_root->inode = inode;
    rt_root->C_downstream = rr_node[inode].C;
    rt_root->R_upstream = rr_node[inode].R;
    rt_root->Tdel = 0.5 * rr_node[inode].R * rr_node[inode].C;
    rr_node_to_rt_node[inode] = rt_root;

    return (rt_root);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void update_net_delays_from_route_tree	(	float *	net_delay,
		t_rt_node **	rt_node_of_sink,
		int	inet
	)

Definition at line 554 of file route_tree_timing.c.

{

/* Goes through all the sinks of this net and copies their delay values from *
 * the route_tree to the net_delay array.                                    */

    int isink;
    t_rt_node *sink_rt_node;

    for(isink = 1; isink <= net[inet].num_sinks; isink++)
        {
            sink_rt_node = rt_node_of_sink[isink];
            net_delay[isink] = sink_rt_node->Tdel;
        }
}

Here is the caller graph for this function:

t_rt_node* update_route_tree

(

struct s_heap *

hptr

)

Definition at line 216 of file route_tree_timing.c.

{

/* Adds the most recently finished wire segment to the routing tree, and    *
 * updates the Tdel, etc. numbers for the rest of the routing tree.  hptr   *
 * is the heap pointer of the SINK that was reached.  This routine returns  *
 * a pointer to the rt_node of the SINK that it adds to the routing.        */

    t_rt_node *start_of_new_path_rt_node, *sink_rt_node;
    t_rt_node *unbuffered_subtree_rt_root, *subtree_parent_rt_node;
    float Tdel_start;
    short iswitch;

    start_of_new_path_rt_node = add_path_to_route_tree(hptr, &sink_rt_node);
    load_new_path_R_upstream(start_of_new_path_rt_node);
    unbuffered_subtree_rt_root =
        update_unbuffered_ancestors_C_downstream(start_of_new_path_rt_node);

    subtree_parent_rt_node = unbuffered_subtree_rt_root->parent_node;

    if(subtree_parent_rt_node != NULL)
        {                       /* Parent exists. */
            Tdel_start = subtree_parent_rt_node->Tdel;
            iswitch = unbuffered_subtree_rt_root->parent_switch;
            Tdel_start += switch_inf[iswitch].R *
                unbuffered_subtree_rt_root->C_downstream;
            Tdel_start += switch_inf[iswitch].Tdel;
        }
    else
        {                       /* Subtree starts at SOURCE */
            Tdel_start = 0.;
        }

    load_rt_subtree_Tdel(unbuffered_subtree_rt_root, Tdel_start);

    return (sink_rt_node);
}

Here is the call graph for this function:

Here is the caller graph for this function: