void netloc_dc_pretty_print(netloc_data_collection_handle_t *handle) { int p; struct netloc_dt_lookup_table_iterator *hti = NULL; const char * key = NULL; netloc_edge_t **path = NULL; int path_len; struct netloc_dt_lookup_table_iterator *htin = NULL; netloc_node_t *cur_node = NULL; htin = netloc_dt_lookup_table_iterator_t_construct(handle->node_list); while( !netloc_lookup_table_iterator_at_end(htin) ) { cur_node = (netloc_node_t*)netloc_lookup_table_iterator_next_entry(htin); if( NULL == cur_node ) { break; } display_node(cur_node, strdup("")); printf("Physical Paths\n"); printf("--------------\n"); // Display all of the paths from this node to other nodes (if any) hti = netloc_dt_lookup_table_iterator_t_construct(cur_node->physical_paths); while( !netloc_lookup_table_iterator_at_end(hti) ) { key = netloc_lookup_table_iterator_next_key(hti); if( NULL == key ) { break; } path = (netloc_edge_t**)netloc_lookup_table_access(cur_node->physical_paths, key); path_len = 0; for(p = 0; NULL != path[p]; ++p) { ++path_len; } display_path(cur_node->physical_id, key, path_len, path, strdup("\t")); } printf("Logical Paths\n"); printf("--------------\n"); // Display all of the paths from this node to other nodes (if any) hti = netloc_dt_lookup_table_iterator_t_construct(cur_node->logical_paths); while( !netloc_lookup_table_iterator_at_end(hti) ) { key = netloc_lookup_table_iterator_next_key(hti); if( NULL == key ) { break; } path = (netloc_edge_t**)netloc_lookup_table_access(cur_node->logical_paths, key); path_len = 0; for(p = 0; NULL != path[p]; ++p) { ++path_len; } display_path(cur_node->physical_id, key, path_len, path, strdup("\t")); } } netloc_dt_lookup_table_iterator_t_destruct(htin); }
json_t* netloc_dt_lookup_table_t_json_encode(struct netloc_dt_lookup_table *table, json_t* (*func)(const char * key, void *value)) { json_t *json_lt = NULL; struct netloc_dt_lookup_table_iterator *hti = NULL; const char * key = NULL; void * value = NULL; json_lt = json_object(); hti = netloc_dt_lookup_table_iterator_t_construct(table); while( !netloc_lookup_table_iterator_at_end(hti) ) { key = netloc_lookup_table_iterator_next_key(hti); if( NULL == key ) { break; } value = netloc_lookup_table_access(table, key); json_object_set_new(json_lt, key, func(key, value)); } netloc_dt_lookup_table_iterator_t_destruct(hti); return json_lt; }
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; }
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; }
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; }
static int display_topo_screen(netloc_topology_t topology, netloc_network_t *network) { int ret, exit_status = NETLOC_SUCCESS; int i; netloc_dt_lookup_table_t hosts_nodes = NULL; netloc_dt_lookup_table_t switches_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; printf("Network: %s\n", netloc_pretty_print_network_t(network) ); printf(" Type : %s\n", netloc_decode_network_type_readable(network->network_type) ); printf(" Subnet : %s\n", network->subnet_id); /* * Get hosts and switches */ ret = netloc_get_all_host_nodes(topology, &hosts_nodes); if( NETLOC_SUCCESS != ret ) { exit_status = ret; goto cleanup; } printf(" Hosts : %d\n", netloc_lookup_table_size(hosts_nodes));; ret = netloc_get_all_switch_nodes(topology, &switches_nodes); if( NETLOC_SUCCESS != ret ) { exit_status = ret; goto cleanup; } printf(" Switches: %d\n", netloc_lookup_table_size(switches_nodes) ); printf("---------------------------------------------------\n"); if( full_output ) { /* * Print out a list of hosts and their connections */ printf("\n"); printf("Information by Host\n"); printf("---------------------\n"); hti = netloc_dt_lookup_table_iterator_t_construct( hosts_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(hosts_nodes, key); ret = netloc_get_all_edges(topology, node, &num_edges, &edges); if( NETLOC_SUCCESS != ret ) { exit_status = ret; goto cleanup; } for(i = 0; i < num_edges; ++i ) { display_netloc_edge_screen(edges[i]); } } /* * Print out a list of switches and their connections */ printf("\n"); printf("Information by Switch\n"); printf("---------------------\n"); hti = netloc_dt_lookup_table_iterator_t_construct( switches_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(switches_nodes, key); ret = netloc_get_all_edges(topology, node, &num_edges, &edges); if( NETLOC_SUCCESS != ret ) { exit_status = ret; goto cleanup; } for(i = 0; i < num_edges; ++i ) { display_netloc_edge_screen(edges[i]); } } printf("------------------------------------------------------------------------------\n"); } printf("\n"); cleanup: return exit_status; }
/************************************************************* * Support Functionality *************************************************************/ static int compute_shortest_path_dijkstra(netloc_data_collection_handle_t *handle, netloc_node_t *src_node, netloc_node_t *dest_node, int *num_edges, netloc_edge_t ***edges) { int exit_status = NETLOC_SUCCESS; int i; pq_queue_t *queue = NULL; int *distance = NULL; bool *not_seen = NULL; netloc_node_t *node_u = NULL; netloc_node_t *node_v = NULL; netloc_node_t **prev_node = NULL; netloc_edge_t **prev_edge = NULL; int alt; int idx_u, idx_v; int num_rev_edges; netloc_edge_t **rev_edges = NULL; struct netloc_dt_lookup_table_iterator *hti = NULL; netloc_node_t *cur_node = NULL; unsigned long key_int; // Just in case things go poorly below (*num_edges) = 0; (*edges) = NULL; /* * Allocate some data structures */ queue = pq_queue_t_construct(); if( NULL == queue ) { fprintf(stderr, "Error: Failed to allocate the queue\n"); exit_status = NETLOC_ERROR; goto cleanup; } distance = (int*)malloc(sizeof(int) * netloc_lookup_table_size(handle->node_list)); if( NULL == distance ) { fprintf(stderr, "Error: Failed to allocate the distance array\n"); exit_status = NETLOC_ERROR; goto cleanup; } not_seen = (bool*)malloc(sizeof(bool) * netloc_lookup_table_size(handle->node_list)); if( NULL == not_seen ) { fprintf(stderr, "Error: Failed to allocate the 'not_seen' array\n"); exit_status = NETLOC_ERROR; goto cleanup; } prev_node = (netloc_node_t**)malloc(sizeof(netloc_node_t*) * netloc_lookup_table_size(handle->node_list)); if( NULL == prev_node ) { fprintf(stderr, "Error: Failed to allocate the 'prev_node' array\n"); exit_status = NETLOC_ERROR; goto cleanup; } prev_edge = (netloc_edge_t**)malloc(sizeof(netloc_edge_t*) * netloc_lookup_table_size(handle->node_list)); if( NULL == prev_edge ) { fprintf(stderr, "Error: Failed to allocate the 'prev_edge' array\n"); exit_status = NETLOC_ERROR; goto cleanup; } /* * Initialize the data structures */ // Make sure to initialize the arrays for( i = 0; i < netloc_lookup_table_size(handle->node_list); ++i){ distance[i] = INT_MAX; not_seen[i] = true; prev_node[i] = NULL; prev_edge[i] = NULL; } i = 0; hti = netloc_dt_lookup_table_iterator_t_construct(handle->node_list); while( !netloc_lookup_table_iterator_at_end(hti) ) { cur_node = (netloc_node_t*)netloc_lookup_table_iterator_next_entry(hti); if( NULL == cur_node ) { break; } if( cur_node == src_node ) { pq_push(queue, 0, cur_node); distance[i] = 0; } else { pq_push(queue, INT_MAX, cur_node); distance[i] = INT_MAX; } not_seen[i] = true; prev_node[i] = NULL; prev_edge[i] = NULL; cur_node->__uid__ = i; ++i; } /* * Search */ while( !pq_is_empty(queue) ) { //pq_dump(queue); // Grab the next hop node_u = pq_pop(queue); // Mark as seen idx_u = -1; i = 0; idx_u = node_u->__uid__; not_seen[idx_u] = false; // For all the edges from this node for(i = 0; i < node_u->num_edges; ++i ) { node_v = NULL; idx_v = -1; // Lookup the "dest" node node_v = node_u->edges[i]->dest_node; idx_v = node_v->__uid__; // If the node has been seen, skip if( !not_seen[idx_v] ) { continue; } // Otherwise check to see if we found a shorter path // Future Work: Add a weight factor other than 1. // Maybe calculated based on speed/width alt = distance[idx_u] + 1; if( alt < distance[idx_v] ) { distance[idx_v] = alt; prev_node[idx_v] = node_u; prev_edge[idx_v] = node_u->edges[i]; // Adjust the priority queue as needed pq_reorder(queue, alt, node_v); } } } /* * Reconstruct the path by picking up the edges * The edges will be in reverse order (dest to source). */ num_rev_edges = 0; rev_edges = NULL; // Find last hop SUPPORT_CONVERT_ADDR_TO_INT(dest_node->physical_id, handle->network->network_type, key_int); node_u = netloc_lookup_table_access_with_int( handle->node_list, dest_node->physical_id, key_int); idx_u = node_u->__uid__; node_v = NULL; idx_v = -1; while( prev_node[idx_u] != NULL ) { // Find the linking edge if( node_u != dest_node) { for(i = 0; i < node_u->num_edges; ++i ) { if( node_v->physical_id_int == node_u->edges[i]->dest_node->physical_id_int ) { ++num_rev_edges; rev_edges = (netloc_edge_t**)realloc(rev_edges, sizeof(netloc_edge_t*) * num_rev_edges); if( NULL == rev_edges ) { fprintf(stderr, "Error: Failed to re-allocate the 'rev_edges' array with %d elements\n", num_rev_edges); exit_status = NETLOC_ERROR; goto cleanup; } rev_edges[num_rev_edges-1] = node_u->edges[i]; break; } } } node_v = node_u; idx_v = idx_u; // Find the next node SUPPORT_CONVERT_ADDR_TO_INT(prev_node[idx_u]->physical_id, handle->network->network_type, key_int); node_u = netloc_lookup_table_access_with_int( handle->node_list, prev_node[idx_u]->physical_id, key_int); idx_u = node_u->__uid__; } for(i = 0; i < src_node->num_edges; ++i ) { if( NULL == node_v ) { fprintf(stderr, "Error: This should never happen, but node_v is NULL at line %d in file %s\n", __LINE__, __FILE__); exit_status = NETLOC_ERROR; goto cleanup; } if( node_v->physical_id_int == src_node->edges[i]->dest_node->physical_id_int ) { ++num_rev_edges; rev_edges = (netloc_edge_t**)realloc(rev_edges, sizeof(netloc_edge_t*) * num_rev_edges); if( NULL == rev_edges ) { fprintf(stderr, "Error: Failed to re-allocate the 'rev_edges' array with %d elements\n", num_rev_edges); exit_status = NETLOC_ERROR; goto cleanup; } rev_edges[num_rev_edges-1] = node_u->edges[i]; break; } } /* * Copy the edges back in correct order */ (*num_edges) = num_rev_edges; (*edges) = (netloc_edge_t**)malloc(sizeof(netloc_edge_t*) * (*num_edges)); if( NULL == (*edges) ) { fprintf(stderr, "Error: Failed to allocate the edges array\n"); exit_status = NETLOC_ERROR; goto cleanup; } for( i = 0; i < num_rev_edges; ++i ) { (*edges)[i] = rev_edges[num_rev_edges-1-i]; //printf("DEBUG: \t Edge: %s\n", netloc_pretty_print_edge_t( (*edges)[i] ) ); } /* * Cleanup */ cleanup: if( NULL != queue ) { pq_queue_t_destruct(queue); queue = NULL; } if( NULL != rev_edges ) { free(rev_edges); rev_edges = NULL; } if( NULL != distance ) { free(distance); distance = NULL; } if( NULL != not_seen ) { free(not_seen); not_seen = NULL; } if( NULL != prev_node ) { free(prev_node); prev_node = NULL; } if( NULL != prev_edge ) { free(prev_edge); prev_edge = NULL; } netloc_dt_lookup_table_iterator_t_destruct(hti); return exit_status; }
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(int argc, char *argv[]) { netloc_map_t map; netloc_topology_t *ntopos; netloc_map_server_t *servers; char *datadir, *path; unsigned nr_ntopos, nr_servers, i, j; int verbose = 0; int err; argc--; argv++; if (argc >= 1) { if (!strcmp(argv[0], "--verbose")) { verbose = 1; argc--; argv++; } } if (argc < 1) { fprintf(stderr, "Missing data directory argument\n"); return -1; } datadir = argv[0]; argv++; argc--; err = netloc_map_create(&map); if (err) { fprintf(stderr, "Failed to create the map\n"); return -1; } asprintf(&path, "%s/hwloc", datadir); err = netloc_map_load_hwloc_data(map, path); if (err) { fprintf(stderr, "Failed to load hwloc data from %s\n", path); return -1; } free(path); asprintf(&path, "file://%s/netloc", datadir); err = netloc_map_load_netloc_data(map, path); if (err) { fprintf(stderr, "Failed to load netloc data from %s\n", path); return -1; } free(path); err = netloc_map_build(map, NETLOC_MAP_BUILD_FLAG_COMPRESS_HWLOC); if (err) { fprintf(stderr, "Failed to build map data\n"); return -1; } if (verbose) netloc_map_dump(map); err = netloc_map_get_subnets(map, &nr_ntopos, &ntopos); if (err) { fprintf(stderr, "Failed to get the number of subnets\n"); return -1; } for(i=0; i<nr_ntopos; i++) { netloc_topology_t ntopo = ntopos[i]; netloc_network_t *net = netloc_access_network_ref(ntopo); const char *type = netloc_decode_network_type(net->network_type); printf("Subnet type %s id %s\n", type, net->subnet_id); netloc_dt_lookup_table_t *nodes; err = netloc_get_all_host_nodes(ntopo, &nodes); if (err) continue; netloc_dt_lookup_table_iterator_t *iter = netloc_dt_lookup_table_iterator_t_construct(nodes); while( !netloc_lookup_table_iterator_at_end(iter) ) { const char *key; netloc_node_t *nnode; netloc_map_port_t port; netloc_map_server_t server; hwloc_topology_t htopo; hwloc_obj_t hobj; const char *servername; key = netloc_lookup_table_iterator_next_key(iter); if (NULL == key) break; nnode = (netloc_node_t*) netloc_lookup_table_access(nodes, key); if (NETLOC_NODE_TYPE_INVALID == nnode->node_type) continue; err = netloc_map_netloc2port(map, ntopo, nnode, NULL, &port); if (err < 0) continue; err = netloc_map_port2hwloc(port, &htopo, &hobj); if (err < 0) continue; err = netloc_map_port2server(port, &server); if (err < 0) continue; err = netloc_map_server2name(server, &servername); if (err < 0) continue; printf(" node %s connected through object %s address %s\n", servername, hobj->name, nnode->physical_id); netloc_map_put_hwloc(map, htopo); } netloc_dt_lookup_table_iterator_t_destruct(iter); netloc_lookup_table_destroy(nodes); free(nodes); } err = netloc_map_get_nbservers(map); if (err < 0) { fprintf(stderr, "Failed to get the number of servers\n"); return -1; } nr_servers = err; servers = malloc(nr_servers * sizeof(*servers)); if (!servers) { fprintf(stderr, "Failed to allocate servers array\n"); return -1; } err = netloc_map_get_servers(map, 0, nr_servers, servers); if (err < 0) { fprintf(stderr, "Failed to get servers\n"); return -1; } assert((unsigned) err == nr_servers); for(i=0; i<nr_servers; i++) { const char *servername = "unknown"; netloc_map_port_t *ports; unsigned ports_nr; err = netloc_map_server2name(servers[i], &servername); assert(!err); printf("Server %s\n", servername); err = netloc_map_get_server_ports(servers[i], &ports_nr, &ports); assert(!err); if (!ports) continue; for(j=0; j<ports_nr; j++) { netloc_topology_t ntopo; netloc_network_t *net; netloc_node_t *nnode; netloc_edge_t *nedge; hwloc_topology_t htopo; hwloc_obj_t hobj; err = netloc_map_port2netloc(ports[j], &ntopo, &nnode, &nedge); assert(!err); net = netloc_access_network_ref(ntopo); err = netloc_map_port2hwloc(ports[j], &htopo, &hobj); assert(!err); const char *type = netloc_decode_network_type(net->network_type); printf(" port %s of device %s (id %s)\n" " on subnet type %s id %s\n" " towards node %s port %s\n", nedge ? nedge->src_port_id : "<unknown>", hobj->name, nnode ? nnode->physical_id : "<none>", type, net->subnet_id, nedge ? nedge->dest_node_id : "<none>", nedge ? nedge->dest_port_id : "<unknown>"); netloc_map_put_hwloc(map, htopo); } } free(servers); free(ntopos); netloc_map_destroy(map); return 0; }
int netloc_dt_data_collection_handle_t_destruct(netloc_data_collection_handle_t *handle) { struct netloc_dt_lookup_table_iterator *hti = NULL; netloc_node_t *cur_node = NULL; netloc_edge_t *cur_edge = NULL; if( NULL != handle->network ) { netloc_dt_network_t_destruct(handle->network); handle->network = NULL; } handle->is_open = false; handle->is_read_only = false; if( NULL != handle->unique_id_str ) { free(handle->unique_id_str); handle->unique_id_str = NULL; } if( NULL != handle->data_uri ) { free(handle->data_uri); handle->data_uri = NULL; } if( NULL != handle->filename_nodes ) { free(handle->filename_nodes); handle->filename_nodes = NULL; } if( NULL != handle->filename_physical_paths ) { free(handle->filename_physical_paths); handle->filename_physical_paths = NULL; } if( NULL != handle->filename_logical_paths ) { free(handle->filename_logical_paths); handle->filename_logical_paths = NULL; } if( NULL != handle->node_list ) { // Make sure to free all of the nodes pointed to in the lookup table hti = netloc_dt_lookup_table_iterator_t_construct(handle->node_list); while( !netloc_lookup_table_iterator_at_end(hti) ) { cur_node = (netloc_node_t*)netloc_lookup_table_iterator_next_entry(hti); if( NULL == cur_node ) { break; } netloc_dt_node_t_destruct(cur_node); } netloc_dt_lookup_table_iterator_t_destruct(hti); netloc_lookup_table_destroy(handle->node_list); free(handle->node_list); handle->node_list = NULL; } if( NULL != handle->edges ) { // Make sure to free all of the edges pointed to in the lookup table hti = netloc_dt_lookup_table_iterator_t_construct(handle->edges); while( !netloc_lookup_table_iterator_at_end(hti) ) { cur_edge = (netloc_edge_t*)netloc_lookup_table_iterator_next_entry(hti); if( NULL == cur_edge ) { break; } netloc_dt_edge_t_destruct(cur_edge); } netloc_dt_lookup_table_iterator_t_destruct(hti); netloc_lookup_table_destroy(handle->edges); free(handle->edges); handle->edges = NULL; } if( NULL != handle->node_data ) { json_decref(handle->node_data); handle->node_data = NULL; // Implied decref of handle->node_data_acc } if( NULL != handle->path_data ) { json_decref(handle->path_data); handle->path_data = NULL; // Implied decref of handle->path_data_acc } free( handle ); return NETLOC_SUCCESS; }
int netloc_dc_close(netloc_data_collection_handle_t *handle) { int ret; /* * Sanity Checks */ if( NULL == handle ) { fprintf(stderr, "Error: Null handle provided\n"); return NETLOC_ERROR; } /* * If read only, then just close the fd */ if( handle->is_read_only ) { handle->is_open = false; return NETLOC_SUCCESS; } /******************** Node and Edge Data **************************/ json_object_set_new(handle->node_data, JSON_NODE_FILE_NODE_INFO, handle->node_data_acc); /* * Add the edge lookup table to the node data */ json_object_set_new(handle->node_data, JSON_NODE_FILE_EDGE_INFO, netloc_dt_lookup_table_t_json_encode(handle->edges, &dc_encode_edge)); //netloc_lookup_table_pretty_print(handle->edges); /* * If creating a new file, then write out the data (Node) */ ret = json_dump_file(handle->node_data, handle->filename_nodes, JSON_COMPACT); if( 0 != ret ) { fprintf(stderr, "Error: Failed to write out node JSON file!\n"); return NETLOC_ERROR; } json_decref(handle->node_data); handle->node_data = NULL; /******************** Physical Path Data **************************/ struct netloc_dt_lookup_table_iterator *hti = NULL; netloc_node_t *cur_node = NULL; /* * Add path entries to the JSON file (physical path) */ hti = netloc_dt_lookup_table_iterator_t_construct(handle->node_list); while( !netloc_lookup_table_iterator_at_end(hti) ) { cur_node = (netloc_node_t*)netloc_lookup_table_iterator_next_entry(hti); if( NULL == cur_node ) { break; } json_object_set_new(handle->phy_path_data_acc, cur_node->physical_id, netloc_dt_node_t_json_encode_paths(cur_node, cur_node->physical_paths)); } netloc_dt_lookup_table_iterator_t_destruct(hti); json_object_set_new(handle->phy_path_data, JSON_NODE_FILE_PATH_INFO, handle->phy_path_data_acc); /* * Write out path data */ ret = json_dump_file(handle->phy_path_data, handle->filename_physical_paths, JSON_COMPACT); if( 0 != ret ) { fprintf(stderr, "Error: Failed to write out physical path JSON file!\n"); return NETLOC_ERROR; } json_decref(handle->phy_path_data); handle->phy_path_data = NULL; /******************** Logical Path Data **************************/ /* * Add path entries to the JSON file (logical path) */ hti = netloc_dt_lookup_table_iterator_t_construct(handle->node_list); while( !netloc_lookup_table_iterator_at_end(hti) ) { cur_node = (netloc_node_t*)netloc_lookup_table_iterator_next_entry(hti); if( NULL == cur_node ) { break; } json_object_set_new(handle->path_data_acc, cur_node->physical_id, netloc_dt_node_t_json_encode_paths(cur_node, cur_node->logical_paths)); } netloc_dt_lookup_table_iterator_t_destruct(hti); json_object_set_new(handle->path_data, JSON_NODE_FILE_PATH_INFO, handle->path_data_acc); /* * Write out path data */ ret = json_dump_file(handle->path_data, handle->filename_logical_paths, JSON_COMPACT); if( 0 != ret ) { fprintf(stderr, "Error: Failed to write out logical path JSON file!\n"); return NETLOC_ERROR; } json_decref(handle->path_data); handle->path_data = NULL; /* * Mark file as closed */ handle->is_open = false; return NETLOC_SUCCESS; }
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; }