teshsuite/smpi/isp/umpire/pt2pt-byte-int-mismatch.c

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