This source file includes following definitions.
- ompi_group_calc_sporadic
- ompi_group_translate_ranks_sporadic
- ompi_group_translate_ranks_sporadic_reverse
- ompi_group_incl_spor
   1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 
   9 
  10 
  11 
  12 
  13 
  14 
  15 
  16 
  17 
  18 
  19 
  20 
  21 
  22 
  23 
  24 #include "ompi_config.h"
  25 #include "ompi/group/group.h"
  26 #include "ompi/constants.h"
  27 #include "mpi.h"
  28 
  29 int ompi_group_calc_sporadic ( int n , const int *ranks)
  30 {
  31     int i,l=0;
  32     for (i=0 ; i<n ; i++) {
  33         if(ranks[i] == ranks[i-1]+1) {
  34             if(l==0) {
  35                 l++;
  36             }
  37         }
  38         else {
  39             l++;
  40         }
  41     }
  42     return sizeof(struct ompi_group_sporadic_list_t ) * l;
  43 }
  44 
  45 
  46 int ompi_group_translate_ranks_sporadic ( ompi_group_t *parent_group,
  47                                           int n_ranks, const int *ranks1,
  48                                           ompi_group_t *child_group,
  49                                           int *ranks2)
  50 {
  51     int i,count,j;
  52     for (j=0 ; j<n_ranks ; j++) {
  53         if (MPI_PROC_NULL == ranks1[j]) {
  54             ranks2[j] = MPI_PROC_NULL;
  55         }
  56         else {
  57             
  58 
  59 
  60 
  61 
  62             ranks2[j] = MPI_UNDEFINED;
  63             count = 0;
  64             for(i=0 ; i <child_group->sparse_data.grp_sporadic.grp_sporadic_list_len ; i++) {
  65                 if( child_group->sparse_data.grp_sporadic.grp_sporadic_list[i].rank_first
  66                     <= ranks1[j] && ranks1[j] <=
  67                     child_group->sparse_data.grp_sporadic.grp_sporadic_list[i].rank_first +
  68                     child_group->sparse_data.grp_sporadic.grp_sporadic_list[i].length -1 ) {
  69 
  70                     ranks2[j] = ranks1[j] - child_group->
  71                         sparse_data.grp_sporadic.grp_sporadic_list[i].rank_first + count;
  72                     break;
  73                 }
  74                 else {
  75                     count = count + child_group->sparse_data.grp_sporadic.grp_sporadic_list[i].length;
  76                 }
  77             }
  78         }
  79     }
  80     return OMPI_SUCCESS;
  81 }
  82 
  83 int ompi_group_translate_ranks_sporadic_reverse ( ompi_group_t *child_group,
  84                                                   int n_ranks, const int *ranks1,
  85                                                   ompi_group_t *parent_group,
  86                                                   int *ranks2)
  87 {
  88     int i,j,count;
  89 
  90     for (j=0 ; j<n_ranks ; j++) {
  91         if (MPI_PROC_NULL == ranks1[j]) {
  92             ranks2[j] = MPI_PROC_NULL;
  93         }
  94         else {
  95             count = 0;
  96             
  97 
  98 
  99 
 100             for (i=0 ; i<child_group->sparse_data.grp_sporadic.grp_sporadic_list_len ; i++) {
 101                 if ( ranks1[j] > ( count +
 102                                    child_group->sparse_data.grp_sporadic.grp_sporadic_list[i].length
 103                                    - 1) ) {
 104                     count = count + child_group->sparse_data.grp_sporadic.grp_sporadic_list[i].length;
 105                 }
 106                 else {
 107                     ranks2[j] = child_group->sparse_data.grp_sporadic.grp_sporadic_list[i].rank_first
 108                         + (ranks1[j] - count);
 109                     break;
 110                 }
 111             }
 112         }
 113     }
 114     return OMPI_SUCCESS;
 115 }
 116 
 117 int ompi_group_incl_spor(ompi_group_t* group, int n, const int *ranks,
 118                          ompi_group_t **new_group)
 119 {
 120     
 121     int my_group_rank,l,i,j,proc_count;
 122     ompi_group_t *group_pointer, *new_group_pointer;
 123 
 124     group_pointer = (ompi_group_t *)group;
 125 
 126     if (0 == n) {
 127         *new_group = MPI_GROUP_EMPTY;
 128         OBJ_RETAIN(MPI_GROUP_EMPTY);
 129         return OMPI_SUCCESS;
 130     }
 131 
 132     l=0;
 133     j=0;
 134     proc_count = 0;
 135 
 136     for(i=0 ; i<n ; i++){
 137         if(ranks[i] == ranks[i-1]+1) {
 138             if(l==0) {
 139                 l++;
 140             }
 141         }
 142         else {
 143             l++;
 144         }
 145     }
 146 
 147     new_group_pointer = ompi_group_allocate_sporadic(l);
 148     if( NULL == new_group_pointer ) {
 149         return MPI_ERR_GROUP;
 150     }
 151 
 152     new_group_pointer ->
 153         sparse_data.grp_sporadic.grp_sporadic_list[j].rank_first = ranks[0];
 154     new_group_pointer ->
 155         sparse_data.grp_sporadic.grp_sporadic_list[j].length = 1;
 156 
 157     for(i=1 ; i<n ; i++){
 158         if(ranks[i] == ranks[i-1]+1) {
 159             new_group_pointer -> sparse_data.grp_sporadic.grp_sporadic_list[j].length ++;
 160         }
 161         else {
 162             j++;
 163             new_group_pointer ->
 164                 sparse_data.grp_sporadic.grp_sporadic_list[j].rank_first = ranks[i];
 165             new_group_pointer ->
 166                 sparse_data.grp_sporadic.grp_sporadic_list[j].length = 1;
 167         }
 168     }
 169 
 170     new_group_pointer->sparse_data.grp_sporadic.grp_sporadic_list_len = j+1;
 171     new_group_pointer -> grp_parent_group_ptr = group_pointer;
 172 
 173     OBJ_RETAIN(new_group_pointer -> grp_parent_group_ptr);
 174     ompi_group_increment_proc_count(new_group_pointer -> grp_parent_group_ptr);
 175 
 176     for(i=0 ; i<new_group_pointer->sparse_data.grp_sporadic.grp_sporadic_list_len ; i++) {
 177         proc_count = proc_count + new_group_pointer ->
 178             sparse_data.grp_sporadic.grp_sporadic_list[i].length;
 179     }
 180     new_group_pointer->grp_proc_count = proc_count;
 181 
 182     ompi_group_increment_proc_count(new_group_pointer);
 183     my_group_rank=group_pointer->grp_my_rank;
 184 
 185     ompi_group_translate_ranks (group_pointer,1,&my_group_rank,
 186                                 new_group_pointer,&new_group_pointer->grp_my_rank);
 187 
 188     *new_group = (MPI_Group)new_group_pointer;
 189 
 190     return OMPI_SUCCESS;
 191 }