sendrecv.c

MPICH是MPI的重要研究,提供了一系列的接口函数,为并行计算的实现提供了编程环境.

	    Test_Failed(message);
	    passed = 0;
	    }
	/* Try different sized messages */
	for (j = 0; j < maxbufferlen; j += 500) {
	    MPI_Recv(bufferspace[i], j, BasicTypes[i], src, 
		     2000, MPI_COMM_WORLD, &Stat);
	    sprintf(message, "Send-Receive Test, Type %d, Count %d",
		    i, j);
	    if (Stat.MPI_SOURCE != src) {
		fprintf(stderr, "*** Incorrect Source returned. ***\n");
		Test_Failed(message);
		passed = 0;
	    } else if (Stat.MPI_TAG != 2000) {	
		fprintf(stderr, "*** Incorrect Tag returned. ***\n");	    
		Test_Failed(message);
		passed = 0;
	    } else if (MPI_Get_count(&Stat, BasicTypes[i], &dummy) ||
		       dummy != j) {
		fprintf(stderr, 
	    "*** Incorrect Count returned, Count = %d (should be %d). ***\n", 
			dummy, j);
		Test_Failed(message);
		passed = 0;
	    } else if(CheckBuffer(bufferspace[i], BasicTypes[i], j)) {
		fprintf(stderr, 
	       "*** Incorrect Message received (type = %d (%s), count = %d). ***\n",
			i, BasicNames[i], j );
		Test_Failed(message);
		passed = 0;
	    } 
#ifdef VERBOSE		
	    else {
		fprintf(stderr, 
	       "Message of count %d, type %d received correctly.\n", 
			   j, i );
	    }
#endif
	}
	sprintf(message, "Send-Receive Test, Type %d (%s)",
		i, BasicNames[i] );
	if (passed) 
	    Test_Passed(message);
	else 
	    Test_Failed(message);
    }
    FreeBuffers(bufferspace, ntypes);
}

#define MAX_ORDER_TAG 2010
/* Test Tag Selectivity.
   Note that we must use non-blocking sends here, since otherwise we could 
   deadlock waiting to receive/send the first message
*/
void 
SenderTest2()
{
    int *buffer;
    int i;
    MPI_Request r[10];
    MPI_Status  s[10];

    buffer = (int *)malloc(maxbufferlen * sizeof(int));
    for (i = 0; i < maxbufferlen; i++)
	buffer[i] = i;
    
    for (i = 2001; i <= MAX_ORDER_TAG; i++)
	MPI_Isend(buffer, maxbufferlen, MPI_INT, dest,
		 i, MPI_COMM_WORLD, &r[i-2001] );
    
    MPI_Waitall( MAX_ORDER_TAG-2001+1, r, s );
    free(buffer);
    
    return;
}

void
ReceiverTest2()
{
    int *buffer;
    int i, j;
    char message[81];
    MPI_Status Stat;
    int dummy, passed;
    int errloc;

    buffer = (int *)calloc(maxbufferlen,sizeof(int));
    passed = 1;

    for (i = MAX_ORDER_TAG; i >= 2001; i--) {
	MPI_Recv(buffer, maxbufferlen, MPI_INT, src, 
		 i, MPI_COMM_WORLD, &Stat);
	sprintf(message, "Tag Selectivity Test, Tag %d",
		i);
	if (Stat.MPI_SOURCE != src) {
	    fprintf(stderr, "*** Incorrect Source returned. ***\n");
	    Test_Failed(message);
	} else if (Stat.MPI_TAG != i) {	
	    fprintf(stderr, "*** Incorrect Tag returned. ***\n");	    
	    Test_Failed(message);
	} else if (MPI_Get_count(&Stat, MPI_INT, &dummy) ||
		   dummy != maxbufferlen) {
	    fprintf(stderr, 
		    "*** Incorrect Count returned, Count = %d. ***\n", 
		    dummy);
	    Test_Failed(message);
	} else if((errloc = 
		   CheckBuffer((void*)buffer, MPI_INT, maxbufferlen))) {
	    fprintf(stderr, 
		    "*** Incorrect Message received at %d (tag=%d). ***\n",
		    errloc-1, i);
	    Test_Failed(message);
	    passed = 0;
	}
	/* Clear out the buffer */
	for (j = 0; j < maxbufferlen; j++)
	    buffer[j] = -1;
    }
    strncpy(message, "Tag Selectivity Test", 81);
    if (passed)
	Test_Passed(message);
    else
	Test_Failed(message);
    free(buffer);
    return;
}

void
SenderTest3()
{
    int ibuf[10];

    /* A receive test might not fail until it is triggered... */
    MPI_Send( ibuf, 10, MPI_INT, dest, 15, MPI_COMM_WORLD);

    return;
}

