teshsuite/smpi/isp/umpire/partial-recv-exhaustive.c

   1 /* -*- Mode: C; -*- */
   2 /* Creator: Bronis R. de Supinski (bronis@llnl.gov) Thu Oct 17, 2002 */
   3 /* partial-recv-exhaustive.c -- do lots pt-2-pt ops w/oversized recv bufs */
   4
   5 #ifndef lint
   6 static char *rcsid =
   7   "$Header: /usr/gapps/asde/cvs-vault/umpire/tests/partial-recv-exhaustive.c,v 1.1 2002/10/24 17:04:56 bronis Exp $";
   8 #endif
   9
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <assert.h>
  13 #include "mpi.h"
  14
  15
  16 #define BUF_SIZE 128
  17 #define NUM_SEND_TYPES 8
  18 #define NUM_PERSISTENT_SEND_TYPES 4
  19 #define NUM_BSEND_TYPES 2
  20 #define NUM_COMPLETION_MECHANISMS 8
  21 #define NUM_RECV_TYPES 2
  22 #define SLOP 128
  23
  24
  25 int
  26 main (int argc, char **argv)
  27 {
  28   int nprocs = -1;
  29   int rank = -1;
  30   MPI_Comm comm = MPI_COMM_WORLD;
  31   char processor_name[128];
  32   int namelen = 128;
  33   int bbuf[(BUF_SIZE + MPI_BSEND_OVERHEAD) * 2 * NUM_BSEND_TYPES];
  34   int buf[BUF_SIZE * 2 * NUM_SEND_TYPES + SLOP];
  35   int i, j, k, l, m, at_size, send_t_number, index, outcount, total, flag;
  36   int num_errors, error_count, indices[2 * NUM_SEND_TYPES];
  37   MPI_Request aReq[2 * NUM_SEND_TYPES];
  38   MPI_Status aStatus[2 * NUM_SEND_TYPES];
  39
  40   /* init */
  41   MPI_Init (&argc, &argv);
  42   MPI_Comm_size (comm, &nprocs);
  43   MPI_Comm_rank (comm, &rank);
  44   MPI_Get_processor_name (processor_name, &namelen);
  45   printf ("(%d) is alive on %s\n", rank, processor_name);
  46   fflush (stdout);
  47
  48   MPI_Buffer_attach (bbuf, sizeof(int) *
  49                      (BUF_SIZE + MPI_BSEND_OVERHEAD) * 2 * NUM_BSEND_TYPES);
  50
  51   if (rank == 0) {
  52     /* set up persistent sends... */
  53     send_t_number = NUM_SEND_TYPES - NUM_PERSISTENT_SEND_TYPES;
  54
  55     MPI_Send_init (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
  56                     1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
  57     MPI_Send_init (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
  58                     BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
  59                     comm, &aReq[send_t_number * 2 + 1]);
  60
  61     send_t_number++;
  62
  63     MPI_Bsend_init (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
  64                     1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
  65     MPI_Bsend_init (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
  66                     BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
  67                     comm, &aReq[send_t_number * 2 + 1]);
  68
  69
  70     send_t_number++;
  71
  72     MPI_Rsend_init (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
  73                     1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
  74     MPI_Rsend_init (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
  75                     BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
  76                     comm, &aReq[send_t_number * 2 + 1]);
  77
  78     send_t_number++;
  79
  80     MPI_Ssend_init (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
  81                     1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
  82     MPI_Ssend_init (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
  83                     BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
  84                     comm, &aReq[send_t_number * 2 + 1]);
  85   }
  86
  87   for (m = 0; m < NUM_RECV_TYPES; m++) {
  88     if ((m == 1) && (rank == 1)) {
  89       /* set up the persistent receives... */
  90       for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
  91         MPI_Recv_init (&buf[j * BUF_SIZE],
  92                        BUF_SIZE + (j % 2) * SLOP,
  93                        MPI_INT, 0, j, comm, &aReq[j]);
  94       }
  95     }
  96
  97     for (l = 0; l < (NUM_COMPLETION_MECHANISMS * 2); l++) {
  98       for (k = 0; k < (NUM_COMPLETION_MECHANISMS * 2); k++) {
  99         if (rank == 0) {
 100           /* initialize all of the send buffers */
 101           for (j = 0; j < NUM_SEND_TYPES; j++) {
 102             for (i = 0; i < BUF_SIZE; i++) {
 103               buf[2 * j * BUF_SIZE + i] = i;
 104               buf[((2 * j + 1) * BUF_SIZE) + i] = BUF_SIZE - 1 - i;
 105             }
 106           }
 107         }
 108         else if (rank == 1) {
 109           /* zero out all of the receive buffers */
 110           bzero (buf, sizeof(int) * BUF_SIZE * 2 * NUM_SEND_TYPES);
 111         }
 112
 113         MPI_Barrier(MPI_COMM_WORLD);
 114
 115         if (rank == 0) {
 116           /* set up transient sends... */
 117           send_t_number = 0;
 118
 119           MPI_Isend (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
 120                      1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
 121           MPI_Isend (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
 122                      BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
 123                      comm, &aReq[send_t_number * 2 + 1]);
 124
 125           send_t_number++;
 126
 127           MPI_Ibsend (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
 128                       1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
 129           MPI_Ibsend (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
 130                       BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
 131                       comm, &aReq[send_t_number * 2 + 1]);
 132
 133           send_t_number++;
 134
 135           /* Barrier to ensure receives are posted for rsends... */
 136           MPI_Barrier(MPI_COMM_WORLD);
 137
 138           MPI_Irsend (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
 139                     1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
 140           MPI_Irsend (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
 141                       BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
 142                       comm, &aReq[send_t_number * 2 + 1]);
 143
 144           send_t_number++;
 145
 146           MPI_Issend (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
 147                       1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
 148           MPI_Issend (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
 149                       BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
 150                       comm, &aReq[send_t_number * 2 + 1]);
 151
 152           /* just to be paranoid */
 153           send_t_number++;
 154           assert (send_t_number ==
 155                   NUM_SEND_TYPES - NUM_PERSISTENT_SEND_TYPES);
 156
 157           /* start the persistent sends... */
 158           if (k % 2) {
 159             MPI_Startall (NUM_PERSISTENT_SEND_TYPES * 2,
 160                           &aReq[2 * send_t_number]);
 161           }
 162           else {
 163             for (j = 0; j < NUM_PERSISTENT_SEND_TYPES * 2; j++) {
 164               MPI_Start (&aReq[2 * send_t_number + j]);
 165             }
 166           }
 167
 168           /* complete the sends */
 169           switch (k/2) {
 170           case 0:
 171             /* use MPI_Wait */
 172             for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 173               MPI_Wait (&aReq[j], &aStatus[j]);
 174             }
 175             break;
 176
 177           case 1:
 178             /* use MPI_Waitall */
 179             MPI_Waitall (NUM_SEND_TYPES * 2, aReq, aStatus);
 180             break;
 181
 182           case 2:
 183             /* use MPI_Waitany */
 184             for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 185               MPI_Waitany (NUM_SEND_TYPES * 2, aReq, &index, aStatus);
 186             }
 187
 188             break;
 189
 190           case 3:
 191             /* use MPI_Waitsome */
 192             total = 0;
 193             while (total < NUM_SEND_TYPES * 2) {
 194               MPI_Waitsome (NUM_SEND_TYPES * 2, aReq,
 195                             &outcount, indices, aStatus);
 196
 197               total += outcount;
 198             }
 199
 200             break;
 201
 202           case 4:
 203             /* use MPI_Test */
 204             for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 205               flag = 0;
 206
 207               while (!flag) {
 208                 MPI_Test (&aReq[j], &flag, &aStatus[j]);
 209               }
 210             }
 211
 212             break;
 213
 214           case 5:
 215             /* use MPI_Testall */
 216             flag = 0;
 217             while (!flag) {
 218               MPI_Testall (NUM_SEND_TYPES * 2, aReq, &flag, aStatus);
 219             }
 220
 221             break;
 222
 223           case 6:
 224             /* use MPI_Testany */
 225             for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 226               flag = 0;
 227               while (!flag) {
 228                 MPI_Testany (NUM_SEND_TYPES * 2, aReq,
 229                              &index, &flag, aStatus);
 230               }
 231             }
 232
 233             break;
 234
 235           case 7:
 236             /* use MPI_Testsome */
 237             total = 0;
 238             while (total < NUM_SEND_TYPES * 2) {
 239               outcount = 0;
 240
 241               while (!outcount) {
 242                 MPI_Testsome (NUM_SEND_TYPES * 2, aReq,
 243                               &outcount, indices, aStatus);
 244               }
 245
 246               total += outcount;
 247             }
 248
 249             break;
 250
 251           default:
 252             assert (0);
 253             break;
 254           }
 255         }
 256         else if (rank == 1) {
 257           /* start receives for all of the sends */
 258           if (m == 0) {
 259             for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 260               MPI_Irecv (&buf[j * BUF_SIZE],
 261                          BUF_SIZE + (j % 2) * SLOP,
 262                          MPI_INT, 0, j, comm, &aReq[j]);
 263             }
 264           }
 265           else {
 266             /* start the persistent receives... */
 267             if (l % 2) {
 268               MPI_Startall (NUM_SEND_TYPES * 2, aReq);
 269             }
 270             else {
 271               for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 272                 MPI_Start (&aReq[j]);
 273               }
 274             }
 275           }
 276
 277           /* Barrier to ensure receives are posted for rsends... */
 278           MPI_Barrier(MPI_COMM_WORLD);
 279
 280           /* complete all of the receives... */
 281           switch (l/2) {
 282           case 0:
 283             /* use MPI_Wait */
 284             for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 285               MPI_Wait (&aReq[j], &aStatus[j]);
 286             }
 287             break;
 288
 289           case 1:
 290             /* use MPI_Waitall */
 291             MPI_Waitall (NUM_SEND_TYPES * 2, aReq, aStatus);
 292             break;
 293
 294           case 2:
 295             /* use MPI_Waitany */
 296             for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 297               MPI_Waitany (NUM_SEND_TYPES * 2, aReq, &index, aStatus);
 298             }
 299
 300             break;
 301
 302           case 3:
 303             /* use MPI_Waitsome */
 304             total = 0;
 305             while (total < NUM_SEND_TYPES * 2) {
 306               MPI_Waitsome (NUM_SEND_TYPES * 2, aReq,
 307                             &outcount, indices, aStatus);
 308
 309               total += outcount;
 310             }
 311
 312             break;
 313
 314           case 4:
 315             /* use MPI_Test */
 316             for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 317               flag = 0;
 318
 319               while (!flag) {
 320                 MPI_Test (&aReq[j], &flag, &aStatus[j]);
 321               }
 322             }
 323
 324             break;
 325
 326           case 5:
 327             /* use MPI_Testall */
 328             flag = 0;
 329             while (!flag) {
 330               MPI_Testall (NUM_SEND_TYPES * 2, aReq, &flag, aStatus);
 331             }
 332
 333             break;
 334
 335           case 6:
 336             /* use MPI_Testany */
 337             for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 338               flag = 0;
 339               while (!flag) {
 340                 MPI_Testany (NUM_SEND_TYPES * 2, aReq,
 341                              &index, &flag, aStatus);
 342               }
 343             }
 344
 345             break;
 346
 347           case 7:
 348             /* use MPI_Testsome */
 349             total = 0;
 350             while (total < NUM_SEND_TYPES * 2) {
 351               outcount = 0;
 352
 353               while (!outcount) {
 354                 MPI_Testsome (NUM_SEND_TYPES * 2, aReq,
 355                               &outcount, indices, aStatus);
 356               }
 357
 358               total += outcount;
 359             }
 360
 361             break;
 362
 363           default:
 364             assert (0);
 365             break;
 366           }
 367         }
 368         else {
 369           /* Barrier to ensure receives are posted for rsends... */
 370           MPI_Barrier(MPI_COMM_WORLD);
 371         }
 372       }
 373     }
 374   }
 375
 376   MPI_Barrier(MPI_COMM_WORLD);
 377
 378   if (rank == 0) {
 379     /* free the persistent send requests */
 380     for (i = 2* (NUM_SEND_TYPES - NUM_PERSISTENT_SEND_TYPES);
 381          i < 2 * NUM_SEND_TYPES; i++) {
 382       MPI_Request_free (&aReq[i]);
 383     }
 384   }
 385   else if (rank == 1) {
 386     /* free the persistent receive requests */
 387     for (i = 0; i < 2 * NUM_SEND_TYPES; i++) {
 388       MPI_Request_free (&aReq[i]);
 389     }
 390   }
 391
 392
 393   MPI_Buffer_detach (bbuf, &at_size);
 394
 395   assert (at_size ==
 396           sizeof(int) * (BUF_SIZE + MPI_BSEND_OVERHEAD) * 2 * NUM_BSEND_TYPES);
 397
 398   MPI_Finalize ();
 399   printf ("(%d) Finished normally\n", rank);
 400 }
 401
 402 /* EOF */