Nothing relevant. Only a set of castings to have a clean compile on

Windows. The cl.exe compiler is pretty good at complaining about
any kind of non explicit cast.

This commit was SVN r12207.

orte/dss/dss_load_unload.c

@@ -58,7 +58,7 @@ int orte_dss_unload(orte_buffer_t *buffer, void **payload,
     
     /* okay, we have something to provide - pass it back */
     *payload = buffer->base_ptr;
-    *bytes_used = buffer->bytes_used;
+    *bytes_used = (orte_std_cntr_t)buffer->bytes_used;
 
     /* dereference everything in buffer */
     buffer->base_ptr = NULL;

orte/dss/dss_pack.c

@@ -325,7 +325,7 @@ int orte_dss_pack_string(orte_buffer_t *buffer, void *src,
                 return ret;
             }
         } else {
-            len = strlen(ssrc[i]) + 1;
+            len = (orte_std_cntr_t)strlen(ssrc[i]) + 1;
             if (ORTE_SUCCESS != (ret = orte_dss_pack_std_cntr(buffer, &len, 1, ORTE_STD_CNTR))) {
                 ORTE_ERROR_LOG(ret);
                 return ret;

orte/mca/gpr/base/gpr_base_open.c

@@ -129,9 +129,9 @@ static void orte_gpr_notify_data_construct(orte_gpr_notify_data_t* ptr)
     ptr->id = ORTE_GPR_SUBSCRIPTION_ID_MAX;
     ptr->remove = false;
     ptr->cnt = 0;
-    orte_pointer_array_init(&(ptr->values), orte_gpr_array_block_size,
+    orte_pointer_array_init(&(ptr->values), (orte_std_cntr_t)orte_gpr_array_block_size,
-                            orte_gpr_array_max_size,
+                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                            orte_gpr_array_block_size);
+                            (orte_std_cntr_t)orte_gpr_array_block_size);
 
 }
 
@@ -244,9 +244,9 @@ static void orte_gpr_notify_message_construct(orte_gpr_notify_message_t* msg)
     msg->id = ORTE_GPR_TRIGGER_ID_MAX;
     msg->remove = false;
     msg->cnt = 0;
-    orte_pointer_array_init(&(msg->data), orte_gpr_array_block_size,
+    orte_pointer_array_init(&(msg->data), (orte_std_cntr_t)orte_gpr_array_block_size,
-                            orte_gpr_array_max_size,
+                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                            orte_gpr_array_block_size);
+                            (orte_std_cntr_t)orte_gpr_array_block_size);
 }
 
 /* destructor - used to free any resources held by instance */

orte/mca/gpr/proxy/gpr_proxy_component.c

@@ -262,9 +262,9 @@ orte_gpr_proxy_component_init(bool *allow_multi_user_threads, bool *have_hidden_
 
         /* initialize the subscription tracker */
         if (ORTE_SUCCESS != (ret = orte_pointer_array_init(&(orte_gpr_proxy_globals.subscriptions),
-                                orte_gpr_array_block_size,
+                                (orte_std_cntr_t)orte_gpr_array_block_size,
-                                orte_gpr_array_max_size,
+                                (orte_std_cntr_t)orte_gpr_array_max_size,
-                                orte_gpr_array_block_size))) {
+                                (orte_std_cntr_t)orte_gpr_array_block_size))) {
             ORTE_ERROR_LOG(ret);
             return NULL;
         }
@@ -272,9 +272,9 @@ orte_gpr_proxy_component_init(bool *allow_multi_user_threads, bool *have_hidden_
 
         /* initialize the trigger counter */
         if (ORTE_SUCCESS != (ret = orte_pointer_array_init(&(orte_gpr_proxy_globals.triggers),
-                                orte_gpr_array_block_size,
+                                (orte_std_cntr_t)orte_gpr_array_block_size,
-                                orte_gpr_array_max_size,
+                                (orte_std_cntr_t)orte_gpr_array_max_size,
-                                orte_gpr_array_block_size))) {
+                                (orte_std_cntr_t)orte_gpr_array_block_size))) {
             ORTE_ERROR_LOG(ret);
             return NULL;
         }

orte/mca/gpr/replica/api_layer/gpr_replica_segment_ops_api.c

