symbol name pollution fix: adding ompi_ prefixes

This is part of a symbol name pollution fix, adding "ompi_" or similar
prefixes to a bunch of symbols.

This commit was largely scripted.

Signed-off-by: Mark Allen <markalle@us.ibm.com>

ompi/mca/coll/adapt/coll_adapt_ibcast.c

@@ -335,7 +335,7 @@ int ompi_coll_adapt_ibcast(void *buff, int count, struct ompi_datatype_t *dataty
     }
 
     return ompi_coll_adapt_ibcast_generic(buff, count, datatype, root, comm, request, module,
-                                          adapt_module_cached_topology(module, comm, root, mca_coll_adapt_component.adapt_ibcast_algorithm),
+                                          ompi_adapt_module_cached_topology(module, comm, root, mca_coll_adapt_component.adapt_ibcast_algorithm),
                                           mca_coll_adapt_component.adapt_ibcast_segment_size);
 }
 

ompi/mca/coll/adapt/coll_adapt_ireduce.c

@@ -504,7 +504,7 @@ int ompi_coll_adapt_ireduce(const void *sbuf, void *rbuf, int count, struct ompi
 
 
     return ompi_coll_adapt_ireduce_generic(sbuf, rbuf, count, dtype, op, root, comm, request, module,
-                                           adapt_module_cached_topology(module, comm, root, mca_coll_adapt_component.adapt_ireduce_algorithm),
+                                           ompi_adapt_module_cached_topology(module, comm, root, mca_coll_adapt_component.adapt_ireduce_algorithm),
                                            mca_coll_adapt_component.adapt_ireduce_segment_size);
 
 }

ompi/mca/coll/adapt/coll_adapt_module.c