void
ReceiverTest3( void )
{
    int buffer[20];
    MPI_Datatype bogus_type = MPI_DATATYPE_NULL;
    MPI_Status status;
    int myrank;
    int *tag_ubp;
    int large_tag, flag, small_tag;

    if (verbose) 
	MPI_Errhandler_set(MPI_COMM_WORLD, TEST_ERRORS_WARN);
    else 
	MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN );

    MPI_Comm_rank( MPI_COMM_WORLD, &myrank );

    if (myrank == 0 && verbose) {
	fprintf( stderr, 
"There should be eight error messages about invalid communicator\n\
count argument, datatype argument, tag, rank, buffer send and buffer recv\n" );
	}
    if (MPI_Send(buffer, 20, MPI_INT, dest,
		 1, MPI_COMM_NULL) == MPI_SUCCESS){
	Test_Failed("NULL Communicator Test");
    }
    else
	Test_Passed("NULL Communicator Test");

    if (MPI_Send(buffer, -1, MPI_INT, dest,
		 1, MPI_COMM_WORLD) == MPI_SUCCESS){
	Test_Failed("Invalid Count Test");
    }
    else
	Test_Passed("Invalid Count Test");

    if (MPI_Send(buffer, 20, bogus_type, dest,
		 1, MPI_COMM_WORLD) == MPI_SUCCESS){
	Test_Failed("Invalid Type Test");
    }
    else
	Test_Passed("Invalid Type Test");

    small_tag = -1;
    if (small_tag == MPI_ANY_TAG) small_tag = -2;
    if (MPI_Send(buffer, 20, MPI_INT, dest, 
		 small_tag, MPI_COMM_WORLD) == MPI_SUCCESS) {
        Test_Failed("Invalid Tag Test");
    }
    else
	Test_Passed("Invalid Tag Test");

    /* Form a tag that is too large */
    MPI_Attr_get( MPI_COMM_WORLD, MPI_TAG_UB, (void **)&tag_ubp, &flag );
    if (!flag) Test_Failed("Could not get tag ub!" );
    large_tag = *tag_ubp + 1;
    if (large_tag > *tag_ubp) {
	if (MPI_Send(buffer, 20, MPI_INT, dest, 
		     large_tag, MPI_COMM_WORLD) == MPI_SUCCESS) {
	    Test_Failed("Invalid Tag Test");
	    }
	else
	    Test_Passed("Invalid Tag Test");
    }

    if (MPI_Send(buffer, 20, MPI_INT, 300,
		 1, MPI_COMM_WORLD) == MPI_SUCCESS) {
	Test_Failed("Invalid Destination Test");
    }
    else
	Test_Passed("Invalid Destination Test");

    if (MPI_Send((void *)0, 10, MPI_INT, dest,
		 1, MPI_COMM_WORLD) == MPI_SUCCESS){
	Test_Failed("Invalid Buffer Test (send)");
    }
    else
	Test_Passed("Invalid Buffer Test (send)");

    /* A receive test might not fail until it is triggered... */
    if (MPI_Recv((void *)0, 10, MPI_INT, src,
		 15, MPI_COMM_WORLD, &status) == MPI_SUCCESS){
	Test_Failed("Invalid Buffer Test (recv)");
    }
    else
	Test_Passed("Invalid Buffer Test (recv)");

    /* Just to keep things happy, see if there is a message to receive */
    { int flag, ibuf[10];

    MPI_Iprobe( src, 15, MPI_COMM_WORLD, &flag, &status );
    if (flag) 
	MPI_Recv( ibuf, 10, MPI_INT, src, 15, MPI_COMM_WORLD, &status );
    }
    MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL );
    return;
}

/* Allow -nolongdouble to suppress long double testing */
int main( int argc, char **argv )
{
    int myrank, mysize;
    int rc, itemp, i;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
    MPI_Comm_size(MPI_COMM_WORLD, &mysize);
    Test_Init("sendrecv", myrank);
    SetupBasicTypes();

    if (mysize != 2) {
	fprintf(stderr, 
		"*** This test program requires exactly 2 processes.\n");
	MPI_Abort( MPI_COMM_WORLD, 1 );
    }

    /* Get the min of the basic types */
    itemp = ntypes;
    MPI_Allreduce( &itemp, &ntypes, 1, MPI_INT, MPI_MIN, MPI_COMM_WORLD );

    /* dest writes out the received stats; for the output to be
       consistant (with the final check), it should be procees 0 */
    for (i=1; i<argc; i++) {
	if (argv[i] && strcmp( "-alt", argv[i] ) == 0) {
	    dest = 1;
	    src  = 0;
	} 
	else if (argv[i] && strcmp( "-nolongdouble", argv[i] ) == 0) {
	    nolongdouble = 1;
	}
	else if (argv[i] && strcmp( "-test1", argv[i] ) == 0) {
	    do_test2 = do_test3 = 0;
	}
	else if (argv[i] && strcmp( "-test2", argv[i] ) == 0) {
	    do_test1 = do_test3 = 0;
	}
	else if (argv[i] && strcmp( "-test3", argv[i] ) == 0) {
	    do_test2 = do_test1 = 0;
	}
	else {
	    printf( "Unrecognized argument %s\n", argv[i] );
	}
    }

    /* Turn stdout's buffering to line buffered so it mixes right with
       stderr in output files. (hopefully) */
    setvbuf(stdout, NULL, _IOLBF, 0);
    setvbuf(stderr, NULL, _IOLBF, 0);

    if (myrank == src) {
	if (do_test1)
	    SenderTest1();
	if (do_test2)
	    SenderTest2();
	if (do_test3)
	    SenderTest3(); 
    } else if (myrank == dest) {
	if (do_test1)
	    ReceiverTest1();
	if (do_test2)
	    ReceiverTest2();
	if (do_test3) 
	    ReceiverTest3();
    } else {
	fprintf(stderr, "*** This program uses exactly 2 processes! ***\n");
	MPI_Abort( MPI_COMM_WORLD, 1 );
    }
    if (myrank == dest) {
	rc = Summarize_Test_Results();
    }
    else {
	rc = 0;
    }
    Test_Finalize();
    Test_Waitforall( );
    MPI_Finalize();
    return rc;
}