teshsuite/smpi/mpich-test/pt2pt/sendrecv.c

   1 /*
   2  * Program to test all of the features of MPI_Send and MPI_Recv
   3  *
   4  * *** What is tested? ***
   5  * 1. Sending and receiving all basic types and many sizes - check
   6  * 2. Tag selectivity - check
   7  * 3. Error return codes for
   8  *    a. Invalid Communicator
   9  *    b. Invalid destination or source
  10  *    c. Count out of range
  11  *    d. Invalid type
  12  *
  13  * Define VERBOSE to get noisier output
  14  */
  15
  16 #include "test.h"
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include "mpi.h"
  21
  22 #ifdef HAVE_MPICHCONF_H
  23 #include "mpichconf.h"
  24 #endif
  25
  26 static int src = 1;
  27 static int dest = 0;
  28
  29 static int do_test1 = 1;
  30 static int do_test2 = 1;
  31 static int do_test3 = 1;
  32
  33 static int verbose = 0;
  34
  35 #define MAX_TYPES 13
  36 static int ntypes = 0;
  37 static int nolongdouble = 0;
  38 static MPI_Datatype BasicTypes[MAX_TYPES];
  39
  40 static int maxbufferlen = 10000;
  41 static char *(BasicNames[MAX_TYPES]);
  42
  43 /* In order to quiet noisy C compilers, we provide ANSI-style prototypes
  44    where possible */
  45
  46 void AllocateBuffers ( void **, MPI_Datatype *, int, int );
  47 void FreeBuffers ( void **, int );
  48 void FillBuffers ( void **, MPI_Datatype *, int, int );
  49 int CheckBuffer ( void *, MPI_Datatype, int );
  50 void SetupBasicTypes (void);
  51 void SenderTest1 (void);
  52 void ReceiverTest1 (void);
  53 void SenderTest2 (void);
  54 void ReceiverTest2 (void);
  55 void SenderTest3 (void);
  56 void ReceiverTest3 (void);
  57
  58 void
  59 AllocateBuffers(bufferspace, buffertypes, num_types, bufferlen)
  60     void **bufferspace;
  61     MPI_Datatype *buffertypes;
  62     int num_types;
  63     int bufferlen;
  64 {
  65     int i;
  66     for (i = 0; i < ntypes; i++) {
  67         if (buffertypes[i] == MPI_CHAR)
  68             bufferspace[i] = malloc(bufferlen * sizeof(char));
  69         else if (buffertypes[i] == MPI_SHORT)
  70             bufferspace[i] = malloc(bufferlen * sizeof(short));
  71         else if (buffertypes[i] == MPI_INT)
  72             bufferspace[i] = malloc(bufferlen * sizeof(int));
  73         else if (buffertypes[i] == MPI_LONG)
  74             bufferspace[i] = malloc(bufferlen * sizeof(long));
  75         else if (buffertypes[i] == MPI_UNSIGNED_CHAR)
  76             bufferspace[i] = malloc(bufferlen * sizeof(unsigned char));
  77         else if (buffertypes[i] == MPI_UNSIGNED_SHORT)
  78             bufferspace[i] = malloc(bufferlen * sizeof(unsigned short));
  79         else if (buffertypes[i] == MPI_UNSIGNED)
  80             bufferspace[i] = malloc(bufferlen * sizeof(unsigned int));
  81         else if (buffertypes[i] == MPI_UNSIGNED_LONG)
  82             bufferspace[i] = malloc(bufferlen * sizeof(unsigned long));
  83         else if (buffertypes[i] == MPI_FLOAT)
  84             bufferspace[i] = malloc(bufferlen * sizeof(float));
  85         else if (buffertypes[i] == MPI_DOUBLE)
  86             bufferspace[i] = malloc(bufferlen * sizeof(double));
  87 #if defined(HAVE_LONG_DOUBLE) && !defined(HAS_XDR)
  88         else if (buffertypes[i] == MPI_LONG_DOUBLE) {
  89             int dlen;
  90             MPI_Type_size( MPI_LONG_DOUBLE, &dlen );
  91             bufferspace[i] = malloc(bufferlen * dlen);
  92         }
  93 #endif
  94 #if defined(HAVE_LONG_LONG_INT) && !defined(HAS_XDR)
  95         else if (buffertypes[i] == MPI_LONG_LONG_INT)
  96             bufferspace[i] = malloc(bufferlen * sizeof(long long) );
  97 #endif
  98         else if (buffertypes[i] == MPI_BYTE)
  99             bufferspace[i] = malloc(bufferlen * sizeof(unsigned char));
 100     }
 101 }
 102
 103 void FreeBuffers(void **buffers, int nbuffers)
 104 {
 105     int i;
 106     for (i = 0; i < nbuffers; i++)
 107         free(buffers[i]);
 108 }
 109
 110 void FillBuffers(bufferspace, buffertypes, num_types, bufferlen)
 111     void **bufferspace;
 112     MPI_Datatype *buffertypes;
 113     int num_types;
 114     int bufferlen;
 115 {
 116     int i, j;
 117     for (i = 0; i < ntypes; i++) {
 118         for (j = 0; j < bufferlen; j++) {
 119             if (buffertypes[i] == MPI_CHAR)
 120                 ((char *)bufferspace[i])[j] = (char)(j & 0x7f);
 121             else if (buffertypes[i] == MPI_SHORT)
 122                 ((short *)bufferspace[i])[j] = (short)j;
 123             else if (buffertypes[i] == MPI_INT)
 124                 ((int *)bufferspace[i])[j] = (int)j;
 125             else if (buffertypes[i] == MPI_LONG)
 126                 ((long *)bufferspace[i])[j] = (long)j;
 127             else if (buffertypes[i] == MPI_UNSIGNED_CHAR)
 128                 ((unsigned char *)bufferspace[i])[j] = (unsigned char)j;
 129             else if (buffertypes[i] == MPI_UNSIGNED_SHORT)
 130                 ((unsigned short *)bufferspace[i])[j] = (unsigned short)j;
 131             else if (buffertypes[i] == MPI_UNSIGNED)
 132                 ((unsigned int *)bufferspace[i])[j] = (unsigned int)j;
 133             else if (buffertypes[i] == MPI_UNSIGNED_LONG)
 134                 ((unsigned long *)bufferspace[i])[j] = (unsigned long)j;
 135             else if (buffertypes[i] == MPI_FLOAT)
 136                 ((float *)bufferspace[i])[j] = (float)j;
 137             else if (buffertypes[i] == MPI_DOUBLE)
 138                 ((double *)bufferspace[i])[j] = (double)j;
 139 #if defined(HAVE_LONG_DOUBLE) && !defined(HAS_XDR)
 140             else if (buffertypes[i] == MPI_LONG_DOUBLE)
 141                 ((long double *)bufferspace[i])[j] = (long double)j;
 142 #endif
 143 #if defined(HAVE_LONG_LONG_INT) && !defined(HAS_XDR)
 144             else if (buffertypes[i] == MPI_LONG_LONG_INT)
 145                 ((long long *)bufferspace[i])[j] = (long long)j;
 146 #endif
 147             else if (buffertypes[i] == MPI_BYTE)
 148                 ((unsigned char *)bufferspace[i])[j] = (unsigned char)j;
 149         }
 150     }
 151 }
 152
 153 int
 154 CheckBuffer(bufferspace, buffertype, bufferlen)
 155     void *bufferspace;
 156     MPI_Datatype buffertype;
 157     int bufferlen;
 158 {
 159     int j;
 160     char valerr[256];
 161     valerr[0] = 0;
 162     for (j = 0; j < bufferlen; j++) {
 163         if (buffertype == MPI_CHAR) {
 164             if (((char *)bufferspace)[j] != (char)(j & 0x7f)) {
 165                 sprintf( valerr, "%x != %x",
 166                         ((char *)bufferspace)[j], (char)(j&0x7f) );
 167                 break;
 168                 }
 169         } else if (buffertype == MPI_SHORT) {
 170             if (((short *)bufferspace)[j] != (short)j) {
 171                 sprintf( valerr, "%d != %d",
 172                         ((short *)bufferspace)[j], (short)j );
 173                 break;
 174                 }
 175         } else if (buffertype == MPI_INT) {
 176             if (((int *)bufferspace)[j] != (int)j) {
 177                 sprintf( valerr, "%d != %d",
 178                         ((int *)bufferspace)[j], (int)j );
 179                 break;
 180                 }
 181         } else if (buffertype == MPI_LONG) {
 182             if (((long *)bufferspace)[j] != (long)j) {
 183                 break;
 184                 }
 185         } else if (buffertype == MPI_UNSIGNED_CHAR) {
 186             if (((unsigned char *)bufferspace)[j] != (unsigned char)j) {
 187                 break;
 188                 }
 189         } else if (buffertype == MPI_UNSIGNED_SHORT) {
 190             if (((unsigned short *)bufferspace)[j] != (unsigned short)j) {
 191                 break;
 192                 }
 193         } else if (buffertype == MPI_UNSIGNED) {
 194             if (((unsigned int *)bufferspace)[j] != (unsigned int)j) {
 195                 break;
 196                 }
 197         } else if (buffertype == MPI_UNSIGNED_LONG) {
 198             if (((unsigned long *)bufferspace)[j] != (unsigned long)j) {
 199                 break;
 200                 }
 201         } else if (buffertype == MPI_FLOAT) {
 202             if (((float *)bufferspace)[j] != (float)j) {
 203                 break;
 204                 }
 205         } else if (buffertype == MPI_DOUBLE) {
 206             if (((double *)bufferspace)[j] != (double)j) {
 207                 break;
 208                 }
 209 #if defined(HAVE_LONG_DOUBLE) && !defined(HAS_XDR)
 210         } else if (buffertype == MPI_LONG_DOUBLE) {
 211             if (((long double *)bufferspace)[j] != (long double)j) {
 212                 break;
 213                 }
 214 #endif
 215 #if defined(HAVE_LONG_LONG_INT) && !defined(HAS_XDR)
 216         } else if (buffertype == MPI_LONG_LONG_INT) {
 217             if (((long long *)bufferspace)[j] != (long long)j) {
 218                 break;
 219                 }
 220 #endif
 221         } else if (buffertype == MPI_BYTE) {
 222             if (((unsigned char *)bufferspace)[j] != (unsigned char)j) {
 223                 break;
 224                 }
 225         }
 226     }
 227     /* Return +1 so an error in the first location is > 0 */
 228     if (j < bufferlen) {
 229         if (valerr[0]) fprintf( stderr, "Different value[%d] = %s\n",
 230                                 j, valerr );
 231         else
 232             fprintf( stderr, "Different value[%d]\n", j );
 233         return j+1;
 234         }
 235     return 0;
 236 }
 237
 238 void
 239 SetupBasicTypes()
 240 {
 241     BasicTypes[0] = MPI_CHAR;        BasicNames[0] = (char*)"MPI_CHAR" ;
 242     BasicTypes[1] = MPI_SHORT;       BasicNames[1] = (char*)"MPI_SHORT";
 243     BasicTypes[2] = MPI_INT;         BasicNames[2] = (char*)"MPI_INT"  ;
 244     BasicTypes[3] = MPI_LONG;        BasicNames[3] = (char*)"MPI_LONG" ;
 245     BasicTypes[4] = MPI_UNSIGNED_CHAR; BasicNames[4] = (char*)"MPI_UNSIGNED_CHAR";
 246     BasicTypes[5] = MPI_UNSIGNED_SHORT; BasicNames[5] = (char*)"MPI_UNSIGNED_SHORT";
 247     BasicTypes[6] = MPI_UNSIGNED;    BasicNames[6] = (char*)"MPI_UNSIGNED";
 248     BasicTypes[7] = MPI_UNSIGNED_LONG; BasicNames[7] = (char*)"MPI_UNSIGNED_LONG";
 249     BasicTypes[8] = MPI_FLOAT;       BasicNames[8] = (char*)"MPI_FLOAT";
 250     BasicTypes[9] = MPI_DOUBLE;      BasicNames[9] = (char*)"MPI_DOUBLE";
 251     BasicTypes[10] = MPI_BYTE;       BasicNames[10] = (char*)"MPI_BYTE";
 252     /* By making the BYTE type LAST, we make it easier to handle heterogeneous
 253        systems that may not support all of the types */
 254     ntypes = 11;
 255 #if defined (HAVE_LONG_DOUBLE) && !defined(HAS_XDR)
 256     /* This test allows us to use MPI_LONG_DOUBLE, but rely on size > 0
 257        for "actually implemented" */
 258     if (!nolongdouble) {
 259         int l;
 260         MPI_Type_size( MPI_LONG_DOUBLE, &l );
 261         if (l > 0) {
 262             BasicTypes[ntypes] = MPI_LONG_DOUBLE;
 263             BasicNames[ntypes] = (char*)"MPI_LONG_DOUBLE";
 264             ntypes++;
 265         }
 266     }
 267 #endif
 268 #if defined(HAVE_LONG_LONG_INT) && !defined(HAS_XDR)
 269     BasicTypes[ntypes] = MPI_LONG_LONG_INT;
 270     BasicNames[ntypes] = (char*)"MPI_LONG_LONG_INT";
 271     ntypes++;
 272 #endif
 273 }
 274
 275 void
 276 SenderTest1()
 277 {
 278     void *bufferspace[MAX_TYPES];
 279     int i, j;
 280
 281     AllocateBuffers(bufferspace, BasicTypes, ntypes, maxbufferlen);
 282     FillBuffers(bufferspace, BasicTypes, ntypes, maxbufferlen);
 283     for (i = 0; i < ntypes; i++) {
 284         MPI_Send( (void *)0, 0, BasicTypes[i], dest, 2000, MPI_COMM_WORLD );
 285         for (j = 0; j < maxbufferlen; j += 500)
 286             MPI_Send(bufferspace[i], j, BasicTypes[i], dest,
 287                      2000, MPI_COMM_WORLD);
 288     }
 289     FreeBuffers(bufferspace, ntypes);
 290 }
 291
 292 void
 293 ReceiverTest1()
 294 {
 295     void *bufferspace[MAX_TYPES];
 296     int i, j;
 297     char message[81];
 298     MPI_Status Stat;
 299     int dummy, passed;
 300
 301     AllocateBuffers(bufferspace, BasicTypes, ntypes, maxbufferlen);
 302     for (i = 0; i < ntypes; i++) {
 303         passed = 1;
 304         MPI_Recv( (void *)0, 0, BasicTypes[i], src,
 305                      2000, MPI_COMM_WORLD, &Stat);
 306         if (Stat.MPI_SOURCE != src) {
 307             fprintf(stderr, "*** Incorrect Source returned. ***\n");
 308             Test_Failed(message);
 309             passed = 0;
 310         } else if (Stat.MPI_TAG != 2000) {
 311             fprintf(stderr, "*** Incorrect Tag returned. ***\n");
 312             Test_Failed(message);
 313             passed = 0;
 314         } else if (MPI_Get_count(&Stat, BasicTypes[i], &dummy) ||
 315                    dummy != 0) {
 316             fprintf(stderr,
 317                     "*** Incorrect Count returned, Count = %d. ***\n",
 318                     dummy);
 319             Test_Failed(message);
 320             passed = 0;
 321             }
 322         /* Try different sized messages */
 323         for (j = 0; j < maxbufferlen; j += 500) {
 324             MPI_Recv(bufferspace[i], j, BasicTypes[i], src,
 325                      2000, MPI_COMM_WORLD, &Stat);
 326             sprintf(message, "Send-Receive Test, Type %d, Count %d",
 327                     i, j);
 328             if (Stat.MPI_SOURCE != src) {
 329                 fprintf(stderr, "*** Incorrect Source returned. ***\n");
 330                 Test_Failed(message);
 331                 passed = 0;
 332             } else if (Stat.MPI_TAG != 2000) {
 333                 fprintf(stderr, "*** Incorrect Tag returned. ***\n");
 334                 Test_Failed(message);
 335                 passed = 0;
 336             } else if (MPI_Get_count(&Stat, BasicTypes[i], &dummy) ||
 337                        dummy != j) {
 338                 fprintf(stderr,
 339             "*** Incorrect Count returned, Count = %d (should be %d). ***\n",
 340                         dummy, j);
 341                 Test_Failed(message);
 342                 passed = 0;
 343             } else if(CheckBuffer(bufferspace[i], BasicTypes[i], j)) {
 344                 fprintf(stderr,
 345                "*** Incorrect Message received (type = %d (%s), count = %d). ***\n",
 346                         i, BasicNames[i], j );
 347                 Test_Failed(message);
 348                 passed = 0;
 349             }
 350 #ifdef VERBOSE
 351             else {
 352                 fprintf(stderr,
 353                "Message of count %d, type %d received correctly.\n",
 354                            j, i );
 355             }
 356 #endif
 357         }
 358         sprintf(message, "Send-Receive Test, Type %d (%s)",
 359                 i, BasicNames[i] );
 360         if (passed)
 361             Test_Passed(message);
 362         else
 363             Test_Failed(message);
 364     }
 365     FreeBuffers(bufferspace, ntypes);
 366 }
 367
 368 #define MAX_ORDER_TAG 2010
 369 /* Test Tag Selectivity.
 370    Note that we must use non-blocking sends here, since otherwise we could
 371    deadlock waiting to receive/send the first message
 372 */
 373 void
 374 SenderTest2()
 375 {
 376     int *buffer;
 377     int i;
 378     MPI_Request r[10];
 379     MPI_Status  s[10];
 380
 381     buffer = (int *)malloc(maxbufferlen * sizeof(int));
 382     for (i = 0; i < maxbufferlen; i++)
 383         buffer[i] = i;
 384
 385     for (i = 2001; i <= MAX_ORDER_TAG; i++)
 386         MPI_Isend(buffer, maxbufferlen, MPI_INT, dest,
 387                  i, MPI_COMM_WORLD, &r[i-2001] );
 388
 389     MPI_Waitall( MAX_ORDER_TAG-2001+1, r, s );
 390     free(buffer);
 391
 392     return;
 393 }
 394
 395 void
 396 ReceiverTest2()
 397 {
 398     int *buffer;
 399     int i, j;
 400     char message[81];
 401     MPI_Status Stat;
 402     int dummy, passed;
 403     int errloc;
 404
 405     buffer = (int *)calloc(maxbufferlen,sizeof(int));
 406     passed = 1;
 407
 408     for (i = MAX_ORDER_TAG; i >= 2001; i--) {
 409         MPI_Recv(buffer, maxbufferlen, MPI_INT, src,
 410                  i, MPI_COMM_WORLD, &Stat);
 411         sprintf(message, "Tag Selectivity Test, Tag %d",
 412                 i);
 413         if (Stat.MPI_SOURCE != src) {
 414             fprintf(stderr, "*** Incorrect Source returned. ***\n");
 415             Test_Failed(message);
 416         } else if (Stat.MPI_TAG != i) {
 417             fprintf(stderr, "*** Incorrect Tag returned. ***\n");
 418             Test_Failed(message);
 419         } else if (MPI_Get_count(&Stat, MPI_INT, &dummy) ||
 420                    dummy != maxbufferlen) {
 421             fprintf(stderr,
 422                     "*** Incorrect Count returned, Count = %d. ***\n",
 423                     dummy);
 424             Test_Failed(message);
 425         } else if((errloc =
 426                    CheckBuffer((void*)buffer, MPI_INT, maxbufferlen))) {
 427             fprintf(stderr,
 428                     "*** Incorrect Message received at %d (tag=%d). ***\n",
 429                     errloc-1, i);
 430             Test_Failed(message);
 431             passed = 0;
 432         }
 433         /* Clear out the buffer */
 434         for (j = 0; j < maxbufferlen; j++)
 435             buffer[j] = -1;
 436     }
 437     strncpy(message, "Tag Selectivity Test", 81);
 438     if (passed)
 439         Test_Passed(message);
 440     else
 441         Test_Failed(message);
 442     free(buffer);
 443     return;
 444 }
 445
 446 void
 447 SenderTest3()
 448 {
 449     int ibuf[10];
 450
 451     /* A receive test might not fail until it is triggered... */
 452     MPI_Send( ibuf, 10, MPI_INT, dest, 15, MPI_COMM_WORLD);
 453
 454     return;
 455 }
 456
 457 void
 458 ReceiverTest3( void )
 459 {
 460     int buffer[20];
 461     MPI_Datatype bogus_type = MPI_DATATYPE_NULL;
 462     MPI_Status status;
 463     int myrank;
 464     int small_tag;
 465 /*
 466     if (verbose)
 467         MPI_Errhandler_set(MPI_COMM_WORLD, TEST_ERRORS_WARN);
 468     else
 469         MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN );
 470 */
 471     MPI_Comm_rank( MPI_COMM_WORLD, &myrank );
 472
 473     if (myrank == 0 && verbose) {
 474         fprintf( stderr,
 475 "There should be eight error messages about invalid communicator\n\
 476 count argument, datatype argument, tag, rank, buffer send and buffer recv\n" );
 477         }
 478     if (MPI_Send(buffer, 20, MPI_INT, dest,
 479                  1, MPI_COMM_NULL) == MPI_SUCCESS){
 480         Test_Failed("NULL Communicator Test");
 481     }
 482     else
 483         Test_Passed("NULL Communicator Test");
 484
 485     if (MPI_Send(buffer, -1, MPI_INT, dest,
 486                  1, MPI_COMM_WORLD) == MPI_SUCCESS){
 487         Test_Failed("Invalid Count Test");
 488     }
 489     else
 490         Test_Passed("Invalid Count Test");
 491
 492     if (MPI_Send(buffer, 20, bogus_type, dest,
 493                  1, MPI_COMM_WORLD) == MPI_SUCCESS){
 494         Test_Failed("Invalid Type Test");
 495     }
 496     else
 497         Test_Passed("Invalid Type Test");
 498
 499     small_tag = -1;
 500     if (small_tag == MPI_ANY_TAG) small_tag = -2;
 501     if (MPI_Send(buffer, 20, MPI_INT, dest,
 502                  small_tag, MPI_COMM_WORLD) == MPI_SUCCESS) {
 503         Test_Failed("Invalid Tag Test");
 504     }
 505     else
 506         Test_Passed("Invalid Tag Test");
 507
 508     /* Form a tag that is too large */
 509     /*MPI_Attr_get( MPI_COMM_WORLD, MPI_TAG_UB, (void **)&tag_ubp, &flag );
 510     if (!flag) Test_Failed("Could not get tag ub!" );
 511     large_tag = *tag_ubp + 1;
 512     if (large_tag > *tag_ubp) {
 513         if (MPI_Send(buffer, 20, MPI_INT, dest,
 514                      large_tag, MPI_COMM_WORLD) == MPI_SUCCESS) {
 515             Test_Failed("Invalid Tag Test");
 516             }
 517         else
 518             Test_Passed("Invalid Tag Test");
 519     }
 520 */
 521     if (MPI_Send(buffer, 20, MPI_INT, 300,
 522                  1, MPI_COMM_WORLD) == MPI_SUCCESS) {
 523         Test_Failed("Invalid Destination Test");
 524     }
 525     else
 526         Test_Passed("Invalid Destination Test");
 527
 528     if (MPI_Send((void *)0, 10, MPI_INT, dest,
 529                  1, MPI_COMM_WORLD) == MPI_SUCCESS){
 530         Test_Failed("Invalid Buffer Test (send)");
 531     }
 532     else
 533         Test_Passed("Invalid Buffer Test (send)");
 534
 535     /* A receive test might not fail until it is triggered... */
 536     if (MPI_Recv((void *)0, 10, MPI_INT, src,
 537                  15, MPI_COMM_WORLD, &status) == MPI_SUCCESS){
 538         Test_Failed("Invalid Buffer Test (recv)");
 539     }
 540     else
 541         Test_Passed("Invalid Buffer Test (recv)");
 542
 543     /* Just to keep things happy, see if there is a message to receive */
 544     { int flag, ibuf[10];
 545
 546     MPI_Iprobe( src, 15, MPI_COMM_WORLD, &flag, &status );
 547     if (flag)
 548         MPI_Recv( ibuf, 10, MPI_INT, src, 15, MPI_COMM_WORLD, &status );
 549     }
 550     MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL );
 551     return;
 552 }
 553
 554 /* Allow -nolongdouble to suppress long double testing */
 555 int main( int argc, char **argv )
 556 {
 557     int myrank, mysize;
 558     int rc, itemp, i;
 559
 560     MPI_Init(&argc, &argv);
 561     MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
 562     MPI_Comm_size(MPI_COMM_WORLD, &mysize);
 563     Test_Init("sendrecv", myrank);
 564     SetupBasicTypes();
 565
 566     if (mysize != 2) {
 567         fprintf(stderr,
 568                 "*** This test program requires exactly 2 processes.\n");
 569         MPI_Abort( MPI_COMM_WORLD, 1 );
 570     }
 571
 572     /* Get the min of the basic types */
 573     itemp = ntypes;
 574     MPI_Allreduce( &itemp, &ntypes, 1, MPI_INT, MPI_MIN, MPI_COMM_WORLD );
 575
 576     /* dest writes out the received stats; for the output to be
 577        consistant (with the final check), it should be procees 0 */
 578     for (i=1; i<argc; i++) {
 579         if (argv[i] && strcmp( "-alt", argv[i] ) == 0) {
 580             dest = 1;
 581             src  = 0;
 582         }
 583         else if (argv[i] && strcmp( "-nolongdouble", argv[i] ) == 0) {
 584             nolongdouble = 1;
 585         }
 586         else if (argv[i] && strcmp( "-test1", argv[i] ) == 0) {
 587             do_test2 = do_test3 = 0;
 588         }
 589         else if (argv[i] && strcmp( "-test2", argv[i] ) == 0) {
 590             do_test1 = do_test3 = 0;
 591         }
 592         else if (argv[i] && strcmp( "-test3", argv[i] ) == 0) {
 593             do_test2 = do_test1 = 0;
 594         }
 595         else {
 596             printf( "Unrecognized argument %s\n", argv[i] );
 597         }
 598     }
 599
 600     /* Turn stdout's buffering to line buffered so it mixes right with
 601        stderr in output files. (hopefully) */
 602     setvbuf(stdout, NULL, _IOLBF, 0);
 603     setvbuf(stderr, NULL, _IOLBF, 0);
 604
 605     if (myrank == src) {
 606         if (do_test1)
 607             SenderTest1();
 608         if (do_test2)
 609             SenderTest2();
 610         if (do_test3)
 611             SenderTest3();
 612     } else if (myrank == dest) {
 613         if (do_test1)
 614             ReceiverTest1();
 615         if (do_test2)
 616             ReceiverTest2();
 617         if (do_test3)
 618             ReceiverTest3();
 619     } else {
 620         fprintf(stderr, "*** This program uses exactly 2 processes! ***\n");
 621         MPI_Abort( MPI_COMM_WORLD, 1 );
 622     }
 623     if (myrank == dest) {
 624         rc = Summarize_Test_Results();
 625     }
 626     else {
 627         rc = 0;
 628     }
 629     Test_Finalize();
 630     Test_Waitforall( );
 631     MPI_Finalize();
 632     return rc;
 633 }
 634