teshsuite/smpi/isp/umpire/change-send-buffer-exhaustive.c

   1 /* -*- Mode: C; -*- */
   2 /* Creator: Bronis R. de Supinski (bronis@llnl.gov) */
   3 /* change-send-buffer-exhaustive.c -- do lots pt-2-pt ops with */
   4 /*                                    send buffer overwrite errors*/
   5
   6 #ifndef lint
   7 static char *rcsid =
   8   "$Header: /usr/gapps/asde/cvs-vault/umpire/tests/change-send-buffer-exhaustive.c,v 1.5 2002/10/24 17:04:54 bronis Exp $";
   9 #endif
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <assert.h>
  14 #include "mpi.h"
  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
  22 int
  23 main (int argc, char **argv)
  24 {
  25   int nprocs = -1;
  26   int rank = -1;
  27   MPI_Comm comm = MPI_COMM_WORLD;
  28   char processor_name[128];
  29   int namelen = 128;
  30   int bbuf[(BUF_SIZE + MPI_BSEND_OVERHEAD) * 2 * NUM_BSEND_TYPES];
  31   int buf[BUF_SIZE * 2 * NUM_SEND_TYPES];
  32   int i, j, k, at_size, send_t_number, index, outcount, total, flag;
  33   int num_errors, error_count, indices[2 * NUM_SEND_TYPES];
  34   MPI_Request aReq[2 * NUM_SEND_TYPES];
  35   MPI_Status aStatus[2 * NUM_SEND_TYPES];
  36
  37   /* init */
  38   MPI_Init (&argc, &argv);
  39   MPI_Comm_size (comm, &nprocs);
  40   MPI_Comm_rank (comm, &rank);
  41   MPI_Get_processor_name (processor_name, &namelen);
  42   printf ("(%d) is alive on %s\n", rank, processor_name);
  43   fflush (stdout);
  44
  45   MPI_Buffer_attach (bbuf, sizeof(int) *
  46                      (BUF_SIZE + MPI_BSEND_OVERHEAD) * 2 * NUM_BSEND_TYPES);
  47
  48   if (rank == 0) {
  49     /* set up persistent sends... */
  50     send_t_number = NUM_SEND_TYPES - NUM_PERSISTENT_SEND_TYPES;
  51
  52     MPI_Send_init (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
  53                     1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
  54     MPI_Send_init (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
  55                     BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
  56                     comm, &aReq[send_t_number * 2 + 1]);
  57
  58     send_t_number++;
  59
  60     MPI_Bsend_init (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
  61                     1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
  62     MPI_Bsend_init (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
  63                     BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
  64                     comm, &aReq[send_t_number * 2 + 1]);
  65
  66
  67     send_t_number++;
  68
  69     MPI_Rsend_init (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
  70                     1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
  71     MPI_Rsend_init (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
  72                     BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
  73                     comm, &aReq[send_t_number * 2 + 1]);
  74
  75     send_t_number++;
  76
  77     MPI_Ssend_init (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
  78                     1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
  79     MPI_Ssend_init (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
  80                     BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
  81                     comm, &aReq[send_t_number * 2 + 1]);
  82   }
  83
  84   for (k = 0; k < (NUM_COMPLETION_MECHANISMS * 2); k++) {
  85     if (rank == 0) {
  86       /* initialize all of the send buffers */
  87       for (j = 0; j < NUM_SEND_TYPES; j++) {
  88         for (i = 0; i < BUF_SIZE; i++) {
  89           buf[2 * j * BUF_SIZE + i] = i;
  90           buf[((2 * j + 1) * BUF_SIZE) + i] = BUF_SIZE - 1 - i;
  91         }
  92       }
  93     }
  94     else if (rank == 1) {
  95       /* zero out all of the receive buffers */
  96       bzero (buf, sizeof(int) * BUF_SIZE * 2 * NUM_SEND_TYPES);
  97     }
  98
  99     MPI_Barrier(MPI_COMM_WORLD);
 100
 101     if (rank == 0) {
 102       /* set up transient sends... */
 103       send_t_number = 0;
 104
 105       MPI_Isend (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
 106                  1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
 107       MPI_Isend (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
 108                  BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
 109                  comm, &aReq[send_t_number * 2 + 1]);
 110
 111       send_t_number++;
 112
 113       MPI_Ibsend (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
 114                   1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
 115       MPI_Ibsend (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
 116                   BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
 117                   comm, &aReq[send_t_number * 2 + 1]);
 118
 119       send_t_number++;
 120
 121       /* Barrier to ensure receives are posted for rsends... */
 122       MPI_Barrier(MPI_COMM_WORLD);
 123
 124       MPI_Irsend (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
 125                   1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
 126       MPI_Irsend (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
 127                   BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
 128                   comm, &aReq[send_t_number * 2 + 1]);
 129
 130       send_t_number++;
 131
 132       MPI_Issend (&buf[send_t_number * 2 * BUF_SIZE], BUF_SIZE, MPI_INT,
 133                   1, send_t_number * 2, comm, &aReq[send_t_number * 2]);
 134       MPI_Issend (&buf[(send_t_number * 2 + 1) * BUF_SIZE],
 135                   BUF_SIZE, MPI_INT, 1, send_t_number * 2 + 1,
 136                   comm, &aReq[send_t_number * 2 + 1]);
 137
 138       /* just to be paranoid */
 139       send_t_number++;
 140       assert (send_t_number == NUM_SEND_TYPES - NUM_PERSISTENT_SEND_TYPES);
 141
 142       /* start the persistent sends... */
 143       if (k % 2) {
 144         MPI_Startall (NUM_PERSISTENT_SEND_TYPES * 2, &aReq[2 * send_t_number]);
 145       }
 146       else {
 147         for (j = 0; j < NUM_PERSISTENT_SEND_TYPES * 2; j++) {
 148           MPI_Start (&aReq[2 * send_t_number + j]);
 149         }
 150       }
 151
 152       /* NOTE: Changing the send buffer of a Bsend is NOT an error... */
 153       for (j = 0; j < NUM_SEND_TYPES; j++) {
 154         /* muck the buffers */
 155         buf[j * 2 * BUF_SIZE + (BUF_SIZE >> 1)] = BUF_SIZE;
 156       }
 157
 158       printf ("USER MSG: 6 change send buffer errors in iteration #%d:\n", k);
 159
 160       /* complete the sends */
 161       switch (k/2) {
 162       case 0:
 163         /* use MPI_Wait */
 164         for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 165           MPI_Wait (&aReq[j], &aStatus[j]);
 166         }
 167         break;
 168
 169       case 1:
 170         /* use MPI_Waitall */
 171         MPI_Waitall (NUM_SEND_TYPES * 2, aReq, aStatus);
 172         break;
 173
 174       case 2:
 175         /* use MPI_Waitany */
 176         for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 177           MPI_Waitany (NUM_SEND_TYPES * 2, aReq, &index, aStatus);
 178         }
 179
 180         break;
 181
 182       case 3:
 183         /* use MPI_Waitsome */
 184         total = 0;
 185         while (total < NUM_SEND_TYPES * 2) {
 186           MPI_Waitsome (NUM_SEND_TYPES * 2, aReq, &outcount, indices, aStatus);
 187
 188           total += outcount;
 189         }
 190
 191         break;
 192
 193       case 4:
 194         /* use MPI_Test */
 195         for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 196           flag = 0;
 197
 198           while (!flag) {
 199             MPI_Test (&aReq[j], &flag, &aStatus[j]);
 200           }
 201         }
 202
 203         break;
 204
 205       case 5:
 206         /* use MPI_Testall */
 207         flag = 0;
 208         while (!flag) {
 209           MPI_Testall (NUM_SEND_TYPES * 2, aReq, &flag, aStatus);
 210         }
 211
 212         break;
 213
 214       case 6:
 215         /* use MPI_Testany */
 216         for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 217           flag = 0;
 218           while (!flag) {
 219             MPI_Testany (NUM_SEND_TYPES * 2, aReq, &index, &flag, aStatus);
 220           }
 221         }
 222
 223         break;
 224
 225       case 7:
 226         /* use MPI_Testsome */
 227         total = 0;
 228         while (total < NUM_SEND_TYPES * 2) {
 229           outcount = 0;
 230
 231           while (!outcount) {
 232             MPI_Testsome (NUM_SEND_TYPES * 2, aReq,
 233                           &outcount, indices, aStatus);
 234           }
 235
 236           total += outcount;
 237         }
 238
 239         break;
 240
 241       default:
 242         assert (0);
 243         break;
 244       }
 245     }
 246     else if (rank == 1) {
 247       /* set up receives for all of the sends */
 248       for (j = 0; j < NUM_SEND_TYPES * 2; j++) {
 249         MPI_Irecv (&buf[j * BUF_SIZE], BUF_SIZE,
 250                    MPI_INT, 0, j, comm, &aReq[j]);
 251       }
 252
 253       /* Barrier to ensure receives are posted for rsends... */
 254       MPI_Barrier(MPI_COMM_WORLD);
 255
 256       /* complete all of the receives... */
 257       MPI_Waitall (NUM_SEND_TYPES * 2, aReq, aStatus);
 258     }
 259     else {
 260       /* Barrier to ensure receives are posted for rsends... */
 261       MPI_Barrier(MPI_COMM_WORLD);
 262     }
 263   }
 264
 265   MPI_Barrier(MPI_COMM_WORLD);
 266
 267   if (rank == 0) {
 268     /* free the persistent requests */
 269     for (i = 2* (NUM_SEND_TYPES - NUM_PERSISTENT_SEND_TYPES);
 270          i < 2 * NUM_SEND_TYPES; i++) {
 271       MPI_Request_free (&aReq[i]);
 272     }
 273   }
 274
 275   MPI_Buffer_detach (bbuf, &at_size);
 276
 277   assert (at_size ==
 278           sizeof(int) * (BUF_SIZE + MPI_BSEND_OVERHEAD) * 2 * NUM_BSEND_TYPES);
 279
 280   MPI_Finalize ();
 281   printf ("(%d) Finished normally\n", rank);
 282 }
 283
 284 /* EOF */