teshsuite/smpi/mpich3-test/coll/nonblocking2.c

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
   2 /*
   3  *  (C) 2011 by Argonne National Laboratory.
   4  *      See COPYRIGHT in top-level directory.
   5  */
   6
   7 /* A basic test of all 17 nonblocking collective operations specified by the
   8  * MPI-3 standard.  It only exercises the intracommunicator functionality,
   9  * does not use MPI_IN_PLACE, and only transmits/receives simple integer types
  10  * with relatively small counts.  It does check a few fancier issues, such as
  11  * ensuring that "premature user releases" of MPI_Op and MPI_Datatype objects
  12  * does not result in an error or segfault. */
  13
  14 #include "mpi.h"
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17
  18 #define COUNT (10)
  19 #define PRIME (17)
  20
  21 #define my_assert(cond_)                                                  \
  22     do {                                                                  \
  23         if (!(cond_)) {                                                   \
  24             fprintf(stderr, "assertion (%s) failed, aborting\n", #cond_); \
  25             MPI_Abort(MPI_COMM_WORLD, 1);                                 \
  26         }                                                                 \
  27     } while (0)
  28
  29 static void sum_fn(void *invec, void *inoutvec, int *len, MPI_Datatype * datatype)
  30 {
  31     int i;
  32     int *in = invec;
  33     int *inout = inoutvec;
  34     for (i = 0; i < *len; ++i) {
  35         inout[i] = in[i] + inout[i];
  36     }
  37 }
  38
  39
  40 int main(int argc, char **argv)
  41 {
  42     int i, j;
  43     int rank, size;
  44     int *buf = NULL;
  45     int *recvbuf = NULL;
  46     int *sendcounts = NULL;
  47     int *recvcounts = NULL;
  48     int *sdispls = NULL;
  49     int *rdispls = NULL;
  50     MPI_Datatype *sendtypes = NULL;
  51     MPI_Datatype *recvtypes = NULL;
  52     signed char *buf_alias = NULL;
  53     MPI_Request req;
  54
  55     MPI_Init(&argc, &argv);
  56     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  57     MPI_Comm_size(MPI_COMM_WORLD, &size);
  58
  59     buf = malloc(COUNT * size * sizeof(int));
  60     recvbuf = malloc(COUNT * size * sizeof(int));
  61     sendcounts = malloc(size * sizeof(int));
  62     recvcounts = malloc(size * sizeof(int));
  63     sdispls = malloc(size * sizeof(int));
  64     rdispls = malloc(size * sizeof(int));
  65     sendtypes = malloc(size * sizeof(MPI_Datatype));
  66     recvtypes = malloc(size * sizeof(MPI_Datatype));
  67
  68     /* MPI_Ibcast */
  69     for (i = 0; i < COUNT; ++i) {
  70         if (rank == 0) {
  71             buf[i] = i;
  72         }
  73         else {
  74             buf[i] = 0xdeadbeef;
  75         }
  76     }
  77     MPI_Ibcast(buf, COUNT, MPI_INT, 0, MPI_COMM_WORLD, &req);
  78     MPI_Wait(&req, MPI_STATUS_IGNORE);
  79
  80     for (i = 0; i < COUNT; ++i) {
  81         if (buf[i] != i)
  82             printf("buf[%d]=%d i=%d\n", i, buf[i], i);
  83         my_assert(buf[i] == i);
  84     }
  85
  86     /* MPI_Ibcast (again, but designed to stress scatter/allgather impls) */
  87     buf_alias = (signed char *) buf;
  88     my_assert(COUNT * size * sizeof(int) > PRIME);      /* sanity */
  89     for (i = 0; i < PRIME; ++i) {
  90         if (rank == 0)
  91             buf_alias[i] = i;
  92         else
  93             buf_alias[i] = 0xdb;
  94     }
  95     for (i = PRIME; i < COUNT * size * sizeof(int); ++i) {
  96         buf_alias[i] = 0xbf;
  97     }
  98     MPI_Ibcast(buf_alias, PRIME, MPI_SIGNED_CHAR, 0, MPI_COMM_WORLD, &req);
  99     MPI_Wait(&req, MPI_STATUS_IGNORE);
 100     for (i = 0; i < PRIME; ++i) {
 101         if (buf_alias[i] != i)
 102             printf("buf_alias[%d]=%d i=%d\n", i, buf_alias[i], i);
 103         my_assert(buf_alias[i] == i);
 104     }
 105
 106     /* MPI_Ibarrier */
 107     MPI_Ibarrier(MPI_COMM_WORLD, &req);
 108     MPI_Wait(&req, MPI_STATUS_IGNORE);
 109
 110     /* MPI_Ireduce */
 111     for (i = 0; i < COUNT; ++i) {
 112         buf[i] = rank + i;
 113         recvbuf[i] = 0xdeadbeef;
 114     }
 115     MPI_Ireduce(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD, &req);
 116     MPI_Wait(&req, MPI_STATUS_IGNORE);
 117     if (rank == 0) {
 118         for (i = 0; i < COUNT; ++i) {
 119             if (recvbuf[i] != ((size * (size - 1) / 2) + (i * size)))
 120                 printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i],
 121                        ((size * (size - 1) / 2) + (i * size)));
 122             my_assert(recvbuf[i] == ((size * (size - 1) / 2) + (i * size)));
 123         }
 124     }
 125
 126     /* same again, use a user op and free it before the wait */
 127     {
 128         MPI_Op op = MPI_OP_NULL;
 129         MPI_Op_create(sum_fn, 1, &op);
 130         for (i = 0; i < COUNT; ++i) {
 131             buf[i] = rank + i;
 132             recvbuf[i] = 0xdeadbeef;
 133         }
 134         MPI_Ireduce(buf, recvbuf, COUNT, MPI_INT, op, 0, MPI_COMM_WORLD, &req);
 135         MPI_Op_free(&op);
 136         MPI_Wait(&req, MPI_STATUS_IGNORE);
 137         if (rank == 0) {
 138             for (i = 0; i < COUNT; ++i) {
 139                 if (recvbuf[i] != ((size * (size - 1) / 2) + (i * size)))
 140                     printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i],
 141                            ((size * (size - 1) / 2) + (i * size)));
 142                 my_assert(recvbuf[i] == ((size * (size - 1) / 2) + (i * size)));
 143             }
 144         }
 145     }
 146
 147     /* MPI_Iallreduce */
 148     for (i = 0; i < COUNT; ++i) {
 149         buf[i] = rank + i;
 150         recvbuf[i] = 0xdeadbeef;
 151     }
 152     MPI_Iallreduce(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req);
 153     MPI_Wait(&req, MPI_STATUS_IGNORE);
 154     for (i = 0; i < COUNT; ++i) {
 155         if (recvbuf[i] != ((size * (size - 1) / 2) + (i * size)))
 156             printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i],
 157                    ((size * (size - 1) / 2) + (i * size)));
 158         my_assert(recvbuf[i] == ((size * (size - 1) / 2) + (i * size)));
 159     }
 160
 161     /* MPI_Ialltoallv (a weak test, neither irregular nor sparse) */
 162     for (i = 0; i < size; ++i) {
 163         sendcounts[i] = COUNT;
 164         recvcounts[i] = COUNT;
 165         sdispls[i] = COUNT * i;
 166         rdispls[i] = COUNT * i;
 167         for (j = 0; j < COUNT; ++j) {
 168             buf[i * COUNT + j] = rank + (i * j);
 169             recvbuf[i * COUNT + j] = 0xdeadbeef;
 170         }
 171     }
 172     MPI_Ialltoallv(buf, sendcounts, sdispls, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT,
 173                    MPI_COMM_WORLD, &req);
 174     MPI_Wait(&req, MPI_STATUS_IGNORE);
 175     for (i = 0; i < size; ++i) {
 176         for (j = 0; j < COUNT; ++j) {
 177             /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (rank * j))); */
 178             my_assert(recvbuf[i * COUNT + j] == (i + (rank * j)));
 179         }
 180     }
 181
 182     /* MPI_Igather */
 183     for (i = 0; i < size * COUNT; ++i) {
 184         buf[i] = rank + i;
 185         recvbuf[i] = 0xdeadbeef;
 186     }
 187     MPI_Igather(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, 0, MPI_COMM_WORLD, &req);
 188     MPI_Wait(&req, MPI_STATUS_IGNORE);
 189     if (rank == 0) {
 190         for (i = 0; i < size; ++i) {
 191             for (j = 0; j < COUNT; ++j) {
 192                 my_assert(recvbuf[i * COUNT + j] == i + j);
 193             }
 194         }
 195     }
 196     else {
 197         for (i = 0; i < size * COUNT; ++i) {
 198             my_assert(recvbuf[i] == 0xdeadbeef);
 199         }
 200     }
 201
 202     /* same test again, just use a dup'ed datatype and free it before the wait */
 203     {
 204         MPI_Datatype type = MPI_DATATYPE_NULL;
 205         MPI_Type_dup(MPI_INT, &type);
 206
 207         for (i = 0; i < size * COUNT; ++i) {
 208             buf[i] = rank + i;
 209             recvbuf[i] = 0xdeadbeef;
 210         }
 211         MPI_Igather(buf, COUNT, MPI_INT, recvbuf, COUNT, type, 0, MPI_COMM_WORLD, &req);
 212         MPI_Type_free(&type);   /* should cause implementations that don't refcount
 213                                  * correctly to blow up or hang in the wait */
 214         MPI_Wait(&req, MPI_STATUS_IGNORE);
 215         if (rank == 0) {
 216             for (i = 0; i < size; ++i) {
 217                 for (j = 0; j < COUNT; ++j) {
 218                     my_assert(recvbuf[i * COUNT + j] == i + j);
 219                 }
 220             }
 221         }
 222         else {
 223             for (i = 0; i < size * COUNT; ++i) {
 224                 my_assert(recvbuf[i] == 0xdeadbeef);
 225             }
 226         }
 227     }
 228
 229     /* MPI_Iscatter */
 230     for (i = 0; i < size; ++i) {
 231         for (j = 0; j < COUNT; ++j) {
 232             if (rank == 0)
 233                 buf[i * COUNT + j] = i + j;
 234             else
 235                 buf[i * COUNT + j] = 0xdeadbeef;
 236             recvbuf[i * COUNT + j] = 0xdeadbeef;
 237         }
 238     }
 239     MPI_Iscatter(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, 0, MPI_COMM_WORLD, &req);
 240     MPI_Wait(&req, MPI_STATUS_IGNORE);
 241     for (j = 0; j < COUNT; ++j) {
 242         my_assert(recvbuf[j] == rank + j);
 243     }
 244     if (rank != 0) {
 245         for (i = 0; i < size * COUNT; ++i) {
 246             /* check we didn't corrupt the sendbuf somehow */
 247             my_assert(buf[i] == 0xdeadbeef);
 248         }
 249     }
 250
 251     /* MPI_Iscatterv */
 252     for (i = 0; i < size; ++i) {
 253         /* weak test, just test the regular case where all counts are equal */
 254         sendcounts[i] = COUNT;
 255         sdispls[i] = i * COUNT;
 256         for (j = 0; j < COUNT; ++j) {
 257             if (rank == 0)
 258                 buf[i * COUNT + j] = i + j;
 259             else
 260                 buf[i * COUNT + j] = 0xdeadbeef;
 261             recvbuf[i * COUNT + j] = 0xdeadbeef;
 262         }
 263     }
 264     MPI_Iscatterv(buf, sendcounts, sdispls, MPI_INT, recvbuf, COUNT, MPI_INT, 0, MPI_COMM_WORLD,
 265                   &req);
 266     MPI_Wait(&req, MPI_STATUS_IGNORE);
 267     for (j = 0; j < COUNT; ++j) {
 268         my_assert(recvbuf[j] == rank + j);
 269     }
 270     if (rank != 0) {
 271         for (i = 0; i < size * COUNT; ++i) {
 272             /* check we didn't corrupt the sendbuf somehow */
 273             my_assert(buf[i] == 0xdeadbeef);
 274         }
 275     }
 276     for (i = 1; i < size; ++i) {
 277         for (j = 0; j < COUNT; ++j) {
 278             /* check we didn't corrupt the rest of the recvbuf */
 279             my_assert(recvbuf[i * COUNT + j] == 0xdeadbeef);
 280         }
 281     }
 282
 283     /* MPI_Ireduce_scatter */
 284 /*    for (i = 0; i < size; ++i) {*/
 285 /*        recvcounts[i] = COUNT;*/
 286 /*        for (j = 0; j < COUNT; ++j) {*/
 287 /*            buf[i * COUNT + j] = rank + i;*/
 288 /*            recvbuf[i * COUNT + j] = 0xdeadbeef;*/
 289 /*        }*/
 290 /*    }*/
 291 /*    MPI_Ireduce_scatter(buf, recvbuf, recvcounts, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req);*/
 292 /*    MPI_Wait(&req, MPI_STATUS_IGNORE);*/
 293 /*    for (j = 0; j < COUNT; ++j) {*/
 294 /*        my_assert(recvbuf[j] == (size * rank + ((size - 1) * size) / 2));*/
 295 /*    }*/
 296 /*    for (i = 1; i < size; ++i) {*/
 297 /*        for (j = 0; j < COUNT; ++j) {*/
 298             /* check we didn't corrupt the rest of the recvbuf */
 299 /*            my_assert(recvbuf[i * COUNT + j] == 0xdeadbeef);*/
 300 /*        }*/
 301 /*    }*/
 302
 303     /* MPI_Ireduce_scatter_block */
 304 /*    for (i = 0; i < size; ++i) {*/
 305 /*        for (j = 0; j < COUNT; ++j) {*/
 306 /*            buf[i * COUNT + j] = rank + i;*/
 307 /*            recvbuf[i * COUNT + j] = 0xdeadbeef;*/
 308 /*        }*/
 309 /*    }*/
 310 /*    MPI_Ireduce_scatter_block(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req);*/
 311 /*    MPI_Wait(&req, MPI_STATUS_IGNORE);*/
 312 /*    for (j = 0; j < COUNT; ++j) {*/
 313 /*        my_assert(recvbuf[j] == (size * rank + ((size - 1) * size) / 2));*/
 314 /*    }*/
 315 /*    for (i = 1; i < size; ++i) {*/
 316 /*        for (j = 0; j < COUNT; ++j) {*/
 317             /* check we didn't corrupt the rest of the recvbuf */
 318 /*            my_assert(recvbuf[i * COUNT + j] == 0xdeadbeef);*/
 319 /*        }*/
 320 /*    }*/
 321
 322     /* MPI_Igatherv */
 323     for (i = 0; i < size * COUNT; ++i) {
 324         buf[i] = 0xdeadbeef;
 325         recvbuf[i] = 0xdeadbeef;
 326     }
 327     for (i = 0; i < COUNT; ++i) {
 328         buf[i] = rank + i;
 329     }
 330     for (i = 0; i < size; ++i) {
 331         recvcounts[i] = COUNT;
 332         rdispls[i] = i * COUNT;
 333     }
 334     MPI_Igatherv(buf, COUNT, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, 0, MPI_COMM_WORLD,
 335                  &req);
 336     MPI_Wait(&req, MPI_STATUS_IGNORE);
 337     if (rank == 0) {
 338         for (i = 0; i < size; ++i) {
 339             for (j = 0; j < COUNT; ++j) {
 340                 my_assert(recvbuf[i * COUNT + j] == i + j);
 341             }
 342         }
 343     }
 344     else {
 345         for (i = 0; i < size * COUNT; ++i) {
 346             my_assert(recvbuf[i] == 0xdeadbeef);
 347         }
 348     }
 349
 350     /* MPI_Ialltoall */
 351     for (i = 0; i < size; ++i) {
 352         for (j = 0; j < COUNT; ++j) {
 353             buf[i * COUNT + j] = rank + (i * j);
 354             recvbuf[i * COUNT + j] = 0xdeadbeef;
 355         }
 356     }
 357     MPI_Ialltoall(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, MPI_COMM_WORLD, &req);
 358     MPI_Wait(&req, MPI_STATUS_IGNORE);
 359     for (i = 0; i < size; ++i) {
 360         for (j = 0; j < COUNT; ++j) {
 361             /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (i * j))); */
 362             my_assert(recvbuf[i * COUNT + j] == (i + (rank * j)));
 363         }
 364     }
 365
 366     /* MPI_Iallgather */
 367     for (i = 0; i < size * COUNT; ++i) {
 368         buf[i] = rank + i;
 369         recvbuf[i] = 0xdeadbeef;
 370     }
 371     MPI_Iallgather(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, MPI_COMM_WORLD, &req);
 372     MPI_Wait(&req, MPI_STATUS_IGNORE);
 373     for (i = 0; i < size; ++i) {
 374         for (j = 0; j < COUNT; ++j) {
 375             my_assert(recvbuf[i * COUNT + j] == i + j);
 376         }
 377     }
 378
 379     /* MPI_Iallgatherv */
 380     for (i = 0; i < size; ++i) {
 381         for (j = 0; j < COUNT; ++j) {
 382             recvbuf[i * COUNT + j] = 0xdeadbeef;
 383         }
 384         recvcounts[i] = COUNT;
 385         rdispls[i] = i * COUNT;
 386     }
 387     for (i = 0; i < COUNT; ++i)
 388         buf[i] = rank + i;
 389     MPI_Iallgatherv(buf, COUNT, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, MPI_COMM_WORLD,
 390                     &req);
 391     MPI_Wait(&req, MPI_STATUS_IGNORE);
 392     for (i = 0; i < size; ++i) {
 393         for (j = 0; j < COUNT; ++j) {
 394             my_assert(recvbuf[i * COUNT + j] == i + j);
 395         }
 396     }
 397
 398     /* MPI_Iscan */
 399     for (i = 0; i < COUNT; ++i) {
 400         buf[i] = rank + i;
 401         recvbuf[i] = 0xdeadbeef;
 402     }
 403     MPI_Iscan(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req);
 404     MPI_Wait(&req, MPI_STATUS_IGNORE);
 405     for (i = 0; i < COUNT; ++i) {
 406         my_assert(recvbuf[i] == ((rank * (rank + 1) / 2) + (i * (rank + 1))));
 407     }
 408
 409     /* MPI_Iexscan */
 410     for (i = 0; i < COUNT; ++i) {
 411         buf[i] = rank + i;
 412         recvbuf[i] = 0xdeadbeef;
 413     }
 414     MPI_Iexscan(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req);
 415     MPI_Wait(&req, MPI_STATUS_IGNORE);
 416     for (i = 0; i < COUNT; ++i) {
 417         if (rank == 0)
 418             my_assert(recvbuf[i] == 0xdeadbeef);
 419         else
 420             my_assert(recvbuf[i] == ((rank * (rank + 1) / 2) + (i * (rank + 1)) - (rank + i)));
 421     }
 422
 423     /* MPI_Ialltoallw (a weak test, neither irregular nor sparse) */
 424     for (i = 0; i < size; ++i) {
 425         sendcounts[i] = COUNT;
 426         recvcounts[i] = COUNT;
 427         sdispls[i] = COUNT * i * sizeof(int);
 428         rdispls[i] = COUNT * i * sizeof(int);
 429         sendtypes[i] = MPI_INT;
 430         recvtypes[i] = MPI_INT;
 431         for (j = 0; j < COUNT; ++j) {
 432             buf[i * COUNT + j] = rank + (i * j);
 433             recvbuf[i * COUNT + j] = 0xdeadbeef;
 434         }
 435     }
 436     MPI_Ialltoallw(buf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes,
 437                    MPI_COMM_WORLD, &req);
 438     MPI_Wait(&req, MPI_STATUS_IGNORE);
 439     for (i = 0; i < size; ++i) {
 440         for (j = 0; j < COUNT; ++j) {
 441 /*            printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (rank * j))); */
 442             my_assert(recvbuf[i * COUNT + j] == (i + (rank * j)));
 443         }
 444     }
 445
 446     if (rank == 0)
 447         printf(" No Errors\n");
 448
 449
 450     MPI_Finalize();
 451     free(buf);
 452     free(recvbuf);
 453     free(sendcounts);
 454     free(recvcounts);
 455     free(rdispls);
 456     free(sdispls);
 457     free(recvtypes);
 458     free(sendtypes);
 459     return 0;
 460 }