@@ -54,8 +54,8 @@ int orte_gpr_replica_preallocate_segment(char *name, orte_std_cntr_t num_slots)
     }
 
     rc = orte_pointer_array_init(&(seg->containers), num_slots,
-                                            orte_gpr_array_max_size,
+                                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                                            orte_gpr_array_block_size);
+                                            (orte_std_cntr_t)orte_gpr_array_block_size);
 
      OPAL_THREAD_UNLOCK(&orte_gpr_replica_globals.mutex);
 

orte/mca/gpr/replica/functional_layer/gpr_replica_dump_fn.c

@@ -213,7 +213,7 @@ int orte_gpr_replica_dump_callbacks_fn(orte_buffer_t *buffer)
     sprintf(tmp_out, "\nDUMP OF GPR REGISTERED CALLBACKS\n");
     orte_gpr_replica_dump_load_string(buffer, &tmp_out);
 
-    if (0 >= (k= opal_list_get_size(&(orte_gpr_replica.callbacks)))) {
+    if (0 >= (k = (orte_std_cntr_t)opal_list_get_size(&(orte_gpr_replica.callbacks)))) {
         sprintf(tmp_out, "--- None registered at this time ---");
         orte_gpr_replica_dump_load_string(buffer, &tmp_out);
     } else {

orte/mca/gpr/replica/functional_layer/gpr_replica_put_get_fn.c

@@ -440,7 +440,7 @@ int orte_gpr_replica_get_fn(orte_gpr_addr_mode_t addr_mode,
         }
         (*values)[i]->addr_mode = addr_mode;
         (*values)[i]->segment = strdup(seg->name);
-        (*values)[i]->cnt = opal_list_get_size(gptr->ival_list);
+        (*values)[i]->cnt = (orte_std_cntr_t)opal_list_get_size(gptr->ival_list);
         cptr2 = gptr->cptr;
         (*values)[i]->num_tokens = cptr2->num_itags;
         (*values)[i]->tokens = (char **)malloc(cptr2->num_itags * sizeof(char*));
@@ -637,7 +637,7 @@ MOVEON:
         }
         (*values)[i]->addr_mode = addr_mode;
         (*values)[i]->segment = strdup(seg->name);
-        (*values)[i]->cnt = opal_list_get_size(gptr->ival_list);
+        (*values)[i]->cnt = (orte_std_cntr_t)opal_list_get_size(gptr->ival_list);
         cptr2 = gptr->cptr;
         (*values)[i]->num_tokens = cptr2->num_itags;
         (*values)[i]->tokens = (char **)malloc(cptr2->num_itags * sizeof(char*));

orte/mca/gpr/replica/gpr_replica_class_instances.h

@@ -84,14 +84,14 @@ static void orte_gpr_replica_segment_construct(orte_gpr_replica_segment_t* seg)
     seg->itag = ORTE_GPR_REPLICA_ITAG_MAX;
 
     seg->num_dict_entries = 0;
-    orte_pointer_array_init(&(seg->dict), orte_gpr_array_block_size,
+    orte_pointer_array_init(&(seg->dict), (orte_std_cntr_t)orte_gpr_array_block_size,
-                            orte_gpr_array_max_size,
+                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                            orte_gpr_array_block_size);
+                            (orte_std_cntr_t)orte_gpr_array_block_size);
 
     seg->num_containers = 0;
-    orte_pointer_array_init(&(seg->containers), orte_gpr_array_block_size,
+    orte_pointer_array_init(&(seg->containers), (orte_std_cntr_t)orte_gpr_array_block_size,
-                            orte_gpr_array_max_size,
+                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                            orte_gpr_array_block_size);
+                            (orte_std_cntr_t)orte_gpr_array_block_size);
 
 }
 
