/* Compare a matrix with the known result */
static int checkResult(int nmat, int mat[], const char *msg)
{
int n, k, errs = 0, wrank;
static int solution[9] = { 0, 1, 0,
0, 0, 1,
1, 0, 0
};
MPI_Comm_rank(MPI_COMM_WORLD, &wrank);
for (n = 0; n < nmat; n++) {
for (k = 0; k < 9; k++) {
if (mat[k] != solution[k]) {
errs++;
if (errs == 1) {
printf("Errors for communicators %s\n", MTestGetIntracommName());
fflush(stdout);
}
if (errs < 10) {
printf("[%d]matrix #%d(%s): Expected mat[%d,%d] = %d, got %d\n",
wrank, n, msg, k / 3, k % 3, solution[k], mat[k]);
fflush(stdout);
}
}
}
/* Advance to the next matrix */
mat += 9;
}
return errs;
}
/* Compare a matrix with the identity matrix */
static int isIdentity( MPI_Comm comm, int mat[] )
{
int i, j, size, rank, lerrs = 0;
int offset;
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
for (i=0; i<size; i++) {
for (j=0; j<size; j++) {
if (i == j) {
offset = j+i*size;
assert(offset < max_offset);
if (mat[offset] != 1) {
lerrs++;
if (errs + lerrs< 10) {
printf( "[%d] mat[%d,%d] = %d, expected 1 for comm %s\n",
rank, i,j, mat[offset], MTestGetIntracommName() );
}
}
}
else {
offset = j+i*size;
assert(offset < max_offset);
if (mat[offset] != 0) {
lerrs++;
if (errs + lerrs< 10) {
printf( "[%d] mat[%d,%d] = %d, expected 0 for comm %s\n",
rank, i,j, mat[offset], MTestGetIntracommName() );
}
}
}
}
}
return lerrs;
}
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, 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;
}
int main(int argc, char *argv[])
{
int errs = 0;
int attrval;
int i, key[32], keyval, saveKeyval;
MPI_Comm comm, dupcomm;
MTest_Init(&argc, &argv);
while (MTestGetIntracomm(&comm, 1)) {
if (comm == MPI_COMM_NULL)
continue;
MPI_Comm_create_keyval(copy_fn, delete_fn, &keyval, (void *) 0);
saveKeyval = keyval; /* in case we need to free explicitly */
attrval = 1;
MPI_Comm_set_attr(comm, keyval, (void *) &attrval);
/* See MPI-1, 5.7.1. Freeing the keyval does not remove it if it
* is in use in an attribute */
MPI_Comm_free_keyval(&keyval);
/* We create some dummy keyvals here in case the same keyval
* is reused */
for (i = 0; i < 32; i++) {
MPI_Comm_create_keyval(MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key[i], (void *) 0);
}
MPI_Comm_dup(comm, &dupcomm);
/* Check that the attribute was copied */
if (attrval != 2) {
errs++;
printf("Attribute not incremented when comm dup'ed (%s)\n", MTestGetIntracommName());
}
MPI_Comm_free(&dupcomm);
if (attrval != 1) {
errs++;
printf("Attribute not decremented when dupcomm %s freed\n", MTestGetIntracommName());
}
/* Check that the attribute was freed in the dupcomm */
if (comm != MPI_COMM_WORLD && comm != MPI_COMM_SELF) {
MPI_Comm_free(&comm);
/* Check that the original attribute was freed */
if (attrval != 0) {
errs++;
printf("Attribute not decremented when comm %s freed\n", MTestGetIntracommName());
}
}
else {
/* Explicitly delete the attributes from world and self */
MPI_Comm_delete_attr(comm, saveKeyval);
}
/* Free those other keyvals */
for (i = 0; i < 32; i++) {
MPI_Comm_free_keyval(&key[i]);
}
}
MTest_Finalize(errs);
MPI_Finalize();
/* The attributes on comm self and world were deleted by finalize
* (see separate test) */
return 0;
}
int main( int argc, char *argv[] )
{
int errs = 0;
int rank, size;
int minsize = 2, count;
MPI_Comm comm;
int *sendbuf, *recvbuf, *p;
int sendcount, recvcount;
int i, j;
MPI_Datatype 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 );
/* printf( "Size of comm = %d\n", size ); */
for (count = 1; count < 65000; count = count * 2) {
/* Create a send buf and a receive buf suitable for testing
all to all. */
sendcount = count;
recvcount = count;
sendbuf = (int *)malloc( count * size * sizeof(int) );
recvbuf = (int *)malloc( count * size * sizeof(int) );
sendtype = MPI_INT;
recvtype = MPI_INT;
if (!sendbuf || !recvbuf) {
errs++;
fprintf( stderr, "Failed to allocate sendbuf and/or recvbuf\n" );
MPI_Abort( MPI_COMM_WORLD, 1 );
}
for (i=0; i<count*size; i++)
recvbuf[i] = -1;
p = sendbuf;
for (j=0; j<size; j++) {
for (i=0; i<count; i++) {
*p++ = j * size + rank + i;
}
}
MPI_Alltoall( sendbuf, sendcount, sendtype,
recvbuf, recvcount, recvtype, comm );
p = recvbuf;
for (j=0; j<size; j++) {
for (i=0; i<count; i++) {
if (*p != rank * size + j + i) {
errs++;
if (errs < 10) {
fprintf( stderr, "Error with communicator %s and size=%d count=%d\n",
MTestGetIntracommName(), size, count );
fprintf( stderr, "recvbuf[%d,%d] = %d, should %d\n",
j,i, *p, rank * size + j + i );
}
}
p++;
}
}
#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
/* check MPI_IN_PLACE, added in MPI-2.2 */
p = recvbuf;
for (j=0; j<size; j++) {
for (i=0; i<count; i++) {
*p++ = j * size + rank + i;
}
}
MPI_Alltoall( MPI_IN_PLACE, 0/*ignored*/, MPI_INT/*ignored*/,
recvbuf, recvcount, recvtype, comm );
p = recvbuf;
for (j=0; j<size; j++) {
for (i=0; i<count; i++) {
if (*p != rank * size + j + i) {
errs++;
if (errs < 10) {
fprintf( stderr, "Error (MPI_IN_PLACE) with communicator %s and size=%d count=%d\n",
MTestGetIntracommName(), size, count );
fprintf(stderr, "recvbuf[%d,%d] = %d, should be %d\n",
j,i, *p, rank * size + j + i );
}
}
p++;
}
}
#endif
free( recvbuf );
free( sendbuf );
}
MTestFreeComm( &comm );
}
MTest_Finalize( errs );
MPI_Finalize();
return 0;
}
