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);*/
}