@@ -148,9 +148,9 @@ static void orte_gpr_replica_container_construct(orte_gpr_replica_container_t* r
     reg->itags = NULL;
     reg->num_itags = 0;
 
-    orte_pointer_array_init(&(reg->itagvals), orte_gpr_array_block_size,
+    orte_pointer_array_init(&(reg->itagvals), (orte_std_cntr_t)orte_gpr_array_block_size,
-                            orte_gpr_array_max_size,
+                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                            orte_gpr_array_block_size);
+                            (orte_std_cntr_t)orte_gpr_array_block_size);
     reg->num_itagvals = 0;
 
     OBJ_CONSTRUCT(&(reg->itaglist), orte_value_array_t);
@@ -306,14 +306,14 @@ static void orte_gpr_replica_subscription_construct(orte_gpr_replica_subscriptio
     sub->action = ORTE_GPR_REPLICA_NO_ACTION;
 
     sub->num_values = 0;
-    orte_pointer_array_init(&(sub->values), orte_gpr_array_block_size,
+    orte_pointer_array_init(&(sub->values), (orte_std_cntr_t)orte_gpr_array_block_size,
-                            orte_gpr_array_max_size,
+                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                            orte_gpr_array_block_size);
+                            (orte_std_cntr_t)orte_gpr_array_block_size);
 
     sub->num_requestors = 0;
-    orte_pointer_array_init(&(sub->requestors), orte_gpr_array_block_size,
+    orte_pointer_array_init(&(sub->requestors), (orte_std_cntr_t)orte_gpr_array_block_size,
-                            orte_gpr_array_max_size,
+                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                            orte_gpr_array_block_size);
+                            (orte_std_cntr_t)orte_gpr_array_block_size);
 }
 
 /* destructor - used to free any resources held by instance */
@@ -391,9 +391,9 @@ static void orte_gpr_replica_trigger_construct(orte_gpr_replica_trigger_t* trig)
     trig->idtag = ORTE_GPR_TRIGGER_ID_MAX;
 
     trig->num_attached = 0;
-    orte_pointer_array_init(&(trig->attached), orte_gpr_array_block_size,
+    orte_pointer_array_init(&(trig->attached), (orte_std_cntr_t)orte_gpr_array_block_size,
-                            orte_gpr_array_max_size,
+                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                            orte_gpr_array_block_size);
+                            (orte_std_cntr_t)orte_gpr_array_block_size);
 
     trig->master = NULL;;
 
@@ -402,14 +402,14 @@ static void orte_gpr_replica_trigger_construct(orte_gpr_replica_trigger_t* trig)
     trig->processing = false;
 
     trig->num_counters = 0;
-    orte_pointer_array_init(&(trig->counters), orte_gpr_array_block_size,
+    orte_pointer_array_init(&(trig->counters), (orte_std_cntr_t)orte_gpr_array_block_size,
-                            orte_gpr_array_max_size,
+                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                            orte_gpr_array_block_size);
+                            (orte_std_cntr_t)orte_gpr_array_block_size);
 
     trig->num_subscriptions = 0;
-    orte_pointer_array_init(&(trig->subscriptions), orte_gpr_array_block_size,
+    orte_pointer_array_init(&(trig->subscriptions), (orte_std_cntr_t)orte_gpr_array_block_size,
-                            orte_gpr_array_max_size,
+                            (orte_std_cntr_t)orte_gpr_array_max_size,
-                            orte_gpr_array_block_size);
+                            (orte_std_cntr_t)orte_gpr_array_block_size);
 
 }
 

orte/mca/gpr/replica/gpr_replica_component.c

@@ -202,27 +202,27 @@ orte_gpr_base_module_t *orte_gpr_replica_init(bool *allow_multi_user_threads, bo
 
         /* initialize the registry head */
         if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica.segments),
-                                orte_gpr_array_block_size,
+                                (orte_std_cntr_t)orte_gpr_array_block_size,
-                                orte_gpr_array_max_size,
+                                (orte_std_cntr_t)orte_gpr_array_max_size,
-                                orte_gpr_array_block_size))) {
+                                (orte_std_cntr_t)orte_gpr_array_block_size))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
         orte_gpr_replica.num_segs = 0;
 
         if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica.triggers),
-                                orte_gpr_array_block_size,
+                                (orte_std_cntr_t)orte_gpr_array_block_size,
-                                orte_gpr_array_max_size,
+                                (orte_std_cntr_t)orte_gpr_array_max_size,
-                                orte_gpr_array_block_size))) {
+                                (orte_std_cntr_t)orte_gpr_array_block_size))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
         orte_gpr_replica.num_trigs = 0;
 
         if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica.subscriptions),
