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     int *sendtypes = NULL;
  51     int *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
 131 /*        for (i = 0; i < COUNT; ++i) {*/
 132 /*            buf[i] = rank + i;*/
 133 /*            recvbuf[i] = 0xdeadbeef;*/
 134 /*        }*/
 135 /*        MPI_Ireduce(buf, recvbuf, COUNT, MPI_INT, op, 0, MPI_COMM_WORLD, &req);*/
 136 /*        MPI_Op_free(&op);*/
 137 /*        MPI_Wait(&req, MPI_STATUS_IGNORE);*/
 138 /*        if (rank == 0) {*/
 139 /*            for (i = 0; i < COUNT; ++i) {*/
 140 /*                if (recvbuf[i] != ((size * (size - 1) / 2) + (i * size)))*/
 141 /*                    printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i],*/
 142 /*                           ((size * (size - 1) / 2) + (i * size)));*/
 143 /*                my_assert(recvbuf[i] == ((size * (size - 1) / 2) + (i * size)));*/
 144 /*            }*/
 145 /*        }*/
 146 /*    }*/
 147
 148     /* MPI_Iallreduce */
 149 /*    for (i = 0; i < COUNT; ++i) {*/
 150 /*        buf[i] = rank + i;*/
 151 /*        recvbuf[i] = 0xdeadbeef;*/
 152 /*    }*/
 153 /*    MPI_Iallreduce(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req);*/
 154 /*    MPI_Wait(&req, MPI_STATUS_IGNORE);*/
 155 /*    for (i = 0; i < COUNT; ++i) {*/
 156 /*        if (recvbuf[i] != ((size * (size - 1) / 2) + (i * size)))*/
 157 /*            printf("got recvbuf[%d]=%d, expected %d\n", i, recvbuf[i],*/
 158 /*                   ((size * (size - 1) / 2) + (i * size)));*/
 159 /*        my_assert(recvbuf[i] == ((size * (size - 1) / 2) + (i * size)));*/
 160 /*    }*/
 161
 162     /* MPI_Ialltoallv (a weak test, neither irregular nor sparse) */
 163     for (i = 0; i < size; ++i) {
 164         sendcounts[i] = COUNT;
 165         recvcounts[i] = COUNT;
 166         sdispls[i] = COUNT * i;
 167         rdispls[i] = COUNT * i;
 168         for (j = 0; j < COUNT; ++j) {
 169             buf[i * COUNT + j] = rank + (i * j);
 170             recvbuf[i * COUNT + j] = 0xdeadbeef;
 171         }
 172     }
 173     MPI_Ialltoallv(buf, sendcounts, sdispls, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT,
 174                    MPI_COMM_WORLD, &req);
 175     MPI_Wait(&req, MPI_STATUS_IGNORE);
 176     for (i = 0; i < size; ++i) {
 177         for (j = 0; j < COUNT; ++j) {
 178             /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (rank * j))); */
 179             my_assert(recvbuf[i * COUNT + j] == (i + (rank * j)));
 180         }
 181     }
 182
 183     /* MPI_Igather */
 184     for (i = 0; i < size * COUNT; ++i) {
 185         buf[i] = rank + i;
 186         recvbuf[i] = 0xdeadbeef;
 187     }
 188     MPI_Igather(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, 0, MPI_COMM_WORLD, &req);
 189     MPI_Wait(&req, MPI_STATUS_IGNORE);
 190     if (rank == 0) {
 191         for (i = 0; i < size; ++i) {
 192             for (j = 0; j < COUNT; ++j) {
 193                 my_assert(recvbuf[i * COUNT + j] == i + j);
 194             }
 195         }
 196     }
 197     else {
 198         for (i = 0; i < size * COUNT; ++i) {
 199             my_assert(recvbuf[i] == 0xdeadbeef);
 200         }
 201     }
 202
 203     /* same test again, just use a dup'ed datatype and free it before the wait */
 204     {
 205         MPI_Datatype type = MPI_DATATYPE_NULL;
 206         MPI_Type_dup(MPI_INT, &type);
 207
 208         for (i = 0; i < size * COUNT; ++i) {
 209             buf[i] = rank + i;
 210             recvbuf[i] = 0xdeadbeef;
 211         }
 212         MPI_Igather(buf, COUNT, MPI_INT, recvbuf, COUNT, type, 0, MPI_COMM_WORLD, &req);
 213         MPI_Type_free(&type);   /* should cause implementations that don't refcount
 214                                  * correctly to blow up or hang in the wait */
 215         MPI_Wait(&req, MPI_STATUS_IGNORE);
 216         if (rank == 0) {
 217             for (i = 0; i < size; ++i) {
 218                 for (j = 0; j < COUNT; ++j) {
 219                     my_assert(recvbuf[i * COUNT + j] == i + j);
 220                 }
 221             }
 222         }
 223         else {
 224             for (i = 0; i < size * COUNT; ++i) {
 225                 my_assert(recvbuf[i] == 0xdeadbeef);
 226             }
 227         }
 228     }
 229
 230     /* MPI_Iscatter */
 231     for (i = 0; i < size; ++i) {
 232         for (j = 0; j < COUNT; ++j) {
 233             if (rank == 0)
 234                 buf[i * COUNT + j] = i + j;
 235             else
 236                 buf[i * COUNT + j] = 0xdeadbeef;
 237             recvbuf[i * COUNT + j] = 0xdeadbeef;
 238         }
 239     }
 240     MPI_Iscatter(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, 0, MPI_COMM_WORLD, &req);
 241     MPI_Wait(&req, MPI_STATUS_IGNORE);
 242     for (j = 0; j < COUNT; ++j) {
 243         my_assert(recvbuf[j] == rank + j);
 244     }
 245     if (rank != 0) {
 246         for (i = 0; i < size * COUNT; ++i) {
 247             /* check we didn't corrupt the sendbuf somehow */
 248             my_assert(buf[i] == 0xdeadbeef);
 249         }
 250     }
 251
 252     /* MPI_Iscatterv */
 253     for (i = 0; i < size; ++i) {
 254         /* weak test, just test the regular case where all counts are equal */
 255         sendcounts[i] = COUNT;
 256         sdispls[i] = i * COUNT;
 257         for (j = 0; j < COUNT; ++j) {
 258             if (rank == 0)
 259                 buf[i * COUNT + j] = i + j;
 260             else
 261                 buf[i * COUNT + j] = 0xdeadbeef;
 262             recvbuf[i * COUNT + j] = 0xdeadbeef;
 263         }
 264     }
 265     MPI_Iscatterv(buf, sendcounts, sdispls, MPI_INT, recvbuf, COUNT, MPI_INT, 0, MPI_COMM_WORLD,
 266                   &req);
 267     MPI_Wait(&req, MPI_STATUS_IGNORE);
 268     for (j = 0; j < COUNT; ++j) {
 269         my_assert(recvbuf[j] == rank + j);
 270     }
 271     if (rank != 0) {
 272         for (i = 0; i < size * COUNT; ++i) {
 273             /* check we didn't corrupt the sendbuf somehow */
 274             my_assert(buf[i] == 0xdeadbeef);
 275         }
 276     }
 277     for (i = 1; i < size; ++i) {
 278         for (j = 0; j < COUNT; ++j) {
 279             /* check we didn't corrupt the rest of the recvbuf */
 280             my_assert(recvbuf[i * COUNT + j] == 0xdeadbeef);
 281         }
 282     }
 283
 284     /* MPI_Ireduce_scatter */
 285 /*    for (i = 0; i < size; ++i) {*/
 286 /*        recvcounts[i] = COUNT;*/
 287 /*        for (j = 0; j < COUNT; ++j) {*/
 288 /*            buf[i * COUNT + j] = rank + i;*/
 289 /*            recvbuf[i * COUNT + j] = 0xdeadbeef;*/
 290 /*        }*/
 291 /*    }*/
 292 /*    MPI_Ireduce_scatter(buf, recvbuf, recvcounts, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req);*/
 293 /*    MPI_Wait(&req, MPI_STATUS_IGNORE);*/
 294 /*    for (j = 0; j < COUNT; ++j) {*/
 295 /*        my_assert(recvbuf[j] == (size * rank + ((size - 1) * size) / 2));*/
 296 /*    }*/
 297 /*    for (i = 1; i < size; ++i) {*/
 298 /*        for (j = 0; j < COUNT; ++j) {*/
 299             /* check we didn't corrupt the rest of the recvbuf */
 300 /*            my_assert(recvbuf[i * COUNT + j] == 0xdeadbeef);*/
 301 /*        }*/
 302 /*    }*/
 303
 304     /* MPI_Ireduce_scatter_block */
 305 /*    for (i = 0; i < size; ++i) {*/
 306 /*        for (j = 0; j < COUNT; ++j) {*/
 307 /*            buf[i * COUNT + j] = rank + i;*/
 308 /*            recvbuf[i * COUNT + j] = 0xdeadbeef;*/
 309 /*        }*/
 310 /*    }*/
 311 /*    MPI_Ireduce_scatter_block(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req);*/
 312 /*    MPI_Wait(&req, MPI_STATUS_IGNORE);*/
 313 /*    for (j = 0; j < COUNT; ++j) {*/
 314 /*        my_assert(recvbuf[j] == (size * rank + ((size - 1) * size) / 2));*/
 315 /*    }*/
 316 /*    for (i = 1; i < size; ++i) {*/
 317 /*        for (j = 0; j < COUNT; ++j) {*/
 318             /* check we didn't corrupt the rest of the recvbuf */
 319 /*            my_assert(recvbuf[i * COUNT + j] == 0xdeadbeef);*/
 320 /*        }*/
 321 /*    }*/
 322
 323     /* MPI_Igatherv */
 324     for (i = 0; i < size * COUNT; ++i) {
 325         buf[i] = 0xdeadbeef;
 326         recvbuf[i] = 0xdeadbeef;
 327     }
 328     for (i = 0; i < COUNT; ++i) {
 329         buf[i] = rank + i;
 330     }
 331     for (i = 0; i < size; ++i) {
 332         recvcounts[i] = COUNT;
 333         rdispls[i] = i * COUNT;
 334     }
 335     MPI_Igatherv(buf, COUNT, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, 0, MPI_COMM_WORLD,
 336                  &req);
 337     MPI_Wait(&req, MPI_STATUS_IGNORE);
 338     if (rank == 0) {
 339         for (i = 0; i < size; ++i) {
 340             for (j = 0; j < COUNT; ++j) {
 341                 my_assert(recvbuf[i * COUNT + j] == i + j);
 342             }
 343         }
 344     }
 345     else {
 346         for (i = 0; i < size * COUNT; ++i) {
 347             my_assert(recvbuf[i] == 0xdeadbeef);
 348         }
 349     }
 350
 351     /* MPI_Ialltoall */
 352     for (i = 0; i < size; ++i) {
 353         for (j = 0; j < COUNT; ++j) {
 354             buf[i * COUNT + j] = rank + (i * j);
 355             recvbuf[i * COUNT + j] = 0xdeadbeef;
 356         }
 357     }
 358     MPI_Ialltoall(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, MPI_COMM_WORLD, &req);
 359     MPI_Wait(&req, MPI_STATUS_IGNORE);
 360     for (i = 0; i < size; ++i) {
 361         for (j = 0; j < COUNT; ++j) {
 362             /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (i * j))); */
 363             my_assert(recvbuf[i * COUNT + j] == (i + (rank * j)));
 364         }
 365     }
 366
 367     /* MPI_Iallgather */
 368     for (i = 0; i < size * COUNT; ++i) {
 369         buf[i] = rank + i;
 370         recvbuf[i] = 0xdeadbeef;
 371     }
 372     MPI_Iallgather(buf, COUNT, MPI_INT, recvbuf, COUNT, MPI_INT, MPI_COMM_WORLD, &req);
 373     MPI_Wait(&req, MPI_STATUS_IGNORE);
 374     for (i = 0; i < size; ++i) {
 375         for (j = 0; j < COUNT; ++j) {
 376             my_assert(recvbuf[i * COUNT + j] == i + j);
 377         }
 378     }
 379
 380     /* MPI_Iallgatherv */
 381     for (i = 0; i < size; ++i) {
 382         for (j = 0; j < COUNT; ++j) {
 383             recvbuf[i * COUNT + j] = 0xdeadbeef;
 384         }
 385         recvcounts[i] = COUNT;
 386         rdispls[i] = i * COUNT;
 387     }
 388     for (i = 0; i < COUNT; ++i)
 389         buf[i] = rank + i;
 390     MPI_Iallgatherv(buf, COUNT, MPI_INT, recvbuf, recvcounts, rdispls, MPI_INT, MPI_COMM_WORLD,
 391                     &req);
 392     MPI_Wait(&req, MPI_STATUS_IGNORE);
 393     for (i = 0; i < size; ++i) {
 394         for (j = 0; j < COUNT; ++j) {
 395             my_assert(recvbuf[i * COUNT + j] == i + j);
 396         }
 397     }
 398
 399     /* MPI_Iscan */
 400 /*    for (i = 0; i < COUNT; ++i) {*/
 401 /*        buf[i] = rank + i;*/
 402 /*        recvbuf[i] = 0xdeadbeef;*/
 403 /*    }*/
 404 /*    MPI_Iscan(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req);*/
 405 /*    MPI_Wait(&req, MPI_STATUS_IGNORE);*/
 406 /*    for (i = 0; i < COUNT; ++i) {*/
 407 /*        my_assert(recvbuf[i] == ((rank * (rank + 1) / 2) + (i * (rank + 1))));*/
 408 /*    }*/
 409
 410     /* MPI_Iexscan */
 411 /*    for (i = 0; i < COUNT; ++i) {*/
 412 /*        buf[i] = rank + i;*/
 413 /*        recvbuf[i] = 0xdeadbeef;*/
 414 /*    }*/
 415 /*    MPI_Iexscan(buf, recvbuf, COUNT, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &req);*/
 416 /*    MPI_Wait(&req, MPI_STATUS_IGNORE);*/
 417 /*    for (i = 0; i < COUNT; ++i) {*/
 418 /*        if (rank == 0)*/
 419 /*            my_assert(recvbuf[i] == 0xdeadbeef);*/
 420 /*        else*/
 421 /*            my_assert(recvbuf[i] == ((rank * (rank + 1) / 2) + (i * (rank + 1)) - (rank + i)));*/
 422 /*    }*/
 423
 424     /* MPI_Ialltoallw (a weak test, neither irregular nor sparse) */
 425 /*    for (i = 0; i < size; ++i) {*/
 426 /*        sendcounts[i] = COUNT;*/
 427 /*        recvcounts[i] = COUNT;*/
 428 /*        sdispls[i] = COUNT * i * sizeof(int);*/
 429 /*        rdispls[i] = COUNT * i * sizeof(int);*/
 430 /*        sendtypes[i] = MPI_INT;*/
 431 /*        recvtypes[i] = MPI_INT;*/
 432 /*        for (j = 0; j < COUNT; ++j) {*/
 433 /*            buf[i * COUNT + j] = rank + (i * j);*/
 434 /*            recvbuf[i * COUNT + j] = 0xdeadbeef;*/
 435 /*        }*/
 436 /*    }*/
 437 /*    MPI_Ialltoallw(buf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes,*/
 438 /*                   MPI_COMM_WORLD, &req);*/
 439 /*    MPI_Wait(&req, MPI_STATUS_IGNORE);*/
 440 /*    for (i = 0; i < size; ++i) {*/
 441 /*        for (j = 0; j < COUNT; ++j) {*/
 442             /*printf("recvbuf[%d*COUNT+%d]=%d, expecting %d\n", i, j, recvbuf[i*COUNT+j], (i + (rank * j))); */
 443 /*            my_assert(recvbuf[i * COUNT + j] == (i + (rank * j)));*/
 444 /*        }*/
 445 /*    }*/
 446
 447     if (rank == 0)
 448         printf(" No Errors\n");
 449
 450
 451     MPI_Finalize();
 452     free(buf);
 453     free(recvbuf);
 454     free(sendcounts);
 455     free(recvcounts);
 456     free(rdispls);
 457     free(sdispls);
 458     free(recvtypes);
 459     free(sendtypes);
 460     return 0;
 461 }