int main(int argc, char *argv[])
{
- MPI_Request request;
int size, rank;
+#if defined(TEST_NBC_ROUTINES)
+ MPI_Request request;
int one = 1, two = 2, isum, sum;
+#endif
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int main(int argc, char *argv[])
{
+#if defined(TEST_NBC_ROUTINES)
MPI_Request barrier;
- int rank,i,done;
+ int i,done;
+#endif
+ int rank;
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD,&rank);
- #if defined(TEST_NBC_ROUTINES)
+#if defined(TEST_NBC_ROUTINES)
MPI_Ibarrier(MPI_COMM_WORLD,&barrier);
for (i=0,done=0; !done; i++) {
usleep(1000);
/*printf("[%d] MPI_Test: %d\n",rank,i);*/
MPI_Test(&barrier,&done,MPI_STATUS_IGNORE);
}
- #endif
+#endif
if (rank == 0)
printf(" No Errors\n");
int errs = 0, err;
int leftGroup;
MPI_Comm comm;
- MPI_Datatype datatype;
+ /* MPI_Datatype datatype; */
MTest_Init( &argc, &argv );
- datatype = MPI_INT;
+ /* datatype = MPI_INT; */
/* Get an intercommunicator */
while (MTestGetIntercomm( &comm, &leftGroup, 4 )) {
if (comm == MPI_COMM_NULL)
/* USE_STRICT_MPI may be defined in mpitestconf.h */
#include "mpitestconf.h"
+#if !defined(USE_STRICT_MPI) && defined(MPICH)
+#define TEST_NBC_ROUTINES 1
+#endif
+
#define NUM_INTS (2)
#define my_assert(cond_) \
int main(int argc, char **argv)
{
int errs = 0;
- int i;
int rank, size;
int *sbuf = NULL;
int *rbuf = NULL;
int *rcounts = NULL;
int *sdispls = NULL;
int *rdispls = NULL;
- int *types = NULL;
MPI_Comm comm;
+#if defined(TEST_NBC_ROUTINES)
+ int i;
+ int *types = NULL;
MPI_Request req;
+#endif
/* intentionally not using MTest_Init/MTest_Finalize in order to make it
* easy to take this test and use it as an NBC sanity test outside of the
MPI_Comm_size(comm, &size);
MPI_Comm_rank(comm, &rank);
-#if !defined(USE_STRICT_MPI) && defined(MPICH)
+#if defined(TEST_NBC_ROUTINES)
/* enough space for every process to contribute at least NUM_INTS ints to any
* collective operation */
sbuf = malloc(NUM_INTS*size*sizeof(int));
int main(int argc, char **argv)
{
- int i, j;
int rank, size;
int *buf = NULL;
int *recvbuf = NULL;
int *rdispls = NULL;
int *sendtypes = NULL;
int *recvtypes = NULL;
+#if defined(TEST_NBC_ROUTINES)
+ int i, j;
char *buf_alias = NULL;
MPI_Request req;
+#endif
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
int main(int argc, char **argv)
{
- int i, num_posted, num_completed;
int wrank, wsize;
+#if defined(TEST_NBC_ROUTINES)
+ int i, num_posted, num_completed;
unsigned int seed = 0x10bc;
unsigned int post_seq, complete_seq;
-#if defined(TEST_NBC_ROUTINES)
struct laundry larr[WINDOW];
-#endif
MPI_Request reqs[WINDOW];
int outcount;
int indices[WINDOW];
MPI_Comm comms[NUM_COMMS];
MPI_Comm comm;
+#endif
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &wrank);
{
MPI_Op c_uop = MPI_OP_NULL;
MPI_Op nc_uop = MPI_OP_NULL;
+#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
int is_commutative = 0;
+#endif
MTest_Init(&argc, &argv);
int main(int argc, char **argv)
{
int err = 0;
- int toterr, size, rank, i, sumval;
+ int toterr, size, rank;
+#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
+ int i, sumval;
int *sendbuf;
int *recvbuf;
+#endif
MPI_Comm comm;
MPI_Init(&argc, &argv);
int main( int argc, char **argv )
{
+#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
int *sendbuf;
int block_size;
int *recvbuf;
- int size, rank, i;
- MPI_Comm comm;
+ int i;
MPI_Op left_op, right_op, nc_sum_op;
+#endif
+ int size, rank;
+ MPI_Comm comm;
MTest_Init( &argc, &argv );
comm = MPI_COMM_WORLD;
int main( int argc, char *argv[] )
{
int errs = 0;
+#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
int i;
int *inbuf = NULL;
int *inoutbuf = NULL;
int count = -1;
MPI_Op uop = MPI_OP_NULL;
+#endif
MTest_Init(&argc, &argv);
#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
int AllocateGrid( int nx, int ny, int **srcArray, int **destArray )
{
int *src, *dest;
- int i, j;
+ int i;
src = (int *)malloc( nx*ny*sizeof(int) );
dest = (int *)malloc( nx*ny*sizeof(int) );
if (!src || !dest) {
#define TEST_HINDEXED_BLOCK 1
#endif
+#if defined(TEST_HINDEXED_BLOCK)
static int verbose = 0;
+#endif
/* tests */
int hindexed_block_contig_test(void);
int main(int argc, char **argv)
{
- int err, errs = 0;
+#if defined(TEST_HINDEXED_BLOCK)
+ int err;
+#endif
+ int errs = 0;
int rank;
MPI_Init(&argc, &argv); /* MPI-1.2 doesn't allow for MPI_Init(0,0) */
} \
} while (0)
+/* Abort when using unimplemented functions. Currently, it should not happen,
+ * since sizeof(MPI_Count) == sizeof(int), but it avoids compile errors about
+ * undefined functions. */
+#define err_unimpl(func) do { \
+ fprintf(stderr, "ERROR: %s is not implemented\n", #func); \
+ abort(); \
+ } while (0)
+
+#define MPI_Type_size_x(a,b) err_unimpl(MPI_Type_size_x)
+#define MPI_Type_get_extent_x(a,b,c) err_unimpl(MPI_Type_get_extent_x)
+#define MPI_Type_get_true_extent_x(a,b,c) err_unimpl(MPI_Type_get_true_extent_x)
+#define MPI_Get_elements_x(a,b,c) err_unimpl(MPI_Get_elements_x)
+#define MPI_Status_set_elements_x(a,b,c) err_unimpl(MPI_Status_set_elements_x)
+
int main(int argc, char *argv[])
{
int errs = 0;
{
int nints, nadds, ntypes, combiner;
- int err, errs = 0;
+ int /* err, */ errs = 0;
- err = MPI_Type_get_envelope(MPI_FLOAT,
+ /* err = */ MPI_Type_get_envelope(MPI_FLOAT,
&nints,
&nadds,
&ntypes,
int i;
MPI_Aint sizeofint, sizeoftype, position;
- int err, errs = 0;
+ int /* err, */ errs = 0;
MPI_Pack_external_size((char*)"external32", 1, MPI_INT, &sizeofint);
}
/* set up type */
- err = MPI_Type_vector(10,
+ /* err = */ MPI_Type_vector(10,
2,
2,
MPI_INT,
buf = (char *) malloc(sizeoftype);
position = 0;
- err = MPI_Pack_external((char*)"external32",
+ /* err = */ MPI_Pack_external((char*)"external32",
array,
1,
parent_type,
memset(array, 0, 20 * sizeof(int));
position = 0;
- err = MPI_Unpack_external((char*)"external32",
+ /* err = */ MPI_Unpack_external((char*)"external32",
buf,
sizeoftype,
&position,
MPI_Aint indices[10];
MPI_Datatype types[10];
- int err, errs = 0;
+ int /* err, */ errs = 0;
MPI_Pack_external_size((char*)"external32", 1, MPI_INT, &sizeofint);
}
/* set up type */
- err = MPI_Type_struct(10,
+ /* err = */ MPI_Type_struct(10,
blocks,
indices,
types,
buf = (char *) malloc(sizeoftype);
position = 0;
- err = MPI_Pack_external((char*)"external32",
+ /* err = */ MPI_Pack_external((char*)"external32",
array,
1,
parent_type,
memset(array, 0, 20 * sizeof(int));
position = 0;
- err = MPI_Unpack_external((char*)"external32",
+ /* err = */ MPI_Unpack_external((char*)"external32",
buf,
sizeoftype,
&position,
{
int nints, nadds, ntypes, combiner;
- int err, errs = 0;
+ int /* err, */ errs = 0;
- err = MPI_Type_get_envelope(MPI_FLOAT,
+ /* err = */ MPI_Type_get_envelope(MPI_FLOAT,
&nints,
&nadds,
&ntypes,
char *buf;
int i, sizeofint, sizeoftype, position;
- int err, errs = 0;
+ int /* err, */ errs = 0;
MPI_Type_size(MPI_INT, &sizeofint);
}
/* set up type */
- err = MPI_Type_vector(10,
+ /* err = */ MPI_Type_vector(10,
2,
2,
MPI_INT,
buf = (char *) malloc(sizeoftype);
position = 0;
- err = MPI_Pack(array,
+ /* err = */ MPI_Pack(array,
1,
parent_type,
buf,
memset(array, 0, 20 * sizeof(int));
position = 0;
- err = MPI_Unpack(buf,
+ /* err = */ MPI_Unpack(buf,
sizeoftype,
&position,
array,
MPI_Datatype row, xpose;
MPI_Aint sizeofint;
- int err, errs = 0;
+ int /* err, */ errs = 0;
int bufsize, position = 0;
void *buffer;
change the error handler to errors return */
MPI_Comm_set_errhandler( MPI_COMM_WORLD, MPI_ERRORS_RETURN );
- err = MPI_Pack(a,
+ /* err = */ MPI_Pack(a,
1,
xpose,
buffer,
/* Unpack the buffer into b. */
position = 0;
- err = MPI_Unpack(buffer,
+ /* err = */ MPI_Unpack(buffer,
bufsize,
&position,
b,
int main(int argc, char *argv[])
{
- int ierr,i,size,rank;
+ int /* ierr, */ i,size,rank;
int cnt = 270000000;
MPI_Status status;
long long *cols;
return 0;
}
- ierr = MPI_Comm_size(MPI_COMM_WORLD,&size);
- ierr = MPI_Comm_rank(MPI_COMM_WORLD,&rank);
+ /* ierr = */ MPI_Comm_size(MPI_COMM_WORLD,&size);
+ /* ierr = */ MPI_Comm_rank(MPI_COMM_WORLD,&rank);
if (size != 3) {
fprintf(stderr,"[%d] usage: mpiexec -n 3 %s\n",rank,argv[0]);
MPI_Abort(MPI_COMM_WORLD,1);
if (rank == 0) {
for (i=0; i<cnt; i++) cols[i] = i;
/* printf("[%d] sending...\n",rank);*/
- ierr = MPI_Send(cols,cnt,MPI_LONG_LONG_INT,1,0,MPI_COMM_WORLD);
- ierr = MPI_Send(cols,cnt,MPI_LONG_LONG_INT,2,0,MPI_COMM_WORLD);
+ /* ierr = */ MPI_Send(cols,cnt,MPI_LONG_LONG_INT,1,0,MPI_COMM_WORLD);
+ /* ierr = */ MPI_Send(cols,cnt,MPI_LONG_LONG_INT,2,0,MPI_COMM_WORLD);
} else {
/* printf("[%d] receiving...\n",rank); */
for (i=0; i<cnt; i++) cols[i] = -1;
- ierr = MPI_Recv(cols,cnt,MPI_LONG_LONG_INT,0,0,MPI_COMM_WORLD,&status);
+ /* ierr = */ MPI_Recv(cols,cnt,MPI_LONG_LONG_INT,0,0,MPI_COMM_WORLD,&status);
/* ierr = MPI_Get_count(&status,MPI_LONG_LONG_INT,&cnt);
Get_count still fails because status.count is not 64 bit */
for (i=0; i<cnt; i++) {
int main(int argc, char **argv)
{
int errs = 0;
- int found, completed;
int rank, size;
+#ifdef TEST_MPROBE_ROUTINES
+ int found, completed;
int sendbuf[8], recvbuf[8];
int count;
-#ifdef TEST_MPROBE_ROUTINES
MPI_Message msg;
-#endif
MPI_Request rreq;
MPI_Status s1, s2;
+#endif
MPI_Init(&argc, &argv);
int main( int argc, char *argv[] )
{
int errs = 0;
- int rank, size, source, dest;
+ int rank, size, /* source, */ dest;
MPI_Comm comm;
MPI_Status status;
MPI_Request req;
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
- source = 0;
+ /* source = 0; */
dest = size - 1;
for (cs=0; cs<4; cs++) {
int main( int argc, char *argv[] )
{
int errs = 0;
- int rank, size, source, dest;
+ int rank, size, /* source, */ dest;
MPI_Comm comm;
MPI_Status status;
MPI_Request req;
MPI_Comm_rank( comm, &rank );
MPI_Comm_size( comm, &size );
- source = 0;
+ /* source = 0; */
dest = size - 1;
MTestPrintfMsg( 1, "Starting scancel test\n" );