-                                orte_gpr_array_block_size,
+                                (orte_std_cntr_t)orte_gpr_array_block_size,
-                                orte_gpr_array_max_size,
+                                (orte_std_cntr_t)orte_gpr_array_max_size,
-                                orte_gpr_array_block_size))) {
+                                (orte_std_cntr_t)orte_gpr_array_block_size))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
@@ -235,9 +235,9 @@ orte_gpr_base_module_t *orte_gpr_replica_init(bool *allow_multi_user_threads, bo
         /* initialize the local subscription and trigger trackers */
         if (ORTE_SUCCESS != (rc = orte_pointer_array_init(
                                 &(orte_gpr_replica_globals.local_subscriptions),
-                                orte_gpr_array_block_size,
+                                (orte_std_cntr_t)orte_gpr_array_block_size,
-                                orte_gpr_array_max_size,
+                                (orte_std_cntr_t)orte_gpr_array_max_size,
-                                orte_gpr_array_block_size))) {
+                                (orte_std_cntr_t)orte_gpr_array_block_size))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
@@ -245,9 +245,9 @@ orte_gpr_base_module_t *orte_gpr_replica_init(bool *allow_multi_user_threads, bo
 
         if (ORTE_SUCCESS != (rc = orte_pointer_array_init(
                                 &(orte_gpr_replica_globals.local_triggers),
-                                orte_gpr_array_block_size,
+                                (orte_std_cntr_t)orte_gpr_array_block_size,
-                                orte_gpr_array_max_size,
+                                (orte_std_cntr_t)orte_gpr_array_max_size,
-                                orte_gpr_array_block_size))) {
+                                (orte_std_cntr_t)orte_gpr_array_block_size))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
@@ -255,34 +255,34 @@ orte_gpr_base_module_t *orte_gpr_replica_init(bool *allow_multi_user_threads, bo
 
         /* initialize the search arrays for temporarily storing search results */
         if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica_globals.sub_ptrs),
-                                100, orte_gpr_array_max_size, 100))) {
+                                100, (orte_std_cntr_t)orte_gpr_array_max_size, 100))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
 
         if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica_globals.srch_cptr),
-                                100, orte_gpr_array_max_size, 100))) {
+                                100, (orte_std_cntr_t)orte_gpr_array_max_size, 100))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
         orte_gpr_replica_globals.num_srch_cptr = 0;
 
         if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica_globals.overwritten),
-                                20, orte_gpr_array_max_size, 20))) {
+                                20, (orte_std_cntr_t)orte_gpr_array_max_size, 20))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
         orte_gpr_replica_globals.num_overwritten = 0;
 
         if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica_globals.srch_ival),
-                                100, orte_gpr_array_max_size, 100))) {
+                                100, (orte_std_cntr_t)orte_gpr_array_max_size, 100))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
         orte_gpr_replica_globals.num_srch_ival = 0;
 
         if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_gpr_replica_globals.acted_upon),
-                                100, orte_gpr_array_max_size, 100))) {
+                                100, (orte_std_cntr_t)orte_gpr_array_max_size, 100))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }

orte/mca/gpr/replica/transition_layer/gpr_replica_dict_tl.c

@@ -56,7 +56,7 @@ orte_gpr_replica_create_itag(orte_gpr_replica_itag_t *itag,
         return ORTE_ERR_BAD_PARAM;
     }
 
-    len = strlen(name);
+    len = (orte_std_cntr_t)strlen(name);
     
     /* check seg's dictionary to ensure uniqueness */
     ptr = (char**)(seg->dict)->addr;
