src/smpi/colls/alltoall-simple.c

   1 #include "colls.h"
   2
   3 /*****************************************************************************
   4
   5  * Function: alltoall_spreading_simple
   6
   7  * Return: int
   8
   9  *  Inputs:
  10     send_buff: send input buffer
  11     send_count: number of elements to send
  12     send_type: data type of elements being sent
  13     recv_buff: receive output buffer
  14     recv_count: number of elements to received
  15     recv_type: data type of elements being received
  16     comm: communicator
  17
  18  * Descrp: Let i -> j denote the communication from node i to node j. The
  19           order of communications for node i is i -> i + 1, i -> i + 2, ...,
  20           i -> (i + p -1) % P.
  21
  22  * Auther: Ahmad Faraj
  23
  24  ****************************************************************************/
  25 int smpi_coll_tuned_alltoall_simple(void *send_buff, int send_count,
  26                                     MPI_Datatype send_type,
  27                                     void *recv_buff, int recv_count,
  28                                     MPI_Datatype recv_type,
  29                                     MPI_Comm comm)
  30 {
  31   int i, rank, size, nreqs, err, src, dst, tag = 101;
  32   char *psnd;
  33   char *prcv;
  34   MPI_Aint sndinc;
  35   MPI_Aint rcvinc;
  36   MPI_Request *req;
  37   MPI_Request *preq;
  38   MPI_Request *qreq;
  39   MPI_Status s, *statuses;
  40
  41
  42   MPI_Comm_size(comm, &size);
  43   MPI_Comm_rank(comm, &rank);
  44   MPI_Type_extent(send_type, &sndinc);
  45   MPI_Type_extent(recv_type, &rcvinc);
  46   sndinc *= send_count;
  47   rcvinc *= recv_count;
  48
  49   /* Allocate arrays of requests. */
  50
  51   nreqs = 2 * (size - 1);
  52   if (nreqs > 0) {
  53     req = (MPI_Request *) malloc(nreqs * sizeof(MPI_Request));
  54     statuses = (MPI_Status *) malloc(nreqs * sizeof(MPI_Status));
  55     if (!req || !statuses) {
  56       free(req);
  57       free(statuses);
  58       return 0;
  59     }
  60   } else {
  61     req = NULL;
  62     statuses = NULL;
  63   }
  64
  65   /* simple optimization */
  66
  67   psnd = ((char *) send_buff) + (rank * sndinc);
  68   prcv = ((char *) recv_buff) + (rank * rcvinc);
  69   MPI_Sendrecv(psnd, send_count, send_type, rank, tag,
  70                prcv, recv_count, recv_type, rank, tag, comm, &s);
  71
  72
  73   /* Initiate all send/recv to/from others. */
  74
  75   preq = req;
  76   qreq = req + size - 1;
  77   prcv = (char *) recv_buff;
  78   psnd = (char *) send_buff;
  79   for (i = 0; i < size; i++) {
  80     src = dst = (rank + i) % size;
  81     if (src == rank)
  82       continue;
  83     if (dst == rank)
  84       continue;
  85     MPI_Recv_init(prcv + (src * rcvinc), recv_count, recv_type, src,
  86                   tag, comm, preq++);
  87     MPI_Send_init(psnd + (dst * sndinc), send_count, send_type, dst,
  88                   tag, comm, qreq++);
  89   }
  90
  91   /* Start all the requests. */
  92
  93   err = MPI_Startall(nreqs, req);
  94
  95   /* Wait for them all. */
  96
  97   err = MPI_Waitall(nreqs, req, statuses);
  98
  99   if (err != MPI_SUCCESS) {
 100     if (req)
 101       free((char *) req);
 102     return err;
 103   }
 104
 105   for (i = 0, preq = req; i < nreqs; ++i, ++preq) {
 106     err = MPI_Request_free(preq);
 107     if (err != MPI_SUCCESS) {
 108       if (req)
 109         free((char *) req);
 110       if (statuses)
 111         free(statuses);
 112       return err;
 113     }
 114   }
 115
 116   /* All done */
 117
 118   if (req)
 119     free((char *) req);
 120   if (statuses)
 121     free(statuses);
 122   return (1);
 123 }