int PrintRecvedError(const char *msg, MTestDatatype * sendtypePtr, MTestDatatype * recvtypePtr)
{
printf
("At step %s, Data in target buffer did not match for destination datatype %s (put with source datatype %s)\n",
msg, MTestGetDatatypeName(recvtypePtr), MTestGetDatatypeName(sendtypePtr));
/* Redo the test, with the errors printed */
recvtypePtr->printErrors = 1;
(void) MTestCheckRecv(0, recvtypePtr);
return 0;
}
int main(int argc, char *argv[])
{
int errs = 0;
int rank, size, source, dest;
int minsize = 2, count;
MPI_Comm comm;
MTestDatatype sendtype, recvtype;
MTest_Init(&argc, &argv);
/* The following illustrates the use of the routines to
* run through a selection of communicators and datatypes.
* Use subsets of these for tests that do not involve combinations
* of communicators, datatypes, and counts of datatypes */
while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
if (comm == MPI_COMM_NULL)
continue;
/* Determine the sender and receiver */
MPI_Comm_rank(comm, &rank);
MPI_Comm_size(comm, &size);
source = 0;
dest = size - 1;
MTEST_DATATYPE_FOR_EACH_COUNT(count) {
while (MTestGetDatatypes(&sendtype, &recvtype, count)) {
errs += test(comm, rank, source, dest, &sendtype, &recvtype);
MTestFreeDatatype(&sendtype);
MTestFreeDatatype(&recvtype);
}
}
MTestFreeComm(&comm);
}
/* Part #2: simple large size test - contiguous and noncontiguous */
if (sizeof(void *) > 4) { /* Only if > 32-bit architecture */
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
source = 0;
dest = size - 1;
MTestGetDatatypes(&sendtype, &recvtype, LARGE_CNT_CONTIG);
errs += test(MPI_COMM_WORLD, rank, source, dest, &sendtype, &recvtype);
do {
MTestFreeDatatype(&sendtype);
MTestFreeDatatype(&recvtype);
MTestGetDatatypes(&sendtype, &recvtype, LARGE_CNT_NONCONTIG);
} while (strstr(MTestGetDatatypeName(&sendtype), "vector") == NULL);
errs += test(MPI_COMM_WORLD, rank, source, dest, &sendtype, &recvtype);
MTestFreeDatatype(&sendtype);
MTestFreeDatatype(&recvtype);
}
MTest_Finalize(errs);
MPI_Finalize();
return 0;
}
int main( int argc, char *argv[] )
{
int errs = 0, err;
int rank, size, root;
int minsize = 2, count;
MPI_Comm comm;
MTestDatatype sendtype, recvtype;
MTest_Init( &argc, &argv );
/* The following illustrates the use of the routines to
run through a selection of communicators and datatypes.
Use subsets of these for tests that do not involve combinations
of communicators, datatypes, and counts of datatypes */
while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
if (comm == MPI_COMM_NULL) continue;
/* Determine the sender and receiver */
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
/* To improve reporting of problems about operations, we
change the error handler to errors return */
MPI_Errhandler_set( comm, MPI_ERRORS_RETURN );
/* The max value of count must be very large to ensure that we
reach the long message algorithms */
for (count = 1; count < 2800; count = count * 4) {
while (MTestGetDatatypes( &sendtype, &recvtype, count )) {
for (root=0; root<size; root++) {
if (rank == root) {
sendtype.InitBuf( &sendtype );
err = MPI_Bcast( sendtype.buf, sendtype.count,
sendtype.datatype, root, comm );
if (err) {
errs++;
MTestPrintError( err );
}
}
else {
recvtype.InitBuf( &recvtype );
err = MPI_Bcast( recvtype.buf, recvtype.count,
recvtype.datatype, root, comm );
if (err) {
errs++;
fprintf( stderr, "Error with communicator %s and datatype %s\n",
MTestGetIntracommName(),
MTestGetDatatypeName( &recvtype ) );
MTestPrintError( err );
}
err = MTestCheckRecv( 0, &recvtype );
if (err) {
errs += errs;
}
}
}
MTestFreeDatatype( &recvtype );
MTestFreeDatatype( &sendtype );
}
}
MTestFreeComm( &comm );
}
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
int main( int argc, char **argv )
{
int errs = 0, err;
int rank, size, source, dest;
int minsize = 2, count;
MPI_Comm comm;
MPI_Win win;
MPI_Aint extent;
MTestDatatype sendtype, recvtype;
int onlyInt = 0;
MTest_Init( &argc, &argv );
/* Check for a simple choice of communicator and datatypes */
if (getenv( "MTEST_SIMPLE" )) onlyInt = 1;
while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
if (comm == MPI_COMM_NULL) continue;
/* Determine the sender and receiver */
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
source = 0;
dest = size - 1;
for (count = 1; count < 65000; count = count * 2) {
while (MTestGetDatatypes( &sendtype, &recvtype, count )) {
MTestPrintfMsg( 1,
"Putting count = %d of sendtype %s receive type %s\n",
count, MTestGetDatatypeName( &sendtype ),
MTestGetDatatypeName( &recvtype ) );
/* Make sure that everyone has a recv buffer */
recvtype.InitBuf( &recvtype );
MPI_Type_extent( recvtype.datatype, &extent );
MPI_Win_create( recvtype.buf, recvtype.count * extent,
extent, MPI_INFO_NULL, comm, &win );
/* To improve reporting of problems about operations, we
change the error handler to errors return */
MPI_Win_set_errhandler( win, MPI_ERRORS_RETURN );
/* At this point, we have all of the elements that we
need to begin the multiple fence and put tests */
/* Fence 1 */
err = MPI_Win_fence( MPI_MODE_NOPRECEDE, win );
if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
/* Source puts */
if (rank == source) {
sendtype.InitBuf( &sendtype );
err = MPI_Put( sendtype.buf, sendtype.count,
sendtype.datatype, dest, 0,
recvtype.count, recvtype.datatype, win );
if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
}
/* Fence 2 */
err = MPI_Win_fence( 0, win );
if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
/* dest checks data, then Dest puts */
if (rank == dest) {
err = MTestCheckRecv( 0, &recvtype );
if (err) { if (errs++ < MAX_PERR) {
PrintRecvedError( "fence 2", &sendtype, &recvtype );
}
}
sendtype.InitBuf( &sendtype );
err = MPI_Put( sendtype.buf, sendtype.count,
sendtype.datatype, source, 0,
recvtype.count, recvtype.datatype, win );
if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
}
/* Fence 3 */
err = MPI_Win_fence( 0, win );
if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
/* src checks data, then Src and dest puts*/
if (rank == source) {
err = MTestCheckRecv( 0, &recvtype );
if (err) { if (errs++ < MAX_PERR) {
PrintRecvedError( "fence 3", &sendtype, &recvtype );
}
}
sendtype.InitBuf( &sendtype );
err = MPI_Put( sendtype.buf, sendtype.count,
sendtype.datatype, dest, 0,
recvtype.count, recvtype.datatype, win );
if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
}
if (rank == dest) {
sendtype.InitBuf( &sendtype );
err = MPI_Put( sendtype.buf, sendtype.count,
sendtype.datatype, source, 0,
recvtype.count, recvtype.datatype, win );
if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
}
/* Fence 4 */
err = MPI_Win_fence( MPI_MODE_NOSUCCEED, win );
if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
/* src and dest checks data */
if (rank == source) {
err = MTestCheckRecv( 0, &recvtype );
if (err) { if (errs++ < MAX_PERR) {
PrintRecvedError( "src fence4", &sendtype, &recvtype );
}
}
}
if (rank == dest) {
err = MTestCheckRecv( 0, &recvtype );
if (err) { if (errs++ < MAX_PERR) {
PrintRecvedError( "dest fence4", &sendtype, &recvtype );
}
}
}
MPI_Win_free( &win );
MTestFreeDatatype( &sendtype );
MTestFreeDatatype( &recvtype );
/* Only do one datatype in the simple case */
if (onlyInt) break;
}
/* Only do one count in the simple case */
if (onlyInt) break;
}
MTestFreeComm(&comm);
/* Only do one communicator in the simple case */
if (onlyInt) break;
}
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
/* ------------------------------------------------------------------------ */
int MTestGetDatatypes(MTestDatatype * sendtype, MTestDatatype * recvtype, MPI_Aint tot_count)
{
int merr = 0;
MTestGetDbgInfo(&dbgflag, &verbose);
MTestInitDatatypeEnv();
MPI_Comm_rank(MPI_COMM_WORLD, &wrank);
/* Initialize the default test level if test does not specify. */
if (!MTestIsDatatypeGenInited()) {
MTestInitDefaultTestFunc();
}
if (datatype_index == 0) {
MTestPrintDatatypeGen();
}
/* Start generating tests */
if (datatype_index < MTEST_BDT_RANGE) {
merr = MTestGetBasicDatatypes(sendtype, recvtype, tot_count);
}
else if (datatype_index < MTEST_SEND_DDT_RANGE) {
merr = MTestGetSendDerivedDatatypes(sendtype, recvtype, tot_count);
}
else if (datatype_index < MTEST_RECV_DDT_RANGE) {
merr = MTestGetRecvDerivedDatatypes(sendtype, recvtype, tot_count);
}
else {
/* out of range */
datatype_index = -1;
MTestResetDatatypeGen();
}
/* stop if error reported */
if (merr) {
datatype_index = -1;
}
if (datatype_index > 0) {
/* general initialization for receive buffer. */
recvtype->InitBuf = MTestTypeInitRecv;
}
datatype_index++;
if (verbose >= 2 && datatype_index > 0) {
MPI_Count ssize, rsize;
MPI_Aint slb, rlb, sextent, rextent;
const char *sendtype_nm = MTestGetDatatypeName(sendtype);
const char *recvtype_nm = MTestGetDatatypeName(recvtype);
MPI_Type_size_x(sendtype->datatype, &ssize);
MPI_Type_size_x(recvtype->datatype, &rsize);
MPI_Type_get_extent(sendtype->datatype, &slb, &sextent);
MPI_Type_get_extent(recvtype->datatype, &rlb, &rextent);
MTestPrintfMsg(2, "Get datatypes: send = %s(size %d ext %ld lb %ld count %d basesize %d), "
"recv = %s(size %d ext %ld lb %ld count %d basesize %d), tot_count=%d\n",
sendtype_nm, ssize, sextent, slb, sendtype->count, sendtype->basesize,
recvtype_nm, rsize, rextent, rlb, recvtype->count, recvtype->basesize,
tot_count);
fflush(stdout);
}
return datatype_index;
}
int main( int argc, char *argv[] )
{
int errs = 0, err;
int rank, size, root;
int minsize = 2, count;
MPI_Comm comm;
MTestDatatype sendtype, recvtype;
MTest_Init( &argc, &argv );
/* The following illustrates the use of the routines to
run through a selection of communicators and datatypes.
Use subsets of these for tests that do not involve combinations
of communicators, datatypes, and counts of datatypes */
while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
if (comm == MPI_COMM_NULL) continue;
/* Determine the sender and receiver */
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
count = 1;
MTEST_DATATYPE_FOR_EACH_COUNT(count) {
/* To shorten test time, only run the default version of datatype tests
* for comm world and run the minimum version for other communicators. */
if (comm != MPI_COMM_WORLD) {
MTestInitMinDatatypes();
}
while (MTestGetDatatypes( &sendtype, &recvtype, count )) {
for (root=0; root<size; root++) {
if (rank == root) {
sendtype.InitBuf( &sendtype );
err = MPI_Bcast( sendtype.buf, sendtype.count,
sendtype.datatype, root, comm );
if (err) {
errs++;
MTestPrintError( err );
}
}
else {
recvtype.InitBuf( &recvtype );
err = MPI_Bcast( recvtype.buf, recvtype.count,
recvtype.datatype, root, comm );
if (err) {
errs++;
fprintf( stderr, "Error with communicator %s and datatype %s\n",
MTestGetIntracommName(),
MTestGetDatatypeName( &recvtype ) );
MTestPrintError( err );
}
err = MTestCheckRecv( 0, &recvtype );
if (err) {
errs += errs;
}
}
}
MTestFreeDatatype( &recvtype );
MTestFreeDatatype( &sendtype );
}
}
MTestFreeComm( &comm );
}
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
int main( int argc, char *argv[] )
{
int errs = 0, err;
int rank, size, source, dest;
int minsize = 2, count;
MPI_Comm comm;
MPI_Status status;
MTestDatatype sendtype, recvtype;
MTest_Init( &argc, &argv );
/* The following illustrates the use of the routines to
run through a selection of communicators and datatypes.
Use subsets of these for tests that do not involve combinations
of communicators, datatypes, and counts of datatypes */
while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
if (comm == MPI_COMM_NULL) continue;
/* Determine the sender and receiver */
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
source = 0;
dest = size - 1;
/* To improve reporting of problems about operations, we
change the error handler to errors return */
MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN );
for (count = 1; count < 65000; count = count * 2) {
while (MTestGetDatatypes( &sendtype, &recvtype, count )) {
if (rank == source) {
sendtype.InitBuf( &sendtype );
err = MPI_Send( sendtype.buf, sendtype.count,
sendtype.datatype, dest, 0, comm );
if (err) {
errs++;
MTestPrintError( err );
}
MTestFreeDatatype( &sendtype );
}
else if (rank == dest) {
recvtype.InitBuf( &recvtype );
err = MPI_Recv( recvtype.buf, recvtype.count,
recvtype.datatype, source, 0, comm, &status );
if (err) {
errs++;
fprintf( stderr, "Error with communicator %s and datatype %s\n",
MTestGetIntracommName(),
MTestGetDatatypeName( &recvtype ) );
MTestPrintError( err );
}
err = MTestCheckRecv( &status, &recvtype );
if (err) {
errs += errs;
}
MTestFreeDatatype( &recvtype );
}
}
}
MTestFreeComm( &comm );
}
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
/*
Create a range of datatypes with a given count elements.
This uses a selection of types, rather than an exhaustive collection.
It allocates both send and receive types so that they can have the same
type signature (collection of basic types) but different type maps (layouts
in memory)
*/
int MTestGetDatatypes( MTestDatatype *sendtype, MTestDatatype *recvtype,
int count )
{
int merr;
int i;
sendtype->InitBuf = 0;
sendtype->FreeBuf = 0;
sendtype->CheckBuf = 0;
sendtype->datatype = 0;
sendtype->isBasic = 0;
sendtype->printErrors = 0;
recvtype->InitBuf = 0;
recvtype->FreeBuf = 0;
recvtype->CheckBuf = 0;
recvtype->datatype = 0;
recvtype->isBasic = 0;
recvtype->printErrors = 0;
sendtype->buf = 0;
recvtype->buf = 0;
/* Set the defaults for the message lengths */
sendtype->count = count;
recvtype->count = count;
/* Use datatype_index to choose a datatype to use. If at the end of the
list, return 0 */
switch (datatype_index) {
case 0:
sendtype->datatype = MPI_INT;
sendtype->isBasic = 1;
recvtype->datatype = MPI_INT;
recvtype->isBasic = 1;
break;
case 1:
sendtype->datatype = MPI_DOUBLE;
sendtype->isBasic = 1;
recvtype->datatype = MPI_DOUBLE;
recvtype->isBasic = 1;
break;
case 2:
sendtype->datatype = MPI_FLOAT_INT;
sendtype->isBasic = 1;
recvtype->datatype = MPI_FLOAT_INT;
recvtype->isBasic = 1;
break;
case 3:
merr = MPI_Type_dup( MPI_INT, &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( sendtype->datatype,
(char*)"dup of MPI_INT" );
if (merr) MTestPrintError( merr );
merr = MPI_Type_dup( MPI_INT, &recvtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( recvtype->datatype,
(char*)"dup of MPI_INT" );
if (merr) MTestPrintError( merr );
/* dup'ed types are already committed if the original type
was committed (MPI-2, section 8.8) */
break;
case 4:
/* vector send type and contiguous receive type */
/* These sizes are in bytes (see the VectorInit code) */
sendtype->stride = 3 * sizeof(int);
sendtype->blksize = sizeof(int);
sendtype->nelm = recvtype->count;
merr = MPI_Type_vector( recvtype->count, 1, 3, MPI_INT,
&sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_commit( &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( sendtype->datatype,
(char*)"int-vector" );
if (merr) MTestPrintError( merr );
sendtype->count = 1;
recvtype->datatype = MPI_INT;
recvtype->isBasic = 1;
sendtype->InitBuf = MTestTypeVectorInit;
recvtype->InitBuf = MTestTypeContigInitRecv;
sendtype->FreeBuf = MTestTypeVectorFree;
recvtype->FreeBuf = MTestTypeContigFree;
sendtype->CheckBuf = 0;
recvtype->CheckBuf = MTestTypeContigCheckbuf;
break;
case 5:
/* Indexed send using many small blocks and contig receive */
sendtype->blksize = sizeof(int);
sendtype->nelm = recvtype->count;
sendtype->basesize = sizeof(int);
sendtype->displs = (int *)malloc( sendtype->nelm * sizeof(int) );
sendtype->index = (int *)malloc( sendtype->nelm * sizeof(int) );
if (!sendtype->displs || !sendtype->index) {
MTestError( "Out of memory in type init\n" );
}
/* Make the sizes larger (4 ints) to help push the total
size to over 256k in some cases, as the MPICH code as of
10/1/06 used large internal buffers for packing non-contiguous
messages */
for (i=0; i<sendtype->nelm; i++) {
sendtype->index[i] = 4;
sendtype->displs[i] = 5*i;
}
merr = MPI_Type_indexed( sendtype->nelm,
sendtype->index, sendtype->displs,
MPI_INT, &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_commit( &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( sendtype->datatype,
(char*)"int-indexed(4-int)" );
if (merr) MTestPrintError( merr );
sendtype->count = 1;
sendtype->InitBuf = MTestTypeIndexedInit;
sendtype->FreeBuf = MTestTypeIndexedFree;
sendtype->CheckBuf = 0;
recvtype->datatype = MPI_INT;
recvtype->isBasic = 1;
recvtype->count = count * 4;
recvtype->InitBuf = MTestTypeContigInitRecv;
recvtype->FreeBuf = MTestTypeContigFree;
recvtype->CheckBuf = MTestTypeContigCheckbuf;
break;
case 6:
/* Indexed send using 2 large blocks and contig receive */
sendtype->blksize = sizeof(int);
sendtype->nelm = 2;
sendtype->basesize = sizeof(int);
sendtype->displs = (int *)malloc( sendtype->nelm * sizeof(int) );
sendtype->index = (int *)malloc( sendtype->nelm * sizeof(int) );
if (!sendtype->displs || !sendtype->index) {
MTestError( "Out of memory in type init\n" );
}
/* index -> block size */
sendtype->index[0] = (recvtype->count + 1) / 2;
sendtype->displs[0] = 0;
sendtype->index[1] = recvtype->count - sendtype->index[0];
sendtype->displs[1] = sendtype->index[0] + 1;
/* There is a deliberate gap here */
merr = MPI_Type_indexed( sendtype->nelm,
sendtype->index, sendtype->displs,
MPI_INT, &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_commit( &sendtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( sendtype->datatype,
(char*)"int-indexed(2 blocks)" );
if (merr) MTestPrintError( merr );
sendtype->count = 1;
sendtype->InitBuf = MTestTypeIndexedInit;
sendtype->FreeBuf = MTestTypeIndexedFree;
sendtype->CheckBuf = 0;
recvtype->datatype = MPI_INT;
recvtype->isBasic = 1;
recvtype->count = sendtype->index[0] + sendtype->index[1];
recvtype->InitBuf = MTestTypeContigInitRecv;
recvtype->FreeBuf = MTestTypeContigFree;
recvtype->CheckBuf = MTestTypeContigCheckbuf;
break;
case 7:
/* Indexed receive using many small blocks and contig send */
recvtype->blksize = sizeof(int);
recvtype->nelm = recvtype->count;
recvtype->basesize = sizeof(int);
recvtype->displs = (int *)malloc( recvtype->nelm * sizeof(int) );
recvtype->index = (int *)malloc( recvtype->nelm * sizeof(int) );
if (!recvtype->displs || !recvtype->index) {
MTestError( "Out of memory in type recv init\n" );
}
/* Make the sizes larger (4 ints) to help push the total
size to over 256k in some cases, as the MPICH code as of
10/1/06 used large internal buffers for packing non-contiguous
messages */
/* Note that there are gaps in the indexed type */
for (i=0; i<recvtype->nelm; i++) {
recvtype->index[i] = 4;
recvtype->displs[i] = 5*i;
}
merr = MPI_Type_indexed( recvtype->nelm,
recvtype->index, recvtype->displs,
MPI_INT, &recvtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_commit( &recvtype->datatype );
if (merr) MTestPrintError( merr );
merr = MPI_Type_set_name( recvtype->datatype,
(char*)"recv-int-indexed(4-int)" );
if (merr) MTestPrintError( merr );
recvtype->count = 1;
recvtype->InitBuf = MTestTypeIndexedInitRecv;
recvtype->FreeBuf = MTestTypeIndexedFree;
recvtype->CheckBuf = MTestTypeIndexedCheckbuf;
sendtype->datatype = MPI_INT;
sendtype->isBasic = 1;
sendtype->count = count * 4;
sendtype->InitBuf = MTestTypeContigInit;
sendtype->FreeBuf = MTestTypeContigFree;
sendtype->CheckBuf = 0;
break;
/* Less commonly used but still simple types */
case 8:
sendtype->datatype = MPI_SHORT;
sendtype->isBasic = 1;
recvtype->datatype = MPI_SHORT;
recvtype->isBasic = 1;
break;
case 9:
sendtype->datatype = MPI_LONG;
sendtype->isBasic = 1;
recvtype->datatype = MPI_LONG;
recvtype->isBasic = 1;
break;
case 10:
sendtype->datatype = MPI_CHAR;
sendtype->isBasic = 1;
recvtype->datatype = MPI_CHAR;
recvtype->isBasic = 1;
break;
case 11:
sendtype->datatype = MPI_UINT64_T;
sendtype->isBasic = 1;
recvtype->datatype = MPI_UINT64_T;
recvtype->isBasic = 1;
break;
case 12:
sendtype->datatype = MPI_FLOAT;
sendtype->isBasic = 1;
recvtype->datatype = MPI_FLOAT;
recvtype->isBasic = 1;
break;
#ifndef USE_STRICT_MPI
/* MPI_BYTE may only be used with MPI_BYTE in strict MPI */
case 13:
sendtype->datatype = MPI_INT;
sendtype->isBasic = 1;
recvtype->datatype = MPI_BYTE;
recvtype->isBasic = 1;
recvtype->count *= sizeof(int);
break;
#endif
default:
datatype_index = -1;
}
if (!sendtype->InitBuf) {
sendtype->InitBuf = MTestTypeContigInit;
recvtype->InitBuf = MTestTypeContigInitRecv;
sendtype->FreeBuf = MTestTypeContigFree;
recvtype->FreeBuf = MTestTypeContigFree;
sendtype->CheckBuf = MTestTypeContigCheckbuf;
recvtype->CheckBuf = MTestTypeContigCheckbuf;
}
datatype_index++;
if (dbgflag && datatype_index > 0) {
int typesize;
fprintf( stderr, "%d: sendtype is %s\n", wrank, MTestGetDatatypeName( sendtype ) );
merr = MPI_Type_size( sendtype->datatype, &typesize );
if (merr) MTestPrintError( merr );
fprintf( stderr, "%d: sendtype size = %d\n", wrank, typesize );
fprintf( stderr, "%d: recvtype is %s\n", wrank, MTestGetDatatypeName( recvtype ) );
merr = MPI_Type_size( recvtype->datatype, &typesize );
if (merr) MTestPrintError( merr );
fprintf( stderr, "%d: recvtype size = %d\n", wrank, typesize );
fflush( stderr );
}
else if (verbose && datatype_index > 0) {
printf( "Get new datatypes: send = %s, recv = %s\n",
MTestGetDatatypeName( sendtype ),
MTestGetDatatypeName( recvtype ) );
fflush( stdout );
}
return datatype_index;
}
int main( int argc, char *argv[] )
{
int errs = 0, err;
int rank, size, source, dest;
int minsize = 2, count, nmsg, maxmsg;
MPI_Comm comm;
MTestDatatype sendtype, recvtype;
MTest_Init( &argc, &argv );
/* The following illustrates the use of the routines to
run through a selection of communicators and datatypes.
Use subsets of these for tests that do not involve combinations
of communicators, datatypes, and counts of datatypes */
while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
if (comm == MPI_COMM_NULL) continue;
/* Determine the sender and receiver */
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
source = 0;
dest = size - 1;
/* To improve reporting of problems about operations, we
change the error handler to errors return */
MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN );
for (count = 1; count < MAX_COUNT; count = count * 2) {
while (MTestGetDatatypes( &sendtype, &recvtype, count )) {
int nbytes;
MPI_Type_size( sendtype.datatype, &nbytes );
/* We may want to limit the total message size sent */
if (nbytes > MAX_MSG_SIZE) {
/* We do not need to free, as we haven't
initialized any of the buffers (?) */
continue;
}
maxmsg = MAX_COUNT - count;
MTestPrintfMsg( 1, "Sending count = %d of sendtype %s of total size %d bytes\n",
count, MTestGetDatatypeName( &sendtype ),
nbytes*count );
/* Make sure that everyone has a recv buffer */
recvtype.InitBuf( &recvtype );
if (rank == source) {
sendtype.InitBuf( &sendtype );
for (nmsg=1; nmsg<maxmsg; nmsg++) {
err = MPI_Send( sendtype.buf, sendtype.count,
sendtype.datatype, dest, 0, comm);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError( err );
}
}
}
}
else if (rank == dest) {
for (nmsg=1; nmsg<maxmsg; nmsg++) {
err = MPI_Recv( recvtype.buf, recvtype.count,
recvtype.datatype, source, 0,
comm, MPI_STATUS_IGNORE);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError( err );
}
}
err = MTestCheckRecv( 0, &recvtype );
if (err) {
if (errs < 10) {
printf( "Data in target buffer did not match for destination datatype %s and source datatype %s, count = %d, message iteration %d of %d\n",
MTestGetDatatypeName( &recvtype ),
MTestGetDatatypeName( &sendtype ),
count, nmsg, maxmsg );
recvtype.printErrors = 1;
(void)MTestCheckRecv( 0, &recvtype );
}
errs += err;
}
}
}
MTestFreeDatatype( &recvtype );
MTestFreeDatatype( &sendtype );
}
}
MTestFreeComm( &comm );
}
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
int main( int argc, char *argv[] )
{
int errs = 0, err;
int rank, size, source, dest;
int minsize = 2, count;
MPI_Comm comm;
MPI_Win win;
MPI_Aint extent;
MTestDatatype sendtype, recvtype;
MTest_Init( &argc, &argv );
/* The following illustrates the use of the routines to
run through a selection of communicators and datatypes.
Use subsets of these for tests that do not involve combinations
of communicators, datatypes, and counts of datatypes */
while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
if (comm == MPI_COMM_NULL) continue;
/* Determine the sender and receiver */
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
source = 0;
dest = size - 1;
for (count = 1; count < 65000; count = count * 2) {
while (MTestGetDatatypes( &sendtype, &recvtype, count )) {
MTestPrintfMsg( 1,
"Putting count = %d of sendtype %s receive type %s\n",
count, MTestGetDatatypeName( &sendtype ),
MTestGetDatatypeName( &recvtype ) );
/* Make sure that everyone has a recv buffer */
recvtype.InitBuf( &recvtype );
MPI_Type_extent( recvtype.datatype, &extent );
MPI_Win_create( recvtype.buf, recvtype.count * extent,
extent, MPI_INFO_NULL, comm, &win );
MPI_Win_fence( 0, win );
if (rank == source) {
/* To improve reporting of problems about operations, we
change the error handler to errors return */
MPI_Win_set_errhandler( win, MPI_ERRORS_RETURN );
sendtype.InitBuf( &sendtype );
err = MPI_Put( sendtype.buf, sendtype.count,
sendtype.datatype, dest, 0,
recvtype.count, recvtype.datatype, win );
if (err) {
errs++;
if (errs < 10) {
MTestPrintError( err );
}
}
err = MPI_Win_fence( 0, win );
if (err) {
errs++;
if (errs < 10) {
MTestPrintError( err );
}
}
}
else if (rank == dest) {
MPI_Win_fence( 0, win );
/* This should have the same effect, in terms of
transfering data, as a send/recv pair */
err = MTestCheckRecv( 0, &recvtype );
if (err) {
if (errs < 10) {
printf( "Data in target buffer did not match for destination datatype %s (put with source datatype %s)\n",
MTestGetDatatypeName( &recvtype ),
MTestGetDatatypeName( &sendtype ) );
/* Redo the test, with the errors printed */
recvtype.printErrors = 1;
(void)MTestCheckRecv( 0, &recvtype );
}
errs += err;
}
}
else {
MPI_Win_fence( 0, win );
}
MPI_Win_free( &win );
MTestFreeDatatype( &sendtype );
MTestFreeDatatype( &recvtype );
}
}
MTestFreeComm(&comm);
}
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
int main(int argc, char *argv[])
{
int errs = 0, err;
int rank, size, source, dest;
int minsize = 2, count;
MPI_Comm comm;
MPI_Win win;
MPI_Aint extent;
MTestDatatype sendtype, recvtype;
MTest_Init(&argc, &argv);
/* The following illustrates the use of the routines to
* run through a selection of communicators and datatypes.
* Use subsets of these for tests that do not involve combinations
* of communicators, datatypes, and counts of datatypes */
while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
if (comm == MPI_COMM_NULL)
continue;
/* Determine the sender and receiver */
MPI_Comm_rank(comm, &rank);
MPI_Comm_size(comm, &size);
source = 0;
dest = size - 1;
MTEST_DATATYPE_FOR_EACH_COUNT(count) {
while (MTestGetDatatypes(&sendtype, &recvtype, count)) {
/* Make sure that everyone has a recv buffer */
recvtype.InitBuf(&recvtype);
MPI_Type_extent(recvtype.datatype, &extent);
MPI_Win_create(recvtype.buf, recvtype.count * extent,
(int) extent, MPI_INFO_NULL, comm, &win);
MPI_Win_fence(0, win);
if (rank == source) {
sendtype.InitBuf(&sendtype);
/* To improve reporting of problems about operations, we
* change the error handler to errors return */
MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
/* MPI_REPLACE on accumulate is almost the same
* as MPI_Put; the only difference is in the
* handling of overlapping accumulate operations,
* which are not tested here */
err = MPI_Accumulate(sendtype.buf, sendtype.count,
sendtype.datatype, dest, 0,
recvtype.count, recvtype.datatype, MPI_REPLACE, win);
if (err) {
errs++;
if (errs < 10) {
printf("Accumulate types: send %s, recv %s\n",
MTestGetDatatypeName(&sendtype),
MTestGetDatatypeName(&recvtype));
MTestPrintError(err);
}
}
err = MPI_Win_fence(0, win);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError(err);
}
}
}
else if (rank == dest) {
MPI_Win_fence(0, win);
/* This should have the same effect, in terms of
* transfering data, as a send/recv pair */
err = MTestCheckRecv(0, &recvtype);
if (err) {
errs += err;
}
}
else {
MPI_Win_fence(0, win);
}
MPI_Win_free(&win);
MTestFreeDatatype(&sendtype);
MTestFreeDatatype(&recvtype);
}
}
MTestFreeComm(&comm);
}
MTest_Finalize(errs);
MPI_Finalize();
return 0;
}
int main(int argc, char *argv[])
{
int errs = 0, err;
int rank, size;
int count;
MPI_Comm comm;
MPI_Request req;
MTestDatatype sendtype, recvtype;
MTest_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_rank(comm, &rank);
MPI_Comm_size(comm, &size);
/* To improve reporting of problems about operations, we
* change the error handler to errors return */
MPI_Comm_set_errhandler(comm, MPI_ERRORS_RETURN);
MTEST_DATATYPE_FOR_EACH_COUNT(count) {
while (MTestGetDatatypes(&sendtype, &recvtype, count)) {
sendtype.InitBuf(&sendtype);
recvtype.InitBuf(&recvtype);
err = MPI_Irecv(recvtype.buf, recvtype.count, recvtype.datatype, rank, 0, comm, &req);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError(err);
}
}
err = MPI_Send(sendtype.buf, sendtype.count, sendtype.datatype, rank, 0, comm);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError(err);
}
}
err = MPI_Wait(&req, MPI_STATUS_IGNORE);
err = MTestCheckRecv(0, &recvtype);
if (err) {
if (errs < 10) {
printf
("Data in target buffer did not match for destination datatype %s and source datatype %s, count = %d\n",
MTestGetDatatypeName(&recvtype), MTestGetDatatypeName(&sendtype), count);
recvtype.printErrors = 1;
(void) MTestCheckRecv(0, &recvtype);
}
errs += err;
}
err = MPI_Irecv(recvtype.buf, recvtype.count, recvtype.datatype, rank, 0, comm, &req);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError(err);
}
}
err = MPI_Ssend(sendtype.buf, sendtype.count, sendtype.datatype, rank, 0, comm);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError(err);
}
}
err = MPI_Wait(&req, MPI_STATUS_IGNORE);
err = MTestCheckRecv(0, &recvtype);
if (err) {
if (errs < 10) {
printf
("Data in target buffer did not match for destination datatype %s and source datatype %s, count = %d\n",
MTestGetDatatypeName(&recvtype), MTestGetDatatypeName(&sendtype), count);
recvtype.printErrors = 1;
(void) MTestCheckRecv(0, &recvtype);
}
errs += err;
}
err = MPI_Irecv(recvtype.buf, recvtype.count, recvtype.datatype, rank, 0, comm, &req);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError(err);
}
}
err = MPI_Rsend(sendtype.buf, sendtype.count, sendtype.datatype, rank, 0, comm);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError(err);
}
}
err = MPI_Wait(&req, MPI_STATUS_IGNORE);
err = MTestCheckRecv(0, &recvtype);
if (err) {
if (errs < 10) {
printf
("Data in target buffer did not match for destination datatype %s and source datatype %s, count = %d\n",
MTestGetDatatypeName(&recvtype), MTestGetDatatypeName(&sendtype), count);
recvtype.printErrors = 1;
(void) MTestCheckRecv(0, &recvtype);
}
errs += err;
}
MTestFreeDatatype(&sendtype);
MTestFreeDatatype(&recvtype);
}
}
MTest_Finalize(errs);
MPI_Finalize();
return 0;
}
static inline int test(MPI_Comm comm, int rank, int source, int dest,
MTestDatatype * sendtype, MTestDatatype * recvtype)
{
int errs = 0, err;
MPI_Aint extent, lb;
MPI_Win win;
MTestPrintfMsg(1,
"Putting count = %ld of sendtype %s - count = %ld receive type %s\n",
sendtype->count, MTestGetDatatypeName(sendtype), recvtype->count,
MTestGetDatatypeName(recvtype));
/* Make sure that everyone has a recv buffer */
recvtype->InitBuf(recvtype);
MPI_Type_extent(recvtype->datatype, &extent);
MPI_Type_lb(recvtype->datatype, &lb);
MPI_Win_create(recvtype->buf, recvtype->count * extent + lb, extent, MPI_INFO_NULL, comm, &win);
MPI_Win_fence(0, win);
if (rank == source) {
/* To improve reporting of problems about operations, we
* change the error handler to errors return */
MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
sendtype->InitBuf(sendtype);
err = MPI_Put(sendtype->buf, sendtype->count,
sendtype->datatype, dest, 0, recvtype->count, recvtype->datatype, win);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError(err);
}
}
err = MPI_Win_fence(0, win);
if (err) {
errs++;
if (errs < 10) {
MTestPrintError(err);
}
}
}
else if (rank == dest) {
MPI_Win_fence(0, win);
/* This should have the same effect, in terms of
* transfering data, as a send/recv pair */
err = MTestCheckRecv(0, recvtype);
if (err) {
if (errs < 10) {
printf
("Data in target buffer did not match for destination datatype %s (put with source datatype %s)\n",
MTestGetDatatypeName(recvtype), MTestGetDatatypeName(sendtype));
/* Redo the test, with the errors printed */
recvtype->printErrors = 1;
(void) MTestCheckRecv(0, recvtype);
}
errs += err;
}
}
else {
MPI_Win_fence(0, win);
}
MPI_Win_free(&win);
return errs;
}