@@ -64,7 +64,7 @@ orte_gpr_replica_create_itag(orte_gpr_replica_itag_t *itag,
                    i < (seg->dict)->size; i++) {
         if (NULL != ptr[i]) {
             j++;
-            len2 = strlen(ptr[i]);
+            len2 = (orte_std_cntr_t)strlen(ptr[i]);
             if ((len == len2 && 0 == strncmp(ptr[i], name, len))) {
                 /* already present */
                 if (i < ORTE_GPR_REPLICA_ITAG_MAX) {
@@ -170,7 +170,7 @@ orte_gpr_replica_dict_lookup(orte_gpr_replica_itag_t *itag,
         return ORTE_SUCCESS;
 	}
 
-    len = strlen(name);
+    len = (orte_std_cntr_t)strlen(name);
     
     /* want specified token-itag pair in that segment's dictionary */
     ptr = (char**)((seg->dict)->addr);
@@ -178,7 +178,7 @@ orte_gpr_replica_dict_lookup(orte_gpr_replica_itag_t *itag,
                    i < (seg->dict)->size; i++) {
         if (NULL != ptr[i]) {
             j++;
-            len2 = strlen(ptr[i]);
+            len2 = (orte_std_cntr_t)strlen(ptr[i]);
 	        if (len == len2 && 0 == strncmp(ptr[i], name, len)) {
                if (i < ORTE_GPR_REPLICA_ITAG_MAX) {
                    *itag = (orte_gpr_replica_itag_t)i;

orte/mca/gpr/replica/transition_layer/gpr_replica_segment_tl.c

@@ -53,7 +53,7 @@ int orte_gpr_replica_find_seg(orte_gpr_replica_segment_t **seg,
         return ORTE_SUCCESS;
     }
     
-    len = strlen(segment);
+    len = (orte_std_cntr_t)strlen(segment);
 
     /* search the registry segments to find which one is being referenced */
     ptr = (orte_gpr_replica_segment_t**)(orte_gpr_replica.segments->addr);

orte/mca/ns/proxy/src/ns_proxy_component.c

@@ -256,9 +256,9 @@ mca_ns_base_module_t* orte_ns_proxy_init(int *priority)
 
           /* initialize the cell info tracker */
           if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_ns_proxy.cells),
-                                    orte_ns_proxy.block_size,
+                                    (orte_std_cntr_t)orte_ns_proxy.block_size,
-                                    orte_ns_proxy.max_size,
+                                    (orte_std_cntr_t)orte_ns_proxy.max_size,
-                                    orte_ns_proxy.block_size))) {
+                                    (orte_std_cntr_t)orte_ns_proxy.block_size))) {
                 ORTE_ERROR_LOG(rc);
                 return NULL;
             }
@@ -268,9 +268,9 @@ mca_ns_base_module_t* orte_ns_proxy_init(int *priority)
           /* initialize the taglist */
 
           if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_ns_proxy.tags),
-                                    orte_ns_proxy.block_size,
+                                    (orte_std_cntr_t)orte_ns_proxy.block_size,
-                                    orte_ns_proxy.max_size,
+                                    (orte_std_cntr_t)orte_ns_proxy.max_size,
-                                    orte_ns_proxy.block_size))) {
+                                    (orte_std_cntr_t)orte_ns_proxy.block_size))) {
                 ORTE_ERROR_LOG(rc);
                 return NULL;
             }
@@ -279,9 +279,9 @@ mca_ns_base_module_t* orte_ns_proxy_init(int *priority)
           /* initialize the dtlist */
 
           if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_ns_proxy.dts),
-                                    orte_ns_proxy.block_size,
+                                    (orte_std_cntr_t)orte_ns_proxy.block_size,
-                                    orte_ns_proxy.max_size,
+                                    (orte_std_cntr_t)orte_ns_proxy.max_size,
-                                    orte_ns_proxy.block_size))) {
+                                    (orte_std_cntr_t)orte_ns_proxy.block_size))) {
                 ORTE_ERROR_LOG(rc);
                 return NULL;
             }

orte/mca/ns/replica/src/ns_replica_component.c

@@ -270,9 +270,9 @@ mca_ns_base_module_t* orte_ns_replica_init(int *priority)
 
       /* initialize the cell info tracker */
       if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_ns_replica.cells),
-                                orte_ns_replica.block_size,
+                                (orte_std_cntr_t)orte_ns_replica.block_size,
-                                orte_ns_replica.max_size,
+                                (orte_std_cntr_t)orte_ns_replica.max_size,
-                                orte_ns_replica.block_size))) {
+                                (orte_std_cntr_t)orte_ns_replica.block_size))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
@@ -280,9 +280,9 @@ mca_ns_base_module_t* orte_ns_replica_init(int *priority)
 
       /* initialize the job id tracker */
       if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_ns_replica.jobids),
-                                orte_ns_replica.block_size,
+                                (orte_std_cntr_t)orte_ns_replica.block_size,
-                                orte_ns_replica.max_size,
+                                (orte_std_cntr_t)orte_ns_replica.max_size,
-                                orte_ns_replica.block_size))) {
+                                (orte_std_cntr_t)orte_ns_replica.block_size))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
@@ -291,9 +291,9 @@ mca_ns_base_module_t* orte_ns_replica_init(int *priority)
       /* initialize the taglist */
 
       if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_ns_replica.tags),
