| #include "profile_lookahead.h" |
| |
| using namespace std; |
| |
| void print_start_end_to_sink(bool is_start, int itry, int inet, int target_node, int itarget) { |
| #if DEBUGEXPANSIONRATIO == 1 |
| if (itry == DB_ITRY && target_node == DB_TARGET_NODE){ |
| if (is_start) { |
| printf("\n**** itry %d\tSTART ROUTE TO net %d\ttarget %d\tinode %d\n", |
| itry, inet, itarget, target_node); |
| printf("COORD: (%d,%d)\n", rr_node[target_node].get_xlow(), rr_node[target_node].get_ylow()); |
| } else { |
| printf("\n**** itry %d\tFINISH ROUTE TO net %d\ttarget %d\tinode %d\n\n", |
| itry, inet, itarget, target_node); |
| } |
| } |
| #endif |
| } |
| |
| void print_expand_neighbours(bool is_parent, int inode, int target_node, |
| int target_chan_type, int target_pin_x, int target_pin_y, |
| float expected_cost, float future_Tdel, float new_tot_cost, |
| float cur_basecost, float cong_cost) { |
| if (itry_share == DB_ITRY && target_node == DB_TARGET_NODE) { |
| const char *dir_name[] = {"INC", "DEC", NULL}; |
| const char *node_seg_type[] = {"source", "sink", "ipin", "opin", "chanX", "chanY", NULL}; |
| int dir = (rr_node[inode].get_direction() == INC_DIRECTION) ? 0 : 1; |
| int inode_type = rr_node[inode].type; |
| int inode_seg_index = rr_indexed_data[rr_node[inode].get_cost_index()].seg_index; |
| float basecost, C, Tdel; |
| int s_x, s_y, e_x, e_y, len; |
| get_unidir_seg_start(inode, &s_x, &s_y); |
| get_unidir_seg_end(inode, &e_x, &e_y); |
| len = rr_node[inode].get_len(); |
| if (is_parent) { |
| if (target_chan_type == UNDEFINED) { |
| printf("TARGET CHAN TYPE UNDEFINED\n"); |
| } else { |
| printf("TARGET CHAN TYPE: %d\tX %d\tY %d\n", target_chan_type, target_pin_x, target_pin_y); |
| } |
| Tdel = get_timing_driven_future_Tdel(inode, target_node, &C, &basecost); |
| printf("EXPAND inode %d(L%d)\t%s\t%s-%d\t(%d,%d)\t(%d,%d)\tpath cost %.3f\texp cost %.3f\n", |
| inode, len, dir_name[dir], node_seg_type[inode_type], |
| inode_seg_index, s_x, s_y, e_x, e_y, |
| rr_node_route_inf[inode].path_cost * pow(10, 10), |
| Tdel * pow(10, 10) ); |
| } else { |
| printf("\texpand %d(L%d)\t%s\t%s-%d\t(%d,%d)\t(%d,%d)\t", |
| inode, len, dir_name[dir], node_seg_type[inode_type], |
| inode_seg_index, s_x, s_y, e_x, e_y); |
| printf("exp cost %.3f\tb-Tdel %.3f\ttot cost %.3f\tbCost %.3fcCost %.3f\n", |
| expected_cost * pow(10, 10), future_Tdel * pow(10, 10), |
| new_tot_cost * pow(10, 10), cur_basecost * pow(10, 10), |
| cong_cost * pow(10, 10)); |
| } |
| } |
| } |
| |
| void setup_max_min_criticality(float &max_crit, float &min_crit, |
| int &max_inet, int &min_inet, int &max_ipin, int &min_ipin, t_slack * slacks) { |
| /* |
| * set up max/min criticality && where the max/min happens |
| * called in try_timing_driven_route() |
| */ |
| float max_crit_len_product = -1; |
| float min_crit_len_product = pow(10, 20); |
| max_crit = -1; |
| min_crit = pow(10, 20); |
| max_inet = -1; |
| max_ipin = -1; |
| min_inet = -1; |
| min_ipin = -1; |
| for (unsigned int inet = 0; inet < g_clbs_nlist.net.size(); ++inet) { |
| if (should_route_net(inet) == false) |
| continue; |
| if (g_clbs_nlist.net[inet].is_global == true) |
| continue; |
| if (g_clbs_nlist.net[inet].is_fixed == true) |
| continue; |
| int source_inode = net_rr_terminals[inet][0]; |
| int x_source_mid = (rr_node[source_inode].get_xhigh() + rr_node[source_inode].get_xlow()) / 2; |
| int y_source_mid = (rr_node[source_inode].get_yhigh() + rr_node[source_inode].get_ylow()) / 2; |
| unsigned int pin_upbound = (g_clbs_nlist.net[inet].pins.size() > 2) ? 2 : g_clbs_nlist.net[inet].pins.size(); |
| for (unsigned int ipin = 1; ipin < pin_upbound; ipin++) { |
| float pin_criticality = slacks->timing_criticality[inet][ipin]; |
| int target_inode = net_rr_terminals[inet][ipin]; |
| int x_target_mid = (rr_node[target_inode].get_xhigh() + rr_node[target_inode].get_xlow()) / 2; |
| int y_target_mid = (rr_node[target_inode].get_yhigh() + rr_node[target_inode].get_ylow()) / 2; |
| // print long nets only |
| int bb_len = abs(x_source_mid - x_target_mid + 1) + abs(y_source_mid - y_target_mid + 1); |
| float len_crit_product = bb_len * pin_criticality; |
| float len_inv_crit_product = (1./bb_len) * pin_criticality; |
| max_inet = (len_crit_product > max_crit_len_product) ? inet : max_inet; |
| max_ipin = (len_crit_product > max_crit_len_product) ? ipin : max_ipin; |
| min_inet = (len_inv_crit_product < min_crit_len_product) ? inet : min_inet; |
| min_ipin = (len_inv_crit_product < min_crit_len_product) ? ipin : min_ipin; |
| max_crit = (len_crit_product > max_crit_len_product) ? pin_criticality : max_crit; |
| min_crit = (len_inv_crit_product < min_crit_len_product) ? pin_criticality : min_crit; |
| max_crit_len_product = (len_crit_product > max_crit_len_product) ? len_crit_product : max_crit_len_product; |
| min_crit_len_product = (len_inv_crit_product < min_crit_len_product) ? len_inv_crit_product : min_crit_len_product; |
| } |
| } |
| //printf("max_inet %d\tmax_ipin %d\tmin_inet %d\tmin_ipin %d\n", max_inet, max_ipin, min_inet, min_ipin); |
| //printf("max_crit_len_product %f\tmin_crit %f\n", max_crit_len_product, min_crit); |
| //printf("\n"); |
| |
| } |
