void try_route(struct city** cities, unsigned* shortest, unsigned* longest) { unsigned distance = measure_route(cities); if (!distance) /* can't get here from there */ return; /*print_route(cities); printf("= %u", distance);*/ if (distance < *shortest) { *shortest = distance; fputs("New shortest: ", stdout); print_route(cities); printf("= %u\n", distance); /*putchar('*');*/ } if (distance > *longest) { *longest = distance; fputs("New longest: ", stdout); print_route(cities); printf("= %u\n", distance); } /*putchar('\n');*/ }
void route_show(void) { int i; print_route(NULL); EnterCritical(); for (i = 0 ; i < GETNUMROUTEENTRIES ; i++) { print_route(GETROUTEP(i)); } ExitCritical(); }
SRL_STATIC_INLINE void srl_parse_next(pTHX_ srl_path_t *path, int expr_idx, SV *route) { srl_iterator_t *iter = path->iter; assert(route != NULL); SRL_PATH_TRACE("expr_idx=%d", expr_idx); if (srl_iterator_eof(aTHX_ iter)) return; if (expr_idx > av_len(path->expr)) { // scaned entiry expr SV *res; print_route(route, "to decode"); res = srl_iterator_decode(aTHX_ iter); SvREFCNT_inc(res); av_push(path->results, res); // TODO store route if needed return; } switch (srl_iterator_object_info(aTHX_ iter, NULL)) { case SRL_ITERATOR_OBJ_IS_HASH: srl_iterator_step_in(aTHX_ iter, 1); srl_parse_hash(aTHX_ path, expr_idx, route); break; case SRL_ITERATOR_OBJ_IS_ARRAY: srl_iterator_step_in(aTHX_ iter, 1); srl_parse_array(aTHX_ path, expr_idx, route); break; } }
void route(pid_t pid, int print_procs) { pid_read(pid); // print processes int i; for (i = 0; i < max_pids; i++) { if (pids[i].level == 1) { if (print_procs || pid == 0) pid_print_list(i, arg_nowrap); int child = find_child(i); if (child != -1) { char *fname; if (asprintf(&fname, "/proc/%d/net/fib_trie", child) == -1) errExit("asprintf"); extract_if(fname); free(fname); if (asprintf(&fname, "/proc/%d/net/route", child) == -1) errExit("asprintf"); print_route(fname); free(fname); } } } printf("\n"); }
int accept_msg(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg) { FILE *fp = (FILE*)arg; if (timestamp) print_timestamp(fp); if (n->nlmsg_type == RTM_NEWROUTE || n->nlmsg_type == RTM_DELROUTE) { print_route(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWLINK || n->nlmsg_type == RTM_DELLINK) { ll_remember_index(who, n, NULL); print_linkinfo(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWADDR || n->nlmsg_type == RTM_DELADDR) { print_addrinfo(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWNEIGH || n->nlmsg_type == RTM_DELNEIGH) { print_neigh(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWPREFIX) { print_prefix(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWRULE || n->nlmsg_type == RTM_DELRULE) { print_rule(who, n, arg); return 0; } if (n->nlmsg_type == 15) { char *tstr; time_t secs = ((__u32*)NLMSG_DATA(n))[0]; long usecs = ((__u32*)NLMSG_DATA(n))[1]; tstr = asctime(localtime(&secs)); tstr[strlen(tstr)-1] = 0; fprintf(fp, "Timestamp: %s %lu us\n", tstr, usecs); return 0; } if (n->nlmsg_type == RTM_NEWQDISC || n->nlmsg_type == RTM_DELQDISC || n->nlmsg_type == RTM_NEWTCLASS || n->nlmsg_type == RTM_DELTCLASS || n->nlmsg_type == RTM_NEWTFILTER || n->nlmsg_type == RTM_DELTFILTER) return 0; if (n->nlmsg_type != NLMSG_ERROR && n->nlmsg_type != NLMSG_NOOP && n->nlmsg_type != NLMSG_DONE) { fprintf(fp, "Unknown message: %08x %08x %08x\n", n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags); } return 0; }
void run_testcase(sc_session *s, int number, const sc_string &graph_str, const sc_string &beg_name, const sc_string &end_name) { std::cout << "[Testcase " << number << "]\n"; // Для работы создаем временный сегмент /tmp/wave_find_path. // sc_segment* tmp_seg = create_unique_segment(s, "/tmp/wave_find_path"); // Генерируем текстовый граф в sc-памяти. // sc_addr graph = gen_undirected_graph(s, tmp_seg, graph_str); // Распечатаем граф на консоль // std::cout << "Graph string: \n" << graph_str << '\n'; std::cout << "Graph from memory: " << '\n'; print_graph(s, graph); // Найдем начальную вершину для тестового поиска минимального пути. // sc_addr beg = s->find_by_idtf(beg_name, tmp_seg); assert(beg); // Найдем конечную вершину для тестового поиска миниального пути. // sc_addr end = s->find_by_idtf(end_name, tmp_seg); assert(end); std::cout << "Find minimal path from '" << beg_name << "' to '" << end_name << "'\n"; // Найдем минимальный пути между начальной и конечной вершинами. // sc_addr result = find_min_path(s, tmp_seg, graph, beg, end); // Распечатаем найденный путь на консоль std::cout << "Path"; if (result) { std::cout << ":\n"; print_route(s, result); } else { std::cout << " isn't exist.\n"; } // Удалим временный sc-сегмент. // s->unlink(tmp_seg->get_full_uri()); std::cout << std::endl; }
static void list_routes( bool bLong ) { int nSocket = socket( AF_INET, SOCK_STREAM, 0 ); struct rttable *psRtTable; struct rtabentry *psTable; int nError; int i; psRtTable = malloc( sizeof( struct rttable ) + sizeof( struct rtabentry ) * 128 ); if ( psRtTable == NULL ) { fprintf( stderr, "Out of memory: %s\n", strerror( errno ) ); exit( 1 ); } psTable = ( struct rtabentry * )( psRtTable + 1 ); if ( nSocket < 0 ) { fprintf( stderr, "Failed to create socket: %s\n", strerror( errno ) ); exit( 1 ); } psRtTable->rtt_count = 128; nError = ioctl( nSocket, SIOCGETRTAB, psRtTable ); if ( nError < 0 ) { fprintf( stderr, "Failed to get routing table: %s\n", strerror( errno ) ); exit( 1 ); } if( bLong ) printf( "Index Interface Destination Netmask Remote Flags\n" ); else printf( "Index Interface Destination Remote Flags\n" ); for ( i = 0; i < psRtTable->rtt_count; ++i ) { printf( "%5d %-10s ", i, psTable[i].rt_dev ); print_route( (uint8*)&((struct sockaddr_in *)&psTable[i].rt_dst)->sin_addr, (uint8*)&((struct sockaddr_in *)&psTable[i].rt_genmask)->sin_addr, (uint8*)&((struct sockaddr_in *)&psTable[i].rt_gateway)->sin_addr, psTable[i].rt_flags, bLong ); } free( psRtTable ); close( nSocket ); }
void trace_route(int triangle[][15], int i, int j, int sum, int *biggest, route_t *route) { route->node_array[i].i = i; route->node_array[i].j = j; if (i == 14) { sum += triangle[i][j]; if (*biggest < sum) *biggest = sum; printf("sum = %d, i=%d, j=%d, biggest = %d\n", sum, i, j, *biggest); print_route(route); return; } trace_route(triangle, i + 1, j, sum + triangle[i][j], biggest, route); trace_route(triangle, i + 1, j + 1, sum + triangle[i][j], biggest, route); return ; }
void ocin_prtr_stats_str::route(ocin_msg * msg, string src, string dest) { // cout <<"Prerouting from "<< src << " to " << dest <<" based upon:\n"; // print(); ocin_prtr_stats_node * current; ocin_prtr_stats_node *next; current = nodes[src]; next = NULL; int edge_count = current->edges.size(); if (src == dest) { // if we are already at the // destination just push on the output // port msg->preroutes.clear(); msg->preroutes.push_back(edge_count); return; } if ((src != last_src)||(ocin_cycle_count != last_cycle)) { // skip // re-calc // if we // don't // need // it... reset(); // reset all the nodes and the // unvisited list current->distance = 0; // I'm maintaining a list of unvisited nodes, I start with the // source as the current node. For each neighbor from the current // node I relax the distance var and rt_est if the distance is // less than the current distance. I then remove the current node // from the unvisited list and look for the next current node from // among the neighbors. If all neighbors have been visited then // go to the lowest among the unvisited. while (current != NULL) { unvisited.remove(current); int dist=current->distance; // current running distance estimate. for (int x =0; x < edge_count; x++) { next = current->edges[x]; if (next == NULL) { continue; // skip non-connected edges } int next_dist = dist + current->weights[x]; // Relax the downstream node if (next_dist < next->distance) { deque <int> new_route = current->rt_est; // route to this point new_route.push_back(x); // cout << "Relaxing " << next->name << " to " << next_dist << " with route:\n"; // print_route(src, new_route); next->distance = next_dist; next->rt_est = new_route; } } // next figure out which node to look at next if(unvisited.empty()) { current = NULL; }else { list <ocin_prtr_stats_node *>::iterator temp; temp = min_element(unvisited.begin(), unvisited.end(), comp_node); current = *temp; } } last_cycle = ocin_cycle_count; last_src = src; } #ifdef DEBUG { stringstream tmp; tmp << ocin_cycle_count << ": Route pid "<< msg->pid <<" from "<< src << " to " << dest<< ":\n"; ocin_name_debug(name,tmp.str()); print_route(src, nodes[dest]->rt_est); } #endif // print(); // cout << "\n\n"; // now we can pull out the desired path from the dest node msg->preroutes = nodes[dest]->rt_est; msg->preroutes.push_back(edge_count); // push on the // output port on // the end... return; }
void place_and_route(enum e_operation operation, struct s_placer_opts placer_opts, char *place_file, char *net_file, char *arch_file, char *route_file, struct s_annealing_sched annealing_sched, struct s_router_opts router_opts, struct s_det_routing_arch det_routing_arch, t_segment_inf * segment_inf, t_timing_inf timing_inf, t_chan_width_dist chan_width_dist, struct s_model *models) { /* This routine controls the overall placement and routing of a circuit. */ char msg[BUFSIZE]; int width_fac, inet, i; boolean success, Fc_clipped; float **net_delay, **net_slack; struct s_linked_vptr *net_delay_chunk_list_head; t_ivec **clb_opins_used_locally; /* [0..num_blocks-1][0..num_class-1] */ t_mst_edge **mst = NULL; /* Make sure mst is never undefined */ int max_pins_per_clb; clock_t begin, end; Fc_clipped = FALSE; max_pins_per_clb = 0; for(i = 0; i < num_types; i++) { if(type_descriptors[i].num_pins > max_pins_per_clb) { max_pins_per_clb = type_descriptors[i].num_pins; } } if(placer_opts.place_freq == PLACE_NEVER) { /* Read the placement from a file */ read_place(place_file, net_file, arch_file, nx, ny, num_blocks, block); sync_grid_to_blocks(num_blocks, block, nx, ny, grid); } else { assert((PLACE_ONCE == placer_opts.place_freq) || (PLACE_ALWAYS == placer_opts.place_freq)); begin = clock(); try_place(placer_opts, annealing_sched, chan_width_dist, router_opts, det_routing_arch, segment_inf, timing_inf, &mst); print_place(place_file, net_file, arch_file); end = clock(); #ifdef CLOCKS_PER_SEC printf("Placement took %g seconds\n", (float)(end - begin) / CLOCKS_PER_SEC); #else printf("Placement took %g seconds\n", (float)(end - begin) / CLK_PER_SEC); #endif } begin = clock(); post_place_sync(num_blocks, block); fflush(stdout); /* reset mst */ if(mst) { for(inet = 0; inet < num_nets; inet++) { if(mst[inet]) { free(mst[inet]); } } free(mst); } mst = NULL; if(!router_opts.doRouting) return; mst = (t_mst_edge **) my_malloc(sizeof(t_mst_edge *) * num_nets); for(inet = 0; inet < num_nets; inet++) { mst[inet] = get_mst_of_net(inet); } width_fac = router_opts.fixed_channel_width; /* If channel width not fixed, use binary search to find min W */ if(NO_FIXED_CHANNEL_WIDTH == width_fac) { binary_search_place_and_route(placer_opts, place_file, net_file, arch_file, route_file, router_opts.full_stats, router_opts.verify_binary_search, annealing_sched, router_opts, det_routing_arch, segment_inf, timing_inf, chan_width_dist, mst, models); } else { if(det_routing_arch.directionality == UNI_DIRECTIONAL) { if(width_fac % 2 != 0) { printf ("Error: pack_place_and_route.c: given odd chan width (%d) for udsd architecture\n", width_fac); exit(1); } } /* Other constraints can be left to rr_graph to check since this is one pass routing */ /* Allocate the major routing structures. */ clb_opins_used_locally = alloc_route_structs(); if(timing_inf.timing_analysis_enabled) { net_slack = alloc_and_load_timing_graph(timing_inf); net_delay = alloc_net_delay(&net_delay_chunk_list_head, clb_net, num_nets); } else { net_delay = NULL; /* Defensive coding. */ net_slack = NULL; } success = try_route(width_fac, router_opts, det_routing_arch, segment_inf, timing_inf, net_slack, net_delay, chan_width_dist, clb_opins_used_locally, mst, &Fc_clipped); if(Fc_clipped) { printf ("Warning: Fc_output was too high and was clipped to full (maximum) connectivity.\n"); } if(success == FALSE) { printf ("Circuit is unrouteable with a channel width factor of %d\n\n", width_fac); sprintf(msg, "Routing failed with a channel width factor of %d. ILLEGAL routing shown.", width_fac); } else { check_route(router_opts.route_type, det_routing_arch.num_switch, clb_opins_used_locally); get_serial_num(); printf ("Circuit successfully routed with a channel width factor of %d.\n\n", width_fac); routing_stats(router_opts.full_stats, router_opts.route_type, det_routing_arch.num_switch, segment_inf, det_routing_arch.num_segment, det_routing_arch.R_minW_nmos, det_routing_arch.R_minW_pmos, det_routing_arch.directionality, timing_inf.timing_analysis_enabled, net_slack, net_delay); print_route(route_file); #ifdef CREATE_ECHO_FILES /*print_sink_delays("routing_sink_delays.echo"); */ #endif /* CREATE_ECHO_FILES */ sprintf(msg, "Routing succeeded with a channel width factor of %d.\n\n", width_fac); } init_draw_coords(max_pins_per_clb); update_screen(MAJOR, msg, ROUTING, timing_inf.timing_analysis_enabled); if(timing_inf.timing_analysis_enabled) { assert(net_slack); #ifdef CREATE_ECHO_FILES print_timing_graph_as_blif("post_flow_timing_graph.blif", models); #endif free_timing_graph(net_slack); assert(net_delay); free_net_delay(net_delay, &net_delay_chunk_list_head); } free_route_structs(clb_opins_used_locally); fflush(stdout); } end = clock(); #ifdef CLOCKS_PER_SEC printf("Routing took %g seconds\n", (float)(end - begin) / CLOCKS_PER_SEC); #else printf("Routing took %g seconds\n", (float)(end - begin) / CLK_PER_SEC); #endif /*WMF: cleaning up memory usage */ if(mst) { for(inet = 0; inet < num_nets; inet++) { if(!mst[inet]) { printf("no mst for net %s #%d\n", clb_net[inet].name, inet); } assert(mst[inet]); free(mst[inet]); } free(mst); mst = NULL; } }
static int accept_msg(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg) { FILE *fp = (FILE*)arg; if (n->nlmsg_type == RTM_NEWROUTE || n->nlmsg_type == RTM_DELROUTE) { struct rtmsg *r = NLMSG_DATA(n); int len = n->nlmsg_len - NLMSG_LENGTH(sizeof(*r)); if (len < 0) { fprintf(stderr, "BUG: wrong nlmsg len %d\n", len); return -1; } if (r->rtm_flags & RTM_F_CLONED) return 0; if (timestamp) print_timestamp(fp); if (r->rtm_family == RTNL_FAMILY_IPMR || r->rtm_family == RTNL_FAMILY_IP6MR) { if (prefix_banner) fprintf(fp, "[MROUTE]"); print_mroute(who, n, arg); return 0; } else { if (prefix_banner) fprintf(fp, "[ROUTE]"); print_route(who, n, arg); return 0; } } if (timestamp) print_timestamp(fp); if (n->nlmsg_type == RTM_NEWLINK || n->nlmsg_type == RTM_DELLINK) { ll_remember_index(who, n, NULL); if (prefix_banner) fprintf(fp, "[LINK]"); print_linkinfo(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWADDR || n->nlmsg_type == RTM_DELADDR) { if (prefix_banner) fprintf(fp, "[ADDR]"); print_addrinfo(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWADDRLABEL || n->nlmsg_type == RTM_DELADDRLABEL) { if (prefix_banner) fprintf(fp, "[ADDRLABEL]"); print_addrlabel(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWNEIGH || n->nlmsg_type == RTM_DELNEIGH || n->nlmsg_type == RTM_GETNEIGH) { if (preferred_family) { struct ndmsg *r = NLMSG_DATA(n); if (r->ndm_family != preferred_family) return 0; } if (prefix_banner) fprintf(fp, "[NEIGH]"); print_neigh(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWPREFIX) { if (prefix_banner) fprintf(fp, "[PREFIX]"); print_prefix(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWRULE || n->nlmsg_type == RTM_DELRULE) { if (prefix_banner) fprintf(fp, "[RULE]"); print_rule(who, n, arg); return 0; } if (n->nlmsg_type == RTM_NEWNETCONF) { if (prefix_banner) fprintf(fp, "[NETCONF]"); print_netconf(who, n, arg); return 0; } if (n->nlmsg_type == NLMSG_TSTAMP) { print_nlmsg_timestamp(fp, n); return 0; } if (n->nlmsg_type != NLMSG_ERROR && n->nlmsg_type != NLMSG_NOOP && n->nlmsg_type != NLMSG_DONE) { fprintf(fp, "Unknown message: type=0x%08x(%d) flags=0x%08x(%d)" "len=0x%08x(%d)\n", n->nlmsg_type, n->nlmsg_type, n->nlmsg_flags, n->nlmsg_flags, n->nlmsg_len, n->nlmsg_len); } return 0; }
int main(void) { int tree[][3] = {{0,1,1}, {0,2,5}, {1,3,1}, {3,4,1}, {2,5,1}, {4,5,4}, {5,6,1}}; int arc_num = sizeof(tree)/sizeof(tree[0]); int open[N]; int closed[7] = {0}; int size = 0; int start =0; int goal = 6; int top,i,mindex,tmp; int prev[N] = {-1,-1,-1,-1,-1,-1,-1}; int k; int l=0; open[size++] = start; while(size > 0){ //mindex = 0; /*for (k = 1; k < size; k++) { if(dist[open[mindex]]> dist[open[k]]){ mindex = k; } } tmp = open[mindex]; open[mindex] = open[size-1]; open[size-1] = tmp; */ top = open[--size]; printf("%d ", top); if(top == goal){ printf("\nOK\n"); print_route(prev,goal); return 0; } for (i = 0; i < arc_num; i++) { if (tree[i][0] == top) { if (closed[tree[i][1]] == 0) { open[size++] = tree[i][1]; prev[tree[i][1]] = top; closed[tree[i][1]] = 1; }else if(closed[tree[i][1]] == 1){ if(distance(prev, i, tree, arc_num) > distance(prev, top, tree, arc_num)) prev[tree[i][1]] = top; } } } } printf("\nNG\n"); return 0; }
static int iproute_get(int argc, char **argv) { struct rtnl_handle rth; struct { struct nlmsghdr n; struct rtmsg r; char buf[1024]; } req; char *idev = NULL; char *odev = NULL; int connected = 0; int from_ok = 0; const char *options[] = { "from", "iif", "oif", "dev", "notify", "connected", "to", 0 }; memset(&req, 0, sizeof(req)); iproute_reset_filter(); req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)); req.n.nlmsg_flags = NLM_F_REQUEST; req.n.nlmsg_type = RTM_GETROUTE; req.r.rtm_family = preferred_family; req.r.rtm_table = 0; req.r.rtm_protocol = 0; req.r.rtm_scope = 0; req.r.rtm_type = 0; req.r.rtm_src_len = 0; req.r.rtm_dst_len = 0; req.r.rtm_tos = 0; while (argc > 0) { switch (compare_string_array(options, *argv)) { case 0: /* from */ { inet_prefix addr; NEXT_ARG(); from_ok = 1; get_prefix(&addr, *argv, req.r.rtm_family); if (req.r.rtm_family == AF_UNSPEC) { req.r.rtm_family = addr.family; } if (addr.bytelen) { addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen); } req.r.rtm_src_len = addr.bitlen; break; } case 1: /* iif */ NEXT_ARG(); idev = *argv; break; case 2: /* oif */ case 3: /* dev */ NEXT_ARG(); odev = *argv; break; case 4: /* notify */ req.r.rtm_flags |= RTM_F_NOTIFY; break; case 5: /* connected */ connected = 1; break; case 6: /* to */ NEXT_ARG(); default: { inet_prefix addr; get_prefix(&addr, *argv, req.r.rtm_family); if (req.r.rtm_family == AF_UNSPEC) { req.r.rtm_family = addr.family; } if (addr.bytelen) { addattr_l(&req.n, sizeof(req), RTA_DST, &addr.data, addr.bytelen); } req.r.rtm_dst_len = addr.bitlen; } argc--; argv++; } } if (req.r.rtm_dst_len == 0) { bb_error_msg_and_die("need at least destination address"); } if (rtnl_open(&rth, 0) < 0) exit(1); ll_init_map(&rth); if (idev || odev) { int idx; if (idev) { if ((idx = ll_name_to_index(idev)) == 0) { bb_error_msg("Cannot find device \"%s\"", idev); return -1; } addattr32(&req.n, sizeof(req), RTA_IIF, idx); } if (odev) { if ((idx = ll_name_to_index(odev)) == 0) { bb_error_msg("Cannot find device \"%s\"", odev); return -1; } addattr32(&req.n, sizeof(req), RTA_OIF, idx); } } if (req.r.rtm_family == AF_UNSPEC) { req.r.rtm_family = AF_INET; } if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) { exit(2); } if (connected && !from_ok) { struct rtmsg *r = NLMSG_DATA(&req.n); int len = req.n.nlmsg_len; struct rtattr * tb[RTA_MAX+1]; if (print_route(NULL, &req.n, (void*)stdout) < 0) { bb_error_msg_and_die("An error :-)"); } if (req.n.nlmsg_type != RTM_NEWROUTE) { bb_error_msg("Not a route?"); return -1; } len -= NLMSG_LENGTH(sizeof(*r)); if (len < 0) { bb_error_msg("Wrong len %d", len); return -1; } memset(tb, 0, sizeof(tb)); parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len); if (tb[RTA_PREFSRC]) { tb[RTA_PREFSRC]->rta_type = RTA_SRC; r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]); } else if (!tb[RTA_SRC]) { bb_error_msg("Failed to connect the route"); return -1; } if (!odev && tb[RTA_OIF]) { tb[RTA_OIF]->rta_type = 0; } if (tb[RTA_GATEWAY]) { tb[RTA_GATEWAY]->rta_type = 0; } if (!idev && tb[RTA_IIF]) { tb[RTA_IIF]->rta_type = 0; } req.n.nlmsg_flags = NLM_F_REQUEST; req.n.nlmsg_type = RTM_GETROUTE; if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) { exit(2); } } if (print_route(NULL, &req.n, (void*)stdout) < 0) { bb_error_msg_and_die("An error :-)"); } exit(0); }
void place_and_route(enum e_operation operation, struct s_placer_opts placer_opts, char *place_file, char *net_file, char *arch_file, char *route_file, struct s_annealing_sched annealing_sched, struct s_router_opts router_opts, struct s_det_routing_arch det_routing_arch, t_segment_inf * segment_inf, t_timing_inf timing_inf, t_chan_width_dist chan_width_dist, struct s_model *models, t_direct_inf *directs, int num_directs) { /* This routine controls the overall placement and routing of a circuit. */ char msg[BUFSIZE]; int width_fac, i; boolean success, Fc_clipped; float **net_delay = NULL; t_slack * slacks = NULL; t_chunk net_delay_ch = {NULL, 0, NULL}; /*struct s_linked_vptr *net_delay_chunk_list_head;*/ t_ivec **clb_opins_used_locally = NULL; /* [0..num_blocks-1][0..num_class-1] */ int max_pins_per_clb; clock_t begin, end; Fc_clipped = FALSE; max_pins_per_clb = 0; for (i = 0; i < num_types; i++) { if (type_descriptors[i].num_pins > max_pins_per_clb) { max_pins_per_clb = type_descriptors[i].num_pins; } } if (placer_opts.place_freq == PLACE_NEVER) { /* Read the placement from a file */ read_place(place_file, net_file, arch_file, nx, ny, num_blocks, block); sync_grid_to_blocks(num_blocks, block, nx, ny, grid); } else { assert( (PLACE_ONCE == placer_opts.place_freq) || (PLACE_ALWAYS == placer_opts.place_freq)); begin = clock(); try_place(placer_opts, annealing_sched, chan_width_dist, router_opts, det_routing_arch, segment_inf, timing_inf, directs, num_directs); print_place(place_file, net_file, arch_file); end = clock(); #ifdef CLOCKS_PER_SEC vpr_printf(TIO_MESSAGE_INFO, "Placement took %g seconds.\n", (float)(end - begin) / CLOCKS_PER_SEC); #else vpr_printf(TIO_MESSAGE_INFO, "Placement took %g seconds.\n", (float)(end - begin) / CLK_PER_SEC); #endif } begin = clock(); post_place_sync(num_blocks, block); fflush(stdout); if (!router_opts.doRouting) return; width_fac = router_opts.fixed_channel_width; /* If channel width not fixed, use binary search to find min W */ if (NO_FIXED_CHANNEL_WIDTH == width_fac) { g_solution_inf.channel_width = binary_search_place_and_route(placer_opts, place_file, net_file, arch_file, route_file, router_opts.full_stats, router_opts.verify_binary_search, annealing_sched, router_opts, det_routing_arch, segment_inf, timing_inf, chan_width_dist, models, directs, num_directs); } else { g_solution_inf.channel_width = width_fac; if (det_routing_arch.directionality == UNI_DIRECTIONAL) { if (width_fac % 2 != 0) { vpr_printf(TIO_MESSAGE_ERROR, "in pack_place_and_route.c: Given odd chan width (%d) for udsd architecture.\n", width_fac); exit(1); } } /* Other constraints can be left to rr_graph to check since this is one pass routing */ /* Allocate the major routing structures. */ clb_opins_used_locally = alloc_route_structs(); slacks = alloc_and_load_timing_graph(timing_inf); net_delay = alloc_net_delay(&net_delay_ch, clb_net, num_nets); success = try_route(width_fac, router_opts, det_routing_arch, segment_inf, timing_inf, net_delay, slacks, chan_width_dist, clb_opins_used_locally, &Fc_clipped, directs, num_directs); if (Fc_clipped) { vpr_printf(TIO_MESSAGE_WARNING, "Fc_output was too high and was clipped to full (maximum) connectivity.\n"); } if (success == FALSE) { vpr_printf(TIO_MESSAGE_INFO, "Circuit is unrouteable with a channel width factor of %d.\n", width_fac); vpr_printf(TIO_MESSAGE_INFO, "\n"); sprintf(msg, "Routing failed with a channel width factor of %d. ILLEGAL routing shown.", width_fac); } else { check_route(router_opts.route_type, det_routing_arch.num_switch, clb_opins_used_locally); get_serial_num(); vpr_printf(TIO_MESSAGE_INFO, "Circuit successfully routed with a channel width factor of %d.\n", width_fac); vpr_printf(TIO_MESSAGE_INFO, "\n"); routing_stats(router_opts.full_stats, router_opts.route_type, det_routing_arch.num_switch, segment_inf, det_routing_arch.num_segment, det_routing_arch.R_minW_nmos, det_routing_arch.R_minW_pmos, det_routing_arch.directionality, timing_inf.timing_analysis_enabled, net_delay, slacks); print_route(route_file); if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_ROUTING_SINK_DELAYS)) { print_sink_delays(getEchoFileName(E_ECHO_ROUTING_SINK_DELAYS)); } sprintf(msg, "Routing succeeded with a channel width factor of %d.\n\n", width_fac); } init_draw_coords(max_pins_per_clb); update_screen(MAJOR, msg, ROUTING, timing_inf.timing_analysis_enabled); if (timing_inf.timing_analysis_enabled) { assert(slacks->slack); if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_POST_FLOW_TIMING_GRAPH)) { print_timing_graph_as_blif (getEchoFileName(E_ECHO_POST_FLOW_TIMING_GRAPH), models); } free_timing_graph(slacks); assert(net_delay); free_net_delay(net_delay, &net_delay_ch); } fflush(stdout); } if (clb_opins_used_locally != NULL) { for (i = 0; i < num_blocks; i++) { free_ivec_vector(clb_opins_used_locally[i], 0, block[i].type->num_class - 1); } free(clb_opins_used_locally); clb_opins_used_locally = NULL; } if(GetPostSynthesisOption()) { verilog_writer(); } end = clock(); #ifdef CLOCKS_PER_SEC vpr_printf(TIO_MESSAGE_INFO, "Routing took %g seconds.\n", (float) (end - begin) / CLOCKS_PER_SEC); #else vpr_printf(TIO_MESSAGE_INFO, "Routing took %g seconds.\n", (float)(end - begin) / CLK_PER_SEC); #endif /*WMF: cleaning up memory usage */ /* if (g_heap_free_head) free(g_heap_free_head); if (g_trace_free_head) free(g_trace_free_head); if (g_linked_f_pointer_free_head) free(g_linked_f_pointer_free_head);*/ }