src/smpi/bindings/smpi_pmpi_group.cpp

   1 /* Copyright (c) 2007-2018. 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_coll.hpp"
   8 #include "smpi_comm.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
  18 int PMPI_Group_free(MPI_Group * group)
  19 {
  20   if (group == nullptr) {
  21     return MPI_ERR_ARG;
  22   } else {
  23     if(*group != MPI_COMM_WORLD->group() && *group != MPI_GROUP_EMPTY)
  24       simgrid::smpi::Group::unref(*group);
  25     *group = MPI_GROUP_NULL;
  26     return MPI_SUCCESS;
  27   }
  28 }
  29
  30 int PMPI_Group_size(MPI_Group group, int *size)
  31 {
  32   if (group == MPI_GROUP_NULL) {
  33     return MPI_ERR_GROUP;
  34   } else if (size == nullptr) {
  35     return MPI_ERR_ARG;
  36   } else {
  37     *size = group->size();
  38     return MPI_SUCCESS;
  39   }
  40 }
  41
  42 int PMPI_Group_rank(MPI_Group group, int *rank)
  43 {
  44   if (group == MPI_GROUP_NULL) {
  45     return MPI_ERR_GROUP;
  46   } else if (rank == nullptr) {
  47     return MPI_ERR_ARG;
  48   } else {
  49     *rank = group->rank(simgrid::s4u::this_actor::get_pid());
  50     return MPI_SUCCESS;
  51   }
  52 }
  53
  54 int PMPI_Group_translate_ranks(MPI_Group group1, int n, int *ranks1, MPI_Group group2, int *ranks2)
  55 {
  56   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
  57     return MPI_ERR_GROUP;
  58   } else {
  59     for (int i = 0; i < n; i++) {
  60       if(ranks1[i]==MPI_PROC_NULL){
  61         ranks2[i]=MPI_PROC_NULL;
  62       }else{
  63         simgrid::s4u::ActorPtr actor = group1->actor(ranks1[i]);
  64         ranks2[i] = group2->rank(actor);
  65       }
  66     }
  67     return MPI_SUCCESS;
  68   }
  69 }
  70
  71 int PMPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)
  72 {
  73   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
  74     return MPI_ERR_GROUP;
  75   } else if (result == nullptr) {
  76     return MPI_ERR_ARG;
  77   } else {
  78     *result = group1->compare(group2);
  79     return MPI_SUCCESS;
  80   }
  81 }
  82
  83 int PMPI_Group_union(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
  84 {
  85
  86   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
  87     return MPI_ERR_GROUP;
  88   } else if (newgroup == nullptr) {
  89     return MPI_ERR_ARG;
  90   } else {
  91     return group1->group_union(group2, newgroup);
  92   }
  93 }
  94
  95 int PMPI_Group_intersection(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
  96 {
  97
  98   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
  99     return MPI_ERR_GROUP;
 100   } else if (newgroup == nullptr) {
 101     return MPI_ERR_ARG;
 102   } else {
 103     return group1->intersection(group2,newgroup);
 104   }
 105 }
 106
 107 int PMPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
 108 {
 109   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
 110     return MPI_ERR_GROUP;
 111   } else if (newgroup == nullptr) {
 112     return MPI_ERR_ARG;
 113   } else {
 114     return group1->difference(group2,newgroup);
 115   }
 116 }
 117
 118 int PMPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
 119 {
 120   if (group == MPI_GROUP_NULL) {
 121     return MPI_ERR_GROUP;
 122   } else if (newgroup == nullptr) {
 123     return MPI_ERR_ARG;
 124   } else {
 125     return group->incl(n, ranks, newgroup);
 126   }
 127 }
 128
 129 int PMPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
 130 {
 131   if (group == MPI_GROUP_NULL) {
 132     return MPI_ERR_GROUP;
 133   } else if (newgroup == nullptr) {
 134     return MPI_ERR_ARG;
 135   } else {
 136     if (n == 0) {
 137       *newgroup = group;
 138       if (group != MPI_COMM_WORLD->group() && group != MPI_COMM_SELF->group() && group != MPI_GROUP_EMPTY)
 139         group->ref();
 140       return MPI_SUCCESS;
 141     } else if (n == group->size()) {
 142       *newgroup = MPI_GROUP_EMPTY;
 143       return MPI_SUCCESS;
 144     } else {
 145       return group->excl(n,ranks,newgroup);
 146     }
 147   }
 148 }
 149
 150 int PMPI_Group_range_incl(MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)
 151 {
 152   if (group == MPI_GROUP_NULL) {
 153     return MPI_ERR_GROUP;
 154   } else if (newgroup == nullptr) {
 155     return MPI_ERR_ARG;
 156   } else {
 157     if (n == 0) {
 158       *newgroup = MPI_GROUP_EMPTY;
 159       return MPI_SUCCESS;
 160     } else {
 161       return group->range_incl(n,ranges,newgroup);
 162     }
 163   }
 164 }
 165
 166 int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)
 167 {
 168   if (group == MPI_GROUP_NULL) {
 169     return MPI_ERR_GROUP;
 170   } else if (newgroup == nullptr) {
 171     return MPI_ERR_ARG;
 172   } else {
 173     if (n == 0) {
 174       *newgroup = group;
 175       if (group != MPI_COMM_WORLD->group() && group != MPI_COMM_SELF->group() &&
 176           group != MPI_GROUP_EMPTY)
 177         group->ref();
 178       return MPI_SUCCESS;
 179     } else {
 180       return group->range_excl(n,ranges,newgroup);
 181     }
 182   }
 183 }
 184
 185 MPI_Group PMPI_Group_f2c(MPI_Fint group){
 186   return simgrid::smpi::Group::f2c(group);
 187 }
 188
 189 MPI_Fint PMPI_Group_c2f(MPI_Group group){
 190   return group->c2f();
 191 }