-                                orte_ns_replica.block_size,
+                                (orte_std_cntr_t)orte_ns_replica.block_size,
-                                orte_ns_replica.max_size,
+                                (orte_std_cntr_t)orte_ns_replica.max_size,
-                                orte_ns_replica.block_size))) {
+                                (orte_std_cntr_t)orte_ns_replica.block_size))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }
@@ -302,9 +302,9 @@ mca_ns_base_module_t* orte_ns_replica_init(int *priority)
       /* initialize the dtlist */
 
       if (ORTE_SUCCESS != (rc = orte_pointer_array_init(&(orte_ns_replica.dts),
-                                orte_ns_replica.block_size,
+                                (orte_std_cntr_t)orte_ns_replica.block_size,
-                                orte_ns_replica.max_size,
+                                (orte_std_cntr_t)orte_ns_replica.max_size,
-                                orte_ns_replica.block_size))) {
+                                (orte_std_cntr_t)orte_ns_replica.block_size))) {
             ORTE_ERROR_LOG(rc);
             return NULL;
         }

orte/mca/odls/process/odls_process.h

@@ -16,6 +16,9 @@
 
 #include "opal/threads/condition.h"
 #include "opal/mca/mca.h"
+
+#include "orte/mca/rmgr/rmgr_types.h"
+
 #include "orte/mca/odls/odls.h"
 
 #if defined(c_plusplus) || defined(__cplusplus)

orte/mca/pls/base/pls_base_dmn_registry_fns.c

@@ -62,7 +62,7 @@ int orte_pls_base_store_active_daemons(opal_list_t *daemons)
     int rc, i, num_daemons;
     
     /* determine the number of daemons */
-    num_daemons = opal_list_get_size(daemons);
+    num_daemons = (int)opal_list_get_size(daemons);
 
     if (0 == num_daemons) {
         return ORTE_SUCCESS;

orte/mca/ras/base/ras_base_node.c

@@ -217,7 +217,7 @@ int orte_ras_base_node_query_alloc(opal_list_t* nodes, orte_jobid_t jobid)
     }
 
     asprintf(&keys[alloc_key_posn], "%s-%s", ORTE_NODE_SLOTS_ALLOC_KEY, jobid_str);
-    keys_len = strlen(keys[alloc_key_posn]);
+    keys_len = (orte_std_cntr_t)strlen(keys[alloc_key_posn]);
     free(jobid_str);
 
     /* query selected node entries */
@@ -520,7 +520,7 @@ int orte_ras_base_node_insert(opal_list_t* nodes)
     };
     orte_ras_node_t* node;
 
