src/smpi/bindings/smpi_pmpi_group.cpp

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