Merge pull request #8593 from awlauria/fix_shadowing

Fix shadowing in ompi

Author: awlauria

config/opal_setup_cc.m4

@@ -296,6 +296,7 @@ AC_DEFUN([OPAL_SETUP_CC],[
         _OPAL_CHECK_SPECIFIC_CFLAGS(-Wmissing-prototypes, Wmissing_prototypes)
         _OPAL_CHECK_SPECIFIC_CFLAGS(-Wstrict-prototypes, Wstrict_prototypes)
         _OPAL_CHECK_SPECIFIC_CFLAGS(-Wcomment, Wcomment)
+        _OPAL_CHECK_SPECIFIC_CFLAGS(-Wshadow, Wshadow)
         _OPAL_CHECK_SPECIFIC_CFLAGS(-Werror-implicit-function-declaration, Werror_implicit_function_declaration)
         _OPAL_CHECK_SPECIFIC_CFLAGS(-Wno-long-double, Wno_long_double, int main() { long double x; })
         _OPAL_CHECK_SPECIFIC_CFLAGS(-fno-strict-aliasing, fno_strict_aliasing, int main() { long double x; })

ompi/communicator/ft/comm_ft_detector.c

@@ -418,8 +418,7 @@ static int fd_heartbeat_request_cb(ompi_communicator_t* comm, ompi_comm_heartbea
     detector->hb_sstamp = 0.;
 
     if( comm_detector_use_rdma_hb ) {
-        ompi_communicator_t* comm = detector->comm;
-        ompi_proc_t* proc = ompi_comm_peer_lookup(comm, msg->from);
+        ompi_proc_t* proc = ompi_comm_peer_lookup(detector->comm, msg->from);
         assert( NULL != proc );
         mca_bml_base_endpoint_t* endpoint = mca_bml_base_get_endpoint(proc);
         assert( NULL != endpoint );
@@ -460,7 +459,7 @@ static int fd_heartbeat_request_cb(ompi_communicator_t* comm, ompi_comm_heartbea
 
 static void fd_event_cb(int fd, short flags, void* pdetector)
 {
-    comm_detector_t* detector = pdetector;;
+    comm_detector_t* detector = pdetector;
     double stamp = PMPI_Wtime();
     double lastpeek = detector->hb_lastpeek;
     detector->hb_lastpeek = stamp;

ompi/datatype/ompi_datatype_args.c

@@ -71,57 +71,45 @@ typedef struct __dt_args {
 #define OMPI_DATATYPE_ALIGN_PTR(PTR, TYPE)
 #endif  /* OPAL_ALIGN_WORD_SIZE_INTEGERS */
 
-/**
- * Some architectures require 64 bits pointers (to pointers) to
- * be 64 bits aligned. As in the ompi_datatype_args_t structure we have
- * 2 such array of pointers and one to an array of ints, if we start by
- * setting the 64 bits aligned one we will not have any trouble. Problem
- * originally reported on SPARC 64.
- */
-#define ALLOC_ARGS(PDATA, IC, AC, DC)                                   \
-    do {                                                                \
-        int length = sizeof(ompi_datatype_args_t) + (IC) * sizeof(int) + \
-            (AC) * sizeof(ptrdiff_t) + (DC) * sizeof(MPI_Datatype); \
-        char* buf = (char*)malloc( length );                            \
-        ompi_datatype_args_t* pArgs = (ompi_datatype_args_t*)buf;       \
-        pArgs->ci = (IC);                                               \
-        pArgs->ca = (AC);                                               \
-        pArgs->cd = (DC);                                               \
-        buf += sizeof(ompi_datatype_args_t);                            \
-        if( pArgs->ca == 0 ) pArgs->a = NULL;                           \
-        else {                                                          \
-            pArgs->a = (ptrdiff_t*)buf;                         \
-            buf += pArgs->ca * sizeof(ptrdiff_t);               \
-        }                                                               \
-        if( pArgs->cd == 0 ) pArgs->d = NULL;                           \
-        else {                                                          \
-            pArgs->d = (ompi_datatype_t**)buf;                          \
-            buf += pArgs->cd * sizeof(MPI_Datatype);                    \
-        }                                                               \
-        if( pArgs->ci == 0 ) pArgs->i = NULL;                           \
-        else pArgs->i = (int*)buf;                                      \
-        pArgs->ref_count = 1;                                           \
-        pArgs->total_pack_size = (4 + (IC) + (DC)) * sizeof(int) +      \
-            (AC) * sizeof(ptrdiff_t);                                   \
-        (PDATA)->args = (void*)pArgs;                                   \
-        (PDATA)->packed_description = 0;                                \
-    } while(0)
-
-
 int32_t ompi_datatype_set_args( ompi_datatype_t* pData,
                                 int32_t ci, const int32_t** i,
                                 int32_t ca, const ptrdiff_t* a,
                                 int32_t cd, ompi_datatype_t* const * d, int32_t type)
 {
     int pos;
-    ompi_datatype_args_t* pArgs;
 
     assert( NULL == pData->args );
-    ALLOC_ARGS( pData, ci, ca, cd );
-
-    pArgs = (ompi_datatype_args_t*)pData->args;
+    int length = sizeof(ompi_datatype_args_t) + ci * sizeof(int) +
+                 ca * sizeof(ptrdiff_t) + cd * sizeof(MPI_Datatype);
+    char* buf = (char*)malloc( length );
+    ompi_datatype_args_t* pArgs = (ompi_datatype_args_t*)buf;
+    pArgs->ci = ci; pArgs->i = NULL;
+    pArgs->ca = ca; pArgs->a = NULL;
+    pArgs->cd = cd; pArgs->d = NULL;
     pArgs->create_type = type;
 
+    /**
+     * Some architectures require 64 bits pointers (to pointers) to
+     * be 64 bits aligned. As in the ompi_datatype_args_t structure we have
+     * 2 such array of pointers and one to an array of ints, if we start by
+     * setting the 64 bits aligned one we will not have any trouble. Problem
+     * originally reported on SPARC 64.
+     */
+    buf += sizeof(ompi_datatype_args_t);
+    if( 0 != pArgs->ca ) {
+        pArgs->a = (ptrdiff_t*)buf;
+        buf += pArgs->ca * sizeof(ptrdiff_t);
+    }
+    if( 0 != pArgs->cd ) {
+        pArgs->d = (ompi_datatype_t**)buf;
+        buf += pArgs->cd * sizeof(MPI_Datatype);
+    }
+    if( 0 != pArgs->ci ) pArgs->i = (int*)buf;
+
+    pArgs->ref_count = 1;
+    pArgs->total_pack_size = (4 + ci) * sizeof(int) +
+                             cd * sizeof(MPI_Datatype) +
+                             ca * sizeof(ptrdiff_t);
     switch(type) {
 
     case MPI_COMBINER_DUP:
@@ -229,7 +217,7 @@ int32_t ompi_datatype_set_args( ompi_datatype_t* pData,
         pArgs->d[pos] = d[pos];
         if( !(ompi_datatype_is_predefined(d[pos])) ) {
             /* We handle a user defined datatype. We should make sure that the
-             * user will not have the oportunity to destroy it before all derived
+             * user will not have the opportunity to destroy it before all derived
              * datatypes are destroyed. As we keep pointers to every datatype
              * (for MPI_Type_get_content and MPI_Type_get_envelope) we have to make
              * sure that those datatype will be available if the user ask for them.
@@ -243,10 +231,12 @@ int32_t ompi_datatype_set_args( ompi_datatype_t* pData,
         pArgs->total_pack_size += sizeof(int);  /* each data has an ID */
     }
 
+    pData->args = (void*)pArgs;
+    pData->packed_description = 0;
+
     return OMPI_SUCCESS;
 }
 
-
 int32_t ompi_datatype_print_args( const ompi_datatype_t* pData )
 {
     int32_t i;

ompi/datatype/ompi_datatype_module.c

@@ -544,6 +544,9 @@ int32_t ompi_datatype_init( void )
 #define MOOG(name, index)                                               \
     do {                                                                \
         int rc;                                                         \
+         /* Silence 'unused' compiler warning in optimized builds,      \
+            where assert() is removed. */                               \
+        (void) rc;                                                      \
         ompi_mpi_##name.dt.d_f_to_c_index = index;                      \
         rc = opal_pointer_array_set_item(&ompi_datatype_f_to_c_table,   \
                                          index, &ompi_mpi_##name);      \

ompi/mca/coll/base/coll_base_alltoallv.c

@@ -63,8 +63,8 @@ mca_coll_base_alltoallv_intra_basic_inplace(const void *rbuf, const int *rcounts
         if (i == rank) {
             continue;
         }
-        size_t size = opal_datatype_span(&rdtype->super, rcounts[i], &gap);
-        max_size = size > max_size ? size : max_size;
+        size_t cur_size = opal_datatype_span(&rdtype->super, rcounts[i], &gap);
+        max_size = cur_size > max_size ? cur_size : max_size;
     }
     /* The gap will always be the same as we are working on the same datatype */
 

ompi/mca/coll/libnbc/nbc_internal.h

@@ -549,13 +549,13 @@ static inline int NBC_Unpack(void *src, int srccount, MPI_Datatype srctype, void
   return OMPI_SUCCESS;
 }
 
-/* deletes elements from dict until low watermark is reached */
-static inline void NBC_SchedCache_dictwipe(hb_tree *dict, int *size) {
+/* deletes elements from dict_in until low watermark is reached */
+static inline void NBC_SchedCache_dictwipe(hb_tree *dict_in, int *size) {
   hb_itor *itor;
 
-  itor = hb_itor_new(dict);
+  itor = hb_itor_new(dict_in);
   for (; hb_itor_valid(itor) && (*size>NBC_SCHED_DICT_LOWER); hb_itor_next(itor)) {
-    hb_tree_remove(dict, hb_itor_key(itor), 0);
+    hb_tree_remove(dict_in, hb_itor_key(itor), 0);
     *size = *size-1;
   }
   hb_itor_destroy(itor);

ompi/mca/coll/sm/coll_sm.h

@@ -38,9 +38,9 @@ BEGIN_C_DECLS
    great while.  Use a "goto" label for expdiency to exit loops. */
 #define SPIN_CONDITION_MAX 100000
 #define SPIN_CONDITION(cond, exit_label) \
-  do { int i; \
+  do { \
        if (cond) goto exit_label; \
-       for (i = 0; i < SPIN_CONDITION_MAX; ++i) { \
+       for (int spin_cond_i = 0; spin_cond_i < SPIN_CONDITION_MAX; ++spin_cond_i) { \
            if (cond) { goto exit_label; } \
        } \
        opal_progress(); \

ompi/mca/coll/sm/coll_sm_module.c

@@ -492,7 +492,6 @@ int ompi_coll_sm_lazy_enable(mca_coll_base_module_t *module,
 static int bootstrap_comm(ompi_communicator_t *comm,
                           mca_coll_sm_module_t *module)
 {
-    int i;
     char *shortpath, *fullpath;
     mca_coll_sm_component_t *c = &mca_coll_sm_component;
     mca_coll_sm_comm_t *data = module->sm_comm_data;
@@ -511,7 +510,7 @@ static int bootstrap_comm(ompi_communicator_t *comm,
        with the lowest ORTE name to form a unique filename. */
     proc = ompi_group_peer_lookup(comm->c_local_group, 0);
     lowest_name = OMPI_CAST_RTE_NAME(&proc->super.proc_name);
-    for (i = 1; i < comm_size; ++i) {
+    for (int i = 1; i < comm_size; ++i) {
         proc = ompi_group_peer_lookup(comm->c_local_group, i);
         if (ompi_rte_compare_name_fields(OMPI_RTE_CMP_ALL,
                                           OMPI_CAST_RTE_NAME(&proc->super.proc_name),

ompi/mca/osc/rdma/osc_rdma_component.c

@@ -916,7 +916,6 @@ static int ompi_osc_rdma_query_alternate_btls (ompi_communicator_t *comm, ompi_o
     mca_btl_base_selected_module_t *item;
     char **btls_to_use = opal_argv_split (ompi_osc_rdma_btl_alternate_names, ',');
     int btls_found = 0;
-    void *tmp;
 
     btls_to_use = opal_argv_split (ompi_osc_rdma_btl_alternate_names, ',');
     if (NULL == btls_to_use) {

ompi/mca/osc/rdma/osc_rdma_peer.c

@@ -79,7 +79,6 @@ int ompi_osc_rdma_new_peer (struct ompi_osc_rdma_module_t *module, int peer_id,
     struct mca_btl_base_endpoint_t *endpoint;
     ompi_osc_rdma_peer_t *peer;
     uint8_t module_btl_index = UINT8_MAX;
-    mca_btl_base_module_t *btl = NULL;
 
     *peer_out = NULL;
 
@@ -90,10 +89,6 @@ int ompi_osc_rdma_new_peer (struct ompi_osc_rdma_module_t *module, int peer_id,
         return ret;
     }
 
-    if (endpoint) {
-        btl = ompi_osc_rdma_selected_btl (module, module_btl_index);
-    }
-
     if (MPI_WIN_FLAVOR_DYNAMIC == module->flavor) {
         peer = (ompi_osc_rdma_peer_t *) OBJ_NEW(ompi_osc_rdma_peer_dynamic_t);
     } else if (module->same_size && module->same_disp_unit) {
@@ -127,7 +122,6 @@ static int ompi_osc_rdma_peer_setup (ompi_osc_rdma_module_t *module, ompi_osc_rd
     ompi_osc_rdma_peer_extended_t *ex_peer = (ompi_osc_rdma_peer_extended_t *) peer;
     uint64_t peer_data_size;
     uint64_t peer_data_offset, array_pointer;
-    mca_btl_base_module_t *array_btl;
     struct mca_btl_base_endpoint_t *array_endpoint;
     ompi_osc_rdma_region_t *array_peer_data, *node_peer_data;
     ompi_osc_rdma_rank_data_t rank_data;