static void breadth_first_expand_neighbours (int inode, float pcost, int inet, float bend_cost) { /* Puts all the rr_nodes adjacent to inode on the heap. rr_nodes outside * * the expanded bounding box specified in route_bb are not added to the * * heap. pcost is the path_cost to get to inode. */ int iconn, to_node, num_edges; t_rr_type from_type, to_type; float tot_cost; num_edges = rr_node[inode].num_edges; for (iconn=0;iconn<num_edges;iconn++) { to_node = rr_node[inode].edges[iconn]; if ( rr_node[to_node].xhigh < route_bb[inet].xmin || rr_node[to_node].xlow > route_bb[inet].xmax || rr_node[to_node].yhigh < route_bb[inet].ymin || rr_node[to_node].ylow > route_bb[inet].ymax ) continue; /* Node is outside (expanded) bounding box. */ tot_cost = pcost + get_rr_cong_cost (to_node); if (bend_cost != 0.) { from_type = rr_node[inode].type; to_type = rr_node[to_node].type; if ((from_type == CHANX && to_type == CHANY) || (from_type == CHANY && to_type == CHANX)) tot_cost += bend_cost; } node_to_heap (to_node, tot_cost, inode, iconn, OPEN, OPEN); } }
static void directed_search_add_source_to_heap(int inet, int target_node, float astar_fac) { /* Adds the SOURCE of this net to the heap. Used to start a net's routing. */ int inode; float back_cost, tot_cost; inode = net_rr_terminals[inet][0]; /* SOURCE */ back_cost = 0.0 + get_rr_cong_cost(inode); /* setting the total cost to 0 because it's the only element on the heap */ if(!is_empty_heap()) { printf ("Error: Wrong Assumption: in directed_search_add_source_to_heap " "the heap is not empty. Need to properly calculate source node's cost.\n"); exit(1); } /* WMF: path cost is 0. could use tot_cost = 0 to save some computation time, but * for consistency, I chose to do the expected cost calculation. */ tot_cost = back_cost + astar_fac * get_directed_search_expected_cost(inode, target_node); node_to_heap(inode, tot_cost, NO_PREVIOUS, NO_PREVIOUS, back_cost, OPEN); }
void reserve_locally_used_opins (float pres_fac, boolean rip_up_local_opins, t_ivec **clb_opins_used_locally) { /* If some subblock outputs are hooked directly to CLB outputs, then * * some CLB outputs are occupied if their associated subblock is used * * locally, even though the inter-CLB netlist does not say those outputs * * have to connect to anything. This is important when you have * * logically equivalent outputs. Code below makes sure any CLB outputs * * that are used by being directly hooked to subblocks get properly * * reserved. */ int iblk, num_local_opin, inode, from_node, iconn, num_edges, to_node; int iclass, ipin; float cost; struct s_heap *heap_head_ptr; if (rip_up_local_opins) { for (iblk=0;iblk<num_blocks;iblk++) { for (iclass=0;iclass<num_class;iclass++) { num_local_opin = clb_opins_used_locally[iblk][iclass].nelem; /* Always 0 for pads and for RECEIVER (IPIN) classes */ for (ipin=0;ipin<num_local_opin;ipin++) { inode = clb_opins_used_locally[iblk][iclass].list[ipin]; adjust_one_rr_occ_and_pcost (inode, -1, pres_fac); } } } } for (iblk=0;iblk<num_blocks;iblk++) { for (iclass=0;iclass<num_class;iclass++) { num_local_opin = clb_opins_used_locally[iblk][iclass].nelem; /* Always 0 for pads and for RECEIVER (IPIN) classes */ if (num_local_opin != 0) { /* Have to reserve (use) some OPINs */ from_node = rr_clb_source[iblk][iclass]; num_edges = rr_node[from_node].num_edges; for (iconn=0;iconn<num_edges;iconn++) { to_node = rr_node[from_node].edges[iconn]; cost = get_rr_cong_cost (to_node); node_to_heap (to_node, cost, OPEN, OPEN, 0., 0.); } for (ipin=0;ipin<num_local_opin;ipin++) { heap_head_ptr = get_heap_head (); inode = heap_head_ptr->index; adjust_one_rr_occ_and_pcost (inode, 1, pres_fac); clb_opins_used_locally[iblk][iclass].list[ipin] = inode; free_heap_data (heap_head_ptr); } empty_heap (); } } } }
static void breadth_first_add_source_to_heap (int inet) { /* Adds the SOURCE of this net to the heap. Used to start a net's routing. */ int inode; float cost; inode = net_rr_terminals[inet][0]; /* SOURCE */ cost = get_rr_cong_cost (inode); node_to_heap (inode, cost, NO_PREVIOUS, NO_PREVIOUS, OPEN, OPEN); }
/** * Adapted from breadth_first_add_source_to_heap() */ static void inc_breadth_first_add_inode_to_heap(int inode) { float cost; cost = get_rr_cong_cost(inode); node_to_heap(inode, cost, NO_PREVIOUS, NO_PREVIOUS, OPEN, OPEN); }
static void directed_search_expand_neighbours(struct s_heap *current, int inet, float bend_cost, int target_node, int highfanout_rlim, float astar_fac) { /* Puts all the rr_nodes adjacent to current on the heap. rr_nodes outside * * the expanded bounding box specified in route_bb are not added to the * * heap. back_cost is the path_cost to get to inode. total cost i.e. * tot_cost is path_cost + (expected_cost to target sink) */ int iconn, to_node, num_edges, inode, target_x, target_y; t_rr_type from_type, to_type; float new_tot_cost, old_back_pcost, new_back_pcost; inode = current->index; old_back_pcost = current->backward_path_cost; num_edges = rr_node[inode].num_edges; target_x = rr_node[target_node].xhigh; target_y = rr_node[target_node].yhigh; for(iconn = 0; iconn < num_edges; iconn++) { to_node = rr_node[inode].edges[iconn]; if(rr_node[to_node].xhigh < route_bb[inet].xmin || rr_node[to_node].xlow > route_bb[inet].xmax || rr_node[to_node].yhigh < route_bb[inet].ymin || rr_node[to_node].ylow > route_bb[inet].ymax) continue; /* Node is outside (expanded) bounding box. */ if(clb_net[inet].num_sinks >= HIGH_FANOUT_NET_LIM) { if(rr_node[to_node].xhigh < target_x - highfanout_rlim || rr_node[to_node].xlow > target_x + highfanout_rlim || rr_node[to_node].yhigh < target_y - highfanout_rlim || rr_node[to_node].ylow > target_y + highfanout_rlim) continue; /* Node is outside high fanout bin. */ } /* Prune away IPINs that lead to blocks other than the target one. Avoids * * the issue of how to cost them properly so they don't get expanded before * * more promising routes, but makes route-throughs (via CLBs) impossible. * * Change this if you want to investigate route-throughs. */ to_type = rr_node[to_node].type; if(to_type == IPIN && (rr_node[to_node].xhigh != target_x || rr_node[to_node].yhigh != target_y)) continue; /* new_back_pcost stores the "known" part of the cost to this node -- the * * congestion cost of all the routing resources back to the existing route * * new_tot_cost * is this "known" backward cost + an expected cost to get to the target. */ new_back_pcost = old_back_pcost + get_rr_cong_cost(to_node); if(bend_cost != 0.) { from_type = rr_node[inode].type; to_type = rr_node[to_node].type; if((from_type == CHANX && to_type == CHANY) || (from_type == CHANY && to_type == CHANX)) new_back_pcost += bend_cost; } /* Calculate the new total cost = path cost + astar_fac * remaining distance to target */ new_tot_cost = new_back_pcost + astar_fac * get_directed_search_expected_cost(to_node, target_node); node_to_heap(to_node, new_tot_cost, inode, iconn, new_back_pcost, OPEN); } }