Пример #1
0
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;
}
Пример #2
0
/*************************************************************
 * 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"));
    }
}
Пример #3
0
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;
}
Пример #4
0
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");
}
Пример #5
0
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;
}
Пример #6
0
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;
}
Пример #7
0
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;
}
Пример #8
0
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;
}
Пример #9
0
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;
}
Пример #10
0
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;
}
Пример #11
0
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;
}