src/smpi/bindings/smpi_pmpi_group.cpp

   1 /* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "private.hpp"
   7 #include "smpi_comm.hpp"
   8 #include "smpi_coll.hpp"
   9 #include "smpi_datatype_derived.hpp"
  10 #include "smpi_op.hpp"
  11 #include "smpi_process.hpp"
  12
  13 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(smpi_pmpi);
  14
  15
  16 /* PMPI User level calls */
  17 extern "C" { // Obviously, the C MPI interface should use the C linkage
  18
  19 int PMPI_Group_free(MPI_Group * group)
  20 {
  21   if (group == nullptr) {
  22     return MPI_ERR_ARG;
  23   } else {
  24     if(*group != MPI_COMM_WORLD->group() && *group != MPI_GROUP_EMPTY)
  25       simgrid::smpi::Group::unref(*group);
  26     *group = MPI_GROUP_NULL;
  27     return MPI_SUCCESS;
  28   }
  29 }
  30
  31 int PMPI_Group_size(MPI_Group group, int *size)
  32 {
  33   if (group == MPI_GROUP_NULL) {
  34     return MPI_ERR_GROUP;
  35   } else if (size == nullptr) {
  36     return MPI_ERR_ARG;
  37   } else {
  38     *size = group->size();
  39     return MPI_SUCCESS;
  40   }
  41 }
  42
  43 int PMPI_Group_rank(MPI_Group group, int *rank)
  44 {
  45   if (group == MPI_GROUP_NULL) {
  46     return MPI_ERR_GROUP;
  47   } else if (rank == nullptr) {
  48     return MPI_ERR_ARG;
  49   } else {
  50     *rank = group->rank(smpi_process()->index());
  51     return MPI_SUCCESS;
  52   }
  53 }
  54
  55 int PMPI_Group_translate_ranks(MPI_Group group1, int n, int *ranks1, MPI_Group group2, int *ranks2)
  56 {
  57   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
  58     return MPI_ERR_GROUP;
  59   } else {
  60     for (int i = 0; i < n; i++) {
  61       if(ranks1[i]==MPI_PROC_NULL){
  62         ranks2[i]=MPI_PROC_NULL;
  63       }else{
  64         int index = group1->index(ranks1[i]);
  65         ranks2[i] = group2->rank(index);
  66       }
  67     }
  68     return MPI_SUCCESS;
  69   }
  70 }
  71
  72 int PMPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)
  73 {
  74   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
  75     return MPI_ERR_GROUP;
  76   } else if (result == nullptr) {
  77     return MPI_ERR_ARG;
  78   } else {
  79     *result = group1->compare(group2);
  80     return MPI_SUCCESS;
  81   }
  82 }
  83
  84 int PMPI_Group_union(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
  85 {
  86
  87   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
  88     return MPI_ERR_GROUP;
  89   } else if (newgroup == nullptr) {
  90     return MPI_ERR_ARG;
  91   } else {
  92     return group1->group_union(group2, newgroup);
  93   }
  94 }
  95
  96 int PMPI_Group_intersection(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
  97 {
  98
  99   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
 100     return MPI_ERR_GROUP;
 101   } else if (newgroup == nullptr) {
 102     return MPI_ERR_ARG;
 103   } else {
 104     return group1->intersection(group2,newgroup);
 105   }
 106 }
 107
 108 int PMPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
 109 {
 110   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
 111     return MPI_ERR_GROUP;
 112   } else if (newgroup == nullptr) {
 113     return MPI_ERR_ARG;
 114   } else {
 115     return group1->difference(group2,newgroup);
 116   }
 117 }
 118
 119 int PMPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
 120 {
 121   if (group == MPI_GROUP_NULL) {
 122     return MPI_ERR_GROUP;
 123   } else if (newgroup == nullptr) {
 124     return MPI_ERR_ARG;
 125   } else {
 126     return group->incl(n, ranks, newgroup);
 127   }
 128 }
 129
 130 int PMPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
 131 {
 132   if (group == MPI_GROUP_NULL) {
 133     return MPI_ERR_GROUP;
 134   } else if (newgroup == nullptr) {
 135     return MPI_ERR_ARG;
 136   } else {
 137     if (n == 0) {
 138       *newgroup = group;
 139       if (group != MPI_COMM_WORLD->group() && group != MPI_COMM_SELF->group() && group != MPI_GROUP_EMPTY)
 140         group->ref();
 141       return MPI_SUCCESS;
 142     } else if (n == group->size()) {
 143       *newgroup = MPI_GROUP_EMPTY;
 144       return MPI_SUCCESS;
 145     } else {
 146       return group->excl(n,ranks,newgroup);
 147     }
 148   }
 149 }
 150
 151 int PMPI_Group_range_incl(MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)
 152 {
 153   if (group == MPI_GROUP_NULL) {
 154     return MPI_ERR_GROUP;
 155   } else if (newgroup == nullptr) {
 156     return MPI_ERR_ARG;
 157   } else {
 158     if (n == 0) {
 159       *newgroup = MPI_GROUP_EMPTY;
 160       return MPI_SUCCESS;
 161     } else {
 162       return group->range_incl(n,ranges,newgroup);
 163     }
 164   }
 165 }
 166
 167 int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)
 168 {
 169   if (group == MPI_GROUP_NULL) {
 170     return MPI_ERR_GROUP;
 171   } else if (newgroup == nullptr) {
 172     return MPI_ERR_ARG;
 173   } else {
 174     if (n == 0) {
 175       *newgroup = group;
 176       if (group != MPI_COMM_WORLD->group() && group != MPI_COMM_SELF->group() &&
 177           group != MPI_GROUP_EMPTY)
 178         group->ref();
 179       return MPI_SUCCESS;
 180     } else {
 181       return group->range_excl(n,ranges,newgroup);
 182     }
 183   }
 184 }
 185
 186 MPI_Group PMPI_Group_f2c(MPI_Fint group){
 187   return simgrid::smpi::Group::f2c(group);
 188 }
 189
 190 MPI_Fint PMPI_Group_c2f(MPI_Group group){
 191   return group->c2f();
 192 }
 193
 194
 195 }