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 "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, 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::ActorPtr 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
  85   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
  86     return MPI_ERR_GROUP;
  87   } else if (newgroup == nullptr) {
  88     return MPI_ERR_ARG;
  89   } else {
  90     return group1->group_union(group2, newgroup);
  91   }
  92 }
  93
  94 int PMPI_Group_intersection(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
  95 {
  96
  97   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
  98     return MPI_ERR_GROUP;
  99   } else if (newgroup == nullptr) {
 100     return MPI_ERR_ARG;
 101   } else {
 102     return group1->intersection(group2,newgroup);
 103   }
 104 }
 105
 106 int PMPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
 107 {
 108   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
 109     return MPI_ERR_GROUP;
 110   } else if (newgroup == nullptr) {
 111     return MPI_ERR_ARG;
 112   } else {
 113     return group1->difference(group2,newgroup);
 114   }
 115 }
 116
 117 int PMPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
 118 {
 119   if (group == MPI_GROUP_NULL) {
 120     return MPI_ERR_GROUP;
 121   } else if (newgroup == nullptr) {
 122     return MPI_ERR_ARG;
 123   } else {
 124     return group->incl(n, ranks, newgroup);
 125   }
 126 }
 127
 128 int PMPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
 129 {
 130   if (group == MPI_GROUP_NULL) {
 131     return MPI_ERR_GROUP;
 132   } else if (newgroup == nullptr) {
 133     return MPI_ERR_ARG;
 134   } else {
 135     if (n == 0) {
 136       *newgroup = group;
 137       if (group != MPI_COMM_WORLD->group() && group != MPI_COMM_SELF->group() && group != MPI_GROUP_EMPTY)
 138         group->ref();
 139       return MPI_SUCCESS;
 140     } else if (n == group->size()) {
 141       *newgroup = MPI_GROUP_EMPTY;
 142       return MPI_SUCCESS;
 143     } else {
 144       return group->excl(n,ranks,newgroup);
 145     }
 146   }
 147 }
 148
 149 int PMPI_Group_range_incl(MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)
 150 {
 151   if (group == MPI_GROUP_NULL) {
 152     return MPI_ERR_GROUP;
 153   } else if (newgroup == nullptr) {
 154     return MPI_ERR_ARG;
 155   } else {
 156     if (n == 0) {
 157       *newgroup = MPI_GROUP_EMPTY;
 158       return MPI_SUCCESS;
 159     } else {
 160       return group->range_incl(n,ranges,newgroup);
 161     }
 162   }
 163 }
 164
 165 int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)
 166 {
 167   if (group == MPI_GROUP_NULL) {
 168     return MPI_ERR_GROUP;
 169   } else if (newgroup == nullptr) {
 170     return MPI_ERR_ARG;
 171   } else {
 172     if (n == 0) {
 173       *newgroup = group;
 174       if (group != MPI_COMM_WORLD->group() && group != MPI_COMM_SELF->group() &&
 175           group != MPI_GROUP_EMPTY)
 176         group->ref();
 177       return MPI_SUCCESS;
 178     } else {
 179       return group->range_excl(n,ranges,newgroup);
 180     }
 181   }
 182 }
 183
 184 MPI_Group PMPI_Group_f2c(MPI_Fint group){
 185   return simgrid::smpi::Group::f2c(group);
 186 }
 187
 188 MPI_Fint PMPI_Group_c2f(MPI_Group group){
 189   return group->c2f();
 190 }