netloc: handle Scotch INTSIZE64

NETLOC_Num replaces int to handle integer that can have different sizes
depending on the compilation options.

Signed-off-by: Cyril Bordage <[email protected]>

Author: cbordage

include/private/netloc.h

@@ -2,7 +2,7 @@
  * Copyright © 2014 Cisco Systems, Inc.  All rights reserved.
  * Copyright © 2013-2014 University of Wisconsin-La Crosse.
  *                         All rights reserved.
- * Copyright © 2015-2016 Inria.  All rights reserved.
+ * Copyright © 2015-2017 Inria.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -19,9 +19,18 @@
 #include <netloc.h>
 #include <netloc/uthash.h>
 #include <netloc/utarray.h>
+#include <private/autogen/config.h>
 
 #define NETLOCFILE_VERSION 1
 
+#ifdef NETLOC_SCOTCH
+#include <stdint.h>
+#include <scotch.h>
+#define NETLOC_int SCOTCH_Num
+#else
+#define NETLOC_int int
+#endif
+
 /*
  * "Import" a few things from hwloc
  */
@@ -257,9 +266,9 @@ struct netloc_path_t {
  *        Architecture structures
  **********************************************************************/
 struct netloc_arch_tree_t {
-    int num_levels;
-    int *degrees;
-    int *cost;
+    NETLOC_int num_levels;
+    NETLOC_int *degrees;
+    NETLOC_int *cost;
 };
 
 struct netloc_arch_node_t {
@@ -272,7 +281,7 @@ struct netloc_arch_node_t {
     int *slot_os_idx; /* corresponding os index for each leaf in tree */
     netloc_arch_tree_t *slot_tree; /* Tree built from hwloc */
     int num_current_slots; /* Number of PUs */
-    int *current_slots; /* indices in the complete tree */
+    NETLOC_int *current_slots; /* indices in the complete tree */
     int *slot_ranks; /* corresponding MPI rank for each leaf in tree */
 };
 
@@ -291,8 +300,8 @@ struct netloc_arch_t {
     } arch;
     netloc_arch_node_t *nodes_by_name;
     netloc_arch_node_slot_t *node_slot_by_idx; /* node_slot by index in complete topo */
-    int num_current_hosts; /* if has_slots, host is a slot, else host is a node */
-    int *current_hosts; /* indices in the complete topology */
+    NETLOC_int num_current_hosts; /* if has_slots, host is a slot, else host is a node */
+    NETLOC_int *current_hosts; /* indices in the complete topology */
 };
 
 /**********************************************************************
@@ -489,7 +498,7 @@ int netloc_arch_node_get_hwloc_info(netloc_arch_node_t *arch);
 void netloc_arch_tree_complete(netloc_arch_tree_t *tree, UT_array **down_degrees_by_level,
         int num_hosts, int **parch_idx);
 
-int netloc_arch_tree_num_leaves(netloc_arch_tree_t *tree);
+NETLOC_int netloc_arch_tree_num_leaves(netloc_arch_tree_t *tree);
 
 
 /**********************************************************************

netloc/architecture.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2016 Inria.  All rights reserved.
+ * Copyright © 2016-2017 Inria.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -41,17 +41,17 @@ void netloc_arch_tree_complete(netloc_arch_tree_t *tree, UT_array **down_degrees
         int num_hosts, int **parch_idx)
 {
     int num_levels = tree->num_levels;
-    int *max_degrees = tree->degrees;
+    NETLOC_int *max_degrees = tree->degrees;
 
     /* Complete the tree by inserting nodes */
     for (int l = 0; l < num_levels-1; l++) { // from the root to the leaves
         int num_degrees = utarray_len(down_degrees_by_level[l]);
         int *degrees = (int *)down_degrees_by_level[l]->d;
-        int max_degree = max_degrees[l];
+        NETLOC_int max_degree = max_degrees[l];
 
         unsigned int down_level_idx = 0;
         UT_array *down_level_degrees = down_degrees_by_level[l+1];
-        int down_level_max_degree = max_degrees[l+1];
+        NETLOC_int down_level_max_degree = max_degrees[l+1];
         for (int d = 0; d < num_degrees; d++) {
             int degree = degrees[d];
             if (degree > 0) {
@@ -72,7 +72,7 @@ void netloc_arch_tree_complete(netloc_arch_tree_t *tree, UT_array **down_degrees
     /* Indices for the list of hosts, in the complete architecture */
     int num_degrees = utarray_len(down_degrees_by_level[num_levels-1]);
     int *degrees = (int *)down_degrees_by_level[num_levels-1]->d;
-    int max_degree = max_degrees[num_levels-1];
+    NETLOC_int max_degree = max_degrees[num_levels-1];
     int ghost_idx = 0;
     int idx = 0;
     netloc_arch_node_t *named_nodes = NULL;
@@ -95,9 +95,9 @@ void netloc_arch_tree_complete(netloc_arch_tree_t *tree, UT_array **down_degrees
     *parch_idx = arch_idx;
 }
 
-int netloc_arch_tree_num_leaves(netloc_arch_tree_t *tree)
+NETLOC_int netloc_arch_tree_num_leaves(netloc_arch_tree_t *tree)
 {
-    int num_leaves = 1;
+    NETLOC_int num_leaves = 1;
     for (int l = 0; l < tree->num_levels; l++) {
         num_leaves *= tree->degrees[l];
     }
@@ -210,10 +210,10 @@ int netloc_arch_set_current_resources(netloc_arch_t *arch)
     if (ret != NETLOC_SUCCESS || num_nodes <= 0)
         assert(0); // XXX
 
-    int *current_nodes = NULL;
+    NETLOC_int *current_nodes = NULL;
 
     if (!arch->has_slots) {
-        current_nodes = (int *) malloc(sizeof(int[num_nodes]));
+        current_nodes = (NETLOC_int *) malloc(sizeof(NETLOC_int[num_nodes]));
     }
 
     netloc_arch_node_t **arch_node_list = (netloc_arch_node_t **)
@@ -267,9 +267,9 @@ int netloc_arch_set_current_resources(netloc_arch_t *arch)
             }
         }
 
-        node->current_slots = (int *)
-            malloc(sizeof(int[num_slots]));
-        int num_leaves = netloc_arch_tree_num_leaves(node->slot_tree);
+        node->current_slots = (NETLOC_int *)
+            malloc(sizeof(NETLOC_int[num_slots]));
+        NETLOC_int num_leaves = netloc_arch_tree_num_leaves(node->slot_tree);
         node->slot_ranks = (int *)
             malloc(sizeof(int[num_leaves]));
 
@@ -286,7 +286,7 @@ int netloc_arch_set_current_resources(netloc_arch_t *arch)
         arch->arch.global_tree = arch->arch.node_tree;
 
         /* Build nodes_by_idx */
-        int tree_size = netloc_arch_tree_num_leaves(arch->arch.node_tree);
+        NETLOC_int tree_size = netloc_arch_tree_num_leaves(arch->arch.node_tree);
         netloc_arch_node_slot_t *nodes_by_idx = (netloc_arch_node_slot_t *)
             malloc(sizeof(netloc_arch_node_slot_t[tree_size]));
         for (int n = 0; n < num_nodes; n++) {
@@ -299,7 +299,8 @@ int netloc_arch_set_current_resources(netloc_arch_t *arch)
 
     } else {
         int num_hosts = slot_idx[num_nodes];
-        int *current_hosts = (int *)malloc(sizeof(int[num_hosts]));
+        NETLOC_int *current_hosts = (NETLOC_int *)
+            malloc(sizeof(NETLOC_int[num_hosts]));
         /* Add the slot trees to the node tree */
 
         /* Check that each slot tree has the same size */
@@ -363,12 +364,12 @@ int netloc_arch_set_current_resources(netloc_arch_t *arch)
 int netloc_arch_set_global_resources(netloc_arch_t *arch)
 {
     int ret;
-    int *current_nodes = NULL;
+    NETLOC_int *current_nodes = NULL;
     int *slot_idx = NULL;
 
     int num_nodes =  HASH_COUNT(arch->nodes_by_name);
     if (!arch->has_slots) {
-        current_nodes = (int *) malloc(sizeof(int[num_nodes]));
+        current_nodes = (NETLOC_int *) malloc(sizeof(NETLOC_int[num_nodes]));
     }
 
     ret = netloc_topology_read_hwloc(arch->topology, 0, NULL);
@@ -431,7 +432,8 @@ int netloc_arch_set_global_resources(netloc_arch_t *arch)
 
     } else {
         int num_hosts = slot_idx[num_nodes];
-        int *current_hosts = (int *)malloc(sizeof(int[num_hosts]));
+        NETLOC_int *current_hosts = (NETLOC_int *)
+            malloc(sizeof(NETLOC_int[num_hosts]));
         netloc_arch_node_t *node, *node_tmp;
         /* Add the slot trees to the node tree */
 
@@ -492,18 +494,20 @@ netloc_arch_tree_t *tree_merge(netloc_arch_tree_t *main, netloc_arch_tree_t *sub
 
     int num_levels = main->num_levels+sub->num_levels;
     new_tree->num_levels = num_levels;
-    new_tree->degrees = (int *)malloc(sizeof(int[num_levels]));
-    new_tree->cost = (int *)malloc(sizeof(int[num_levels]));
+    new_tree->degrees = (NETLOC_int *)malloc(sizeof(NETLOC_int[num_levels]));
+    new_tree->cost = (NETLOC_int *)malloc(sizeof(NETLOC_int[num_levels]));
 
-    memcpy(new_tree->degrees, main->degrees, main->num_levels*sizeof(int));
+    memcpy(new_tree->degrees, main->degrees,
+            main->num_levels*sizeof(*new_tree->degrees));
     memcpy(new_tree->degrees+main->num_levels, sub->degrees,
-            sub->num_levels*sizeof(int));
+            sub->num_levels*sizeof(*new_tree->degrees));
 
     int out_coeff = 10;
     for (int l = 0; l < main->num_levels; l++) {
         new_tree->cost[l] = main->cost[l]*sub->cost[0]*out_coeff;
     }
-    memcpy(new_tree->cost+main->num_levels, sub->cost, sub->num_levels*sizeof(int));
+    memcpy(new_tree->cost+main->num_levels, sub->cost,
+            sub->num_levels*sizeof(*new_tree->cost));
 
     return new_tree;
 }
@@ -607,15 +611,16 @@ int partition_topology_to_tleaf(netloc_topology_t *topology,
      * structure */
     UT_array *ordered_name_array = NULL;
     UT_array **down_degrees_by_level = NULL;
-    int *max_down_degrees_by_level;
+    NETLOC_int *max_down_degrees_by_level;
 
     utarray_new(ordered_name_array, &ut_ptr_icd);
 
     down_degrees_by_level = (UT_array **)malloc(num_levels*sizeof(UT_array *));
     for (int l = 0; l < num_levels; l++) {
         utarray_new(down_degrees_by_level[l], &ut_int_icd);
     }
-    max_down_degrees_by_level = (int *)calloc(num_levels-1, sizeof(int));
+    max_down_degrees_by_level = (NETLOC_int *)
+        calloc(num_levels-1, sizeof(NETLOC_int));
 
     UT_array *down_edges = NULL;
     utarray_new(down_edges, &ut_ptr_icd);
@@ -662,7 +667,7 @@ int partition_topology_to_tleaf(netloc_topology_t *topology,
                     continue;
                 netloc_analysis_data *edge_data = (netloc_analysis_data *)edge->userdata;
                 int edge_level = edge_data->level;
-                
+
                 netloc_node_t *dest_node = edge->dest;
 
                 /* If the is the node where we are from */
@@ -695,7 +700,7 @@ int partition_topology_to_tleaf(netloc_topology_t *topology,
     tree->degrees = max_down_degrees_by_level;
 
     int network_coeff = 2;
-    tree->cost = (int *)malloc(sizeof(int[tree->num_levels]));
+    tree->cost = (NETLOC_int *)malloc(sizeof(NETLOC_int[tree->num_levels]));
     tree->cost[tree->num_levels-1] = 1;
     for (int i = tree->num_levels-2; i >= 0 ; i--) {
         tree->cost[i] = tree->cost[i+1]*network_coeff;
@@ -790,9 +795,7 @@ int netloc_arch_build(netloc_arch_t *arch, int add_slots)
     }
     topopath = strdup(topopath);
 
-    netloc_topology_t *topology = NULL;
-
-    topology = netloc_topology_construct(topopath);
+    netloc_topology_t *topology = netloc_topology_construct(topopath);
     if (topology == NULL) {
         fprintf(stderr, "Error: netloc_topology_construct failed\n");
         return NETLOC_ERROR;

netloc/hwloc.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2016 Inria.  All rights reserved.
+ * Copyright © 2016-2017 Inria.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -193,13 +193,14 @@ int netloc_arch_node_get_hwloc_info(netloc_arch_node_t *arch_node)
     hwloc_obj_t first_object = root->first_child;
 
     UT_array **down_degrees_by_level;
-    int *max_down_degrees_by_level;
+    NETLOC_int *max_down_degrees_by_level;
 
     down_degrees_by_level = (UT_array **)malloc(depth*sizeof(UT_array *));
     for (int l = 0; l < depth; l++) {
         utarray_new(down_degrees_by_level[l], &ut_int_icd);
     }
-    max_down_degrees_by_level = (int *)calloc(depth-1, sizeof(int));
+    max_down_degrees_by_level = (NETLOC_int *)
+        calloc(depth-1, sizeof(NETLOC_int));
 
     int level = depth-1;
     hwloc_obj_t current_object = first_object;
@@ -242,7 +243,7 @@ int netloc_arch_node_get_hwloc_info(netloc_arch_node_t *arch_node)
     ordered_hosts = (int *)ordered_host_array->d;;
 
     /* Weight for the edges in the tree */
-    int *cost = (int *)malloc((depth-1)*sizeof(int));
+    NETLOC_int *cost = (NETLOC_int *)malloc((depth-1)*sizeof(NETLOC_int));
     int level_coeff = 3;
     cost[depth-2] = 1;
     for (int l = depth-3; l >= 0; l--) {

netloc/scotch.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2016 Inria.  All rights reserved.
+ * Copyright © 2016-2017 Inria.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -32,7 +32,7 @@ static int compareint(void const *a, void const *b)
    return *int_a-*int_b;
 }
 
-static int build_subarch(SCOTCH_Arch *scotch, int num_nodes, int *node_list,
+static int build_subarch(SCOTCH_Arch *scotch, NETLOC_int num_nodes, NETLOC_int *node_list,
         SCOTCH_Arch *subarch)
 {
     int ret;
@@ -237,7 +237,7 @@ int netlocscotch_get_mapping_from_graph(SCOTCH_Graph *graph,
         return ret;
     }
 
-    int graph_size;
+    NETLOC_int graph_size;
     SCOTCH_graphSize(graph, &graph_size, NULL);
 
     int num_hosts = arch->num_current_hosts;
@@ -249,7 +249,7 @@ int netlocscotch_get_mapping_from_graph(SCOTCH_Graph *graph,
     SCOTCH_stratGraphMapBuild(&strategy, SCOTCH_STRATQUALITY, graph_size, 0.01);
 
     /* The ranks are the indices of the nodes in the complete graph */
-    int *ranks = (int *)malloc(graph_size*sizeof(int));
+    NETLOC_int *ranks = (NETLOC_int *)malloc(graph_size*sizeof(NETLOC_int));
     ret = SCOTCH_graphMap(graph, &scotch_subarch, &strategy, ranks);
 
     SCOTCH_stratExit(&strategy);
@@ -289,7 +289,7 @@ int netlocscotch_get_mapping_from_graph(SCOTCH_Graph *graph,
             netloc_arch_node_t *node =
                 arch->node_slot_by_idx[arch->current_hosts[n]].node;
             char *nodename = node->name;
-            int node_ranks[num_processes];
+            NETLOC_int node_ranks[num_processes];
 
             /* We need to extract the subgraph with only the vertices mapped to the
              * current node */

tests/netloc/data/scotch/scotch_get_arch.c

@@ -1,4 +1,5 @@
 #include <stdio.h> // for scotch
+#include <stdint.h>
 #include <scotch.h>
 #include <netloc.h>
 #include <netlocscotch.h>