int test_all_edges(netloc_topology_t topology)
{
int ret;
netloc_dt_lookup_table_t nodes = NULL;
netloc_dt_lookup_table_iterator_t hti = NULL;
const char * key = NULL;
netloc_node_t *node = NULL;
int num_edges;
netloc_edge_t **edges = NULL;
ret = netloc_get_all_nodes(topology, &nodes);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: get_all_nodes returned %d\n", ret);
return ret;
}
/*
* For each node, get the edges from it
*/
hti = netloc_dt_lookup_table_iterator_t_construct( nodes );
while( !netloc_lookup_table_iterator_at_end(hti) ) {
key = netloc_lookup_table_iterator_next_key(hti);
if( NULL == key ) {
break;
}
node = (netloc_node_t*)netloc_lookup_table_access(nodes, key);
/*
* Get all of the edges
*/
ret = netloc_get_all_edges(topology, node, &num_edges, &edges);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: get_all_edges_by_id returned %d for node %s\n", ret, netloc_pretty_print_node_t(node));
return ret;
}
/*
* Verify the edges
*/
#if DEBUG == 1
printf("Found: %d edges for host %s\n", num_edges, netloc_pretty_print_node_t(node));
for(i = 0; i < num_edges; ++i ) {
printf("\tEdge: %s\n", netloc_pretty_print_edge_t(edges[i]));
}
#endif
}
/* Cleanup */
netloc_dt_lookup_table_iterator_t_destruct(hti);
netloc_lookup_table_destroy(nodes);
free(nodes);
return NETLOC_SUCCESS;
}
/*************************************************************
* Support Functionality
*************************************************************/
static void display_node(netloc_node_t *node, char * prefix)
{
int i;
printf("%s%s\n",
prefix,
netloc_pretty_print_node_t(node) );
for(i = 0; i < node->num_edges; ++i ) {
display_edge(node->edges[i], strdup("\t"));
}
}
int test_all_host_nodes(netloc_topology_t topology)
{
int ret;
netloc_dt_lookup_table_t hosts = NULL;
netloc_dt_lookup_table_iterator_t hti = NULL;
const char * key = NULL;
netloc_node_t *node = NULL;
ret = netloc_get_all_host_nodes(topology, &hosts);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: get_all_host_nodes returned %d\n", ret);
return ret;
}
/* Verify the data */
hti = netloc_dt_lookup_table_iterator_t_construct( hosts );
while( !netloc_lookup_table_iterator_at_end(hti) ) {
key = netloc_lookup_table_iterator_next_key(hti);
if( NULL == key ) {
break;
}
node = (netloc_node_t*)netloc_lookup_table_access(hosts, key);
if( NETLOC_NODE_TYPE_HOST != node->node_type ) {
fprintf(stderr, "Error: Returned unexpected node: %s\n", netloc_pretty_print_node_t(node));
return NETLOC_ERROR;
}
#if DEBUG == 1
printf("Found: %s\n", netloc_pretty_print_node_t(node));
#endif
}
/* Cleanup */
netloc_dt_lookup_table_iterator_t_destruct(hti);
netloc_lookup_table_destroy(hosts);
free(hosts);
return NETLOC_SUCCESS;
}
static void pq_dump(pq_queue_t *pq)
{
int i;
for(i = 0; i < pq->size; ++i) {
printf("Dump: %3d) ", i);
if( NULL == pq->data[i].data ) {
printf("NULL\n");
} else {
printf("%3d | %s\n",
pq->data[i].priority,
netloc_pretty_print_node_t((netloc_node_t*)pq->data[i].data));
}
}
printf("---------------------------------------\n");
}
int test_get_logical_path(netloc_topology_t topology)
{
int ret;
netloc_dt_lookup_table_t nodes = NULL;
netloc_dt_lookup_table_iterator_t hti_src = NULL;
netloc_dt_lookup_table_iterator_t hti_dest = NULL;
const char * src_key = NULL;
const char * dest_key = NULL;
netloc_node_t *src_node = NULL;
netloc_node_t *dest_node = NULL;
int num_edges;
netloc_edge_t **edges = NULL;
ret = netloc_get_all_host_nodes(topology, &nodes);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: get_all_host_nodes returned %d\n", ret);
return ret;
}
/*
* For each node, get the physical path for the node
*/
hti_src = netloc_dt_lookup_table_iterator_t_construct( nodes );
while( !netloc_lookup_table_iterator_at_end(hti_src) ) {
src_key = netloc_lookup_table_iterator_next_key(hti_src);
if( NULL == src_key ) {
break;
}
src_node = (netloc_node_t*)netloc_lookup_table_access(nodes, src_key);
/*
* From this source to all destinations
*/
hti_dest = netloc_dt_lookup_table_iterator_t_construct( nodes );
while( !netloc_lookup_table_iterator_at_end(hti_dest) ) {
dest_key = netloc_lookup_table_iterator_next_key(hti_dest);
if( NULL == dest_key ) {
break;
}
/*
* Skip self reference
*/
dest_node = (netloc_node_t*)netloc_lookup_table_access(nodes, dest_key);
if( NETLOC_CMP_SAME == netloc_dt_node_t_compare(src_node, dest_node) ) {
continue;
}
/*
* Get the logical path, if any
*/
ret = netloc_get_path(topology, src_node, dest_node, &num_edges, &edges, true);
if( NETLOC_ERROR_NOT_FOUND == ret ) {
fprintf(stderr, "Warning: No path information between these two nodes\n\tSrc node %s\n\tDest node %s\n",
netloc_pretty_print_node_t(src_node),
netloc_pretty_print_node_t(dest_node));
continue;
}
else if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: get_logical_path returned %d\nError: Src node %s\nError: Dest node %s\n",
ret,
netloc_pretty_print_node_t(src_node),
netloc_pretty_print_node_t(dest_node));
return ret;
}
/*
* Verify the edges
*/
#if DEBUG == 1
printf("Path Between: %d edges\n", num_edges);
printf("\tSrc : %s\n", netloc_pretty_print_node_t(src_node));
printf("\tDest: %s\n", netloc_pretty_print_node_t(dest_node));
for(i = 0; i < num_edges; ++i ) {
printf("\t\tEdge: %s\n", netloc_pretty_print_edge_t(edges[i]));
}
#endif
}
netloc_dt_lookup_table_iterator_t_destruct(hti_dest);
}
/* Cleanup */
netloc_dt_lookup_table_iterator_t_destruct(hti_src);
netloc_lookup_table_destroy(nodes);
free(nodes);
return NETLOC_SUCCESS;
}
int main(void) {
int i, num_uris = 1;
char **search_uris = NULL;
int ret, exit_status = NETLOC_SUCCESS;
int num_all_networks = 0;
netloc_network_t **all_networks = NULL;
netloc_topology_t topology;
netloc_dt_lookup_table_t nodes = NULL;
netloc_dt_lookup_table_iterator_t hti = NULL;
netloc_node_t *node = NULL;
/*
* Where to search for network topology information.
* Information generated from a netloc reader.
*/
search_uris = (char**)malloc(sizeof(char*) * num_uris );
if( NULL == search_uris ) {
return NETLOC_ERROR;
}
search_uris[0] = strdup("file://data/netloc");
/*
* Find all of the networks in the specified serach URI locations
*/
ret = netloc_foreach_network((const char * const *) search_uris,
num_uris,
NULL, // Callback function (NULL = include all networks)
NULL, // Callback function data
&num_all_networks,
&all_networks);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_foreach_network returned an error (%d)\n", ret);
exit_status = ret;
goto cleanup;
}
/*
* For each of those networks access the detailed topology
*/
for(i = 0; i < num_all_networks; ++i ) {
// Pretty print the network for debugging purposes
printf("\tIncluded Network: %s\n", netloc_pretty_print_network_t(all_networks[i]) );
/*
* Attach to the network
*/
ret = netloc_attach(&topology, *(all_networks[i]));
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_attach returned an error (%d)\n", ret);
return ret;
}
/*
* Access all of the nodes in the topology
*/
ret = netloc_get_all_nodes(topology, &nodes);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: get_all_nodes returned %d\n", ret);
return ret;
}
// Display all of the nodes found
hti = netloc_dt_lookup_table_iterator_t_construct( nodes );
while( !netloc_lookup_table_iterator_at_end(hti) ) {
node = netloc_lookup_table_iterator_next_entry(hti);
if( NULL == node ) {
break;
}
if( NETLOC_NODE_TYPE_INVALID == node->node_type ) {
fprintf(stderr, "Error: Returned unexpected node: %s\n", netloc_pretty_print_node_t(node));
return NETLOC_ERROR;
}
printf("Found: %s\n", netloc_pretty_print_node_t(node));
}
/* Cleanup the lookup table objects */
if( NULL != hti ) {
netloc_dt_lookup_table_iterator_t_destruct(hti);
hti = NULL;
}
if( NULL != nodes ) {
netloc_lookup_table_destroy(nodes);
free(nodes);
nodes = NULL;
}
/*
* Detach from the network
*/
ret = netloc_detach(topology);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_detach returned an error (%d)\n", ret);
return ret;
}
}
/*
* Cleanup
*/
cleanup:
if( NULL != hti ) {
netloc_dt_lookup_table_iterator_t_destruct(hti);
hti = NULL;
}
if( NULL != nodes ) {
netloc_lookup_table_destroy(nodes);
free(nodes);
nodes = NULL;
}
if( NULL != all_networks ) {
for(i = 0; i < num_all_networks; ++i ) {
netloc_dt_network_t_destruct(all_networks[i]);
all_networks[i] = NULL;
}
free(all_networks);
all_networks = NULL;
}
if( NULL != search_uris ) {
for(i = 0; i < num_uris; ++i) {
free(search_uris[i]);
search_uris[i] = NULL;
}
free(search_uris);
search_uris = NULL;
}
return NETLOC_SUCCESS;
}
int main(void) {
char **search_uris = NULL;
int num_uris = 1, ret;
netloc_network_t *tmp_network = NULL;
netloc_topology_t topology;
netloc_dt_lookup_table_t nodes = NULL;
netloc_dt_lookup_table_iterator_t hti = NULL;
const char * key = NULL;
netloc_node_t *node = NULL;
// Specify where to search for network data
search_uris = (char**)malloc(sizeof(char*) * num_uris );
search_uris[0] = strdup("file://data/netloc");
// Find a specific InfiniBand network
tmp_network = netloc_dt_network_t_construct();
tmp_network->network_type = NETLOC_NETWORK_TYPE_INFINIBAND;
tmp_network->subnet_id = strdup("fe80:0000:0000:0000");
// Search for the specific network
ret = netloc_find_network(search_uris[0], tmp_network);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: network not found!\n");
netloc_dt_network_t_destruct(tmp_network);
return NETLOC_ERROR;
}
printf("\tFound Network: %s\n", netloc_pretty_print_network_t(tmp_network));
// Attach to the network
ret = netloc_attach(&topology, *tmp_network);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_attach returned an error (%d)\n", ret);
return ret;
}
// Query the network topology
// Access all of the nodes in the topology
ret = netloc_get_all_nodes(topology, &nodes);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: get_all_nodes returned %d\n", ret);
return ret;
}
// Display all of the nodes found
hti = netloc_dt_lookup_table_iterator_t_construct( nodes );
while( !netloc_lookup_table_iterator_at_end(hti) ) {
// Access the data by key (could also access by entry in the example)
key = netloc_lookup_table_iterator_next_key(hti);
if( NULL == key ) {
break;
}
node = (netloc_node_t*)netloc_lookup_table_access(nodes, key);
if( NETLOC_NODE_TYPE_INVALID == node->node_type ) {
fprintf(stderr, "Error: Returned unexpected node: %s\n", netloc_pretty_print_node_t(node));
return NETLOC_ERROR;
}
printf("Found: %s\n", netloc_pretty_print_node_t(node));
}
/* Cleanup the lookup table objects */
if( NULL != hti ) {
netloc_dt_lookup_table_iterator_t_destruct(hti);
hti = NULL;
}
if( NULL != nodes ) {
netloc_lookup_table_destroy(nodes);
free(nodes);
nodes = NULL;
}
// Detach from the network
ret = netloc_detach(topology);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_detach returned an error (%d)\n", ret);
return ret;
}
/*
* Cleanup
*/
netloc_dt_network_t_destruct(tmp_network);
tmp_network = NULL;
return NETLOC_SUCCESS;
}
int main(void) {
int ret, exit_status = NETLOC_SUCCESS;
int i;
netloc_topology_t topology;
netloc_network_t *network = NULL;
char *search_uri = NULL;
netloc_dt_lookup_table_t *nodes = NULL;
netloc_dt_lookup_table_iterator_t *hti = NULL;
const char * key = NULL;
netloc_node_t *node = NULL;
int num_edges;
netloc_edge_t **edges = NULL;
/*
* Setup a Network connection
*/
network = netloc_dt_network_t_construct();
network->network_type = NETLOC_NETWORK_TYPE_ETHERNET;
network->subnet_id = strdup("unknown");
search_uri = strdup("file://data/");
ret = netloc_find_network(search_uri, network);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_find_network returned an error (%d)\n", ret);
return ret;
}
/*
* Attach to the topology context
*/
printf("Test attach: ");
fflush(NULL);
ret = netloc_attach(&topology, *network);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_attach returned an error (%d)\n", ret);
return ret;
}
printf("Success\n");
/*
* Get all the verticies
*/
ret = netloc_get_all_nodes(topology, &nodes);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: get_all_nodes returned %d\n", ret);
exit_status = ret;
goto cleanup;
}
/*
* Display the data
*/
hti = netloc_dt_lookup_table_iterator_t_construct( nodes );
while( !netloc_lookup_table_iterator_at_end(hti) ) {
key = netloc_lookup_table_iterator_next_key(hti);
if( NULL == key ) {
break;
}
node = (netloc_node_t*)netloc_lookup_table_access(nodes, key);
if( NETLOC_NODE_TYPE_INVALID == node->node_type ) {
fprintf(stderr, "Error: Returned unexpected node: %s\n", netloc_pretty_print_node_t(node));
return NETLOC_ERROR;
}
/*
* Get all of the edges
*/
ret = netloc_get_all_edges(topology, node, &num_edges, &edges);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: get_all_edges_by_id returned %d for node %s\n", ret, netloc_pretty_print_node_t(node));
return ret;
}
/*
* Verify the edges
*/
printf("Found: %d edges for host %s\n", num_edges, netloc_pretty_print_node_t(node));
for(i = 0; i < num_edges; ++i ) {
printf("\tEdge: %s\n", netloc_pretty_print_edge_t(edges[i]));
}
}
/* Cleanup */
netloc_dt_lookup_table_iterator_t_destruct(hti);
netloc_lookup_table_destroy(nodes);
free(nodes);
cleanup:
/*
* Cleanup
*/
ret = netloc_detach(topology);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_detach returned an error (%d)\n", ret);
return ret;
}
if( NULL != search_uri ) {
free(search_uri);
search_uri = NULL;
}
return exit_status;
}
int main(void) {
int ret, exit_status = NETLOC_SUCCESS;
int i;
netloc_topology_t topology;
netloc_network_t *network = NULL;
char *search_uri = NULL;
netloc_dt_lookup_table_t *nodes = NULL;
netloc_node_t *node = NULL;
int num_edges;
netloc_edge_t **edges = NULL;
netloc_node_t *src_node = NULL;
char * phy_id = NULL;
char * tmp_str = NULL;
phy_id = strdup("0002:c903:0002:a0eb");
/*
* Setup a Network connection
*/
network = netloc_dt_network_t_construct();
network->network_type = NETLOC_NETWORK_TYPE_INFINIBAND;
network->subnet_id = strdup("fe80:0000:0000:0000");
search_uri = strdup("file://data/");
ret = netloc_find_network(search_uri, network);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_find_network returned an error (%d)\n", ret);
return ret;
}
/*
* Attach to the topology context
*/
printf("Test attach: ");
fflush(NULL);
ret = netloc_attach(&topology, *network);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_attach returned an error (%d)\n", ret);
return ret;
}
netloc_dt_network_t_destruct(network);
network = NULL;
printf("Success\n");
/*
* Get all the verticies
*/
ret = netloc_get_all_nodes(topology, &nodes);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: get_all_nodes returned %d\n", ret);
exit_status = ret;
goto cleanup;
}
/*
* Get all of the edges
*/
src_node = netloc_get_node_by_physical_id(topology, phy_id);
if( NULL == src_node ) {
fprintf(stderr, "Error: Failed to in the node associated with the physical id %s\n", phy_id);
return NETLOC_ERROR;
}
ret = netloc_get_all_edges(topology, src_node, &num_edges, &edges);
if( NETLOC_SUCCESS != ret ) {
tmp_str = netloc_pretty_print_node_t(node);
fprintf(stderr, "Error: get_all_edges_by_id returned %d for node %s\n", ret, tmp_str);
free(tmp_str);
return ret;
}
/*
* Display the data
*/
tmp_str = netloc_pretty_print_node_t(src_node);
printf("Neighbors of %s\n", tmp_str);
free(tmp_str);
for(i = 0; i < num_edges; ++i ) {
node = netloc_get_node_by_physical_id(topology, edges[i]->dest_node_id);
printf("%s ( from port %3s to port %3s, type: %6s) has %3d directed edge(s)\n",
node->physical_id,
edges[i]->src_port_id,
edges[i]->dest_port_id,
(NETLOC_NODE_TYPE_SWITCH == node->node_type ? "switch" : "host"),
node->num_edges);
}
/* Cleanup */
netloc_lookup_table_destroy(nodes);
free(nodes);
cleanup:
/*
* Cleanup
*/
ret = netloc_detach(topology);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: netloc_detach returned an error (%d)\n", ret);
return ret;
}
if( NULL != phy_id ) {
free(phy_id);
phy_id = NULL;
}
if( NULL != search_uri ) {
free(search_uri);
search_uri = NULL;
}
return exit_status;
}
static int check_dat_files() {
int ret, exit_status = NETLOC_SUCCESS;
char * spec = NULL;
char * hosts_filename = NULL;
char * switches_filename = NULL;
char *search_uri = NULL;
netloc_topology_t topology;
netloc_dt_lookup_table_t nodes = NULL;
netloc_dt_lookup_table_iterator_t hti = NULL;
const char * key = NULL;
netloc_node_t *node = NULL;
int num_bad = 0;
netloc_network_t *network = NULL;
int total_num_edges = 0;
printf("Status: Validating the output...\n");
network = netloc_dt_network_t_construct();
network->network_type = NETLOC_NETWORK_TYPE_ETHERNET;
network->subnet_id = strdup(subnet);
asprintf(&search_uri, "file://%s/", outdir);
if( NETLOC_SUCCESS != (ret = netloc_find_network(search_uri, network)) ) {
fprintf(stderr, "Error: Cannot find the network data. (%d)\n", ret);
exit_status = ret;
goto cleanup;
}
/*
* Attach to Netloc
*/
if( NETLOC_SUCCESS != (ret = netloc_attach(&topology, *network)) ) {
fprintf(stderr, "Error: Cannot attach the topology\n");
exit_status = ret;
goto cleanup;
}
/*
* Check the 'hosts'
*/
ret = netloc_get_all_host_nodes(topology, &nodes);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: Cannot access the list of hosts!\n");
exit_status = ret;
goto cleanup;
}
printf("\tNumber of hosts : %4d\n", netloc_lookup_table_size(nodes) );
hti = netloc_dt_lookup_table_iterator_t_construct( nodes );
while( !netloc_lookup_table_iterator_at_end(hti) ) {
key = netloc_lookup_table_iterator_next_key(hti);
if( NULL == key ) {
break;
}
node = (netloc_node_t*)netloc_lookup_table_access(nodes, key);
if( NETLOC_NODE_TYPE_INVALID == node->node_type ) {
printf("Host Node: %s is invalid\n", netloc_pretty_print_node_t(node) );
num_bad++;
}
else {
total_num_edges += node->num_edges;
}
}
netloc_dt_lookup_table_iterator_t_destruct(hti);
netloc_lookup_table_destroy(nodes);
free(nodes);
/*
* Check 'switches'
*/
ret = netloc_get_all_switch_nodes(topology, &nodes);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: Cannot access the list of switches!\n");
exit_status = ret;
goto cleanup;
}
printf("\tNumber of switches: %4d\n", netloc_lookup_table_size(nodes) );
hti = netloc_dt_lookup_table_iterator_t_construct( nodes );
while( !netloc_lookup_table_iterator_at_end(hti) ) {
key = netloc_lookup_table_iterator_next_key(hti);
if( NULL == key ) {
break;
}
node = (netloc_node_t*)netloc_lookup_table_access(nodes, key);
if( NETLOC_NODE_TYPE_INVALID == node->node_type ) {
printf("Switch Node: %s is invalid\n", netloc_pretty_print_node_t(node) );
num_bad++;
}
else {
total_num_edges += node->num_edges;
}
}
netloc_dt_lookup_table_iterator_t_destruct(hti);
netloc_lookup_table_destroy(nodes);
free(nodes);
if( num_bad > 0 ) {
fprintf(stderr, "Error: Found %2d malformed nodes in the .dat files\n", num_bad);
exit_status = NETLOC_ERROR;
}
printf("\tNumber of edges : %4d\n", total_num_edges );
/*
* Cleanup
*/
if( NETLOC_SUCCESS != (ret = netloc_detach(topology)) ) {
fprintf(stderr, "Error: Failed to detach the topology\n");
exit_status = ret;
goto cleanup;
}
cleanup:
netloc_dt_network_t_destruct(network);
free(search_uri);
free(spec);
free(hosts_filename);
free(switches_filename);
return exit_status;
}
static int compute_physical_paths(netloc_data_collection_handle_t *dc_handle)
{
int ret;
int src_idx, dst_idx;
int num_edges = 0;
netloc_edge_t **edges = NULL;
netloc_dt_lookup_table_iterator_t hti_src = NULL;
netloc_dt_lookup_table_iterator_t hti_dst = NULL;
netloc_node_t *cur_src_node = NULL;
netloc_node_t *cur_dst_node = NULL;
printf("Status: Computing Physical Paths\n");
/*
* Calculate the path from all sources to all destinations
*/
src_idx = 0;
hti_src = netloc_dt_lookup_table_iterator_t_construct(dc_handle->node_list);
hti_dst = netloc_dt_lookup_table_iterator_t_construct(dc_handle->node_list);
netloc_lookup_table_iterator_reset(hti_src);
while( !netloc_lookup_table_iterator_at_end(hti_src) ) {
cur_src_node = (netloc_node_t*)netloc_lookup_table_iterator_next_entry(hti_src);
if( NULL == cur_src_node ) {
break;
}
// JJH: For now limit to just the "host" nodes
if( NETLOC_NODE_TYPE_HOST != cur_src_node->node_type ) {
src_idx++;
continue;
}
#if 0
printf("\tSource: %s\n", netloc_pretty_print_node_t(cur_src_node));
#endif
dst_idx = 0;
netloc_lookup_table_iterator_reset(hti_dst);
while( !netloc_lookup_table_iterator_at_end(hti_dst) ) {
cur_dst_node = (netloc_node_t*)netloc_lookup_table_iterator_next_entry(hti_dst);
if( NULL == cur_dst_node ) {
break;
}
// Skip path to self
if( src_idx == dst_idx ) {
dst_idx++;
continue;
}
// JJH: For now limit to just the "host" nodes
if( NETLOC_NODE_TYPE_HOST != cur_dst_node->node_type ) {
dst_idx++;
continue;
}
#if 0
printf("Computing a path between the following two nodes\n");
printf("\tSource: %s\n", netloc_pretty_print_node_t(cur_src_node));
printf("\tDestination: %s\n", netloc_pretty_print_node_t(cur_dst_node));
#endif
/*
* Calculate the path between these nodes
*/
ret = netloc_dc_compute_path_between_nodes(dc_handle,
cur_src_node,
cur_dst_node,
&num_edges,
&edges,
false);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: Failed to compute a path between the following two nodes\n");
fprintf(stderr, "Error: Source: %s\n", netloc_pretty_print_node_t(cur_src_node));
fprintf(stderr, "Error: Destination: %s\n", netloc_pretty_print_node_t(cur_dst_node));
return ret;
}
/*
* Store that path in the data collection
*/
ret = netloc_dc_append_path(dc_handle,
cur_src_node->physical_id,
cur_dst_node->physical_id,
num_edges,
edges,
false);
if( NETLOC_SUCCESS != ret ) {
fprintf(stderr, "Error: Could not append the physical path between the following two nodes\n");
fprintf(stderr, "Error: Source: %s\n", netloc_pretty_print_node_t(cur_src_node));
fprintf(stderr, "Error: Destination: %s\n", netloc_pretty_print_node_t(cur_dst_node));
return ret;
}
free(edges);
dst_idx++;
}
src_idx++;
}
netloc_dt_lookup_table_iterator_t_destruct(hti_src);
netloc_dt_lookup_table_iterator_t_destruct(hti_dst);
return NETLOC_SUCCESS;
}
