symbol name pollution fix: making some things static

This is part of a symbol name pollution fix.  In another commit
I have a prefix being added to a lot of symbols.

Since "static" was added by hand I have all the by-hand work done
in this commit and the more automated changes where prefixes are
added to other symbols is its own separate commit

Signed-off-by: Mark Allen <[email protected]>

Author: markalle

ompi/mca/fcoll/two_phase/fcoll_two_phase_file_write_all.c

@@ -120,7 +120,7 @@ static int is_aggregator(int rank,
 			 int *aggregator_list);
 #endif
 
-void two_phase_heap_merge(mca_common_ompio_access_array_t *others_req,
+static void two_phase_heap_merge(mca_common_ompio_access_array_t *others_req,
 			  int *count,
 			  OMPI_MPI_OFFSET_TYPE *srt_off,
 			  int *srt_len,
@@ -1404,7 +1404,7 @@ static int two_phase_fill_send_buffer(ompio_file_t *fh,
 
 
 
-void two_phase_heap_merge( mca_common_ompio_access_array_t *others_req,
+static void two_phase_heap_merge( mca_common_ompio_access_array_t *others_req,
 			   int *count,
 			   OMPI_MPI_OFFSET_TYPE *srt_off,
 			   int *srt_len,

ompi/mca/topo/treematch/treematch/k-partitioning.c

@@ -4,17 +4,17 @@
 #include "tm_mt.h"
 #include "tm_verbose.h"
 
-void memory_allocation(PriorityQueue ** Q, PriorityQueue ** Qinst, double *** D, int n, int k);
-void initialization(int * const part, double ** const matrice, PriorityQueue * const Qpart, PriorityQueue * const Q, PriorityQueue * const Qinst, double ** const D, int n, int k, int * const deficit, int * const surplus);
-void algo(int * const part, double ** const matrice, PriorityQueue * const Qpart, PriorityQueue * const Q, PriorityQueue * const Qinst, double ** const D, int n,  int * const deficit, int * const surplus);
-double nextGain(PriorityQueue * const Qpart, PriorityQueue * const Q, int * const deficit, int * const surplus);
-void balancing(int n, int deficit, int surplus, double ** const D, int * const part);
-void destruction(PriorityQueue * Qpart, PriorityQueue * Q, PriorityQueue * Qinst, double ** D, int n, int k);
-
-void allocate_vertex2(int u, int *res, double **comm, int n, int *size, int max_size);
-double eval_cost2(int *,int,double **);
+static void memory_allocation(PriorityQueue ** Q, PriorityQueue ** Qinst, double *** D, int n, int k);
+static void initialization(int * const part, double ** const matrice, PriorityQueue * const Qpart, PriorityQueue * const Q, PriorityQueue * const Qinst, double ** const D, int n, int k, int * const deficit, int * const surplus);
+static void algo(int * const part, double ** const matrice, PriorityQueue * const Qpart, PriorityQueue * const Q, PriorityQueue * const Qinst, double ** const D, int n,  int * const deficit, int * const surplus);
+static double nextGain(PriorityQueue * const Qpart, PriorityQueue * const Q, int * const deficit, int * const surplus);
+static void balancing(int n, int deficit, int surplus, double ** const D, int * const part);
+static void destruction(PriorityQueue * Qpart, PriorityQueue * Q, PriorityQueue * Qinst, double ** D, int n, int k);
+
+static void allocate_vertex2(int u, int *res, double **comm, int n, int *size, int max_size);
+static double eval_cost2(int *,int,double **);
 int  *kpartition_greedy2(int k, double **comm, int n, int nb_try_max, int *constraints, int nb_constraints);
-int*  build_p_vector(double **comm, int n, int k, int greedy_trials, int * constraints, int nb_constraints);
+static int*  build_p_vector(double **comm, int n, int k, int greedy_trials, int * constraints, int nb_constraints);
 
 int* kPartitioning(double ** comm, int n, int k, int * constraints, int nb_constraints, int greedy_trials)
 {
@@ -48,7 +48,7 @@ int* kPartitioning(double ** comm, int n, int k, int * constraints, int nb_const
   return part;
 }
 
-void memory_allocation(PriorityQueue ** Q, PriorityQueue ** Qinst, double *** D, int n, int k)
+static void memory_allocation(PriorityQueue ** Q, PriorityQueue ** Qinst, double *** D, int n, int k)
 {
   int i;
   *Q = calloc(k, sizeof(PriorityQueue)); /*one Q for each partition*/
@@ -58,7 +58,7 @@ void memory_allocation(PriorityQueue ** Q, PriorityQueue ** Qinst, double *** D,
     (*D)[i] = calloc(k, sizeof(double));
 }
 
-void initialization(int * const part, double ** const matrice, PriorityQueue * const Qpart, PriorityQueue * const Q, PriorityQueue * const Qinst, double ** const D, int n, int k, int * const deficit, int * const surplus)
+static void initialization(int * const part, double ** const matrice, PriorityQueue * const Qpart, PriorityQueue * const Q, PriorityQueue * const Qinst, double ** const D, int n, int k, int * const deficit, int * const surplus)
 {
   int i,j;
 
@@ -103,7 +103,7 @@ void initialization(int * const part, double ** const matrice, PriorityQueue * c
   *surplus = *deficit = 0;
 }
 
-void algo(int * const part, double ** const matrice, PriorityQueue * const Qpart, PriorityQueue * const Q, PriorityQueue * const Qinst, double ** const D, int n, int * const deficit, int * const surplus)
+static void algo(int * const part, double ** const matrice, PriorityQueue * const Qpart, PriorityQueue * const Q, PriorityQueue * const Qinst, double ** const D, int n, int * const deficit, int * const surplus)
 {
   int p,u,v,j;
   double d;
@@ -149,7 +149,7 @@ void algo(int * const part, double ** const matrice, PriorityQueue * const Qpart
   PQ_adjustKey(Qpart, part[u], d); /*we update the new highest possible gain in u's subset*/
 }
 
-double nextGain(PriorityQueue * const Qpart, PriorityQueue * const Q, int * const deficit, int * const surplus)
+static double nextGain(PriorityQueue * const Qpart, PriorityQueue * const Q, int * const deficit, int * const surplus)
 {
   double res;
   if(*deficit == *surplus) /*if the current partition is balanced*/
@@ -159,7 +159,7 @@ double nextGain(PriorityQueue * const Qpart, PriorityQueue * const Q, int * cons
   return res;
 }
 
-void balancing(int n, int deficit, int surplus, double ** const D, int * const part)
+static void balancing(int n, int deficit, int surplus, double ** const D, int * const part)
 {
   if(surplus != deficit) /*if the current partition is not balanced*/
     {
@@ -176,7 +176,7 @@ void balancing(int n, int deficit, int surplus, double ** const D, int * const p
     }
 }
 
-void destruction(PriorityQueue * Qpart, PriorityQueue * Q, PriorityQueue * Qinst, double ** D, int n, int k)
+static void destruction(PriorityQueue * Qpart, PriorityQueue * Q, PriorityQueue * Qinst, double ** D, int n, int k)
 {
   int i;
   PQ_exit(Qpart);
@@ -261,7 +261,7 @@ int  *kpartition_greedy2(int k, double **comm, int n, int nb_try_max, int *const
   return best_res;
 }
 
-void allocate_vertex2(int u, int *res, double **comm, int n, int *size, int max_size)
+static void allocate_vertex2(int u, int *res, double **comm, int n, int *size, int max_size)
 {
   int i,best_part = -1;
   double cost, best_cost = -1;
@@ -285,7 +285,7 @@ void allocate_vertex2(int u, int *res, double **comm, int n, int *size, int max_
   size[best_part]++;
 }
 
-double eval_cost2(int *partition, int n, double **comm)
+static double eval_cost2(int *partition, int n, double **comm)
 {
   double cost = 0;
   int i,j;
@@ -298,7 +298,7 @@ double eval_cost2(int *partition, int n, double **comm)
   return cost;
 }
 
-int* build_p_vector(double **comm, int n, int k, int greedy_trials, int * constraints, int nb_constraints)
+static int* build_p_vector(double **comm, int n, int k, int greedy_trials, int * constraints, int nb_constraints)
 {
   int * part = NULL;
   if(greedy_trials>0) /*if greedy_trials > 0 then we use kpartition_greedy with greedy_trials trials*/

ompi/mca/topo/treematch/treematch/tm_bucket.c

@@ -33,27 +33,27 @@ static int verbose_level = ERROR;
 
 static bucket_list_t global_bl = {0};
 
-int tab_cmp(const void*,const void*);
-int old_bucket_id(int,int,bucket_list_t);
-int bucket_id(int,int,bucket_list_t);
-void display_bucket(bucket_t *);
-void check_bucket(bucket_t *,double **,double, double);
-void display_pivots(bucket_list_t);
-void display_bucket_list(bucket_list_t);
-void add_to_bucket(int,int,int,bucket_list_t);
-void dfs(int,int,int,double *,double *,int,int);
-void built_pivot_tree(bucket_list_t);
-void fill_buckets(bucket_list_t);
-int is_power_of_2(int);
-void partial_sort(bucket_list_t *,double **,int);
-void next_bucket_elem(bucket_list_t,int *,int *);
-int add_edge_3(tm_tree_t *,tm_tree_t *,int,int,int *);
-void free_bucket(bucket_t *);
-void free_tab_bucket(bucket_t **,int);
-void free_bucket_list(bucket_list_t);
-void partial_update_val (int nb_args, void **args, int thread_id);
+static int tab_cmp(const void*,const void*);
+static int old_bucket_id(int,int,bucket_list_t);
+static int bucket_id(int,int,bucket_list_t);
+static void display_bucket(bucket_t *);
+static void check_bucket(bucket_t *,double **,double, double);
+static void display_pivots(bucket_list_t);
+static void display_bucket_list(bucket_list_t);
+static void add_to_bucket(int,int,int,bucket_list_t);
+static void dfs(int,int,int,double *,double *,int,int);
+static void built_pivot_tree(bucket_list_t);
+static void fill_buckets(bucket_list_t);
+static int is_power_of_2(int);
+static void partial_sort(bucket_list_t *,double **,int);
+static void next_bucket_elem(bucket_list_t,int *,int *);
+static int add_edge_3(tm_tree_t *,tm_tree_t *,int,int,int *);
+static void free_bucket(bucket_t *);
+static void free_tab_bucket(bucket_t **,int);
+static void free_bucket_list(bucket_list_t);
+static void partial_update_val (int nb_args, void **args, int thread_id);
 double bucket_grouping(tm_affinity_mat_t *,tm_tree_t *, tm_tree_t *, int ,int);
-int tab_cmp(const void* x1,const void* x2)
+static int tab_cmp(const void* x1,const void* x2)
 {
   int *e1 = NULL,*e2 = NULL,i1,i2,j1,j2;
   double **tab = NULL;
@@ -82,7 +82,7 @@ int tab_cmp(const void* x1,const void* x2)
 }
 
 
-int old_bucket_id(int i,int j,bucket_list_t bucket_list)
+static int old_bucket_id(int i,int j,bucket_list_t bucket_list)
 {
   double *pivot = NULL,val;
   int n,sup,inf,p;
@@ -111,7 +111,7 @@ int old_bucket_id(int i,int j,bucket_list_t bucket_list)
   return sup;
 }
 
-int bucket_id(int i,int j,bucket_list_t bucket_list)
+static int bucket_id(int i,int j,bucket_list_t bucket_list)
 {
   double *pivot_tree = NULL,val;
   int p,k;
@@ -131,14 +131,14 @@ int bucket_id(int i,int j,bucket_list_t bucket_list)
   return (int)pivot_tree[p];
 }
 
-void  display_bucket(bucket_t *b)
+static void  display_bucket(bucket_t *b)
 {
   printf("\tb.bucket=%p\n",(void *)b->bucket);
   printf("\tb.bucket_len=%d\n",(int)b->bucket_len);
   printf("\tb.nb_elem=%d\n",(int)b->nb_elem);
 }
 
-void check_bucket(bucket_t *b,double **tab,double inf, double sup)
+static void check_bucket(bucket_t *b,double **tab,double inf, double sup)
 {
   int i,j,k;
   for( k = 0 ; k < b->nb_elem ; k++ ){
@@ -152,15 +152,15 @@ void check_bucket(bucket_t *b,double **tab,double inf, double sup)
   }
 }
 
-void display_pivots(bucket_list_t bucket_list)
+static void display_pivots(bucket_list_t bucket_list)
 {
   int i;
   for( i = 0 ; i < bucket_list->nb_buckets-1 ; i++)
     printf("pivot[%d]=%f\n",i,bucket_list->pivot[i]);
   printf("\n");
 }
 
-void display_bucket_list(bucket_list_t bucket_list)
+static void display_bucket_list(bucket_list_t bucket_list)
 {
   int i;
   double inf,sup;
@@ -184,7 +184,7 @@ void display_bucket_list(bucket_list_t bucket_list)
 
 }
 
-void add_to_bucket(int id,int i,int j,bucket_list_t bucket_list)
+static void add_to_bucket(int id,int i,int j,bucket_list_t bucket_list)
 {
   bucket_t *bucket = NULL;
   int N,n,size;
@@ -222,7 +222,7 @@ void add_to_bucket(int id,int i,int j,bucket_list_t bucket_list)
  /* exit(-1); */
 }
 
-void dfs(int i,int inf,int sup,double *pivot,double *pivot_tree,int depth,int max_depth)
+static void dfs(int i,int inf,int sup,double *pivot,double *pivot_tree,int depth,int max_depth)
 {
   int p;
   if( depth == max_depth )
@@ -235,7 +235,7 @@ void dfs(int i,int inf,int sup,double *pivot,double *pivot_tree,int depth,int ma
   dfs(2*i+1,p+1,sup,pivot,pivot_tree,depth+1,max_depth);
 }
 
-void  built_pivot_tree(bucket_list_t bucket_list)
+static void  built_pivot_tree(bucket_list_t bucket_list)
 {
   double *pivot_tree = NULL,*pivot = NULL;
   int n,i,k;
@@ -261,7 +261,7 @@ void  built_pivot_tree(bucket_list_t bucket_list)
   }
 }
 
-void fill_buckets(bucket_list_t bucket_list)
+static void fill_buckets(bucket_list_t bucket_list)
 {
   int N,i,j,id;
 
@@ -274,7 +274,7 @@ void fill_buckets(bucket_list_t bucket_list)
     }
 }
 
-int is_power_of_2(int val)
+static int is_power_of_2(int val)
 {
   int n = 1;
   do{
@@ -286,7 +286,7 @@ int is_power_of_2(int val)
 }
 
 
-void partial_sort(bucket_list_t *bl,double **tab,int N)
+static void partial_sort(bucket_list_t *bl,double **tab,int N)
 {
   double *pivot = NULL;
   int *sample = NULL;
@@ -386,7 +386,7 @@ void partial_sort(bucket_list_t *bl,double **tab,int N)
   *bl = bucket_list;
 }
 
-void next_bucket_elem(bucket_list_t bucket_list,int *i,int *j)
+static void next_bucket_elem(bucket_list_t bucket_list,int *i,int *j)
 {
   bucket_t *bucket = bucket_list->bucket_tab[bucket_list->cur_bucket];
 
@@ -415,7 +415,7 @@ void next_bucket_elem(bucket_list_t bucket_list,int *i,int *j)
 }
 
 
-int add_edge_3(tm_tree_t *tab_node, tm_tree_t *parent,int i,int j,int *nb_groups)
+static int add_edge_3(tm_tree_t *tab_node, tm_tree_t *parent,int i,int j,int *nb_groups)
 {
   /* printf("%d <-> %d ?\n",tab_node[i].id,tab_node[j].id); */
   if((!tab_node[i].parent) && (!tab_node[j].parent)){
@@ -492,21 +492,21 @@ int try_add_edge(tm_tree_t *tab_node, tm_tree_t *parent,int arity,int i,int j,in
   }
 }
 
-void free_bucket(bucket_t *bucket)
+static void free_bucket(bucket_t *bucket)
 {
   FREE(bucket->bucket);
   FREE(bucket);
 }
 
-void free_tab_bucket(bucket_t **bucket_tab,int N)
+static void free_tab_bucket(bucket_t **bucket_tab,int N)
 {
   int i;
   for( i = 0 ; i < N ; i++ )
     free_bucket(bucket_tab[i]);
   FREE(bucket_tab);
 }
 
-void free_bucket_list(bucket_list_t bucket_list)
+static void free_bucket_list(bucket_list_t bucket_list)
 {
   /* Do not free the tab field it is used elsewhere */
   free_tab_bucket(bucket_list->bucket_tab,bucket_list->nb_buckets);
@@ -515,7 +515,7 @@ void free_bucket_list(bucket_list_t bucket_list)
   FREE(bucket_list);
 }
 
-void partial_update_val (int nb_args, void **args, int thread_id){
+static void partial_update_val (int nb_args, void **args, int thread_id){
   int inf = *(int*)args[0];
   int sup = *(int*)args[1];
   tm_affinity_mat_t *aff_mat = (tm_affinity_mat_t*)args[2];