@@ -63,8 +63,8 @@ static void adapt_module_construct(mca_coll_adapt_module_t * module)
 static void adapt_module_destruct(mca_coll_adapt_module_t * module)
 {
     if (NULL != module->topo_cache) {
-        adapt_topology_cache_item_t *item;
-        while (NULL != (item = (adapt_topology_cache_item_t*)opal_list_remove_first(module->topo_cache))) {
+        ompi_adapt_topology_cache_item_t *item;
+        while (NULL != (item = (ompi_adapt_topology_cache_item_t*)opal_list_remove_first(module->topo_cache))) {
             OBJ_RELEASE(item);
         }
         OBJ_RELEASE(module->topo_cache);

ompi/mca/coll/adapt/coll_adapt_topocache.c

@@ -14,14 +14,14 @@
 
 #include "ompi/communicator/communicator.h"
 
-static void destruct_topology_cache(adapt_topology_cache_item_t *item)
+static void destruct_topology_cache(ompi_adapt_topology_cache_item_t *item)
 {
     if (NULL != item->tree) {
         ompi_coll_base_topo_destroy_tree(&item->tree);
     }
 }
 
-OBJ_CLASS_INSTANCE(adapt_topology_cache_item_t, opal_list_item_t,
+OBJ_CLASS_INSTANCE(ompi_adapt_topology_cache_item_t, opal_list_item_t,
                    NULL, &destruct_topology_cache);
 
 static ompi_coll_tree_t *create_topology(
@@ -73,17 +73,17 @@ static ompi_coll_tree_t *create_topology(
     }
 }
 
-ompi_coll_tree_t* adapt_module_cached_topology(
+ompi_coll_tree_t* ompi_adapt_module_cached_topology(
     mca_coll_base_module_t *module,
     struct ompi_communicator_t *comm,
     int root,
     ompi_coll_adapt_algorithm_t algorithm)
 {
     mca_coll_adapt_module_t *adapt_module = (mca_coll_adapt_module_t*)module;
-    adapt_topology_cache_item_t *item;
+    ompi_adapt_topology_cache_item_t *item;
     ompi_coll_tree_t * tree;
     if (NULL != adapt_module->topo_cache) {
-        OPAL_LIST_FOREACH(item, adapt_module->topo_cache, adapt_topology_cache_item_t) {
+        OPAL_LIST_FOREACH(item, adapt_module->topo_cache, ompi_adapt_topology_cache_item_t) {
             if (item->root == root && item->algorithm == algorithm) {
                 return item->tree;
             }
@@ -95,7 +95,7 @@ ompi_coll_tree_t* adapt_module_cached_topology(
     /* topology not found, create one */
     tree = create_topology(algorithm, root, comm);
 
-    item = OBJ_NEW(adapt_topology_cache_item_t);
+    item = OBJ_NEW(ompi_adapt_topology_cache_item_t);
     item->tree = tree;
     item->root = root;
     item->algorithm = algorithm;

ompi/mca/coll/adapt/coll_adapt_topocache.h

@@ -17,17 +17,17 @@
 #include "ompi/mca/coll/coll.h"
 #include "ompi/mca/coll/base/coll_base_topo.h"
 
-typedef struct adapt_topology_cache_item_t {
+typedef struct ompi_adapt_topology_cache_item_t {
     opal_list_item_t super;
     ompi_coll_tree_t *tree;
     int root;
     ompi_coll_adapt_algorithm_t algorithm;
-} adapt_topology_cache_item_t;
+} ompi_adapt_topology_cache_item_t;
 
-OBJ_CLASS_DECLARATION(adapt_topology_cache_item_t);
+OBJ_CLASS_DECLARATION(ompi_adapt_topology_cache_item_t);
 
 
-OMPI_DECLSPEC ompi_coll_tree_t* adapt_module_cached_topology(
+OMPI_DECLSPEC ompi_coll_tree_t* ompi_adapt_module_cached_topology(
     mca_coll_base_module_t *module,
     struct ompi_communicator_t *comm,
     int root,

ompi/mca/coll/han/coll_han.h

@@ -356,7 +356,7 @@ int mca_coll_han_init_query(bool enable_progress_threads, bool enable_mpi_thread
 
 mca_coll_base_module_t *mca_coll_han_comm_query(struct ompi_communicator_t *comm, int *priority);
 
-int han_request_free(ompi_request_t ** request);
+int ompi_han_han_request_free(ompi_request_t ** request);
 
 /* Subcommunicator creation */
 int mca_coll_han_comm_create(struct ompi_communicator_t *comm, mca_coll_han_module_t * han_module);

ompi/mca/coll/han/coll_han_allgather.c

@@ -96,7 +96,7 @@ mca_coll_han_allgather_intra(const void *sbuf, int scount,
     temp_request = OBJ_NEW(ompi_request_t);
     temp_request->req_state = OMPI_REQUEST_ACTIVE;
     temp_request->req_type = OMPI_REQUEST_COLL;
-    temp_request->req_free = han_request_free;
+    temp_request->req_free = ompi_han_han_request_free;
     temp_request->req_status = (ompi_status_public_t){0};
     temp_request->req_complete = REQUEST_PENDING;
 

ompi/mca/coll/han/coll_han_allreduce.c

@@ -525,7 +525,7 @@ mca_coll_han_allreduce_reproducible_decision(struct ompi_communicator_t *comm,
                 opal_output_verbose(30, mca_coll_han_component.han_output,
                                     "coll:han:allreduce_reproducible: "
                                     "fallback on %s\n",
-                                    available_components[fallback].component_name);
+                                    ompi_han_available_components[fallback].component_name);
             }
             han_module->reproducible_allreduce_module = fallback_module;
             han_module->reproducible_allreduce = fallback_module->coll_allreduce;

ompi/mca/coll/han/coll_han_component.c

@@ -33,7 +33,7 @@
 const char *mca_coll_han_component_version_string =
     "Open MPI HAN collective MCA component version " OMPI_VERSION;
 
-ompi_coll_han_components available_components[COMPONENTS_COUNT] = {
+ompi_coll_han_components ompi_han_available_components[COMPONENTS_COUNT] = {
     { SELF, "self",  NULL },
     { BASIC, "basic", NULL },
     { LIBNBC, "libnbc", NULL },
@@ -328,7 +328,7 @@ static int han_register(void)
                 param_desc_size += snprintf(param_desc+param_desc_size, sizeof(param_desc) - param_desc_size,
                                             "%d = %s; ",
                                             component,
-                                            available_components[component].component_name);
+                                            ompi_han_available_components[component].component_name);
             }
 
             mca_base_component_var_register(c, param_name, param_desc,

ompi/mca/coll/han/coll_han_dynamic.c

@@ -44,7 +44,7 @@ mca_coll_han_component_name_to_id(const char* name)
     }
 
     for( int i = SELF; i < COMPONENTS_COUNT ; i++ ) {
-        if (0 == strcmp(name, available_components[i].component_name)) {
+        if (0 == strcmp(name, ompi_han_available_components[i].component_name)) {
             return i;
         }
     }
@@ -237,7 +237,7 @@ get_dynamic_rule(COLLTYPE_T collective,
                         msg_size_rule->topologic_level,
                         mca_coll_han_topo_lvl_to_str(msg_size_rule->topologic_level),
                         msg_size_rule->configuration_size,
-                        msg_size_rule->msg_size, component, available_components[component].component_name);
+                        msg_size_rule->msg_size, component, ompi_han_available_components[component].component_name);
 
     return msg_size_rule;
 }

ompi/mca/coll/han/coll_han_dynamic.h

@@ -113,7 +113,7 @@ typedef struct {
     mca_coll_base_component_t* component;
 } ompi_coll_han_components;
 
-extern ompi_coll_han_components available_components[COMPONENTS_COUNT];
+extern ompi_coll_han_components ompi_han_available_components[COMPONENTS_COUNT];
 
 /* Topologic levels */
 typedef enum TOPO_LVL {

ompi/mca/coll/han/coll_han_dynamic_file.c

@@ -600,7 +600,7 @@ void mca_coll_han_dump_dynamic_rules(void)
                                 "mesage size %d -> collective component %d (%s)\n",
                                 nb_entries, coll_id, mca_coll_base_colltype_to_str(coll_id),
                                 topo_lvl, mca_coll_han_topo_lvl_to_str(topo_lvl), conf_size,
-                                msg_size, component, available_components[component].component_name);
+                                msg_size, component, ompi_han_available_components[component].component_name);
 
                     nb_entries++;
                 }

ompi/mca/coll/han/coll_han_gather.c

@@ -108,7 +108,7 @@ mca_coll_han_gather_intra(const void *sbuf, int scount,
     temp_request = OBJ_NEW(ompi_request_t);
     temp_request->req_state = OMPI_REQUEST_ACTIVE;
     temp_request->req_type = OMPI_REQUEST_COLL;
-    temp_request->req_free = han_request_free;
+    temp_request->req_free = ompi_han_han_request_free;
     temp_request->req_status = (ompi_status_public_t){0};
     temp_request->req_complete = REQUEST_PENDING;
 

ompi/mca/coll/han/coll_han_module.c

@@ -330,7 +330,7 @@ mca_coll_han_module_disable(mca_coll_base_module_t * module,
 /*
  * Free the han request
  */
-int han_request_free(ompi_request_t ** request)
+int ompi_han_han_request_free(ompi_request_t ** request)
 {
     (*request)->req_state = OMPI_REQUEST_INVALID;
     OBJ_RELEASE(*request);

ompi/mca/coll/han/coll_han_reduce.c

@@ -405,7 +405,7 @@ mca_coll_han_reduce_reproducible_decision(struct ompi_communicator_t *comm,
                 opal_output_verbose(30, mca_coll_han_component.han_output,
                                     "coll:han:reduce_reproducible: "
                                     "fallback on %s\n",
-                                    available_components[fallback].component_name);
+                                    ompi_han_available_components[fallback].component_name);
             }
             han_module->reproducible_reduce_module = fallback_module;
             han_module->reproducible_reduce = fallback_module->coll_reduce;

ompi/mca/coll/han/coll_han_scatter.c

@@ -107,7 +107,7 @@ mca_coll_han_scatter_intra(const void *sbuf, int scount,
     ompi_request_t *temp_request = OBJ_NEW(ompi_request_t);
     temp_request->req_state = OMPI_REQUEST_ACTIVE;
     temp_request->req_type = OMPI_REQUEST_COLL;
-    temp_request->req_free = han_request_free;
+    temp_request->req_free = ompi_han_han_request_free;
     temp_request->req_status = (ompi_status_public_t){0};
     temp_request->req_complete = REQUEST_PENDING;
 

ompi/mca/coll/libnbc/libdict/dict.c

@@ -12,22 +12,22 @@
 #include "dict.h"
 #include "dict_private.h"
 
-dict_malloc_func _dict_malloc = malloc;
-dict_free_func _dict_free = free;
+dict_malloc_func ompi_nbc_dict_malloc = malloc;
+dict_free_func ompi_nbc_dict_free = free;
 
 dict_malloc_func
-dict_set_malloc(dict_malloc_func func)
+ompi_nbc_dict_set_malloc(dict_malloc_func func)
 {
-	dict_malloc_func old = _dict_malloc;
-	_dict_malloc = func ? func : malloc;
+	dict_malloc_func old = ompi_nbc_dict_malloc;
+	ompi_nbc_dict_malloc = func ? func : malloc;
 	return old;
 }
 
 dict_free_func
-dict_set_free(dict_free_func func)
+ompi_nbc_dict_set_free(dict_free_func func)
 {
-	dict_free_func old = _dict_free;
-	_dict_free = func ? func : free;
+	dict_free_func old = ompi_nbc_dict_free;
+	ompi_nbc_dict_free = func ? func : free;
 	return old;
 }
 
@@ -36,45 +36,45 @@ dict_set_free(dict_free_func func)
  * overflow.
  */
 int
-dict_int_cmp(const void *k1, const void *k2)
+ompi_nbc_dict_int_cmp(const void *k1, const void *k2)
 {
 	const int *a = (int*)k1, *b = (int*)k2;
 
 	return (*a < *b) ? -1 : (*a > *b) ? +1 : 0;
 }
 
 int
-dict_uint_cmp(const void *k1, const void *k2)
+ompi_nbc_dict_uint_cmp(const void *k1, const void *k2)
 {
 	const unsigned int *a = (unsigned int*)k1, *b = (unsigned int*)k2;
 
 	return (*a < *b) ? -1 : (*a > *b) ? +1 : 0;
 }
 
 int
-dict_long_cmp(const void *k1, const void *k2)
+ompi_nbc_dict_long_cmp(const void *k1, const void *k2)
 {
 	const long *a = (long*)k1, *b = (long*)k2;
 
 	return (*a < *b) ? -1 : (*a > *b) ? +1 : 0;
 }
 
 int
-dict_ulong_cmp(const void *k1, const void *k2)
+ompi_nbc_dict_ulong_cmp(const void *k1, const void *k2)
 {
 	const unsigned long *a = (unsigned long*)k1, *b = (unsigned long*)k2;
 
 	return (*a < *b) ? -1 : (*a > *b) ? +1 : 0;
 }
 
 int
-dict_ptr_cmp(const void *k1, const void *k2)
+ompi_nbc_dict_ptr_cmp(const void *k1, const void *k2)
 {
 	return (k1 > k2) - (k1 < k2);
 }
 
 int
-dict_str_cmp(const void *k1, const void *k2)
+ompi_nbc_dict_str_cmp(const void *k1, const void *k2)
 {
 	const char *a = (char*)k1, *b = (char*)k2;
 	char p, q;
@@ -88,7 +88,7 @@ dict_str_cmp(const void *k1, const void *k2)
 }
 
 void
-dict_destroy(dict *dct, int del)
+ompi_nbc_dict_destroy(dict *dct, int del)
 {
 	ASSERT(dct != NULL);
 
@@ -97,7 +97,7 @@ dict_destroy(dict *dct, int del)
 }
 
 void
-dict_itor_destroy(dict_itor *itor)
+ompi_nbc_dict_itor_destroy(dict_itor *itor)
 {
 	ASSERT(itor != NULL);
 

ompi/mca/coll/libnbc/libdict/dict.h

@@ -46,8 +46,8 @@ BEGIN_DECL
 typedef void *(*dict_malloc_func)(size_t);
 typedef void  (*dict_free_func)(void *);
 
-dict_malloc_func	dict_set_malloc		__P((dict_malloc_func func));
-dict_free_func		dict_set_free		__P((dict_free_func func));
+dict_malloc_func	ompi_nbc_dict_set_malloc		__P((dict_malloc_func func));
+dict_free_func		ompi_nbc_dict_set_free		__P((dict_free_func func));
 
 typedef int			(*dict_cmp_func)	__P((const void *, const void *));
 typedef void		(*dict_del_func)	__P((void *));
@@ -78,7 +78,7 @@ struct dict {
 #define dict_walk(dct,f)		(dct)->_walk((dct)->_object, (f))
 #define dict_count(dct)			(dct)->_count((dct)->_object)
 #define dict_empty(dct,d)		(dct)->_empty((dct)->_object, (d))
-void dict_destroy __P((dict *dct, int del));
+void ompi_nbc_dict_destroy __P((dict *dct, int del));
 #define dict_itor_new(dct)		(dct)->_inew((dct)->_object)
 
 struct dict_itor {
@@ -116,14 +116,14 @@ struct dict_itor {
 #define dict_itor_cdata(i)			(i)->_cdata((i)->_itor)
 #define dict_itor_set_data(i,dat,d)	(i)->_setdata((i)->_itor, (dat), (d))
 #define dict_itor_remove(i)			(i)->_remove((i)->_itor)
-void dict_itor_destroy __P((dict_itor *itor));
-
-int		dict_int_cmp __P((const void *k1, const void *k2));
-int		dict_uint_cmp __P((const void *k1, const void *k2));
-int		dict_long_cmp __P((const void *k1, const void *k2));
-int		dict_ulong_cmp __P((const void *k1, const void *k2));
-int		dict_ptr_cmp __P((const void *k1, const void *k2));
-int		dict_str_cmp __P((const void *k1, const void *k2));
+void ompi_nbc_dict_itor_destroy __P((dict_itor *itor));
+
+int		ompi_nbc_dict_int_cmp __P((const void *k1, const void *k2));
+int		ompi_nbc_dict_uint_cmp __P((const void *k1, const void *k2));
+int		ompi_nbc_dict_long_cmp __P((const void *k1, const void *k2));
+int		ompi_nbc_dict_ulong_cmp __P((const void *k1, const void *k2));
+int		ompi_nbc_dict_ptr_cmp __P((const void *k1, const void *k2));
+int		ompi_nbc_dict_str_cmp __P((const void *k1, const void *k2));
 
 END_DECL
 

ompi/mca/coll/libnbc/libdict/dict_private.h

@@ -59,10 +59,10 @@ typedef int			 (*icompare_func)	__P((void *, void *itor2));
 # define ASSERT(expr)
 #endif
 
-extern dict_malloc_func _dict_malloc;
-extern dict_free_func _dict_free;
-#define MALLOC(n)	(*_dict_malloc)(n)
-#define FREE(p)		(*_dict_free)(p)
+extern dict_malloc_func ompi_nbc_dict_malloc;
+extern dict_free_func ompi_nbc_dict_free;
+#define MALLOC(n)	(*ompi_nbc_dict_malloc)(n)
+#define FREE(p)		(*ompi_nbc_dict_free)(p)
 
 #define ABS(a)		((a) < 0 ? -(a) : +(a))
 #define MIN(a,b)	((a) < (b) ? (a) : (b))