src/smpi/colls/smpi_coll.cpp

   1 /* smpi_coll.c -- various optimized routing for collectives                 */
   2
   3 /* Copyright (c) 2009-2019. The SimGrid Team. All rights reserved.          */
   4
   5 /* This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the license (GNU LGPL) which comes with this package. */
   7
   8 #include "smpi_coll.hpp"
   9 #include "private.hpp"
  10 #include "smpi_comm.hpp"
  11 #include "smpi_datatype.hpp"
  12 #include "smpi_op.hpp"
  13 #include "smpi_request.hpp"
  14 #include "xbt/config.hpp"
  15
  16 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_coll, smpi, "Logging specific to SMPI (coll)");
  17
  18 #define COLL_SETTER(cat, ret, args, args2)                                                                             \
  19   int(*Colls::cat) args;                                                                                               \
  20   void Colls::set_##cat(const std::string& name)                                                                       \
  21   {                                                                                                                    \
  22     int id = find_coll_description(mpi_coll_##cat##_description, name, #cat);                                          \
  23     cat    = reinterpret_cast<ret(*) args>(mpi_coll_##cat##_description[id].coll);                                     \
  24     if (cat == nullptr)                                                                                                \
  25       xbt_die("Collective " #cat " set to nullptr!");                                                                  \
  26   }
  27
  28 namespace simgrid{
  29 namespace smpi{
  30
  31 void (*Colls::smpi_coll_cleanup_callback)();
  32
  33 /* these arrays must be nullptr terminated */
  34 s_mpi_coll_description_t Colls::mpi_coll_gather_description[] = {
  35     COLL_GATHERS(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  36 s_mpi_coll_description_t Colls::mpi_coll_allgather_description[] = {
  37     COLL_ALLGATHERS(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  38 s_mpi_coll_description_t Colls::mpi_coll_allgatherv_description[] = {
  39     COLL_ALLGATHERVS(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  40 s_mpi_coll_description_t Colls::mpi_coll_allreduce_description[] ={
  41     COLL_ALLREDUCES(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  42 s_mpi_coll_description_t Colls::mpi_coll_reduce_scatter_description[] = {
  43     COLL_REDUCE_SCATTERS(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  44 s_mpi_coll_description_t Colls::mpi_coll_scatter_description[] ={
  45     COLL_SCATTERS(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  46 s_mpi_coll_description_t Colls::mpi_coll_barrier_description[] ={
  47     COLL_BARRIERS(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  48 s_mpi_coll_description_t Colls::mpi_coll_alltoall_description[] = {
  49     COLL_ALLTOALLS(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  50 s_mpi_coll_description_t Colls::mpi_coll_alltoallv_description[] = {
  51     COLL_ALLTOALLVS(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  52 s_mpi_coll_description_t Colls::mpi_coll_bcast_description[] = {
  53     COLL_BCASTS(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  54 s_mpi_coll_description_t Colls::mpi_coll_reduce_description[] = {
  55     COLL_REDUCES(COLL_DESCRIPTION, COLL_COMMA), {"", "", nullptr} };
  56
  57 /** Displays the long description of all registered models, and quit */
  58 void Colls::coll_help(const char *category, s_mpi_coll_description_t * table)
  59 {
  60   XBT_WARN("Long description of the %s models accepted by this simulator:\n", category);
  61   for (int i = 0; not table[i].name.empty(); i++)
  62     XBT_WARN("  %s: %s\n", table[i].name.c_str(), table[i].description.c_str());
  63 }
  64
  65 int Colls::find_coll_description(s_mpi_coll_description_t* table, const std::string& name, const char* desc)
  66 {
  67   for (int i = 0; not table[i].name.empty(); i++)
  68     if (name == table[i].name) {
  69       if (table[i].name != "default")
  70         XBT_INFO("Switch to algorithm %s for collective %s",table[i].name.c_str(),desc);
  71       return i;
  72     }
  73
  74   if (table[0].name.empty())
  75     xbt_die("No collective is valid for '%s'! This is a bug.", name.c_str());
  76   std::string name_list = table[0].name;
  77   for (int i = 1; not table[i].name.empty(); i++)
  78     name_list = name_list + ", " + table[i].name;
  79
  80   xbt_die("Collective '%s' is invalid! Valid collectives are: %s.", name.c_str(), name_list.c_str());
  81   return -1;
  82 }
  83
  84 COLL_APPLY(COLL_SETTER,COLL_GATHER_SIG,"");
  85 COLL_APPLY(COLL_SETTER,COLL_ALLGATHER_SIG,"");
  86 COLL_APPLY(COLL_SETTER,COLL_ALLGATHERV_SIG,"");
  87 COLL_APPLY(COLL_SETTER,COLL_REDUCE_SIG,"");
  88 COLL_APPLY(COLL_SETTER,COLL_ALLREDUCE_SIG,"");
  89 COLL_APPLY(COLL_SETTER,COLL_REDUCE_SCATTER_SIG,"");
  90 COLL_APPLY(COLL_SETTER,COLL_SCATTER_SIG,"");
  91 COLL_APPLY(COLL_SETTER,COLL_BARRIER_SIG,"");
  92 COLL_APPLY(COLL_SETTER,COLL_BCAST_SIG,"");
  93 COLL_APPLY(COLL_SETTER,COLL_ALLTOALL_SIG,"");
  94 COLL_APPLY(COLL_SETTER,COLL_ALLTOALLV_SIG,"");
  95
  96 void Colls::set_collectives(){
  97   std::string selector_name = simgrid::config::get_value<std::string>("smpi/coll-selector");
  98   if (selector_name.empty())
  99     selector_name = "default";
 100
 101   std::pair<std::string, std::function<void(std::string)>> setter_callbacks[] = {
 102       {"gather", &Colls::set_gather},         {"allgather", &Colls::set_allgather},
 103       {"allgatherv", &Colls::set_allgatherv}, {"allreduce", &Colls::set_allreduce},
 104       {"alltoall", &Colls::set_alltoall},     {"alltoallv", &Colls::set_alltoallv},
 105       {"reduce", &Colls::set_reduce},         {"reduce_scatter", &Colls::set_reduce_scatter},
 106       {"scatter", &Colls::set_scatter},       {"bcast", &Colls::set_bcast},
 107       {"barrier", &Colls::set_barrier}};
 108
 109   for (auto& elem : setter_callbacks) {
 110     std::string name = simgrid::config::get_value<std::string>(("smpi/" + elem.first).c_str());
 111     if (name.empty())
 112       name = selector_name;
 113
 114     (elem.second)(name);
 115   }
 116 }
 117
 118
 119 //Implementations of the single algorith collectives
 120
 121 int Colls::gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *displs,
 122                       MPI_Datatype recvtype, int root, MPI_Comm comm)
 123 {
 124   int system_tag = COLL_TAG_GATHERV;
 125   MPI_Aint lb = 0;
 126   MPI_Aint recvext = 0;
 127
 128   int rank = comm->rank();
 129   int size = comm->size();
 130   if (rank != root) {
 131     // Send buffer to root
 132     Request::send(sendbuf, sendcount, sendtype, root, system_tag, comm);
 133   } else {
 134     recvtype->extent(&lb, &recvext);
 135     // Local copy from root
 136     Datatype::copy(sendbuf, sendcount, sendtype, static_cast<char*>(recvbuf) + displs[root] * recvext,
 137                        recvcounts[root], recvtype);
 138     // Receive buffers from senders
 139     MPI_Request *requests = xbt_new(MPI_Request, size - 1);
 140     int index = 0;
 141     for (int src = 0; src < size; src++) {
 142       if(src != root) {
 143         requests[index] = Request::irecv_init(static_cast<char*>(recvbuf) + displs[src] * recvext,
 144                           recvcounts[src], recvtype, src, system_tag, comm);
 145         index++;
 146       }
 147     }
 148     // Wait for completion of irecv's.
 149     Request::startall(size - 1, requests);
 150     Request::waitall(size - 1, requests, MPI_STATUS_IGNORE);
 151     for (int src = 0; src < size-1; src++) {
 152       Request::unref(&requests[src]);
 153     }
 154     xbt_free(requests);
 155   }
 156   return MPI_SUCCESS;
 157 }
 158
 159
 160 int Colls::scatterv(void *sendbuf, int *sendcounts, int *displs, MPI_Datatype sendtype, void *recvbuf, int recvcount,
 161                        MPI_Datatype recvtype, int root, MPI_Comm comm)
 162 {
 163   int system_tag = COLL_TAG_SCATTERV;
 164   MPI_Aint lb = 0;
 165   MPI_Aint sendext = 0;
 166
 167   int rank = comm->rank();
 168   int size = comm->size();
 169   if(rank != root) {
 170     // Recv buffer from root
 171     Request::recv(recvbuf, recvcount, recvtype, root, system_tag, comm, MPI_STATUS_IGNORE);
 172   } else {
 173     sendtype->extent(&lb, &sendext);
 174     // Local copy from root
 175     if(recvbuf!=MPI_IN_PLACE){
 176       Datatype::copy(static_cast<char *>(sendbuf) + displs[root] * sendext, sendcounts[root],
 177                        sendtype, recvbuf, recvcount, recvtype);
 178     }
 179     // Send buffers to receivers
 180     MPI_Request *requests = xbt_new(MPI_Request, size - 1);
 181     int index = 0;
 182     for (int dst = 0; dst < size; dst++) {
 183       if (dst != root) {
 184         requests[index] = Request::isend_init(static_cast<char *>(sendbuf) + displs[dst] * sendext, sendcounts[dst],
 185                             sendtype, dst, system_tag, comm);
 186         index++;
 187       }
 188     }
 189     // Wait for completion of isend's.
 190     Request::startall(size - 1, requests);
 191     Request::waitall(size - 1, requests, MPI_STATUS_IGNORE);
 192     for (int dst = 0; dst < size-1; dst++) {
 193       Request::unref(&requests[dst]);
 194     }
 195     xbt_free(requests);
 196   }
 197   return MPI_SUCCESS;
 198 }
 199
 200
 201 int Colls::scan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 202 {
 203   int system_tag = -888;
 204   MPI_Aint lb      = 0;
 205   MPI_Aint dataext = 0;
 206
 207   int rank = comm->rank();
 208   int size = comm->size();
 209
 210   datatype->extent(&lb, &dataext);
 211
 212   // Local copy from self
 213   Datatype::copy(sendbuf, count, datatype, recvbuf, count, datatype);
 214
 215   // Send/Recv buffers to/from others
 216   MPI_Request *requests = xbt_new(MPI_Request, size - 1);
 217   void **tmpbufs = xbt_new(void *, rank);
 218   int index = 0;
 219   for (int other = 0; other < rank; other++) {
 220     tmpbufs[index] = smpi_get_tmp_sendbuffer(count * dataext);
 221     requests[index] = Request::irecv_init(tmpbufs[index], count, datatype, other, system_tag, comm);
 222     index++;
 223   }
 224   for (int other = rank + 1; other < size; other++) {
 225     requests[index] = Request::isend_init(sendbuf, count, datatype, other, system_tag, comm);
 226     index++;
 227   }
 228   // Wait for completion of all comms.
 229   Request::startall(size - 1, requests);
 230
 231   if(op != MPI_OP_NULL && op->is_commutative()){
 232     for (int other = 0; other < size - 1; other++) {
 233       index = Request::waitany(size - 1, requests, MPI_STATUS_IGNORE);
 234       if(index == MPI_UNDEFINED) {
 235         break;
 236       }
 237       if(index < rank) {
 238         // #Request is below rank: it's a irecv
 239         op->apply( tmpbufs[index], recvbuf, &count, datatype);
 240       }
 241     }
 242   }else{
 243     //non commutative case, wait in order
 244     for (int other = 0; other < size - 1; other++) {
 245       Request::wait(&(requests[other]), MPI_STATUS_IGNORE);
 246       if(index < rank && op!=MPI_OP_NULL) {
 247         op->apply( tmpbufs[other], recvbuf, &count, datatype);
 248       }
 249     }
 250   }
 251   for(index = 0; index < rank; index++) {
 252     smpi_free_tmp_buffer(tmpbufs[index]);
 253   }
 254   for(index = 0; index < size-1; index++) {
 255     Request::unref(&requests[index]);
 256   }
 257   xbt_free(tmpbufs);
 258   xbt_free(requests);
 259   return MPI_SUCCESS;
 260 }
 261
 262 int Colls::exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
 263 {
 264   int system_tag = -888;
 265   MPI_Aint lb         = 0;
 266   MPI_Aint dataext    = 0;
 267   int recvbuf_is_empty=1;
 268   int rank = comm->rank();
 269   int size = comm->size();
 270
 271   datatype->extent(&lb, &dataext);
 272
 273   // Send/Recv buffers to/from others
 274   MPI_Request *requests = xbt_new(MPI_Request, size - 1);
 275   void **tmpbufs = xbt_new(void *, rank);
 276   int index = 0;
 277   for (int other = 0; other < rank; other++) {
 278     tmpbufs[index] = smpi_get_tmp_sendbuffer(count * dataext);
 279     requests[index] = Request::irecv_init(tmpbufs[index], count, datatype, other, system_tag, comm);
 280     index++;
 281   }
 282   for (int other = rank + 1; other < size; other++) {
 283     requests[index] = Request::isend_init(sendbuf, count, datatype, other, system_tag, comm);
 284     index++;
 285   }
 286   // Wait for completion of all comms.
 287   Request::startall(size - 1, requests);
 288
 289   if(op != MPI_OP_NULL && op->is_commutative()){
 290     for (int other = 0; other < size - 1; other++) {
 291       index = Request::waitany(size - 1, requests, MPI_STATUS_IGNORE);
 292       if(index == MPI_UNDEFINED) {
 293         break;
 294       }
 295       if(index < rank) {
 296         if(recvbuf_is_empty){
 297           Datatype::copy(tmpbufs[index], count, datatype, recvbuf, count, datatype);
 298           recvbuf_is_empty=0;
 299         } else
 300           // #Request is below rank: it's a irecv
 301           op->apply( tmpbufs[index], recvbuf, &count, datatype);
 302       }
 303     }
 304   }else{
 305     //non commutative case, wait in order
 306     for (int other = 0; other < size - 1; other++) {
 307      Request::wait(&(requests[other]), MPI_STATUS_IGNORE);
 308       if(index < rank) {
 309         if (recvbuf_is_empty) {
 310           Datatype::copy(tmpbufs[other], count, datatype, recvbuf, count, datatype);
 311           recvbuf_is_empty = 0;
 312         } else
 313           if(op!=MPI_OP_NULL)
 314             op->apply( tmpbufs[other], recvbuf, &count, datatype);
 315       }
 316     }
 317   }
 318   for(index = 0; index < rank; index++) {
 319     smpi_free_tmp_buffer(tmpbufs[index]);
 320   }
 321   for(index = 0; index < size-1; index++) {
 322     Request::unref(&requests[index]);
 323   }
 324   xbt_free(tmpbufs);
 325   xbt_free(requests);
 326   return MPI_SUCCESS;
 327 }
 328
 329 }
 330 }