-    num_values = opal_list_get_size(nodes);
+    num_values = (orte_std_cntr_t)opal_list_get_size(nodes);
     if (0 >= num_values) {
         ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
         return ORTE_ERR_BAD_PARAM;
@@ -630,7 +630,7 @@ int orte_ras_base_node_delete(opal_list_t* nodes)
     orte_ras_node_t* node;
     char** tokens;
 
-    num_values = opal_list_get_size(nodes);
+    num_values = (orte_std_cntr_t)opal_list_get_size(nodes);
     if (0 >= num_values) {
         ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
         return ORTE_ERR_BAD_PARAM;
@@ -679,7 +679,7 @@ int orte_ras_base_node_assign(opal_list_t* nodes, orte_jobid_t jobid)
     orte_ras_node_t* node;
     char* jobid_str, *key=NULL;
 
-    num_values = opal_list_get_size(nodes);
+    num_values = (orte_std_cntr_t)opal_list_get_size(nodes);
     if (0 >= num_values) {
         ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
         return ORTE_ERR_BAD_PARAM;

orte/mca/rds/base/rds_base_registry_fns.c

@@ -50,7 +50,7 @@ int orte_rds_base_store_resource(opal_list_t *resources)
         return ORTE_ERR_BAD_PARAM;
     }
 
-    num_vals = opal_list_get_size(resources);
+    num_vals = (orte_std_cntr_t)opal_list_get_size(resources);
     if (0 == num_vals) {  /* nothing to do */
         return ORTE_SUCCESS;
     }
@@ -62,7 +62,7 @@ int orte_rds_base_store_resource(opal_list_t *resources)
     }
 
     for (i=0; i < num_vals && NULL != (cell = (orte_rds_cell_desc_t*)opal_list_remove_first(resources)); i++) {
-        num_attr = opal_list_get_size(&cell->attributes);
+        num_attr = (orte_std_cntr_t)opal_list_get_size(&cell->attributes);
         if (ORTE_SUCCESS != (rc = orte_gpr.create_value(&(values[i]), ORTE_GPR_TOKENS_XAND | ORTE_GPR_KEYS_OR,
                                                         ORTE_RESOURCE_SEGMENT, num_attr, 0))) {
             ORTE_ERROR_LOG(rc);

orte/mca/rmaps/base/rmaps_base_registry_fns.c

@@ -279,7 +279,7 @@ int orte_rmaps_base_put_job_map(orte_job_map_t *map)
         item != opal_list_get_end(&map->nodes);
         item =  opal_list_get_next(item)) {
         node = (orte_mapped_node_t*)item;
-        num_procs += opal_list_get_size(&node->procs);
+        num_procs += (orte_std_cntr_t)opal_list_get_size(&node->procs);
     }
     if(num_procs == 0) {
         ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);

orte/mca/rmaps/base/rmaps_base_support_fns.c

@@ -370,7 +370,7 @@ int orte_rmaps_base_update_node_usage(opal_list_t *nodes)
     orte_std_cntr_t num_values, i, j;
     orte_ras_node_t* node;
     
-    num_values = opal_list_get_size(nodes);
+    num_values = (orte_std_cntr_t)opal_list_get_size(nodes);
     if (0 >= num_values) {
         ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
         return ORTE_ERR_BAD_PARAM;

orte/mca/rmaps/round_robin/rmaps_rr.c

@@ -423,9 +423,9 @@ static int orte_rmaps_rr_map(orte_jobid_t jobid, opal_list_t *attributes)
                    user has specified "-pernode", then set it to the number of nodes
                 */
                 if (mca_rmaps_round_robin_component.per_node) {
-                    app->num_procs = opal_list_get_size(&mapped_node_list);
+                    app->num_procs = (orte_std_cntr_t)opal_list_get_size(&mapped_node_list);
                 } else {
-                    app->num_procs = mapped_num_slots;
+                    app->num_procs = (orte_std_cntr_t)mapped_num_slots;
                 }
                 modify_app_context = true;
             }
@@ -443,7 +443,7 @@ static int orte_rmaps_rr_map(orte_jobid_t jobid, opal_list_t *attributes)
                 user has specified "-pernode", then set it to the number of nodes
                 */
                 if (mca_rmaps_round_robin_component.per_node) {
-                    app->num_procs = opal_list_get_size(&master_node_list);
+                    app->num_procs = (orte_std_cntr_t)opal_list_get_size(&master_node_list);
                 } else {
                     app->num_procs = total_num_slots;
                 }

orte/mca/rmgr/base/data_type_support/rmgr_data_type_packing_fns.c

@@ -215,7 +215,7 @@ int orte_rmgr_base_pack_attr_list(orte_buffer_t *buffer, void *src,
     orte_std_cntr_t num_attr;
     
     /* get the number of attributes and pack it */
-    num_attr = opal_list_get_size(attrs);
+    num_attr = (orte_std_cntr_t)opal_list_get_size(attrs);
     if (ORTE_SUCCESS != (rc = orte_dss_pack_buffer(buffer, (void*)&num_attr, 1, ORTE_STD_CNTR))) {
         ORTE_ERROR_LOG(rc);
         return rc;

orte/mca/rmgr/base/data_type_support/rmgr_data_type_unpacking_fns.c

@@ -272,7 +272,7 @@ int orte_rmgr_base_unpack_attr_list(orte_buffer_t *buffer, void *dest,
             ORTE_ERROR_LOG(rc);
             return rc;
         }
-        opal_list_append(dest, &attr->super);
+        opal_list_append((opal_list_t*)dest, &attr->super);
     }
     
     return ORTE_SUCCESS;

orte/mca/sds/env/sds_env_module.c

@@ -126,7 +126,7 @@ orte_sds_env_set_name(void)
     }
     
     orte_process_info.vpid_start = (orte_vpid_t)vpid_start;
-    orte_process_info.num_procs = (size_t)num_procs;
+    orte_process_info.num_procs = (orte_std_cntr_t)num_procs;
     return ORTE_SUCCESS;
 }
 

orte/mca/sds/pipe/sds_pipe_module.c

@@ -77,7 +77,7 @@ orte_sds_pipe_set_name(void)
         ORTE_ERROR_LOG(ORTE_ERR_NOT_FOUND);
         return ORTE_ERR_NOT_FOUND;
     }
-    orte_process_info.num_procs = num_procs;
+    orte_process_info.num_procs = (orte_std_cntr_t)num_procs;
 
     close(fd);
     return ORTE_SUCCESS;