int main( int argc, char **argv )
{
MPI_Comm comm;
MPI_Request r[MAX_REQ];
MPI_Status s[MAX_REQ];
int msgsize, maxmsg, root, i, j, size, rank, err = 0, msgcnt, toterr;
int *sbuf, *rbuf;
MPI_Init( &argc, &argv );
comm = MPI_COMM_WORLD;
MPI_Comm_size( comm, &size );
MPI_Comm_rank( comm, &rank );
if (size < 2) {
printf( "This test requires at least 2 processors\n" );
MPI_Abort( comm, 1 );
}
/* First, try large blocking sends to root */
root = 0;
maxmsg = MAX_MSG;
msgsize = 128;
msgcnt = MAX_MSG_CNT;
if (rank == root && verbose) printf( "Blocking sends: " );
while (msgsize <= maxmsg) {
if (rank == root) {
if (verbose) { printf( "%d ", msgsize ); fflush( stdout ); }
rbuf = (int *)malloc( msgsize * sizeof(int) );
if (!rbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
for (i=0; i<size; i++) {
if (i == rank) continue;
for (j=0; j<msgcnt; j++) {
SetupRdata( rbuf, msgsize );
MPI_Recv( rbuf, msgsize, MPI_INT, i, 2*i, comm, s );
err += CheckData( rbuf, msgsize, 2*i, s );
}
}
free( rbuf );
}
else {
sbuf = (int *)malloc( msgsize * sizeof(int) );
if (!sbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
SetupData( sbuf, msgsize, 2*rank );
for (j=0; j<msgcnt; j++)
MPI_Send( sbuf, msgsize, MPI_INT, root, 2*rank, comm );
free( sbuf );
}
msgsize *= 4;
}
if (rank == 0 && verbose) { printf( "\n" ); fflush( stdout ); }
/* Next, try unexpected messages with Isends */
msgsize = 128;
maxmsg = MAX_MSG;
msgcnt = MAX_REQ;
if (rank == root && verbose) printf( "Unexpected recvs: " );
while (msgsize <= maxmsg) {
if (rank == root) {
if (verbose) { printf( "%d ", msgsize ); fflush( stdout ); }
rbuf = (int *)malloc( msgsize * sizeof(int) );
if (!rbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
MPI_Barrier( comm );
for (i=0; i<size; i++) {
if (i == rank) continue;
for (j=0; j<msgcnt; j++) {
SetupRdata( rbuf, msgsize );
MPI_Recv( rbuf, msgsize, MPI_INT, i, 2*i, comm, s );
err += CheckData( rbuf, msgsize, 2*i, s );
}
}
free( rbuf );
}
else {
sbuf = (int *)malloc( msgsize * sizeof(int) );
if (!sbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
SetupData( sbuf, msgsize, 2*rank );
for (j=0; j<msgcnt; j++) {
MPI_Isend( sbuf, msgsize, MPI_INT, root, 2*rank, comm, &r[j] );
}
MPI_Barrier( comm );
MPI_Waitall( msgcnt, r, s );
free( sbuf );
}
msgsize *= 4;
}
if (rank == 0 && verbose) { printf( "\n" ); fflush( stdout ); }
/* Try large synchronous blocking sends to root */
root = 0;
msgsize = 128;
maxmsg = MAX_MSG;
if (rank == root && verbose) printf( "Synchronous sends: " );
while (msgsize <= maxmsg) {
if (rank == root) {
if (verbose) { printf( "%d ", msgsize ); fflush( stdout ); }
rbuf = (int *)malloc( msgsize * sizeof(int) );
if (!rbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
for (i=0; i<size; i++) {
if (i == rank) continue;
for (j=0; j<msgcnt; j++) {
SetupRdata( rbuf, msgsize );
MPI_Recv( rbuf, msgsize, MPI_INT, i, 2*i, comm, s );
err += CheckData( rbuf, msgsize, 2*i, s );
}
}
free( rbuf );
}
else {
sbuf = (int *)malloc( msgsize * sizeof(int) );
if (!sbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
SetupData( sbuf, msgsize, 2*rank );
for (j=0; j<msgcnt; j++)
MPI_Ssend( sbuf, msgsize, MPI_INT, root, 2*rank, comm );
free( sbuf );
}
msgsize *= 4;
}
if (rank == 0 && verbose) { printf( "\n" ); fflush( stdout ); }
MPI_Allreduce( &err, &toterr, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD );
if (rank == 0) {
if (toterr == 0) printf( "No errors\n" );
else printf( "!! found %d errors\n", toterr );
}
if (toterr) {
printf( "!! found %d errors on processor %d\n", err, rank );
}
MPI_Finalize( );
return 0;
}
int main( int argc, char **argv )
{
MPI_Comm comm;
MPI_Request r[MAX_REQ];
MPI_Status s[MAX_REQ];
int msgsize, maxmsg, root, i, size, rank, err = 0, toterr;
int max_msg_size = DEF_MAX_MSG;
int *sbuf, *rbuf;
MPI_Init( &argc, &argv );
comm = MPI_COMM_WORLD;
MPI_Comm_size( comm, &size );
MPI_Comm_rank( comm, &rank );
if (size < 2) {
printf( "This test requires at least 2 processors\n" );
MPI_Abort( comm, 1 );
}
/* Check for a max message argument */
if (rank == 0) {
if (argc > 1) {
max_msg_size = atoi( argv[1] );
/* Correct if unrecognized argument */
if (max_msg_size <= 0) max_msg_size = DEF_MAX_MSG;
}
}
MPI_Bcast( &max_msg_size, 1, MPI_INT, 0, MPI_COMM_WORLD );
/* First, try large blocking sends to root */
root = 0;
msgsize = 128;
maxmsg = max_msg_size;
if (rank == root && verbose) printf( "Blocking sends: " );
while (msgsize < maxmsg) {
if (rank == root) {
if (verbose) { printf( "%d ", msgsize ); fflush( stdout ); }
rbuf = (int *)malloc( msgsize * sizeof(int) );
if (!rbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
for (i=0; i<size; i++) {
if (i == rank) continue;
SetupRdata( rbuf, msgsize );
MPI_Recv( rbuf, msgsize, MPI_INT, i, 2*i, comm, s );
err += CheckData( rbuf, msgsize, 2*i, s );
}
free( rbuf );
}
else {
sbuf = (int *)malloc( msgsize * sizeof(int) );
if (!sbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
SetupData( sbuf, msgsize, 2*rank );
MPI_Ssend( sbuf, msgsize, MPI_INT, root, 2*rank, comm );
free( sbuf );
}
msgsize *= 4;
}
if (rank == 0 && verbose) { printf( "\n" ); fflush( stdout ); }
/* Next, try unexpected messages with Isends */
msgsize = 128;
maxmsg = max_msg_size;
if (rank == root && verbose) printf( "Unexpected recvs: " );
while (msgsize < maxmsg) {
if (rank == root) {
if (verbose) { printf( "%d ", msgsize ); fflush( stdout ); }
rbuf = (int *)malloc( msgsize * sizeof(int) );
if (!rbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
MPI_Barrier( comm );
for (i=0; i<size; i++) {
if (i == rank) continue;
SetupRdata( rbuf, msgsize );
MPI_Recv( rbuf, msgsize, MPI_INT, i, 2*i, comm, s );
err += CheckData( rbuf, msgsize, 2*i, s );
}
free( rbuf );
}
else {
sbuf = (int *)malloc( msgsize * sizeof(int) );
if (!sbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
SetupData( sbuf, msgsize, 2*rank );
MPI_Isend( sbuf, msgsize, MPI_INT, root, 2*rank, comm, r );
MPI_Barrier( comm );
MPI_Wait( r, s );
free( sbuf );
}
msgsize *= 4;
}
if (rank == 0 && verbose) { printf( "\n" ); fflush( stdout ); }
/* Try large synchronous blocking sends to root */
root = 0;
msgsize = 128;
maxmsg = max_msg_size;
if (rank == root && verbose) printf( "Synchronous sends: " );
while (msgsize < maxmsg) {
if (rank == root) {
if (verbose) { printf( "%d ", msgsize ); fflush( stdout ); }
rbuf = (int *)malloc( msgsize * sizeof(int) );
if (!rbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
for (i=0; i<size; i++) {
if (i == rank) continue;
SetupRdata( rbuf, msgsize );
MPI_Recv( rbuf, msgsize, MPI_INT, i, 2*i, comm, s );
err += CheckData( rbuf, msgsize, 2*i, s );
}
free( rbuf );
}
else {
sbuf = (int *)malloc( msgsize * sizeof(int) );
if (!sbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
SetupData( sbuf, msgsize, 2*rank );
MPI_Send( sbuf, msgsize, MPI_INT, root, 2*rank, comm );
free( sbuf );
}
msgsize *= 4;
}
if (rank == 0 && verbose) { printf( "\n" ); fflush( stdout ); }
/* Next, try expected messages with Rsend */
msgsize = 128;
maxmsg = max_msg_size;
if (rank == root && verbose) printf( "Expected recvs and Rsend: " );
while (msgsize < maxmsg) {
if (rank == root) {
if (verbose) { printf( "%d ", msgsize ); fflush( stdout ); }
rbuf = (int *)malloc( msgsize * sizeof(int) );
if (!rbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
for (i=0; i<size; i++) {
if (i == rank) continue;
SetupRdata( rbuf, msgsize );
MPI_Irecv( rbuf, msgsize, MPI_INT, i, 2*i, comm, r );
MPI_Send( MPI_BOTTOM, 0, MPI_INT, i, 2*i+1, comm );
MPI_Wait( r, s );
err += CheckData( rbuf, msgsize, 2*i, s );
}
free( rbuf );
}
else {
sbuf = (int *)malloc( msgsize * sizeof(int) );
if (!sbuf) {
printf( "Could not allocate %d words\n", msgsize );
MPI_Abort( comm, 1 );
}
SetupData( sbuf, msgsize, 2*rank );
MPI_Recv( MPI_BOTTOM, 0, MPI_INT, root, 2*rank+1, comm, s );
MPI_Send( sbuf, msgsize, MPI_INT, root, 2*rank, comm );
free( sbuf );
}
msgsize *= 4;
}
if (rank == 0 && verbose) { printf( "\n" ); fflush( stdout ); }
MPI_Allreduce( &err, &toterr, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD );
if (rank == 0) {
if (toterr == 0) printf( " No Errors\n" );
else printf( "!! found %d errors\n", toterr );
}
if (toterr) {
printf( "!! found %d errors on processor %d\n", err, rank );
}
MPI_Finalize( );
return 0;
}
