teshsuite/smpi/alltoallv.c

   1 /* -*- Mode: C; c-basic-offset:4 ; -*- */
   2 /*
   3  *  (C) 2001 by Argonne National Laboratory.
   4  *      See COPYRIGHT in top-level directory.
   5  */
   6 #include "mpi.h"
   7 #include <string.h>
   8
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11
  12 /*
  13    This program tests MPI_Alltoallv by having processor i send different
  14    amounts of data to each processor.
  15
  16    Because there are separate send and receive types to alltoallv,
  17    there need to be tests to rearrange data on the fly.  Not done yet.
  18
  19    The first test sends i items to processor i from all processors.
  20
  21    Currently, the test uses only MPI_INT; this is adequate for testing systems
  22    that use point-to-point operations
  23  */
  24
  25
  26 /* example values:
  27  * For 3 processes:
  28  * <0> sbuf: (#9):   [0][1][2][3][4][5][6][7][8]
  29    <0> scount: (#3): [0][1][2]
  30    <0> rcount: (#3): [0][0][0]
  31    <0> sdisp: (#3):  [0][1][3]
  32    <0> rdisp: (#3):  [0][0][0]
  33
  34    <1> sbuf: (#9):   [100][101][102][103][104][105][106][107][108]
  35    <1> scount: (#3): [0][1][2]
  36    <1> rcount: (#3): [1][1][1]
  37    <1> sdisp: (#3):  [0][1][3]
  38    <1> rdisp: (#3):  [0][1][2]
  39
  40    <2> sbuf: (#9):   [200][201][202][203][204][205][206][207][208]
  41    <2> scount: (#3): [0][1][2]
  42    <2> rcount: (#3): [2][2][2]
  43    <2> sdisp: (#3):  [0][1][3]
  44    <2> rdisp: (#3):  [0][2][4]
  45
  46    after MPI_Alltoallv :
  47    <0> rbuf: (#9):   [0][-1][-2][-3][-4][-5][-6][-7][-8]
  48    <1> rbuf: (#9):   [1][101][201][-3][-4][-5][-6][-7][-8]
  49    <2> rbuf: (#9):   [3][4][103][104][203][204][-6][-7][-8]
  50 */
  51
  52
  53 static void print_buffer_int(void *buf, int len, char *msg, int rank)
  54 {
  55   int tmp, *v;
  56   printf("**<%d> %s (#%d): ", rank, msg, len);
  57   for (tmp = 0; tmp < len; tmp++) {
  58     v = buf;
  59     printf("[%d]", v[tmp]);
  60   }
  61   printf("\n");
  62   free(msg);
  63 }
  64
  65
  66 int main(int argc, char **argv)
  67 {
  68
  69   MPI_Comm comm;
  70   int *sbuf, *rbuf, *erbuf;
  71   int rank, size;
  72   int *sendcounts, *recvcounts, *rdispls, *sdispls;
  73   int i, j, *p, err;
  74
  75   MPI_Init(&argc, &argv);
  76   err = 0;
  77
  78   comm = MPI_COMM_WORLD;
  79
  80   /* Create the buffer */
  81   MPI_Comm_size(comm, &size);
  82   MPI_Comm_rank(comm, &rank);
  83   sbuf = (int *) malloc(size * size * sizeof(int));
  84   rbuf = (int *) malloc(size * size * sizeof(int));
  85   erbuf = (int *) malloc(size * size * sizeof(int));    // expected
  86   if (!sbuf || !rbuf) {
  87     fprintf(stderr, "Could not allocated buffers!\n");
  88     MPI_Abort(comm, 1);
  89   }
  90
  91   /* Load up the buffers */
  92   for (i = 0; i < size * size; i++) {
  93     sbuf[i] = i + 100 * rank;
  94     rbuf[i] = -i;
  95     erbuf[i] = -i;
  96   }
  97
  98   /* Create and load the arguments to alltoallv */
  99   sendcounts = (int *) malloc(size * sizeof(int));
 100   recvcounts = (int *) malloc(size * sizeof(int));
 101   rdispls = (int *) malloc(size * sizeof(int));
 102   sdispls = (int *) malloc(size * sizeof(int));
 103   if (!sendcounts || !recvcounts || !rdispls || !sdispls) {
 104     fprintf(stderr, "Could not allocate arg items!\n");
 105     MPI_Abort(comm, 1);
 106   }
 107   for (i = 0; i < size; i++) {
 108     sendcounts[i] = i;
 109     recvcounts[i] = rank;
 110     rdispls[i] = i * rank;
 111     sdispls[i] = (i * (i + 1)) / 2;
 112   }
 113
 114   /* debug */
 115   /*
 116      print_buffer_int( sbuf, size*size, strdup("sbuf:"),rank);
 117      print_buffer_int( sendcounts, size, strdup("scount:"),rank);
 118      print_buffer_int( recvcounts, size, strdup("rcount:"),rank);
 119      print_buffer_int( sdispls, size, strdup("sdisp:"),rank);
 120      print_buffer_int( rdispls, size, strdup("rdisp:"),rank);
 121    */
 122
 123
 124   /* debug : erbuf */
 125   /* debug
 126      for (i=0; i<size; i++) {
 127      for (j=0; j<rank; j++) {
 128      *(erbuf+j+ rdispls[i]) = i * 100 + (rank*(rank+1))/2 + j;
 129      }
 130      }
 131    */
 132
 133
 134   //print_buffer_int( erbuf, size*size, strdup("erbuf:"),rank);
 135
 136   MPI_Alltoallv(sbuf, sendcounts, sdispls, MPI_INT,
 137                 rbuf, recvcounts, rdispls, MPI_INT, comm);
 138
 139   // debug: print_buffer_int( rbuf, size*size, strdup("rbuf:"),rank);
 140
 141
 142   /* Check rbuf */
 143   for (i = 0; i < size; i++) {
 144     p = rbuf + rdispls[i];
 145     for (j = 0; j < rank; j++) {
 146       if (p[j] != i * 100 + (rank * (rank + 1)) / 2 + j) {
 147         fprintf(stderr, "** Error: <%d> got %d expected %d for %dth\n",
 148                 rank, p[j], (i * (i + 1)) / 2 + j, j);
 149         err++;
 150       }
 151     }
 152   }
 153
 154   /* Summary */
 155   if (err > 0) {
 156     printf("<%d> Alltoallv test: failure (%d errors).\n", rank, err);
 157   }
 158   if (0 == rank) {
 159     printf("* Alltoallv TEST COMPLETE.\n");
 160   }
 161   free(sdispls);
 162   free(rdispls);
 163   free(recvcounts);
 164   free(sendcounts);
 165   free(rbuf);
 166   free(sbuf);
 167
 168   MPI_Barrier(MPI_COMM_WORLD);
 169   MPI_Finalize();
 170   return 0;
 171 }