Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Upgrade coll mpich testlist to new mpich
authordegomme <augustin.degomme@unibas.ch>
Sat, 11 Feb 2017 01:41:42 +0000 (02:41 +0100)
committerdegomme <augustin.degomme@unibas.ch>
Sun, 12 Feb 2017 01:08:28 +0000 (02:08 +0100)
94 files changed:
teshsuite/smpi/mpich3-test/coll/CMakeLists.txt
teshsuite/smpi/mpich3-test/coll/allgather2.c
teshsuite/smpi/mpich3-test/coll/allgather3.c
teshsuite/smpi/mpich3-test/coll/allgather_struct.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/coll/allgatherv2.c
teshsuite/smpi/mpich3-test/coll/allgatherv3.c
teshsuite/smpi/mpich3-test/coll/allred.c
teshsuite/smpi/mpich3-test/coll/allred2.c
teshsuite/smpi/mpich3-test/coll/allred3.c
teshsuite/smpi/mpich3-test/coll/allred4.c
teshsuite/smpi/mpich3-test/coll/allred5.c
teshsuite/smpi/mpich3-test/coll/allred6.c
teshsuite/smpi/mpich3-test/coll/allredmany.c
teshsuite/smpi/mpich3-test/coll/alltoall1.c
teshsuite/smpi/mpich3-test/coll/alltoallv.c
teshsuite/smpi/mpich3-test/coll/alltoallv0.c
teshsuite/smpi/mpich3-test/coll/alltoallw1.c
teshsuite/smpi/mpich3-test/coll/alltoallw2.c
teshsuite/smpi/mpich3-test/coll/alltoallw_zeros.c
teshsuite/smpi/mpich3-test/coll/bcast.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/coll/bcast2.c [deleted file]
teshsuite/smpi/mpich3-test/coll/bcast3.c [deleted file]
teshsuite/smpi/mpich3-test/coll/bcasttest.c
teshsuite/smpi/mpich3-test/coll/bcastzerotype.c
teshsuite/smpi/mpich3-test/coll/coll10.c
teshsuite/smpi/mpich3-test/coll/coll11.c
teshsuite/smpi/mpich3-test/coll/coll12.c
teshsuite/smpi/mpich3-test/coll/coll13.c
teshsuite/smpi/mpich3-test/coll/coll2.c
teshsuite/smpi/mpich3-test/coll/coll3.c
teshsuite/smpi/mpich3-test/coll/coll4.c
teshsuite/smpi/mpich3-test/coll/coll5.c
teshsuite/smpi/mpich3-test/coll/coll6.c
teshsuite/smpi/mpich3-test/coll/coll7.c
teshsuite/smpi/mpich3-test/coll/coll8.c
teshsuite/smpi/mpich3-test/coll/coll9.c
teshsuite/smpi/mpich3-test/coll/exscan.c
teshsuite/smpi/mpich3-test/coll/exscan2.c
teshsuite/smpi/mpich3-test/coll/gather.c
teshsuite/smpi/mpich3-test/coll/gather2.c
teshsuite/smpi/mpich3-test/coll/gather2_save.c [deleted file]
teshsuite/smpi/mpich3-test/coll/gather_big.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/coll/iallred.c
teshsuite/smpi/mpich3-test/coll/ibarrier.c
teshsuite/smpi/mpich3-test/coll/icallgather.c
teshsuite/smpi/mpich3-test/coll/icallgatherv.c
teshsuite/smpi/mpich3-test/coll/icallreduce.c
teshsuite/smpi/mpich3-test/coll/icalltoall.c
teshsuite/smpi/mpich3-test/coll/icalltoallv.c
teshsuite/smpi/mpich3-test/coll/icalltoallw.c
teshsuite/smpi/mpich3-test/coll/icbarrier.c
teshsuite/smpi/mpich3-test/coll/icbcast.c
teshsuite/smpi/mpich3-test/coll/icgather.c
teshsuite/smpi/mpich3-test/coll/icgatherv.c
teshsuite/smpi/mpich3-test/coll/icreduce.c
teshsuite/smpi/mpich3-test/coll/icscatter.c
teshsuite/smpi/mpich3-test/coll/icscatterv.c
teshsuite/smpi/mpich3-test/coll/longuser.c
teshsuite/smpi/mpich3-test/coll/nonblocking.c
teshsuite/smpi/mpich3-test/coll/nonblocking2.c
teshsuite/smpi/mpich3-test/coll/nonblocking3.c
teshsuite/smpi/mpich3-test/coll/nonblocking4.c [deleted file]
teshsuite/smpi/mpich3-test/coll/op_commutative.c
teshsuite/smpi/mpich3-test/coll/opband.c
teshsuite/smpi/mpich3-test/coll/opbor.c
teshsuite/smpi/mpich3-test/coll/opbxor.c
teshsuite/smpi/mpich3-test/coll/opland.c
teshsuite/smpi/mpich3-test/coll/oplor.c
teshsuite/smpi/mpich3-test/coll/oplxor.c
teshsuite/smpi/mpich3-test/coll/opmax.c
teshsuite/smpi/mpich3-test/coll/opmaxloc.c
teshsuite/smpi/mpich3-test/coll/opmin.c
teshsuite/smpi/mpich3-test/coll/opminloc.c
teshsuite/smpi/mpich3-test/coll/opprod.c
teshsuite/smpi/mpich3-test/coll/opsum.c
teshsuite/smpi/mpich3-test/coll/red3.c
teshsuite/smpi/mpich3-test/coll/red4.c
teshsuite/smpi/mpich3-test/coll/red_scat_block.c
teshsuite/smpi/mpich3-test/coll/red_scat_block2.c
teshsuite/smpi/mpich3-test/coll/redscat.c
teshsuite/smpi/mpich3-test/coll/redscat2.c
teshsuite/smpi/mpich3-test/coll/redscat3.c
teshsuite/smpi/mpich3-test/coll/redscatbkinter.c
teshsuite/smpi/mpich3-test/coll/redscatblk3.c
teshsuite/smpi/mpich3-test/coll/redscatinter.c
teshsuite/smpi/mpich3-test/coll/reduce.c
teshsuite/smpi/mpich3-test/coll/reduce_local.c
teshsuite/smpi/mpich3-test/coll/scantst.c
teshsuite/smpi/mpich3-test/coll/scatter2.c
teshsuite/smpi/mpich3-test/coll/scatter3.c
teshsuite/smpi/mpich3-test/coll/scattern.c
teshsuite/smpi/mpich3-test/coll/scatterv.c
teshsuite/smpi/mpich3-test/coll/testlist
teshsuite/smpi/mpich3-test/coll/uoplong.c

index 9f36155..6265ad1 100644 (file)
@@ -11,6 +11,7 @@ if(enable_smpi AND enable_smpi_MPICH3_testsuite)
 
   add_executable(allgather2 allgather2.c)
   add_executable(allgather3 allgather3.c)
+  add_executable(allgather_struct allgather_struct.c)
   add_executable(allgatherv2 allgatherv2.c)
   add_executable(allgatherv3 allgatherv3.c)
   if(HAVE_PRIVATIZATION)
@@ -31,8 +32,9 @@ if(enable_smpi AND enable_smpi_MPICH3_testsuite)
 #  add_executable(alltoallw1 alltoallw1.c)
 #  add_executable(alltoallw2 alltoallw2.c)
 #  add_executable(alltoallw_zeros alltoallw_zeros.c)
-  add_executable(bcast2 bcast2.c)
-  add_executable(bcast3 bcast3.c)
+  add_executable(bcast_full bcast.c)
+  add_executable(bcast_min_datatypes bcast.c)
+  add_executable(bcast_comm_world bcast.c)
   add_executable(bcasttest bcasttest.c)
   add_executable(bcastzerotype bcastzerotype.c)
   add_executable(coll10 coll10.c)
@@ -50,7 +52,6 @@ if(enable_smpi AND enable_smpi_MPICH3_testsuite)
   add_executable(exscan2 exscan2.c)
   add_executable(exscan exscan.c)
   add_executable(gather2 gather2.c)
-#  add_executable(gather2_save gather2_save.c)
   add_executable(gather gather.c)
 #  add_executable(iallred iallred.c)
 #  add_executable(ibarrier ibarrier.c)
@@ -109,6 +110,7 @@ if(enable_smpi AND enable_smpi_MPICH3_testsuite)
   target_link_libraries(allgatherv2  simgrid mtest_c)
   target_link_libraries(allgatherv3  simgrid mtest_c)
   target_link_libraries(allgatherv4  simgrid mtest_c)
+  target_link_libraries(allgather_struct  simgrid mtest_c)
   target_link_libraries(allred2  simgrid mtest_c)
   target_link_libraries(allred3  simgrid mtest_c)
   target_link_libraries(allred4  simgrid mtest_c)
@@ -122,8 +124,9 @@ if(enable_smpi AND enable_smpi_MPICH3_testsuite)
 #  target_link_libraries(alltoallw1  simgrid mtest_c)
 #  target_link_libraries(alltoallw2  simgrid mtest_c)
 #  target_link_libraries(alltoallw_zeros  simgrid mtest_c)
-  target_link_libraries(bcast2  simgrid mtest_c)
-  target_link_libraries(bcast3  simgrid mtest_c)
+  target_link_libraries(bcast_full  simgrid mtest_c)
+  target_link_libraries(bcast_min_datatypes  simgrid mtest_c)
+  target_link_libraries(bcast_comm_world  simgrid mtest_c)
   target_link_libraries(bcasttest  simgrid mtest_c)
   target_link_libraries(bcastzerotype  simgrid mtest_c)
   target_link_libraries(coll10  simgrid mtest_c)
@@ -141,7 +144,6 @@ if(enable_smpi AND enable_smpi_MPICH3_testsuite)
   target_link_libraries(exscan2  simgrid mtest_c)
   target_link_libraries(exscan  simgrid mtest_c)
   target_link_libraries(gather2  simgrid mtest_c)
-#  target_link_libraries(gather2_save  simgrid mtest_c)
   target_link_libraries(gather  simgrid mtest_c)
 #  target_link_libraries(iallred  simgrid mtest_c)
 #  target_link_libraries(ibarrier  simgrid mtest_c)
@@ -196,6 +198,8 @@ if(enable_smpi AND enable_smpi_MPICH3_testsuite)
 #  target_link_libraries(uoplong  simgrid mtest_c)
 
   set_target_properties(allred PROPERTIES COMPILE_FLAGS "-O0" LINK_FLAGS "-O0")
+  set_target_properties(bcast_min_datatypes PROPERTIES COMPILE_FLAGS "-DBCAST_MIN_DATATYPES_ONLY" LINK_FLAGS "-DBCAST_MIN_DATATYPES_ONLY")
+  set_target_properties(bcast_comm_world PROPERTIES COMPILE_FLAGS "-DBCAST_COMM_WORLD_ONLY" LINK_FLAGS "-DBCAST_COMM_WORLD_ONLY")
 
   if(HAVE_THREAD_CONTEXTS)
     ADD_TEST(test-smpi-mpich3-coll-thread      ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll ${PERL_EXECUTABLE} ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests ${TESH_OPTION} -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:thread -execarg=--cfg=smpi/privatize-global-variables:${HAVE_PRIVATIZATION})
@@ -243,8 +247,7 @@ set(examples_src  ${examples_src}
  ${CMAKE_CURRENT_SOURCE_DIR}/alltoallw1.c 
  ${CMAKE_CURRENT_SOURCE_DIR}/alltoallw2.c 
  ${CMAKE_CURRENT_SOURCE_DIR}/alltoallw_zeros.c 
- ${CMAKE_CURRENT_SOURCE_DIR}/bcast2.c 
- ${CMAKE_CURRENT_SOURCE_DIR}/bcast3.c 
+ ${CMAKE_CURRENT_SOURCE_DIR}/bcast.c 
  ${CMAKE_CURRENT_SOURCE_DIR}/bcasttest.c 
  ${CMAKE_CURRENT_SOURCE_DIR}/bcastzerotype.c 
  ${CMAKE_CURRENT_SOURCE_DIR}/coll10.c 
@@ -262,7 +265,6 @@ set(examples_src  ${examples_src}
  ${CMAKE_CURRENT_SOURCE_DIR}/exscan2.c 
  ${CMAKE_CURRENT_SOURCE_DIR}/exscan.c 
  ${CMAKE_CURRENT_SOURCE_DIR}/gather2.c 
- ${CMAKE_CURRENT_SOURCE_DIR}/gather2_save.c 
  ${CMAKE_CURRENT_SOURCE_DIR}/gather.c 
  ${CMAKE_CURRENT_SOURCE_DIR}/iallred.c 
  ${CMAKE_CURRENT_SOURCE_DIR}/ibarrier.c 
index 66a21ec..01cf4ab 100644 (file)
 
 /* Gather data from a vector to contiguous.  Use IN_PLACE */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
     double *vecout;
     MPI_Comm comm;
-    int    count, minsize = 2;
-    int    i, errs = 0;
-    int    rank, size;
+    int count, minsize = 2;
+    int i, errs = 0;
+    int rank, size;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
+
+    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);
 
-    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 );
-       
         for (count = 1; count < 9000; count = count * 2) {
-            vecout = (double *)malloc( size * count * sizeof(double) );
-            
-            for (i=0; i<count; i++) {
-                vecout[rank*count+i] = rank*count+i;
+            vecout = (double *) malloc(size * count * sizeof(double));
+
+            for (i = 0; i < count; i++) {
+                vecout[rank * count + i] = rank * count + i;
             }
-            MPI_Allgather( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, 
-                           vecout, count, MPI_DOUBLE, comm );
-            for (i=0; i<count*size; i++) {
+            MPI_Allgather(MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, vecout, count, MPI_DOUBLE, comm);
+            for (i = 0; i < count * size; i++) {
                 if (vecout[i] != i) {
                     errs++;
                     if (errs < 10) {
-                        fprintf( stderr, "vecout[%d]=%d\n",
-                                 i, (int)vecout[i] );
+                        fprintf(stderr, "vecout[%d]=%d\n", i, (int) vecout[i]);
                     }
                 }
             }
-            free( vecout );
+            free(vecout);
         }
 
-       MTestFreeComm( &comm );
+        MTestFreeComm(&comm);
     }
 
-#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
-    MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
-    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-    MPI_Comm_size(MPI_COMM_WORLD, &size);
-    vecout = (double *) malloc(size * sizeof(double));
-    if (MPI_SUCCESS == MPI_Allgather(&vecout[rank], 1, MPI_DOUBLE,
-                                      vecout, 1, MPI_DOUBLE, MPI_COMM_WORLD))
-        errs++;
-    free(vecout);
-#endif
-
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
-
-
index 66389b5..408ac2e 100644 (file)
 
 /* Gather data from a vector to contiguous. */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
     double *vecout, *invec;
     MPI_Comm comm;
-    int    count, minsize = 2;
-    int    i, errs = 0;
-    int    rank, size;
+    int count, minsize = 2;
+    int i, errs = 0;
+    int rank, size;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
+
+    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);
 
-    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 );
-       
         for (count = 1; count < 9000; count = count * 2) {
-           invec = (double *)malloc( count * sizeof(double) );
-            vecout = (double *)malloc( size * count * sizeof(double) );
-            
-            for (i=0; i<count; i++) {
-                invec[i] = rank*count+i;
+            invec = (double *) malloc(count * sizeof(double));
+            vecout = (double *) malloc(size * count * sizeof(double));
+
+            for (i = 0; i < count; i++) {
+                invec[i] = rank * count + i;
             }
-            MPI_Allgather( invec, count, MPI_DOUBLE, 
-                           vecout, count, MPI_DOUBLE, comm );
-            for (i=0; i<count*size; i++) {
+            MPI_Allgather(invec, count, MPI_DOUBLE, vecout, count, MPI_DOUBLE, comm);
+            for (i = 0; i < count * size; i++) {
                 if (vecout[i] != i) {
                     errs++;
                     if (errs < 10) {
-                        fprintf( stderr, "vecout[%d]=%d\n",
-                                 i, (int)vecout[i] );
+                        fprintf(stderr, "vecout[%d]=%d\n", i, (int) vecout[i]);
                     }
                 }
             }
-           free( invec );
-            free( vecout );
+            free(invec);
+            free(vecout);
         }
 
-       MTestFreeComm( &comm );
+        MTestFreeComm(&comm);
     }
 
     /* Do a zero byte gather */
-    MPI_Allgather( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, NULL, 0, MPI_BYTE, MPI_COMM_WORLD );
+    MPI_Allgather(MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, NULL, 0, MPI_BYTE, MPI_COMM_WORLD);
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
-
-
diff --git a/teshsuite/smpi/mpich3-test/coll/allgather_struct.c b/teshsuite/smpi/mpich3-test/coll/allgather_struct.c
new file mode 100644 (file)
index 0000000..b2a421f
--- /dev/null
@@ -0,0 +1,77 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *
+ *  (C) 2015 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+#include <stdlib.h>
+#include "mpi.h"
+#include "mpitest.h"
+
+/* Allgather a two-field struct datatype. This test
+   may trigger bugs such as when the implementation
+   does not handle well misaligned types.*/
+
+typedef struct {
+    int first;
+    long second;
+} int_long_t;
+
+int main(int argc, char **argv)
+{
+    MPI_Comm comm;
+    int minsize = 2;
+    int i, errs = 0;
+    int rank, size;
+    int_long_t object;
+    MPI_Datatype type;
+    MPI_Aint begin;
+    MPI_Aint displacements[2];
+    MPI_Datatype types[] = { MPI_INT, MPI_LONG };
+    int blocklength[2] = { 1, 1 };
+    int_long_t* gathered_objects;
+
+    MTest_Init(&argc, &argv);
+
+    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);
+
+        gathered_objects = (int_long_t*) malloc (size*sizeof(int_long_t));
+
+        /* Local object */
+        object.first = rank;
+        object.second = rank * 10;
+
+        /* Datatype creation */
+        MPI_Get_address(&object, &begin);
+        MPI_Get_address(&object.first, &displacements[0]);
+        MPI_Get_address(&object.second, &displacements[1]);
+
+        for (i = 0; i != 2; ++i)
+            displacements[i] -= begin;
+
+        MPI_Type_create_struct(2, &blocklength[0], &displacements[0], &types[0], &type);
+        MPI_Type_commit(&type);
+
+        MPI_Allgather(&object, 1, type, gathered_objects, 1, type, comm);
+
+        for (i = 0; i < size; i++) {
+            if (gathered_objects[i].first != i || gathered_objects[i].second != i * 10)
+                errs++;
+        }
+
+        MPI_Type_free(&type);
+        MTestFreeComm(&comm);
+        free(gathered_objects);
+    }
+
+    MTest_Finalize(errs);
+    MPI_Finalize();
+    return 0;
+}
index 55119d9..0d4248e 100644 (file)
 #include <stdlib.h>
 #include <stdio.h>
 
-/* Gather data from a vector to contiguous.  Use IN_PLACE.  This is 
+/* Gather data from a vector to contiguous.  Use IN_PLACE.  This is
    the trivial version based on the allgather test (allgatherv but with
    constant data sizes) */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
     double *vecout;
     MPI_Comm comm;
-    int    count, minsize = 2;
-    int    i, errs = 0;
-    int    rank, size;
-    int    *displs, *recvcounts;
+    int count, minsize = 2;
+    int i, errs = 0;
+    int rank, size;
+    int *displs, *recvcounts;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
-    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 );
+    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);
+
+        displs = (int *) malloc(size * sizeof(int));
+        recvcounts = (int *) malloc(size * sizeof(int));
 
-       displs     = (int *)malloc( size * sizeof(int) );
-       recvcounts = (int *)malloc( size * sizeof(int) );
-       
         for (count = 1; count < 9000; count = count * 2) {
-            vecout = (double *)malloc( size * count * sizeof(double) );
-            
-            for (i=0; i<count; i++) {
-                vecout[rank*count+i] = rank*count+i;
+            vecout = (double *) malloc(size * count * sizeof(double));
+
+            for (i = 0; i < count; i++) {
+                vecout[rank * count + i] = rank * count + i;
             }
-            for (i=0; i<size; i++) {
+            for (i = 0; i < size; i++) {
                 recvcounts[i] = count;
-                displs[i]    = i * count;
+                displs[i] = i * count;
             }
-            MPI_Allgatherv( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, 
-                            vecout, recvcounts, displs, MPI_DOUBLE, comm );
-            for (i=0; i<count*size; i++) {
+            MPI_Allgatherv(MPI_IN_PLACE, -1, MPI_DATATYPE_NULL,
+                           vecout, recvcounts, displs, MPI_DOUBLE, comm);
+            for (i = 0; i < count * size; i++) {
                 if (vecout[i] != i) {
                     errs++;
                     if (errs < 10) {
-                        fprintf( stderr, "vecout[%d]=%d\n",
-                                 i, (int)vecout[i] );
+                        fprintf(stderr, "vecout[%d]=%d\n", i, (int) vecout[i]);
                     }
                 }
             }
-            free( vecout );
+            free(vecout);
         }
 
-#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
-        MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
-        vecout = (double *) malloc(size * sizeof(double));
-        if (MPI_SUCCESS == MPI_Allgatherv(&vecout[rank * recvcounts[rank]], recvcounts[rank], MPI_DOUBLE,
-                                           vecout, recvcounts, displs, MPI_DOUBLE, comm))
-            errs++;
-        free(vecout);
-#endif
-
-       free( displs );
-       free( recvcounts );
-       MTestFreeComm( &comm );
+        free(displs);
+        free(recvcounts);
+        MTestFreeComm(&comm);
     }
-    
-    MTest_Finalize( errs );
+
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
-
-
index 7ba9a66..25066aa 100644 (file)
 #include <stdlib.h>
 #include <stdio.h>
 
-/* Gather data from a vector to contiguous.  This is 
+/* Gather data from a vector to contiguous.  This is
    the trivial version based on the allgather test (allgatherv but with
    constant data sizes) */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
     double *vecout, *invec;
     MPI_Comm comm;
-    int    count, minsize = 2;
-    int    i, errs = 0;
-    int    rank, size;
-    int    *displs, *recvcounts;
+    int count, minsize = 2;
+    int i, errs = 0;
+    int rank, size;
+    int *displs, *recvcounts;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
-    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 );
+    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);
+
+        displs = (int *) malloc(size * sizeof(int));
+        recvcounts = (int *) malloc(size * sizeof(int));
 
-       displs     = (int *)malloc( size * sizeof(int) );
-       recvcounts = (int *)malloc( size * sizeof(int) );
-       
         for (count = 1; count < 9000; count = count * 2) {
-           invec = (double *)malloc( count * sizeof(double) );
-            vecout = (double *)malloc( size * count * sizeof(double) );
-            
-            for (i=0; i<count; i++) {
-                invec[i] = rank*count+i;
+            invec = (double *) malloc(count * sizeof(double));
+            vecout = (double *) malloc(size * count * sizeof(double));
+
+            for (i = 0; i < count; i++) {
+                invec[i] = rank * count + i;
             }
-            for (i=0; i<size; i++) {
+            for (i = 0; i < size; i++) {
                 recvcounts[i] = count;
-                displs[i]    = i * count;
+                displs[i] = i * count;
             }
-            MPI_Allgatherv( invec, count, MPI_DOUBLE, 
-                            vecout, recvcounts, displs, MPI_DOUBLE, comm );
-            for (i=0; i<count*size; i++) {
+            MPI_Allgatherv(invec, count, MPI_DOUBLE, vecout, recvcounts, displs, MPI_DOUBLE, comm);
+            for (i = 0; i < count * size; i++) {
                 if (vecout[i] != i) {
                     errs++;
                     if (errs < 10) {
-                        fprintf( stderr, "vecout[%d]=%d\n",
-                                 i, (int)vecout[i] );
+                        fprintf(stderr, "vecout[%d]=%d\n", i, (int) vecout[i]);
                     }
                 }
             }
-           free( invec );
-            free( vecout );
+            free(invec);
+            free(vecout);
         }
-       free( displs );
-       free( recvcounts );
-       MTestFreeComm( &comm );
+        free(displs);
+        free(recvcounts);
+        MTestFreeComm(&comm);
     }
-    
-    MTest_Finalize( errs );
+
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
-
-
index 3caf57e..ea6fff5 100644 (file)
 #include <stdint.h>
 #endif
 
-SMPI_VARINIT_GLOBAL(count, int);
-SMPI_VARINIT_GLOBAL(size, int);
-SMPI_VARINIT_GLOBAL(rank, int);
-SMPI_VARINIT_GLOBAL(cerrcnt, int);
-
-struct int_test { int a; int b; };
-struct long_test { long a; int b; };
-struct short_test { short a; int b; };
-struct float_test { float a; int b; };
-struct double_test { double a; int b; };
+int count, size, rank;
+int cerrcnt;
+
+struct int_test {
+    int a;
+    int b;
+};
+struct long_test {
+    long a;
+    int b;
+};
+struct short_test {
+    short a;
+    int b;
+};
+struct float_test {
+    float a;
+    int b;
+};
+struct double_test {
+    double a;
+    int b;
+};
 
 #define mpi_op2str(op)                   \
     ((op == MPI_SUM) ? "MPI_SUM" :       \
@@ -46,35 +59,35 @@ struct double_test { double a; int b; };
 /* calloc to avoid spurious valgrind warnings when "type" has padding bytes */
 #define DECL_MALLOC_IN_OUT_SOL(type)                 \
     type *in, *out, *sol;                            \
-    in  = (type *) calloc(SMPI_VARGET_GLOBAL(count), sizeof(type));      \
-    out = (type *) calloc(SMPI_VARGET_GLOBAL(count), sizeof(type));      \
-    sol = (type *) calloc(SMPI_VARGET_GLOBAL(count), sizeof(type));
+    in  = (type *) calloc(count, sizeof(type));      \
+    out = (type *) calloc(count, sizeof(type));      \
+    sol = (type *) calloc(count, sizeof(type));
 
 #define SET_INDEX_CONST(arr, val)               \
     {                                           \
         int i;                                  \
-        for (i = 0; i < SMPI_VARGET_GLOBAL(count); i++)             \
+        for (i = 0; i < count; i++)             \
             arr[i] = val;                       \
     }
 
 #define SET_INDEX_SUM(arr, val)                 \
     {                                           \
         int i;                                  \
-        for (i = 0; i < SMPI_VARGET_GLOBAL(count); i++)             \
+        for (i = 0; i < count; i++)             \
             arr[i] = i + val;                   \
     }
 
 #define SET_INDEX_FACTOR(arr, val)              \
     {                                           \
         int i;                                  \
-        for (i = 0; i < SMPI_VARGET_GLOBAL(count); i++)             \
+        for (i = 0; i < count; i++)             \
             arr[i] = i * (val);                 \
     }
 
 #define SET_INDEX_POWER(arr, val)               \
     {                                           \
         int i, j;                               \
-        for (i = 0; i < SMPI_VARGET_GLOBAL(count); i++) {           \
+        for (i = 0; i < count; i++) {           \
             (arr)[i] = 1;                       \
             for (j = 0; j < (val); j++)         \
                 arr[i] *= i;                    \
@@ -88,26 +101,26 @@ struct double_test { double a; int b; };
         if (lerrcnt) {                                                  \
             MPI_Type_get_name(mpi_type, name, &len);                    \
             fprintf(stderr, "(%d) Error for type %s and op %s\n",       \
-                    SMPI_VARGET_GLOBAL(rank), name, mpi_op2str(mpi_op));                    \
+                    rank, name, mpi_op2str(mpi_op));                    \
         }                                                               \
         free(in); free(out); free(sol);                                 \
-    } while(0)
+    } while (0)
 
-/* The logic on the error check on MPI_Allreduce assumes that all 
+/* The logic on the error check on MPI_Allreduce assumes that all
    MPI_Allreduce routines return a failure if any do - this is sufficient
    for MPI implementations that reject some of the valid op/datatype pairs
-   (and motivated this addition, as some versions of the IBM MPI 
+   (and motivated this addition, as some versions of the IBM MPI
    failed in just this way).
 */
 #define ALLREDUCE_AND_FREE(mpi_type, mpi_op, in, out, sol)              \
     {                                                                   \
         int i, rc, lerrcnt = 0;                                                \
-        rc = MPI_Allreduce(in, out, SMPI_VARGET_GLOBAL(count), mpi_type, mpi_op, MPI_COMM_WORLD); \
-       if (rc) { lerrcnt++; SMPI_VARGET_GLOBAL(cerrcnt)++; MTestPrintError( rc ); }        \
+        rc = MPI_Allreduce(in, out, count, mpi_type, mpi_op, MPI_COMM_WORLD); \
+       if (rc) { lerrcnt++; cerrcnt++; MTestPrintError(rc); }        \
        else {                                                          \
-          for (i = 0; i < SMPI_VARGET_GLOBAL(count); i++) {                                   \
+          for (i = 0; i < count; i++) {                                   \
               if (out[i] != sol[i]) {                                     \
-                  SMPI_VARGET_GLOBAL(cerrcnt)++;                                              \
+                  cerrcnt++;                                              \
                   lerrcnt++;                                              \
               }                                                           \
           }                                                              \
@@ -118,12 +131,12 @@ struct double_test { double a; int b; };
 #define STRUCT_ALLREDUCE_AND_FREE(mpi_type, mpi_op, in, out, sol)       \
     {                                                                   \
         int i, rc, lerrcnt = 0;                                                \
-        rc = MPI_Allreduce(in, out, SMPI_VARGET_GLOBAL(count), mpi_type, mpi_op, MPI_COMM_WORLD); \
-       if (rc) { lerrcnt++; SMPI_VARGET_GLOBAL(cerrcnt)++; MTestPrintError( rc ); }        \
+        rc = MPI_Allreduce(in, out, count, mpi_type, mpi_op, MPI_COMM_WORLD); \
+       if (rc) { lerrcnt++; cerrcnt++; MTestPrintError(rc); }        \
         else {                                                            \
-          for (i = 0; i < SMPI_VARGET_GLOBAL(count); i++) {                                   \
+          for (i = 0; i < count; i++) {                                   \
               if ((out[i].a != sol[i].a) || (out[i].b != sol[i].b)) {     \
-                  SMPI_VARGET_GLOBAL(cerrcnt)++;                                              \
+                  cerrcnt++;                                              \
                   lerrcnt++;                                              \
               }                                                           \
             }                                                             \
@@ -134,14 +147,14 @@ struct double_test { double a; int b; };
 #define SET_INDEX_STRUCT_CONST(arr, val, el)                    \
     {                                                           \
         int i;                                                  \
-        for (i = 0; i < SMPI_VARGET_GLOBAL(count); i++)                             \
+        for (i = 0; i < count; i++)                             \
             arr[i].el = val;                                    \
     }
 
 #define SET_INDEX_STRUCT_SUM(arr, val, el)                      \
     {                                                           \
         int i;                                                  \
-        for (i = 0; i < SMPI_VARGET_GLOBAL(count); i++)                             \
+        for (i = 0; i < count; i++)                             \
             arr[i].el = i + (val);                              \
     }
 
@@ -149,7 +162,7 @@ struct double_test { double a; int b; };
     {                                                                   \
         DECL_MALLOC_IN_OUT_SOL(type);                                   \
         SET_INDEX_SUM(in, 0);                                           \
-        SET_INDEX_FACTOR(sol, SMPI_VARGET_GLOBAL(size));                                    \
+        SET_INDEX_FACTOR(sol, size);                                    \
         SET_INDEX_CONST(out, 0);                                        \
         ALLREDUCE_AND_FREE(mpi_type, MPI_SUM, in, out, sol);            \
     }
@@ -158,7 +171,7 @@ struct double_test { double a; int b; };
     {                                                                   \
         DECL_MALLOC_IN_OUT_SOL(type);                                   \
         SET_INDEX_SUM(in, 0);                                           \
-        SET_INDEX_POWER(sol, SMPI_VARGET_GLOBAL(size));                                     \
+        SET_INDEX_POWER(sol, size);                                     \
         SET_INDEX_CONST(out, 0);                                        \
         ALLREDUCE_AND_FREE(mpi_type, MPI_PROD, in, out, sol);           \
     }
@@ -166,8 +179,8 @@ struct double_test { double a; int b; };
 #define max_test1(type, mpi_type)                                       \
     {                                                                   \
         DECL_MALLOC_IN_OUT_SOL(type);                                   \
-        SET_INDEX_SUM(in, SMPI_VARGET_GLOBAL(rank));                                        \
-        SET_INDEX_SUM(sol, SMPI_VARGET_GLOBAL(size) - 1);                                   \
+        SET_INDEX_SUM(in, rank);                                        \
+        SET_INDEX_SUM(sol, size - 1);                                   \
         SET_INDEX_CONST(out, 0);                                        \
         ALLREDUCE_AND_FREE(mpi_type, MPI_MAX, in, out, sol);            \
     }
@@ -175,7 +188,7 @@ struct double_test { double a; int b; };
 #define min_test1(type, mpi_type)                                       \
     {                                                                   \
         DECL_MALLOC_IN_OUT_SOL(type);                                   \
-        SET_INDEX_SUM(in, SMPI_VARGET_GLOBAL(rank));                                        \
+        SET_INDEX_SUM(in, rank);                                        \
         SET_INDEX_SUM(sol, 0);                                          \
         SET_INDEX_CONST(out, 0);                                        \
         ALLREDUCE_AND_FREE(mpi_type, MPI_MIN, in, out, sol);            \
@@ -191,32 +204,32 @@ struct double_test { double a; int b; };
     }
 
 #define lor_test1(type, mpi_type)                                       \
-    const_test(type, mpi_type, MPI_LOR, (SMPI_VARGET_GLOBAL(rank) & 0x1), (SMPI_VARGET_GLOBAL(size) > 1), 0)
+    const_test(type, mpi_type, MPI_LOR, (rank & 0x1), (size > 1), 0)
 #define lor_test2(type, mpi_type)                       \
     const_test(type, mpi_type, MPI_LOR, 0, 0, 0)
 #define lxor_test1(type, mpi_type)                                      \
-    const_test(type, mpi_type, MPI_LXOR, (SMPI_VARGET_GLOBAL(rank) == 1), (SMPI_VARGET_GLOBAL(size) > 1), 0)
+    const_test(type, mpi_type, MPI_LXOR, (rank == 1), (size > 1), 0)
 #define lxor_test2(type, mpi_type)                      \
     const_test(type, mpi_type, MPI_LXOR, 0, 0, 0)
 #define lxor_test3(type, mpi_type)                      \
-    const_test(type, mpi_type, MPI_LXOR, 1, (SMPI_VARGET_GLOBAL(size) & 0x1), 0)
+    const_test(type, mpi_type, MPI_LXOR, 1, (size & 0x1), 0)
 #define land_test1(type, mpi_type)                              \
-    const_test(type, mpi_type, MPI_LAND, (SMPI_VARGET_GLOBAL(rank) & 0x1), 0, 0)
+    const_test(type, mpi_type, MPI_LAND, (rank & 0x1), 0, 0)
 #define land_test2(type, mpi_type)                      \
     const_test(type, mpi_type, MPI_LAND, 1, 1, 0)
 #define bor_test1(type, mpi_type)                                       \
-    const_test(type, mpi_type, MPI_BOR, (SMPI_VARGET_GLOBAL(rank) & 0x3), ((SMPI_VARGET_GLOBAL(size) < 3) ? SMPI_VARGET_GLOBAL(size) - 1 : 0x3), 0)
+    const_test(type, mpi_type, MPI_BOR, (rank & 0x3), ((size < 3) ? size - 1 : 0x3), 0)
 #define bxor_test1(type, mpi_type)                                      \
-    const_test(type, mpi_type, MPI_BXOR, (SMPI_VARGET_GLOBAL(rank) == 1) * 0xf0, (SMPI_VARGET_GLOBAL(size) > 1) * 0xf0, 0)
+    const_test(type, mpi_type, MPI_BXOR, (rank == 1) * 0xf0, (size > 1) * 0xf0, 0)
 #define bxor_test2(type, mpi_type)                      \
     const_test(type, mpi_type, MPI_BXOR, 0, 0, 0)
 #define bxor_test3(type, mpi_type)                      \
-    const_test(type, mpi_type, MPI_BXOR, ~0, (SMPI_VARGET_GLOBAL(size) &0x1) ? ~0 : 0, 0)
+    const_test(type, mpi_type, MPI_BXOR, ~0, (size &0x1) ? ~0 : 0, 0)
 
 #define band_test1(type, mpi_type)                                      \
     {                                                                   \
         DECL_MALLOC_IN_OUT_SOL(type);                                   \
-        if (SMPI_VARGET_GLOBAL(rank) == SMPI_VARGET_GLOBAL(size)-1) {                                           \
+        if (rank == size-1) {                                           \
             SET_INDEX_SUM(in, 0);                                       \
         }                                                               \
         else {                                                          \
@@ -230,7 +243,7 @@ struct double_test { double a; int b; };
 #define band_test2(type, mpi_type)                                      \
     {                                                                   \
         DECL_MALLOC_IN_OUT_SOL(type);                                   \
-        if (SMPI_VARGET_GLOBAL(rank) == SMPI_VARGET_GLOBAL(size)-1) {                                           \
+        if (rank == size-1) {                                           \
             SET_INDEX_SUM(in, 0);                                       \
         }                                                               \
         else {                                                          \
@@ -244,10 +257,10 @@ struct double_test { double a; int b; };
 #define maxloc_test(type, mpi_type)                                     \
     {                                                                   \
         DECL_MALLOC_IN_OUT_SOL(type);                                   \
-        SET_INDEX_STRUCT_SUM(in, SMPI_VARGET_GLOBAL(rank), a);                              \
-        SET_INDEX_STRUCT_CONST(in, SMPI_VARGET_GLOBAL(rank), b);                            \
-        SET_INDEX_STRUCT_SUM(sol, SMPI_VARGET_GLOBAL(size) - 1, a);                         \
-        SET_INDEX_STRUCT_CONST(sol, SMPI_VARGET_GLOBAL(size) - 1, b);                       \
+        SET_INDEX_STRUCT_SUM(in, rank, a);                              \
+        SET_INDEX_STRUCT_CONST(in, rank, b);                            \
+        SET_INDEX_STRUCT_SUM(sol, size - 1, a);                         \
+        SET_INDEX_STRUCT_CONST(sol, size - 1, b);                       \
         SET_INDEX_STRUCT_CONST(out, 0, a);                              \
         SET_INDEX_STRUCT_CONST(out, -1, b);                             \
         STRUCT_ALLREDUCE_AND_FREE(mpi_type, MPI_MAXLOC, in, out, sol);   \
@@ -256,8 +269,8 @@ struct double_test { double a; int b; };
 #define minloc_test(type, mpi_type)                                     \
     {                                                                   \
         DECL_MALLOC_IN_OUT_SOL(type);                                   \
-        SET_INDEX_STRUCT_SUM(in, SMPI_VARGET_GLOBAL(rank), a);                              \
-        SET_INDEX_STRUCT_CONST(in, SMPI_VARGET_GLOBAL(rank), b);                            \
+        SET_INDEX_STRUCT_SUM(in, rank, a);                              \
+        SET_INDEX_STRUCT_CONST(in, rank, b);                            \
         SET_INDEX_STRUCT_SUM(sol, 0, a);                                \
         SET_INDEX_STRUCT_CONST(sol, 0, b);                              \
         SET_INDEX_STRUCT_CONST(out, 0, a);                              \
@@ -284,7 +297,7 @@ struct double_test { double a; int b; };
 
 #if MTEST_HAVE_MIN_MPI_VERSION(3,0)
 #define test_types_set_mpi_3_0_integer(op,post) do {                \
-        op##_test##post(MPI_SMPI_VARGET_GLOBAL(count), MPI_SMPI_VARGET_GLOBAL(count));                      \
+        op##_test##post(MPI_Count, MPI_COUNT);                      \
     } while (0)
 #else
 #define test_types_set_mpi_3_0_integer(op,post) do { } while (0)
@@ -315,7 +328,7 @@ struct double_test { double a; int b; };
         op##_test##post(unsigned char, MPI_BYTE);                   \
     }
 
-/* Make sure that we test complex and double complex, even if long 
+/* Make sure that we test complex and double complex, even if long
    double complex is not available */
 #if defined(USE_LONG_DOUBLE_COMPLEX)
 
@@ -337,7 +350,7 @@ struct double_test { double a; int b; };
 #else
 
 #if MTEST_HAVE_MIN_MPI_VERSION(2,2) && defined(HAVE_FLOAT__COMPLEX) \
-    && defined(HAVE_DOUBLE__COMPLEX) 
+    && defined(HAVE_DOUBLE__COMPLEX)
 #define test_types_set4(op, post)                                         \
     do {                                                                  \
         op##_test##post(float _Complex, MPI_C_FLOAT_COMPLEX);             \
@@ -360,34 +373,32 @@ struct double_test { double a; int b; };
 #define test_types_set5(op, post) do { } while (0)
 #endif
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
-    MPI_Comm_size(MPI_COMM_WORLD, &SMPI_VARGET_GLOBAL(size));
-    MPI_Comm_rank(MPI_COMM_WORLD, &SMPI_VARGET_GLOBAL(rank));
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
-    if (SMPI_VARGET_GLOBAL(size) < 2) {
-       fprintf( stderr, "At least 2 processes required\n" );
-       MPI_Abort( MPI_COMM_WORLD, 1 );
-        exit(1);
+    if (size < 2) {
+        fprintf(stderr, "At least 2 processes required\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
     }
 
-    /* Set errors return so that we can provide better information 
-       should a routine reject one of the operand/datatype pairs */
-    MPI_Errhandler_set( MPI_COMM_WORLD, MPI_ERRORS_RETURN );
+    /* Set errors return so that we can provide better information
+     * should a routine reject one of the operand/datatype pairs */
+    MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
 
-    SMPI_VARGET_GLOBAL(count) = 10;
+    count = 10;
     /* Allow an argument to override the count.
-       Note that the product tests may fail if the count is very large.
+     * Note that the product tests may fail if the count is very large.
      */
     if (argc >= 2) {
-       SMPI_VARGET_GLOBAL(count) = atoi( argv[1] );
-       if  (SMPI_VARGET_GLOBAL(count) <= 0) {
-           fprintf( stderr, "Invalid count argument %s\n", argv[1] );
-           MPI_Abort( MPI_COMM_WORLD, 1 );
-            exit(1);
-       }
+        count = atoi(argv[1]);
+        if (count <= 0) {
+            fprintf(stderr, "Invalid count argument %s\n", argv[1]);
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
     }
 
     test_types_set2(sum, 1);
@@ -444,8 +455,8 @@ int main( int argc, char **argv )
     minloc_test(struct float_test, MPI_FLOAT_INT);
     minloc_test(struct double_test, MPI_DOUBLE_INT);
 
-    MPI_Errhandler_set( MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL );
-    MTest_Finalize( SMPI_VARGET_GLOBAL(cerrcnt) );
+    MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL);
+    MTest_Finalize(cerrcnt);
     MPI_Finalize();
     return 0;
 }
index f33b245..ece4009 100644 (file)
 static char MTEST_Descrip[] = "Test MPI_Allreduce with MPI_IN_PLACE";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0;
     int rank, size;
-    int minsize = 2, count; 
-    MPI_Comm      comm;
+    int minsize = 2, count;
+    MPI_Comm comm;
     int *buf, i;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
-    while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
-       if (comm == MPI_COMM_NULL) continue;
-       MPI_Comm_size( comm, &size );
-       MPI_Comm_rank( comm, &rank );
-       
-       for (count = 1; count < 65000; count = count * 2) {
-           /* Contiguous data */
-           buf = (int *)malloc( count * sizeof(int) );
-           for (i=0; i<count; i++) buf[i] = rank + i;
-           MPI_Allreduce( MPI_IN_PLACE, buf, count, MPI_INT, MPI_SUM, comm );
-           /* Check the results */
-           for (i=0; i<count; i++) {
-               int result = i * size + (size*(size-1))/2;
-               if (buf[i] != result) {
-                   errs ++;
-                   if (errs < 10) {
-                       fprintf( stderr, "buf[%d] = %d expected %d\n",
-                                i, buf[i], result );
-                   }
-               }
-           }
-           free( buf );
-       }
-       MTestFreeComm( &comm );
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        MPI_Comm_size(comm, &size);
+        MPI_Comm_rank(comm, &rank);
+
+        for (count = 1; count < 65000; count = count * 2) {
+            /* Contiguous data */
+            buf = (int *) malloc(count * sizeof(int));
+            for (i = 0; i < count; i++)
+                buf[i] = rank + i;
+            MPI_Allreduce(MPI_IN_PLACE, buf, count, MPI_INT, MPI_SUM, comm);
+            /* Check the results */
+            for (i = 0; i < count; i++) {
+                int result = i * size + (size * (size - 1)) / 2;
+                if (buf[i] != result) {
+                    errs++;
+                    if (errs < 10) {
+                        fprintf(stderr, "buf[%d] = %d expected %d\n", i, buf[i], result);
+                    }
+                }
+            }
+            free(buf);
+        }
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 61f1a7c..6c5d680 100644 (file)
@@ -14,7 +14,7 @@ static char MTEST_Descrip[] = "Test MPI_Allreduce with non-commutative user-defi
 */
 
 /* We make the error count global so that we can easily control the output
-   of error information (in particular, limiting it after the first 10 
+   of error information (in particular, limiting it after the first 10
    errors */
 int errs = 0;
 
@@ -25,39 +25,39 @@ int errs = 0;
      c(i,j) is cin[j+i*matSize]
  */
 #define MAXCOL 256
-static int matSize = 0;  /* Must be < MAXCOL */
+static int matSize = 0;         /* Must be < MAXCOL */
 static int max_offset = 0;
-void uop( void *, void *, int *, MPI_Datatype * );
-void uop( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype )
+void uop(void *, void *, int *, MPI_Datatype *);
+void uop(void *cinPtr, void *coutPtr, int *count, MPI_Datatype * dtype)
 {
-    const int *cin = (const int *)cinPtr;
-    int *cout = (int *)coutPtr;
+    const int *cin = (const int *) cinPtr;
+    int *cout = (int *) coutPtr;
     int i, j, k, nmat;
     int tempcol[MAXCOL];
     int offset1, offset2;
-    int matsize2 = matSize*matSize;
+    int matsize2 = matSize * matSize;
 
     for (nmat = 0; nmat < *count; nmat++) {
-       for (j=0; j<matSize; j++) {
-           for (i=0; i<matSize; i++) {
-               tempcol[i] = 0;
-               for (k=0; k<matSize; k++) {
-                   /* col[i] += cin(i,k) * cout(k,j) */
-                   offset1    = k+i*matSize;
-                   offset2    = j+k*matSize;
-                   assert(offset1 < max_offset);
-                   assert(offset2 < max_offset);
-                   tempcol[i] += cin[offset1] * cout[offset2];
-               }
-           }
-           for (i=0; i<matSize; i++) {
-               offset1       = j+i*matSize;
-               assert(offset1 < max_offset);
-               cout[offset1] = tempcol[i];
-           }
-       }
-       cin  += matsize2;
-       cout += matsize2;
+        for (j = 0; j < matSize; j++) {
+            for (i = 0; i < matSize; i++) {
+                tempcol[i] = 0;
+                for (k = 0; k < matSize; k++) {
+                    /* col[i] += cin(i,k) * cout(k,j) */
+                    offset1 = k + i * matSize;
+                    offset2 = j + k * matSize;
+                    assert(offset1 < max_offset);
+                    assert(offset2 < max_offset);
+                    tempcol[i] += cin[offset1] * cout[offset2];
+                }
+            }
+            for (i = 0; i < matSize; i++) {
+                offset1 = j + i * matSize;
+                assert(offset1 < max_offset);
+                cout[offset1] = tempcol[i];
+            }
+        }
+        cin += matsize2;
+        cout += matsize2;
     }
 }
 
@@ -66,149 +66,148 @@ void uop( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype )
    is the the matrix representing the permutation that shifts left by one.
    As the final matrix (in the size-1 position), we use the matrix that
    shifts RIGHT by one
-*/   
-static void initMat( MPI_Comm comm, int mat[] )
+*/
+static void initMat(MPI_Comm comm, int mat[])
 {
     int i, j, size, rank;
     int offset;
-    
-    MPI_Comm_rank( comm, &rank );
-    MPI_Comm_size( comm, &size );
 
-    for (i=0; i<size*size; i++) {
-       assert(i < max_offset);
-       mat[i] = 0;
+    MPI_Comm_rank(comm, &rank);
+    MPI_Comm_size(comm, &size);
+
+    for (i = 0; i < size * size; i++) {
+        assert(i < max_offset);
+        mat[i] = 0;
     }
 
-    if (rank < size-1) {
-       /* Create the permutation matrix that exchanges r with r+1 */
-       for (i=0; i<size; i++) {
-           if (i == rank) {
-               offset = ((i+1)%size) + i * size;
-               assert(offset < max_offset);
-               mat[offset] = 1;
-           }
-           else if (i == ((rank + 1)%size)) {
-               offset = ((i+size-1)%size) + i * size;
-               assert(offset < max_offset);
-               mat[offset] = 1;
-           }
-           else {
-               offset = i+i*size;
-               assert(offset < max_offset);
-               mat[offset] = 1;
-           }
-       }
+    if (rank < size - 1) {
+        /* Create the permutation matrix that exchanges r with r+1 */
+        for (i = 0; i < size; i++) {
+            if (i == rank) {
+                offset = ((i + 1) % size) + i * size;
+                assert(offset < max_offset);
+                mat[offset] = 1;
+            }
+            else if (i == ((rank + 1) % size)) {
+                offset = ((i + size - 1) % size) + i * size;
+                assert(offset < max_offset);
+                mat[offset] = 1;
+            }
+            else {
+                offset = i + i * size;
+                assert(offset < max_offset);
+                mat[offset] = 1;
+            }
+        }
     }
     else {
-       /* Create the permutation matrix that shifts right by one */
-       for (i=0; i<size; i++) {
-           for (j=0; j<size; j++) {
-               offset = j + i * size;  /* location of c(i,j) */
-               mat[offset] = 0;
-               if ( ((j-i+size)%size) == 1 ) mat[offset] = 1;
-           }
-       }
-       
+        /* Create the permutation matrix that shifts right by one */
+        for (i = 0; i < size; i++) {
+            for (j = 0; j < size; j++) {
+                offset = j + i * size;  /* location of c(i,j) */
+                mat[offset] = 0;
+                if (((j - i + size) % size) == 1)
+                    mat[offset] = 1;
+            }
+        }
+
     }
 }
 
 /* Compare a matrix with the identity matrix */
-static int isIdentity( MPI_Comm comm, int mat[] )
+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() );
-                   }
-               }
-           }
-       }
+
+    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 main(int argc, char *argv[])
 {
     int size;
-    int minsize = 2, count; 
-    MPI_Comm      comm;
+    int minsize = 2, count;
+    MPI_Comm comm;
     int *buf, *bufout;
     MPI_Op op;
     MPI_Datatype mattype;
 
-    MTest_Init( &argc, &argv );
-
-    MPI_Op_create( uop, 0, &op );
-    
-    while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
-       if (comm == MPI_COMM_NULL) {
-           continue;
-       }
-       MPI_Comm_size( comm, &size );
-       matSize = size;
-
-       /* Only one matrix for now */
-       count = 1;
-
-       /* A single matrix, the size of the communicator */
-       MPI_Type_contiguous( size*size, MPI_INT, &mattype );
-       MPI_Type_commit( &mattype );
-
-       max_offset = count * size * size;
-       buf = (int *)malloc( max_offset * sizeof(int) );
-       if (!buf) {
-           MPI_Abort( MPI_COMM_WORLD, 1 );
-            exit(1);
-       }
-       bufout = (int *)malloc( max_offset * sizeof(int) );
-       if (!bufout) {
-           MPI_Abort( MPI_COMM_WORLD, 1 );
-            exit(1);
-       }
-
-       initMat( comm, buf );
-       MPI_Allreduce( buf, bufout, count, mattype, op, comm );
-       errs += isIdentity( comm, bufout );
-
-       /* Try the same test, but using MPI_IN_PLACE */
-       initMat( comm, bufout );
-       MPI_Allreduce( MPI_IN_PLACE, bufout, count, mattype, op, comm );
-       errs += isIdentity( comm, bufout );
-
-       free( buf );
-       free( bufout );
-
-       MPI_Type_free( &mattype );
-       MTestFreeComm( &comm );
+    MTest_Init(&argc, &argv);
+
+    MPI_Op_create(uop, 0, &op);
+
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL) {
+            continue;
+        }
+        MPI_Comm_size(comm, &size);
+        matSize = size;
+
+        /* Only one matrix for now */
+        count = 1;
+
+        /* A single matrix, the size of the communicator */
+        MPI_Type_contiguous(size * size, MPI_INT, &mattype);
+        MPI_Type_commit(&mattype);
+
+        max_offset = count * size * size;
+        buf = (int *) malloc(max_offset * sizeof(int));
+        if (!buf) {
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
+        bufout = (int *) malloc(max_offset * sizeof(int));
+        if (!bufout) {
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
+
+        initMat(comm, buf);
+        MPI_Allreduce(buf, bufout, count, mattype, op, comm);
+        errs += isIdentity(comm, bufout);
+
+        /* Try the same test, but using MPI_IN_PLACE */
+        initMat(comm, bufout);
+        MPI_Allreduce(MPI_IN_PLACE, bufout, count, mattype, op, comm);
+        errs += isIdentity(comm, bufout);
+
+        free(buf);
+        free(bufout);
+
+        MPI_Type_free(&mattype);
+        MTestFreeComm(&comm);
     }
 
-    MPI_Op_free( &op );
+    MPI_Op_free(&op);
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 1638657..0efc440 100644 (file)
@@ -13,7 +13,7 @@
 static char MTEST_Descrip[] = "Test MPI_Allreduce with non-commutative user-defined operations using matrix rotations";
 */
 
-/* This example is similar to allred3.c, but uses only 3x3 matrics with 
+/* This example is similar to allred3.c, but uses only 3x3 matrics with
    integer-valued entries.  This is an associative but not commutative
    operation.
    The number of matrices is the count argument. The matrix is stored
@@ -26,211 +26,214 @@ static char MTEST_Descrip[] = "Test MPI_Allreduce with non-commutative user-defi
         0 0 1         1 0 0
         0 1 0)        0 0 1)
 
-   The product 
+   The product
 
          I^k A I^(p-2-k-j) B I^j
 
-   is 
+   is
 
-   ( 0 1 0 
+   (0 1 0
      0 0 1
-     1 0 0 )
+     1 0 0)
 
-   for all values of k, p, and j.  
+   for all values of k, p, and j.
  */
 
-void matmult( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype );
+void matmult(void *cinPtr, void *coutPtr, int *count, MPI_Datatype * dtype);
 
-void matmult( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype )
+void matmult(void *cinPtr, void *coutPtr, int *count, MPI_Datatype * dtype)
 {
-    const int *cin = (const int *)cinPtr;
-    int *cout = (int *)coutPtr;
+    const int *cin = (const int *) cinPtr;
+    int *cout = (int *) coutPtr;
     int i, j, k, nmat;
     int tempcol[3];
     int offset1, offset2;
 
     for (nmat = 0; nmat < *count; nmat++) {
-       for (j=0; j<3; j++) {
-           for (i=0; i<3; i++) {
-               tempcol[i] = 0;
-               for (k=0; k<3; k++) {
-                   /* col[i] += cin(i,k) * cout(k,j) */
-                   offset1 = k+i*3;
-                   offset2 = j+k*3;
-                   tempcol[i] += cin[offset1] * cout[offset2];
-               }
-           }
-           for (i=0; i<3; i++) {
-               offset1 = j+i*3;
-               cout[offset1] = tempcol[i];
-           }
-       }
-       /* Advance to the next matrix */
-       cin += 9;
-       cout += 9;
+        for (j = 0; j < 3; j++) {
+            for (i = 0; i < 3; i++) {
+                tempcol[i] = 0;
+                for (k = 0; k < 3; k++) {
+                    /* col[i] += cin(i,k) * cout(k,j) */
+                    offset1 = k + i * 3;
+                    offset2 = j + k * 3;
+                    tempcol[i] += cin[offset1] * cout[offset2];
+                }
+            }
+            for (i = 0; i < 3; i++) {
+                offset1 = j + i * 3;
+                cout[offset1] = tempcol[i];
+            }
+        }
+        /* Advance to the next matrix */
+        cin += 9;
+        cout += 9;
     }
 }
 
-/* Initialize the integer matrix as one of the 
+/* Initialize the integer matrix as one of the
    above matrix entries, as a function of count.
    We guarantee that both the A and B matrices are included.
-*/   
-static void initMat( int rank, int size, int nmat, int mat[] )
+*/
+static void initMat(int rank, int size, int nmat, int mat[])
 {
     int i, kind;
 
     /* Zero the matrix */
-    for (i=0; i<9; i++) {
-       mat[i] = 0;
+    for (i = 0; i < 9; i++) {
+        mat[i] = 0;
     }
 
     /* Decide which matrix to create (I, A, or B) */
-    if ( size == 2) {
-       /* rank 0 is A, 1 is B */
-       kind = 1 + rank;
+    if (size == 2) {
+        /* rank 0 is A, 1 is B */
+        kind = 1 + rank;
     }
     else {
-       int tmpA, tmpB;
-       /* Most ranks are identity matrices */
-       kind = 0;
-       /* Make sure exactly one rank gets the A matrix
-          and one the B matrix */
-       tmpA = size / 4;
-       tmpB = (3 * size) / 4;
-       
-       if (rank == tmpA) kind = 1;
-       if (rank == tmpB) kind = 2;
+        int tmpA, tmpB;
+        /* Most ranks are identity matrices */
+        kind = 0;
+        /* Make sure exactly one rank gets the A matrix
+         * and one the B matrix */
+        tmpA = size / 4;
+        tmpB = (3 * size) / 4;
+
+        if (rank == tmpA)
+            kind = 1;
+        if (rank == tmpB)
+            kind = 2;
     }
-    
+
     switch (kind) {
-    case 0: /* Identity */
-       mat[0] = 1;
-       mat[4] = 1;
-       mat[8] = 1;
-       break;
-    case 1: /* A */
-       mat[0] = 1;
-       mat[5] = 1;
-       mat[7] = 1;
-       break;
-    case 2: /* B */
-       mat[1] = 1;
-       mat[3] = 1;
-       mat[8] = 1;
-       break;
+    case 0:    /* Identity */
+        mat[0] = 1;
+        mat[4] = 1;
+        mat[8] = 1;
+        break;
+    case 1:    /* A */
+        mat[0] = 1;
+        mat[5] = 1;
+        mat[7] = 1;
+        break;
+    case 2:    /* B */
+        mat[1] = 1;
+        mat[3] = 1;
+        mat[8] = 1;
+        break;
     }
 }
 
 /* Compare a matrix with the known result */
-static int checkResult( int nmat, int mat[], const char *msg )
+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;
+    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;
 }
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0;
     int size, rank;
-    int minsize = 2, count; 
-    MPI_Comm      comm;
+    int minsize = 2, count;
+    MPI_Comm comm;
     int *buf, *bufout;
     MPI_Op op;
     MPI_Datatype mattype;
     int i;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
+
+    MPI_Op_create(matmult, 0, &op);
 
-    MPI_Op_create( matmult, 0, &op );
-    
     /* A single rotation matrix (3x3, stored as 9 consequetive elements) */
-    MPI_Type_contiguous( 9, MPI_INT, &mattype );
-    MPI_Type_commit( &mattype );
+    MPI_Type_contiguous(9, MPI_INT, &mattype);
+    MPI_Type_commit(&mattype);
 
     /* Sanity check: test that our routines work properly */
-    { int one = 1;
-    buf = (int *)malloc( 4*9 * sizeof(int) );
-    initMat( 0, 4, 0, &buf[0] );
-    initMat( 1, 4, 0, &buf[9] );
-    initMat( 2, 4, 0, &buf[18] );
-    initMat( 3, 4, 0, &buf[27] );
-    matmult( &buf[0], &buf[9], &one, &mattype );
-    matmult( &buf[9], &buf[18], &one, &mattype );
-    matmult( &buf[18], &buf[27], &one, &mattype );
-    checkResult( 1, &buf[27], "Sanity Check" );
-    free(buf);
+    {
+        int one = 1;
+        buf = (int *) malloc(4 * 9 * sizeof(int));
+        initMat(0, 4, 0, &buf[0]);
+        initMat(1, 4, 0, &buf[9]);
+        initMat(2, 4, 0, &buf[18]);
+        initMat(3, 4, 0, &buf[27]);
+        matmult(&buf[0], &buf[9], &one, &mattype);
+        matmult(&buf[9], &buf[18], &one, &mattype);
+        matmult(&buf[18], &buf[27], &one, &mattype);
+        checkResult(1, &buf[27], "Sanity Check");
+        free(buf);
     }
-    
-    while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
-       if (comm == MPI_COMM_NULL) continue;
-
-       MPI_Comm_size( comm, &size );
-       MPI_Comm_rank( comm, &rank );
-
-       for (count = 1; count < size; count ++ ) {
-           
-           /* Allocate the matrices */
-           buf = (int *)malloc( count * 9 * sizeof(int) );
-           if (!buf) {
-               MPI_Abort( MPI_COMM_WORLD, 1 );
-                exit(1);
-           }
-
-           bufout = (int *)malloc( count * 9 * sizeof(int) );
-           if (!bufout) {
-               MPI_Abort( MPI_COMM_WORLD, 1 );
-                exit(1);
-           }
-
-           for (i=0; i < count; i++) {
-               initMat( rank, size, i, &buf[i*9] );
-           }
-           
-           MPI_Allreduce( buf, bufout, count, mattype, op, comm );
-           errs += checkResult( count, bufout, "" );
-
-           /* Try the same test, but using MPI_IN_PLACE */
-           for (i=0; i < count; i++) {
-               initMat( rank, size, i, &bufout[i*9] );
-           }
-           MPI_Allreduce( MPI_IN_PLACE, bufout, count, mattype, op, comm );
-           errs += checkResult( count, bufout, "IN_PLACE" );
-
-           free( buf );
-           free( bufout );
-       }
-       MTestFreeComm( &comm );
+
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+
+        MPI_Comm_size(comm, &size);
+        MPI_Comm_rank(comm, &rank);
+
+        for (count = 1; count < size; count++) {
+
+            /* Allocate the matrices */
+            buf = (int *) malloc(count * 9 * sizeof(int));
+            if (!buf) {
+                MPI_Abort(MPI_COMM_WORLD, 1);
+            }
+
+            bufout = (int *) malloc(count * 9 * sizeof(int));
+            if (!bufout) {
+                MPI_Abort(MPI_COMM_WORLD, 1);
+            }
+
+            for (i = 0; i < count; i++) {
+                initMat(rank, size, i, &buf[i * 9]);
+            }
+
+            MPI_Allreduce(buf, bufout, count, mattype, op, comm);
+            errs += checkResult(count, bufout, "");
+
+            /* Try the same test, but using MPI_IN_PLACE */
+            for (i = 0; i < count; i++) {
+                initMat(rank, size, i, &bufout[i * 9]);
+            }
+            MPI_Allreduce(MPI_IN_PLACE, bufout, count, mattype, op, comm);
+            errs += checkResult(count, bufout, "IN_PLACE");
+
+            free(buf);
+            free(bufout);
+        }
+        MTestFreeComm(&comm);
     }
-       
-    MPI_Op_free( &op );
-    MPI_Type_free( &mattype );
 
-    MTest_Finalize( errs );
+    MPI_Op_free(&op);
+    MPI_Type_free(&mattype);
+
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 7bba665..1e6d0e2 100644 (file)
@@ -14,53 +14,50 @@ static char MTEST_Descrip[] = "Test MPI_Allreduce with count greater than the nu
 */
 
 /* We make the error count global so that we can easily control the output
-   of error information (in particular, limiting it after the first 10 
+   of error information (in particular, limiting it after the first 10
    errors */
 int errs = 0;
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     MPI_Comm comm;
     MPI_Datatype dtype;
-    int count, *bufin, *bufout, size, i, minsize=1;
+    int count, *bufin, *bufout, size, i, minsize = 1;
 
-    MTest_Init( &argc, &argv );
-    
-    while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
-       if (comm == MPI_COMM_NULL) {
-           continue;
-       }
-       MPI_Comm_size( comm, &size );
-       count = size * 2;
-       bufin = (int *)malloc( count * sizeof(int) );
-       bufout = (int *)malloc( count * sizeof(int) );
-       if (!bufin || !bufout) {
-           fprintf( stderr, "Unable to allocated space for buffers (%d)\n",
-                    count );
-           MPI_Abort( MPI_COMM_WORLD, 1 );
-            exit(1);
-       }
-       for (i=0; i<count; i++) {
-           bufin[i] = i;
-           bufout[i] = -1;
-       }
+    MTest_Init(&argc, &argv);
 
-       dtype = MPI_INT;
-       MPI_Allreduce( bufin, bufout, count, dtype, MPI_SUM, comm );
-       /* Check output */
-       for (i=0; i<count; i++) {
-           if (bufout[i] != i * size) {
-               fprintf( stderr, "Expected bufout[%d] = %d but found %d\n",
-                        i, i * size, bufout[i] );
-               errs++;
-           }
-       }
-       free( bufin );
-       free( bufout );
-       MTestFreeComm( &comm );
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL) {
+            continue;
+        }
+        MPI_Comm_size(comm, &size);
+        count = size * 2;
+        bufin = (int *) malloc(count * sizeof(int));
+        bufout = (int *) malloc(count * sizeof(int));
+        if (!bufin || !bufout) {
+            fprintf(stderr, "Unable to allocated space for buffers (%d)\n", count);
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
+        for (i = 0; i < count; i++) {
+            bufin[i] = i;
+            bufout[i] = -1;
+        }
+
+        dtype = MPI_INT;
+        MPI_Allreduce(bufin, bufout, count, dtype, MPI_SUM, comm);
+        /* Check output */
+        for (i = 0; i < count; i++) {
+            if (bufout[i] != i * size) {
+                fprintf(stderr, "Expected bufout[%d] = %d but found %d\n", i, i * size, bufout[i]);
+                errs++;
+            }
+        }
+        free(bufin);
+        free(bufout);
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 65629de..dec9a00 100644 (file)
 static char MTEST_Descrip[] = "Test MPI_Allreduce with apparent non-commutative operators";
 */
 /* While the operator is in fact commutative, this forces the MPI code to
-   run the code that is used for non-commutative operators, and for 
-   various message lengths.  Other tests check truly non-commutative 
+   run the code that is used for non-commutative operators, and for
+   various message lengths.  Other tests check truly non-commutative
    operators */
 
-void mysum( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype );
+void mysum(void *cinPtr, void *coutPtr, int *count, MPI_Datatype * dtype);
 
-void mysum( void *cinPtr, void *coutPtr, int *count, MPI_Datatype *dtype )
+void mysum(void *cinPtr, void *coutPtr, int *count, MPI_Datatype * dtype)
 {
-    const int *cin = (const int *)cinPtr;
-    int       *cout = (int *)coutPtr;
-    int        i, n = *count;
-    for (i=0; i<n; i++) 
-       cout[i] += cin[i];
+    const int *cin = (const int *) cinPtr;
+    int *cout = (int *) coutPtr;
+    int i, n = *count;
+    for (i = 0; i < n; i++)
+        cout[i] += cin[i];
 }
-int main( int argc, char *argv[] )
+
+int main(int argc, char *argv[])
 {
-    int      errs = 0;
-    int      rank, size;
-    int      minsize = 2, count; 
+    int errs = 0;
+    int rank, size;
+    int minsize = 2, count;
     MPI_Comm comm;
-    MPI_Op   op;
-    int      *buf, i;
+    MPI_Op op;
+    int *buf, i;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
-    MPI_Op_create( mysum, 0, &op );
+    MPI_Op_create(mysum, 0, &op);
 
-    while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
-       if (comm == MPI_COMM_NULL) continue;
-       MPI_Comm_size( comm, &size );
-       MPI_Comm_rank( comm, &rank );
-       
-       for (count = 1; count < 65000; count = count * 2) {
-           /* Contiguous data */
-           buf = (int *)malloc( count * sizeof(int) );
-           for (i=0; i<count; i++) buf[i] = rank + i;
-           MPI_Allreduce( MPI_IN_PLACE, buf, count, MPI_INT, op, comm );
-           /* Check the results */
-           for (i=0; i<count; i++) {
-               int result = i * size + (size*(size-1))/2;
-               if (buf[i] != result) {
-                   errs ++;
-                   if (errs < 10) {
-                       fprintf( stderr, "buf[%d] = %d expected %d\n",
-                                i, buf[i], result );
-                   }
-               }
-           }
-           free( buf );
-       }
-       MTestFreeComm( &comm );
-    }
-    MPI_Op_free( &op );
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        MPI_Comm_size(comm, &size);
+        MPI_Comm_rank(comm, &rank);
 
-#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
-    /* Check to make sure that aliasing is disallowed correctly */
-    MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
-    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-    if (MPI_SUCCESS == MPI_Allreduce(&rank, &rank, 1, MPI_INT, MPI_OP_NULL, MPI_COMM_WORLD))
-        errs++;
-#endif
+        for (count = 1; count < 65000; count = count * 2) {
+            /* Contiguous data */
+            buf = (int *) malloc(count * sizeof(int));
+            for (i = 0; i < count; i++)
+                buf[i] = rank + i;
+            MPI_Allreduce(MPI_IN_PLACE, buf, count, MPI_INT, op, comm);
+            /* Check the results */
+            for (i = 0; i < count; i++) {
+                int result = i * size + (size * (size - 1)) / 2;
+                if (buf[i] != result) {
+                    errs++;
+                    if (errs < 10) {
+                        fprintf(stderr, "buf[%d] = %d expected %d\n", i, buf[i], result);
+                    }
+                }
+            }
+            free(buf);
+        }
+        MTestFreeComm(&comm);
+    }
+    MPI_Op_free(&op);
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 438119e..49aa6f9 100644 (file)
  * implementation to handle a flood of one-way messages.
  */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-  double wscale = 10.0, scale;
-  int numprocs, myid,i;
+    double wscale = 10.0, scale;
+    int numprocs, myid, i;
 
-  MPI_Init(&argc,&argv);
-  MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
-  MPI_Comm_rank(MPI_COMM_WORLD,&myid);
+    MPI_Init(&argc, &argv);
+    MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
+    MPI_Comm_rank(MPI_COMM_WORLD, &myid);
 
-  for ( i=0; i<10000; i++) {
-    MPI_Allreduce(&wscale,&scale,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
-  }
+    for (i = 0; i < 10000; i++) {
+        MPI_Allreduce(&wscale, &scale, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
+    }
 
-  if (myid == 0) {
-      /* If we get here at all, we're ok */
-      printf( " No Errors\n" );
-  }
-  MPI_Finalize();
-  
-  return 0;
+    if (myid == 0) {
+        /* If we get here at all, we're ok */
+        printf(" No Errors\n");
+    }
+    MPI_Finalize();
+
+    return 0;
 }
index 6974627..41739af 100644 (file)
 #include <stdio.h>
 #include "mpitest.h"
 #include <stdlib.h>
+#include "mpicolltest.h"
 
 /*
 static char MTEST_Descrip[] = "";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0;
     int rank, size;
-    int minsize = 2, count; 
-    MPI_Comm      comm;
+    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 );
+    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;
+    /* 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;
+        /* Determine the sender and receiver */
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_size(comm, &size);
 
-           if (!sendbuf || !recvbuf) {
-               errs++;
-               fprintf( stderr, "Failed to allocate sendbuf and/or recvbuf\n" );
-               MPI_Abort( MPI_COMM_WORLD, 1 );
-                exit(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;
-               }
-           }
+        /* printf("Size of comm = %d\n", size); */
+        for (count = 1; count < 65000; count = count * 2) {
 
-           MPI_Alltoall( sendbuf, sendcount, sendtype,
-                         recvbuf, recvcount, recvtype, comm );
+            /* 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;
 
-           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 (!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;
+                }
+            }
+
+            MTest_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++) {
+            for (j = 0; j < size; j++) {
+                for (i = 0; i < count; i++) {
                     *p++ = j * size + rank + i;
                 }
             }
-            MPI_Alltoall( MPI_IN_PLACE, -1/*ignored*/, MPI_DATATYPE_NULL/*ignored*/,
-                          recvbuf, recvcount, recvtype, comm );
+            MPI_Alltoall(MPI_IN_PLACE, -1 /*ignored */ , MPI_DATATYPE_NULL /*ignored */ ,
+                         recvbuf, recvcount, recvtype, comm);
             p = recvbuf;
-            for (j=0; j<size; j++) {
-                for (i=0; i<count; i++) {
+            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 );
+                            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++;
@@ -110,21 +111,13 @@ int main( int argc, char *argv[] )
             }
 #endif
 
-           free( recvbuf );
-           free( sendbuf );
-       }
-       MTestFreeComm( &comm );
+            free(recvbuf);
+            free(sendbuf);
+        }
+        MTestFreeComm(&comm);
     }
 
-#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
-    /* Check to make sure that aliasing is disallowed correctly */
-    MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
-    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-    if (MPI_SUCCESS == MPI_Alltoall(&rank, 1, MPI_INT, &rank, 1, MPI_INT, MPI_COMM_WORLD))
-        errs++;
-#endif
-
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 844596e..bc286c2 100644 (file)
 
   Because there are separate send and receive types to alltoallv,
   there need to be tests to rearrange data on the fly.  Not done yet.
-  
+
   The first test sends i items to processor i from all processors.
 
   Currently, the test uses only MPI_INT; this is adequate for testing systems
   that use point-to-point operations
  */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
 
     MPI_Comm comm;
-    int      *sbuf, *rbuf;
-    int      rank, size;
-    int      *sendcounts, *recvcounts, *rdispls, *sdispls;
-    int      i, j, *p, err;
-    
-    MTest_Init( &argc, &argv );
+    int *sbuf, *rbuf;
+    int rank, size;
+    int *sendcounts, *recvcounts, *rdispls, *sdispls;
+    int i, j, *p, err;
+
+    MTest_Init(&argc, &argv);
     err = 0;
-    
-    while (MTestGetIntracommGeneral( &comm, 2, 1 )) {
-      if (comm == MPI_COMM_NULL) continue;
-
-      /* Create the buffer */
-      MPI_Comm_size( comm, &size );
-      MPI_Comm_rank( comm, &rank );
-      sbuf = (int *)malloc( size * size * sizeof(int) );
-      rbuf = (int *)malloc( size * size * sizeof(int) );
-      if (!sbuf || !rbuf) {
-       fprintf( stderr, "Could not allocated buffers!\n" );
-       MPI_Abort( comm, 1 );
-        exit(1);
-      }
-      
-      /* Load up the buffers */
-      for (i=0; i<size*size; i++) {
-       sbuf[i] = i + 100*rank;
-       rbuf[i] = -i;
-      }
-      
-      /* Create and load the arguments to alltoallv */
-      sendcounts = (int *)malloc( size * sizeof(int) );
-      recvcounts = (int *)malloc( size * sizeof(int) );
-      rdispls    = (int *)malloc( size * sizeof(int) );
-      sdispls    = (int *)malloc( size * sizeof(int) );
-      if (!sendcounts || !recvcounts || !rdispls || !sdispls) {
-       fprintf( stderr, "Could not allocate arg items!\n" );
-       MPI_Abort( comm, 1 );
-        exit(1);
-      }
-      for (i=0; i<size; i++) {
-       sendcounts[i] = i;
-       recvcounts[i] = rank;
-       rdispls[i]    = i * rank;
-       sdispls[i]    = (i * (i+1))/2;
-      }
-      MPI_Alltoallv( sbuf, sendcounts, sdispls, MPI_INT,
-                    rbuf, recvcounts, rdispls, MPI_INT, comm );
-      
-      /* Check rbuf */
-      for (i=0; i<size; i++) {
-       p = rbuf + rdispls[i];
-       for (j=0; j<rank; j++) {
-         if (p[j] != i * 100 + (rank*(rank+1))/2 + j) {
-           fprintf( stderr, "[%d] got %d expected %d for %dth\n",
-                    rank, p[j],(i*(i+1))/2 + j, j );
-           err++;
-         }
-       }
-      }
-
-      free( sdispls );
-      free( sendcounts );
-      free( sbuf );
 
-#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
-      /* check MPI_IN_PLACE, added in MPI-2.2 */
-      free( rbuf );
-      rbuf = (int *)malloc( size * (2 * size) * sizeof(int) );
-      if (!rbuf) {
-        fprintf( stderr, "Could not reallocate rbuf!\n" );
-        MPI_Abort( comm, 1 );
-        exit(1);
-      }
-
-      /* Load up the buffers */
-      for (i = 0; i < size; i++) {
-        recvcounts[i] = i + rank;
-        rdispls[i]    = i * (2 * size);
-      }
-      memset(rbuf, -1, size * (2 * size) * sizeof(int));
-      for (i=0; i < size; i++) {
-        p = rbuf + rdispls[i];
-        for (j = 0; j < recvcounts[i]; ++j) {
-          p[j] = 100 * rank + 10 * i + j;
+    while (MTestGetIntracommGeneral(&comm, 2, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+
+        /* Create the buffer */
+        MPI_Comm_size(comm, &size);
+        MPI_Comm_rank(comm, &rank);
+        sbuf = (int *) malloc(size * size * sizeof(int));
+        rbuf = (int *) malloc(size * size * sizeof(int));
+        if (!sbuf || !rbuf) {
+            fprintf(stderr, "Could not allocated buffers!\n");
+            MPI_Abort(comm, 1);
         }
-      }
-      MPI_Alltoallv( MPI_IN_PLACE, NULL, NULL, MPI_INT,
-                     rbuf, recvcounts, rdispls, MPI_INT, comm );
-      /* Check rbuf */
-      for (i=0; i<size; i++) {
-        p = rbuf + rdispls[i];
-        for (j=0; j<recvcounts[i]; j++) {
-          int expected = 100 * i + 10 * rank + j;
-          if (p[j] != expected) {
-            fprintf(stderr, "[%d] got %d expected %d for block=%d, element=%dth\n",
-                    rank, p[j], expected, i, j);
-            ++err;
-          }
+
+        /* Load up the buffers */
+        for (i = 0; i < size * size; i++) {
+            sbuf[i] = i + 100 * rank;
+            rbuf[i] = -i;
         }
-      }
 
-      /* Check to make sure that aliasing is disallowed correctly */
-      MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
-      if (MPI_SUCCESS == MPI_Alltoallv(rbuf, recvcounts, rdispls, MPI_INT,
-                                       rbuf, recvcounts, rdispls, MPI_INT, comm))
-          err++;
+        /* Create and load the arguments to alltoallv */
+        sendcounts = (int *) malloc(size * sizeof(int));
+        recvcounts = (int *) malloc(size * sizeof(int));
+        rdispls = (int *) malloc(size * sizeof(int));
+        sdispls = (int *) malloc(size * sizeof(int));
+        if (!sendcounts || !recvcounts || !rdispls || !sdispls) {
+            fprintf(stderr, "Could not allocate arg items!\n");
+            MPI_Abort(comm, 1);
+        }
+        for (i = 0; i < size; i++) {
+            sendcounts[i] = i;
+            recvcounts[i] = rank;
+            rdispls[i] = i * rank;
+            sdispls[i] = (i * (i + 1)) / 2;
+        }
+        MPI_Alltoallv(sbuf, sendcounts, sdispls, MPI_INT, rbuf, recvcounts, rdispls, MPI_INT, comm);
+
+        /* Check rbuf */
+        for (i = 0; i < size; i++) {
+            p = rbuf + rdispls[i];
+            for (j = 0; j < rank; j++) {
+                if (p[j] != i * 100 + (rank * (rank + 1)) / 2 + j) {
+                    fprintf(stderr, "[%d] got %d expected %d for %dth\n",
+                            rank, p[j], (i * (i + 1)) / 2 + j, j);
+                    err++;
+                }
+            }
+        }
+
+        free(sdispls);
+        free(sendcounts);
+        free(sbuf);
+
+#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
+        /* check MPI_IN_PLACE, added in MPI-2.2 */
+        free(rbuf);
+        rbuf = (int *) malloc(size * (2 * size) * sizeof(int));
+        if (!rbuf) {
+            fprintf(stderr, "Could not reallocate rbuf!\n");
+            MPI_Abort(comm, 1);
+        }
+
+        /* Load up the buffers */
+        for (i = 0; i < size; i++) {
+            recvcounts[i] = i + rank;
+            rdispls[i] = i * (2 * size);
+        }
+        memset(rbuf, -1, size * (2 * size) * sizeof(int));
+        for (i = 0; i < size; i++) {
+            p = rbuf + rdispls[i];
+            for (j = 0; j < recvcounts[i]; ++j) {
+                p[j] = 100 * rank + 10 * i + j;
+            }
+        }
+        MPI_Alltoallv(MPI_IN_PLACE, NULL, NULL, MPI_INT, rbuf, recvcounts, rdispls, MPI_INT, comm);
+        /* Check rbuf */
+        for (i = 0; i < size; i++) {
+            p = rbuf + rdispls[i];
+            for (j = 0; j < recvcounts[i]; j++) {
+                int expected = 100 * i + 10 * rank + j;
+                if (p[j] != expected) {
+                    fprintf(stderr, "[%d] got %d expected %d for block=%d, element=%dth\n",
+                            rank, p[j], expected, i, j);
+                    ++err;
+                }
+            }
+        }
 #endif
 
-      free( rdispls );
-      free( recvcounts );
-      free( rbuf );
-      MTestFreeComm( &comm );
+        free(rdispls);
+        free(recvcounts);
+        free(rbuf);
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( err );
+    MTest_Finalize(err);
     MPI_Finalize();
     return 0;
 }
index 5890043..a771c76 100644 (file)
 #include <stdio.h>
 
 /*
-  This program tests MPI_Alltoallv by having processor each process 
+  This program tests MPI_Alltoallv by having processor each process
   send data to two neighbors only, using counts of 0 for the other processes.
   This idiom is sometimes used for halo exchange operations.
 
   Because there are separate send and receive types to alltoallv,
   there need to be tests to rearrange data on the fly.  Not done yet.
-  
+
   Currently, the test uses only MPI_INT; this is adequate for testing systems
   that use point-to-point operations
  */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
 
     MPI_Comm comm;
-    int      *sbuf, *rbuf;
-    int      rank, size;
-    int      *sendcounts, *recvcounts, *rdispls, *sdispls;
-    int      i, *p, err;
-    int      left, right, length;
-    
-    MTest_Init( &argc, &argv );
+    int *sbuf, *rbuf;
+    int rank, size;
+    int *sendcounts, *recvcounts, *rdispls, *sdispls;
+    int i, *p, err;
+    int left, right, length;
+
+    MTest_Init(&argc, &argv);
     err = 0;
-    
-    while (MTestGetIntracommGeneral( &comm, 2, 1 )) {
-      if (comm == MPI_COMM_NULL) continue;
-
-      MPI_Comm_size( comm, &size );
-      MPI_Comm_rank( comm, &rank );
-      
-      if (size < 3) continue;
-
-      /* Create and load the arguments to alltoallv */
-      sendcounts = (int *)malloc( size * sizeof(int) );
-      recvcounts = (int *)malloc( size * sizeof(int) );
-      rdispls    = (int *)malloc( size * sizeof(int) );
-      sdispls    = (int *)malloc( size * sizeof(int) );
-      if (!sendcounts || !recvcounts || !rdispls || !sdispls) {
-       fprintf( stderr, "Could not allocate arg items!\n" );
-       MPI_Abort( comm, 1 );
-        exit(1);
-      }
-
-      /* Get the neighbors */
-      left  = (rank - 1 + size) % size;
-      right = (rank + 1) % size;
-
-      /* Set the defaults */
-      for (i=0; i<size; i++) {
-         sendcounts[i] = 0;
-         recvcounts[i] = 0;
-         rdispls[i]    = 0;
-         sdispls[i]    = 0;
-      }
-
-      for (length=1; length < 66000; length = length*2+1 ) {
-         /* Get the buffers */
-         sbuf = (int *)malloc( 2 * length * sizeof(int) );
-         rbuf = (int *)malloc( 2 * length * sizeof(int) );
-         if (!sbuf || !rbuf) {
-             fprintf( stderr, "Could not allocate buffers!\n" );
-             MPI_Abort( comm, 1 );
-              exit(1);
-         }
-         
-         /* Load up the buffers */
-         for (i=0; i<length; i++) {
-             sbuf[i]        = i + 100000*rank;
-             sbuf[i+length] = i + 100000*rank;
-             rbuf[i]        = -i;
-             rbuf[i+length] = -i-length;
-         }
-         sendcounts[left]  = length;
-         sendcounts[right] = length;
-         recvcounts[left]  = length;
-         recvcounts[right] = length;
-         rdispls[left]     = 0;
-         rdispls[right]    = length;
-         sdispls[left]     = 0;
-         sdispls[right]    = length;
-      
-         MPI_Alltoallv( sbuf, sendcounts, sdispls, MPI_INT,
-                        rbuf, recvcounts, rdispls, MPI_INT, comm );
-      
-         /* Check rbuf */
-         p = rbuf;          /* left */
-
-         for (i=0; i<length; i++) {
-             if (p[i] != i + 100000 * left) {
-                 if (err < 10) {
-                     fprintf( stderr, "[%d from %d] got %d expected %d for %dth\n", 
-                              rank, left, p[i], i + 100000 * left, i );
-                 }
-                 err++;
-             }
-         }
-
-         p = rbuf + length; /* right */
-         for (i=0; i<length; i++) {
-             if (p[i] != i + 100000 * right) {
-                 if (err < 10) {
-                     fprintf( stderr, "[%d from %d] got %d expected %d for %dth\n", 
-                              rank, right, p[i], i + 100000 * right, i );
-                 }
-                 err++;
-             }
-         }
-
-         free( rbuf );
-         free( sbuf );
-      }
-         
-      free( sdispls );
-      free( rdispls );
-      free( recvcounts );
-      free( sendcounts );
-      MTestFreeComm( &comm );
+
+    while (MTestGetIntracommGeneral(&comm, 2, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+
+        MPI_Comm_size(comm, &size);
+        MPI_Comm_rank(comm, &rank);
+
+        if (size < 3)
+            continue;
+
+        /* Create and load the arguments to alltoallv */
+        sendcounts = (int *) malloc(size * sizeof(int));
+        recvcounts = (int *) malloc(size * sizeof(int));
+        rdispls = (int *) malloc(size * sizeof(int));
+        sdispls = (int *) malloc(size * sizeof(int));
+        if (!sendcounts || !recvcounts || !rdispls || !sdispls) {
+            fprintf(stderr, "Could not allocate arg items!\n");
+            MPI_Abort(comm, 1);
+        }
+
+        /* Get the neighbors */
+        left = (rank - 1 + size) % size;
+        right = (rank + 1) % size;
+
+        /* Set the defaults */
+        for (i = 0; i < size; i++) {
+            sendcounts[i] = 0;
+            recvcounts[i] = 0;
+            rdispls[i] = 0;
+            sdispls[i] = 0;
+        }
+
+        for (length = 1; length < 66000; length = length * 2 + 1) {
+            /* Get the buffers */
+            sbuf = (int *) malloc(2 * length * sizeof(int));
+            rbuf = (int *) malloc(2 * length * sizeof(int));
+            if (!sbuf || !rbuf) {
+                fprintf(stderr, "Could not allocate buffers!\n");
+                MPI_Abort(comm, 1);
+            }
+
+            /* Load up the buffers */
+            for (i = 0; i < length; i++) {
+                sbuf[i] = i + 100000 * rank;
+                sbuf[i + length] = i + 100000 * rank;
+                rbuf[i] = -i;
+                rbuf[i + length] = -i - length;
+            }
+            sendcounts[left] = length;
+            sendcounts[right] = length;
+            recvcounts[left] = length;
+            recvcounts[right] = length;
+            rdispls[left] = 0;
+            rdispls[right] = length;
+            sdispls[left] = 0;
+            sdispls[right] = length;
+
+            MPI_Alltoallv(sbuf, sendcounts, sdispls, MPI_INT,
+                          rbuf, recvcounts, rdispls, MPI_INT, comm);
+
+            /* Check rbuf */
+            p = rbuf;   /* left */
+
+            for (i = 0; i < length; i++) {
+                if (p[i] != i + 100000 * left) {
+                    if (err < 10) {
+                        fprintf(stderr, "[%d from %d] got %d expected %d for %dth\n",
+                                rank, left, p[i], i + 100000 * left, i);
+                    }
+                    err++;
+                }
+            }
+
+            p = rbuf + length;  /* right */
+            for (i = 0; i < length; i++) {
+                if (p[i] != i + 100000 * right) {
+                    if (err < 10) {
+                        fprintf(stderr, "[%d from %d] got %d expected %d for %dth\n",
+                                rank, right, p[i], i + 100000 * right, i);
+                    }
+                    err++;
+                }
+            }
+
+            free(rbuf);
+            free(sbuf);
+        }
+
+        free(sdispls);
+        free(rdispls);
+        free(recvcounts);
+        free(sendcounts);
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( err );
+    MTest_Finalize(err);
     MPI_Finalize();
     return 0;
 }
index ba655ab..fe5fd00 100644 (file)
@@ -6,10 +6,10 @@
  */
 
 /*
- * This example is taken from MPI-The complete reference, Vol 1, 
+ * This example is taken from MPI-The complete reference, Vol 1,
  * pages 222-224.
- * 
- * Lines after the "--CUT HERE--" were added to make this into a complete 
+ *
+ * Lines after the "--CUT HERE--" were added to make this into a complete
  * test program.
  */
 
@@ -27,241 +27,239 @@ MPI_Datatype transpose_type(int M, int m, int n, MPI_Datatype type);
 MPI_Datatype submatrix_type(int N, int m, int n, MPI_Datatype type);
 void Transpose(float *localA, float *localB, int M, int N, MPI_Comm comm);
 void Transpose(float *localA, float *localB, int M, int N, MPI_Comm comm)
-/* transpose MxN matrix A that is block distributed (1-D) on  
+/* transpose MxN matrix A that is block distributed (1-D) on
    processes of comm onto block distributed matrix B  */
 {
-  int i, j, extent, myrank, p, n[2], m[2];
-  int lasti, lastj;
-  int *sendcounts, *recvcounts;
-  int *sdispls, *rdispls;
-  MPI_Datatype xtype[2][2], stype[2][2], *sendtypes, *recvtypes;
-
-  MTestPrintfMsg( 2, "M = %d, N = %d\n", M, N );
-
-  /* compute parameters */
-  MPI_Comm_size(comm, &p);
-  MPI_Comm_rank(comm, &myrank);
-  extent = sizeof(float);
-
-  /* allocate arrays */
-  sendcounts = (int *)malloc(p*sizeof(int));
-  recvcounts = (int *)malloc(p*sizeof(int));
-  sdispls    = (int *)malloc(p*sizeof(int));
-  rdispls    = (int *)malloc(p*sizeof(int));
-  sendtypes  = (MPI_Datatype *)malloc(p*sizeof(MPI_Datatype));
-  recvtypes  = (MPI_Datatype *)malloc(p*sizeof(MPI_Datatype));
-
-  /* compute block sizes */
-  m[0] = M/p;
-  m[1] = M - (p-1)*(M/p);
-  n[0] = N/p;
-  n[1] = N - (p-1)*(N/p);
-
-  /* compute types */
-  for (i=0; i <= 1; i++)
-      for (j=0; j <= 1; j++) {
-         xtype[i][j] = transpose_type(N, m[i], n[j], MPI_FLOAT);
-         stype[i][j] = submatrix_type(M, m[i], n[j], MPI_FLOAT);
-      }
-  
-  /* prepare collective operation arguments */
-  lasti = myrank == p-1;
-  for (j=0;  j < p; j++) {
-    lastj        = j == p-1;
-    sendcounts[j] = 1;
-    sdispls[j]   = j*n[0]*extent;
-    sendtypes[j]  = xtype[lasti][lastj];
-    recvcounts[j] = 1;
-    rdispls[j]   = j*m[0]*extent;
-    recvtypes[j]  = stype[lastj][lasti];
-  }
-  
-  /* communicate */
-  MTestPrintfMsg( 2, "Begin Alltoallw...\n" ); 
-  /* -- Note that the book incorrectly uses &localA and &localB 
-     as arguments to MPI_Alltoallw */
-  MPI_Alltoallw(localA, sendcounts, sdispls, sendtypes, 
-                localB, recvcounts, rdispls, recvtypes, comm);
-  MTestPrintfMsg( 2, "Done with Alltoallw\n" ); 
-
-  /* Free buffers */
-  free( sendcounts );
-  free( recvcounts );
-  free( sdispls );
-  free( rdispls );
-  free( sendtypes );
-  free( recvtypes );
-
-  /* Free datatypes */
-  for (i=0; i <= 1; i++)
-      for (j=0; j <= 1; j++) {
-         MPI_Type_free( &xtype[i][j] );
-         MPI_Type_free( &stype[i][j] );
-      }
+    int i, j, extent, myrank, p, n[2], m[2];
+    int lasti, lastj;
+    int *sendcounts, *recvcounts;
+    int *sdispls, *rdispls;
+    MPI_Datatype xtype[2][2], stype[2][2], *sendtypes, *recvtypes;
+
+    MTestPrintfMsg(2, "M = %d, N = %d\n", M, N);
+
+    /* compute parameters */
+    MPI_Comm_size(comm, &p);
+    MPI_Comm_rank(comm, &myrank);
+    extent = sizeof(float);
+
+    /* allocate arrays */
+    sendcounts = (int *) malloc(p * sizeof(int));
+    recvcounts = (int *) malloc(p * sizeof(int));
+    sdispls = (int *) malloc(p * sizeof(int));
+    rdispls = (int *) malloc(p * sizeof(int));
+    sendtypes = (MPI_Datatype *) malloc(p * sizeof(MPI_Datatype));
+    recvtypes = (MPI_Datatype *) malloc(p * sizeof(MPI_Datatype));
+
+    /* compute block sizes */
+    m[0] = M / p;
+    m[1] = M - (p - 1) * (M / p);
+    n[0] = N / p;
+    n[1] = N - (p - 1) * (N / p);
+
+    /* compute types */
+    for (i = 0; i <= 1; i++)
+        for (j = 0; j <= 1; j++) {
+            xtype[i][j] = transpose_type(N, m[i], n[j], MPI_FLOAT);
+            stype[i][j] = submatrix_type(M, m[i], n[j], MPI_FLOAT);
+        }
+
+    /* prepare collective operation arguments */
+    lasti = myrank == p - 1;
+    for (j = 0; j < p; j++) {
+        lastj = j == p - 1;
+        sendcounts[j] = 1;
+        sdispls[j] = j * n[0] * extent;
+        sendtypes[j] = xtype[lasti][lastj];
+        recvcounts[j] = 1;
+        rdispls[j] = j * m[0] * extent;
+        recvtypes[j] = stype[lastj][lasti];
+    }
+
+    /* communicate */
+    MTestPrintfMsg(2, "Begin Alltoallw...\n");
+    /* -- Note that the book incorrectly uses &localA and &localB
+     as arguments to MPI_Alltoallw */
+    MPI_Alltoallw(localA, sendcounts, sdispls, sendtypes,
+                  localB, recvcounts, rdispls, recvtypes, comm);
+    MTestPrintfMsg(2, "Done with Alltoallw\n");
+
+    /* Free buffers */
+    free(sendcounts);
+    free(recvcounts);
+    free(sdispls);
+    free(rdispls);
+    free(sendtypes);
+    free(recvtypes);
+
+    /* Free datatypes */
+    for (i = 0; i <= 1; i++)
+        for (j = 0; j <= 1; j++) {
+            MPI_Type_free(&xtype[i][j]);
+            MPI_Type_free(&stype[i][j]);
+        }
 }
 
 
-/* Define an n x m submatrix in a n x M local matrix (this is the 
+/* Define an n x m submatrix in a n x M local matrix (this is the
    destination in the transpose matrix */
 MPI_Datatype submatrix_type(int M, int m, int n, MPI_Datatype type)
-/* computes a datatype for an mxn submatrix within an MxN matrix 
+/* computes a datatype for an mxn submatrix within an MxN matrix
    with entries of type type */
 {
-  /* MPI_Datatype subrow; */
-  MPI_Datatype submatrix;
-
-  /* The book, MPI: The Complete Reference, has the wrong type constructor 
-     here.  Since the stride in the vector type is relative to the input 
-     type, the stride in the book's code is n times as long as is intended. 
-     Since n may not exactly divide N, it is better to simply use the 
-     blocklength argument in Type_vector */
-  /*
-  MPI_Type_contiguous(n, type, &subrow);
-  MPI_Type_vector(m, 1, N, subrow, &submatrix);  
-  */
-  MPI_Type_vector(n, m, M, type, &submatrix );
-  MPI_Type_commit(&submatrix);
-
-  /* Add a consistency test: the size of submatrix should be
-     n * m * sizeof(type) and the extent should be ((n-1)*M+m) * sizeof(type) */
-  {
-      int      tsize;
-      MPI_Aint textent, lb;
-      MPI_Type_size( type, &tsize );
-      MPI_Type_get_extent( submatrix, &lb, &textent );
-      
-      if (textent != tsize * (M * (n-1)+m)) {
-         fprintf( stderr, "Submatrix extent is %ld, expected %ld (%d,%d,%d)\n",
-                  (long)textent, (long)(tsize * (M * (n-1)+m)), M, n, m );
-      }
-  }
-  return(submatrix);
+    /* MPI_Datatype subrow; */
+    MPI_Datatype submatrix;
+
+    /* The book, MPI: The Complete Reference, has the wrong type constructor
+     * here.  Since the stride in the vector type is relative to the input
+     * type, the stride in the book's code is n times as long as is intended.
+     * Since n may not exactly divide N, it is better to simply use the
+     blocklength argument in Type_vector */
+    /*
+     * MPI_Type_contiguous(n, type, &subrow);
+     * MPI_Type_vector(m, 1, N, subrow, &submatrix);
+     */
+    MPI_Type_vector(n, m, M, type, &submatrix);
+    MPI_Type_commit(&submatrix);
+
+    /* Add a consistency test: the size of submatrix should be
+     n * m * sizeof(type) and the extent should be ((n-1)*M+m) * sizeof(type) */
+    {
+        int tsize;
+        MPI_Aint textent, lb;
+        MPI_Type_size(type, &tsize);
+        MPI_Type_get_extent(submatrix, &lb, &textent);
+
+        if (textent != tsize * (M * (n - 1) + m)) {
+            fprintf(stderr, "Submatrix extent is %ld, expected %ld (%d,%d,%d)\n",
+                    (long) textent, (long) (tsize * (M * (n - 1) + m)), M, n, m);
+        }
+    }
+    return (submatrix);
 }
 
 /* Extract an m x n submatrix within an m x N matrix and transpose it.
    Assume storage by rows; the defined datatype accesses by columns */
 MPI_Datatype transpose_type(int N, int m, int n, MPI_Datatype type)
-/* computes a datatype for the transpose of an mxn matrix 
+/* computes a datatype for the transpose of an mxn matrix
    with entries of type type */
 {
-  MPI_Datatype subrow, subrow1, submatrix;
-  MPI_Aint lb, extent;
-  
-  MPI_Type_vector(m, 1, N, type, &subrow);
-  MPI_Type_get_extent(type, &lb, &extent);
-  MPI_Type_create_resized(subrow, 0, extent, &subrow1);
-  MPI_Type_contiguous(n, subrow1, &submatrix); 
-  MPI_Type_commit(&submatrix);
-  MPI_Type_free( &subrow );
-  MPI_Type_free( &subrow1 );
-
-  /* Add a consistency test: the size of submatrix should be
-     n * m * sizeof(type) and the extent should be ((m-1)*N+n) * sizeof(type) */
-  {
-      int      tsize;
-      MPI_Aint textent, llb;
-      MPI_Type_size( type, &tsize );
-      MPI_Type_get_true_extent( submatrix, &llb, &textent );
-      
-      if (textent != tsize * (N * (m-1)+n)) {
-         fprintf( stderr, "Transpose Submatrix extent is %ld, expected %ld (%d,%d,%d)\n",
-                  (long)textent, (long)(tsize * (N * (m-1)+n)), N, n, m );
-      }
-  }
-
-  return(submatrix);
+    MPI_Datatype subrow, subrow1, submatrix;
+    MPI_Aint lb, extent;
+
+    MPI_Type_vector(m, 1, N, type, &subrow);
+    MPI_Type_get_extent(type, &lb, &extent);
+    MPI_Type_create_resized(subrow, 0, extent, &subrow1);
+    MPI_Type_contiguous(n, subrow1, &submatrix);
+    MPI_Type_commit(&submatrix);
+    MPI_Type_free(&subrow);
+    MPI_Type_free(&subrow1);
+
+    /* Add a consistency test: the size of submatrix should be
+     n * m * sizeof(type) and the extent should be ((m-1)*N+n) * sizeof(type) */
+    {
+        int tsize;
+        MPI_Aint textent, llb;
+        MPI_Type_size(type, &tsize);
+        MPI_Type_get_true_extent(submatrix, &llb, &textent);
+
+        if (textent != tsize * (N * (m - 1) + n)) {
+            fprintf(stderr, "Transpose Submatrix extent is %ld, expected %ld (%d,%d,%d)\n",
+                    (long) textent, (long) (tsize * (N * (m - 1) + n)), N, n, m);
+        }
+    }
+
+    return (submatrix);
 }
 
 /* -- CUT HERE -- */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int gM, gN, lm, lmlast, ln, lnlast, i, j, errs = 0;
     int size, rank;
     float *localA, *localB;
     MPI_Comm comm;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
     comm = MPI_COMM_WORLD;
-    
-    MPI_Comm_size( comm, &size );
-    MPI_Comm_rank( comm, &rank );
+
+    MPI_Comm_size(comm, &size);
+    MPI_Comm_rank(comm, &rank);
 
     gM = 20;
     gN = 30;
 
-    /* Each block is lm x ln in size, except for the last process, 
-       which has lmlast x lnlast */
-    lm     = gM/size;
-    lmlast = gM - (size - 1)*lm;
-    ln     = gN/size;
-    lnlast = gN - (size - 1)*ln;
+    /* Each block is lm x ln in size, except for the last process,
+     * which has lmlast x lnlast */
+    lm = gM / size;
+    lmlast = gM - (size - 1) * lm;
+    ln = gN / size;
+    lnlast = gN - (size - 1) * ln;
 
     /* Create the local matrices.
-       Initialize the input matrix so that the entries are 
-       consequtive integers, by row, starting at 0.
+     * Initialize the input matrix so that the entries are
+     * consequtive integers, by row, starting at 0.
      */
     if (rank == size - 1) {
-       localA = (float *)malloc( gN * lmlast * sizeof(float) );
-       localB = (float *)malloc( gM * lnlast * sizeof(float) );
-       for (i=0; i<lmlast; i++) {
-           for (j=0; j<gN; j++) {
-               localA[i*gN+j] = (float)(i*gN+j + rank * gN * lm);
-           }
-       }
-       
+        localA = (float *) malloc(gN * lmlast * sizeof(float));
+        localB = (float *) malloc(gM * lnlast * sizeof(float));
+        for (i = 0; i < lmlast; i++) {
+            for (j = 0; j < gN; j++) {
+                localA[i * gN + j] = (float) (i * gN + j + rank * gN * lm);
+            }
+        }
+
     }
     else {
-       localA = (float *)malloc( gN * lm * sizeof(float) );
-       localB = (float *)malloc( gM * ln * sizeof(float) );
-       for (i=0; i<lm; i++) {
-           for (j=0; j<gN; j++) {
-               localA[i*gN+j] = (float)(i*gN+j + rank * gN * lm);
-           }
-       }
+        localA = (float *) malloc(gN * lm * sizeof(float));
+        localB = (float *) malloc(gM * ln * sizeof(float));
+        for (i = 0; i < lm; i++) {
+            for (j = 0; j < gN; j++) {
+                localA[i * gN + j] = (float) (i * gN + j + rank * gN * lm);
+            }
+        }
     }
 
-    MTestPrintfMsg( 2, "Allocated local arrays\n" );
+    MTestPrintfMsg(2, "Allocated local arrays\n");
     /* Transpose */
-    Transpose( localA, localB, gM, gN, comm );
+    Transpose(localA, localB, gM, gN, comm);
 
     /* check the transposed matrix
-       In the global matrix, the transpose has consequtive integers, 
-       organized by columns.
+     * In the global matrix, the transpose has consequtive integers,
+     * organized by columns.
      */
     if (rank == size - 1) {
-       for (i=0; i<lnlast; i++) {
-           for (j=0; j<gM; j++) {
-               int expected = i+gN*j + rank * ln;
-               if ((int)localB[i*gM+j] != expected) {
-                   if (errs < MAX_ERRORS) 
-                       printf( "Found %d but expected %d\n", 
-                               (int)localB[i*gM+j], expected );
-                   errs++;
-               }
-           }
-       }
-       
+        for (i = 0; i < lnlast; i++) {
+            for (j = 0; j < gM; j++) {
+                int expected = i + gN * j + rank * ln;
+                if ((int) localB[i * gM + j] != expected) {
+                    if (errs < MAX_ERRORS)
+                        printf("Found %d but expected %d\n", (int) localB[i * gM + j], expected);
+                    errs++;
+                }
+            }
+        }
+
     }
     else {
-       for (i=0; i<ln; i++) {
-           for (j=0; j<gM; j++) {
-               int expected = i+gN*j + rank * ln;
-               if ((int)localB[i*gM+j] != expected) {
-                   if (errs < MAX_ERRORS) 
-                       printf( "Found %d but expected %d\n", 
-                               (int)localB[i*gM+j], expected );
-                   errs++;
-               }
-           }
-       }
+        for (i = 0; i < ln; i++) {
+            for (j = 0; j < gM; j++) {
+                int expected = i + gN * j + rank * ln;
+                if ((int) localB[i * gM + j] != expected) {
+                    if (errs < MAX_ERRORS)
+                        printf("Found %d but expected %d\n", (int) localB[i * gM + j], expected);
+                    errs++;
+                }
+            }
+        }
     }
 
     /* Free storage */
-    free( localA );
-    free( localB );
+    free(localA);
+    free(localB);
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
 
     MPI_Finalize();
 
index 981b770..379cdae 100644 (file)
 
   Because there are separate send and receive types to alltoallw,
   there need to be tests to rearrange data on the fly.  Not done yet.
-  
+
   The first test sends i items to processor i from all processors.
 
   Currently, the test uses only MPI_INT; this is adequate for testing systems
   that use point-to-point operations
  */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
 
     MPI_Comm comm;
-    int      *sbuf, *rbuf;
-    int      rank, size;
-    int      *sendcounts, *recvcounts, *rdispls, *sdispls;
-    int      i, j, *p, err;
+    int *sbuf, *rbuf;
+    int rank, size;
+    int *sendcounts, *recvcounts, *rdispls, *sdispls;
+    int i, j, *p, err;
     MPI_Datatype *sendtypes, *recvtypes;
-    
-    MTest_Init( &argc, &argv );
+
+    MTest_Init(&argc, &argv);
     err = 0;
-    
-    while (MTestGetIntracommGeneral( &comm, 2, 1 )) {
-      if (comm == MPI_COMM_NULL) continue;
-
-      /* Create the buffer */
-      MPI_Comm_size( comm, &size );
-      MPI_Comm_rank( comm, &rank );
-      sbuf = (int *)malloc( size * size * sizeof(int) );
-      rbuf = (int *)malloc( size * size * sizeof(int) );
-      if (!sbuf || !rbuf) {
-       fprintf( stderr, "Could not allocated buffers!\n" );
-       MPI_Abort( comm, 1 );
-        exit(1);
-      }
-      
-      /* Load up the buffers */
-      for (i=0; i<size*size; i++) {
-       sbuf[i] = i + 100*rank;
-       rbuf[i] = -i;
-      }
-      
-      /* Create and load the arguments to alltoallv */
-      sendcounts = (int *)malloc( size * sizeof(int) );
-      recvcounts = (int *)malloc( size * sizeof(int) );
-      rdispls    = (int *)malloc( size * sizeof(int) );
-      sdispls    = (int *)malloc( size * sizeof(int) );
-      sendtypes    = (MPI_Datatype *)malloc( size * sizeof(MPI_Datatype) );
-      recvtypes    = (MPI_Datatype *)malloc( size * sizeof(MPI_Datatype) );
-      if (!sendcounts || !recvcounts || !rdispls || !sdispls || !sendtypes || !recvtypes) {
-       fprintf( stderr, "Could not allocate arg items!\n" );
-       MPI_Abort( comm, 1 );
-        exit(1);
-      }
-      /* Note that process 0 sends no data (sendcounts[0] = 0) */
-      for (i=0; i<size; i++) {
-       sendcounts[i] = i;
-       recvcounts[i] = rank;
-       rdispls[i]    = i * rank * sizeof(int);
-       sdispls[i]    = (((i+1) * (i))/2) * sizeof(int);
-        sendtypes[i] = recvtypes[i] = MPI_INT;
-      }
-      MPI_Alltoallw( sbuf, sendcounts, sdispls, sendtypes,
-                    rbuf, recvcounts, rdispls, recvtypes, comm );
-      
-      /* Check rbuf */
-      for (i=0; i<size; i++) {
-       p = rbuf + rdispls[i]/sizeof(int);
-       for (j=0; j<rank; j++) {
-         if (p[j] != i * 100 + (rank*(rank+1))/2 + j) {
-           fprintf( stderr, "[%d] got %d expected %d for %dth\n",
-                    rank, p[j],(i*(i+1))/2 + j, j );
-           err++;
-         }
-       }
-      }
-
-      free(sendtypes);
-      free(sdispls);
-      free(sendcounts);
-      free(sbuf);
+
+    while (MTestGetIntracommGeneral(&comm, 2, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+
+        /* Create the buffer */
+        MPI_Comm_size(comm, &size);
+        MPI_Comm_rank(comm, &rank);
+        sbuf = (int *) malloc(size * size * sizeof(int));
+        rbuf = (int *) malloc(size * size * sizeof(int));
+        if (!sbuf || !rbuf) {
+            fprintf(stderr, "Could not allocated buffers!\n");
+            MPI_Abort(comm, 1);
+        }
+
+        /* Load up the buffers */
+        for (i = 0; i < size * size; i++) {
+            sbuf[i] = i + 100 * rank;
+            rbuf[i] = -i;
+        }
+
+        /* Create and load the arguments to alltoallv */
+        sendcounts = (int *) malloc(size * sizeof(int));
+        recvcounts = (int *) malloc(size * sizeof(int));
+        rdispls = (int *) malloc(size * sizeof(int));
+        sdispls = (int *) malloc(size * sizeof(int));
+        sendtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
+        recvtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
+        if (!sendcounts || !recvcounts || !rdispls || !sdispls || !sendtypes || !recvtypes) {
+            fprintf(stderr, "Could not allocate arg items!\n");
+            MPI_Abort(comm, 1);
+        }
+        /* Note that process 0 sends no data (sendcounts[0] = 0) */
+        for (i = 0; i < size; i++) {
+            sendcounts[i] = i;
+            recvcounts[i] = rank;
+            rdispls[i] = i * rank * sizeof(int);
+            sdispls[i] = (((i + 1) * (i)) / 2) * sizeof(int);
+            sendtypes[i] = recvtypes[i] = MPI_INT;
+        }
+        MPI_Alltoallw(sbuf, sendcounts, sdispls, sendtypes,
+                      rbuf, recvcounts, rdispls, recvtypes, comm);
+
+        /* Check rbuf */
+        for (i = 0; i < size; i++) {
+            p = rbuf + rdispls[i] / sizeof(int);
+            for (j = 0; j < rank; j++) {
+                if (p[j] != i * 100 + (rank * (rank + 1)) / 2 + j) {
+                    fprintf(stderr, "[%d] got %d expected %d for %dth\n",
+                            rank, p[j], (i * (i + 1)) / 2 + j, j);
+                    err++;
+                }
+            }
+        }
+
+        free(sendtypes);
+        free(sdispls);
+        free(sendcounts);
+        free(sbuf);
 
 #if MTEST_HAVE_MIN_MPI_VERSION(2,2)
-      /* check MPI_IN_PLACE, added in MPI-2.2 */
-      free( rbuf );
-      rbuf = (int *)malloc( size * (2 * size) * sizeof(int) );
-      if (!rbuf) {
-        fprintf( stderr, "Could not reallocate rbuf!\n" );
-        MPI_Abort( comm, 1 );
-        exit(1);
-      }
-
-      /* Load up the buffers */
-      for (i = 0; i < size; i++) {
-        /* alltoallw displs are in bytes, not in type extents */
-        rdispls[i]    = i * (2 * size) * sizeof(int);
-        recvtypes[i]  = MPI_INT;
-        recvcounts[i] = i + rank;
-      }
-      memset(rbuf, -1, size * (2 * size) * sizeof(int));
-      for (i=0; i < size; i++) {
-        p = rbuf + (rdispls[i] / sizeof(int));
-        for (j = 0; j < recvcounts[i]; ++j) {
-          p[j] = 100 * rank + 10 * i + j;
+        /* check MPI_IN_PLACE, added in MPI-2.2 */
+        free(rbuf);
+        rbuf = (int *) malloc(size * (2 * size) * sizeof(int));
+        if (!rbuf) {
+            fprintf(stderr, "Could not reallocate rbuf!\n");
+            MPI_Abort(comm, 1);
         }
-      }
-
-      MPI_Alltoallw( MPI_IN_PLACE, NULL, NULL, NULL,
-                     rbuf, recvcounts, rdispls, recvtypes, comm );
-
-      /* Check rbuf */
-      for (i=0; i<size; i++) {
-        p = rbuf + (rdispls[i] / sizeof(int));
-        for (j=0; j<recvcounts[i]; j++) {
-          int expected = 100 * i + 10 * rank + j;
-          if (p[j] != expected) {
-            fprintf(stderr, "[%d] got %d expected %d for block=%d, element=%dth\n",
-                    rank, p[j], expected, i, j);
-            ++err;
-          }
+
+        /* Load up the buffers */
+        for (i = 0; i < size; i++) {
+            /* alltoallw displs are in bytes, not in type extents */
+            rdispls[i] = i * (2 * size) * sizeof(int);
+            recvtypes[i] = MPI_INT;
+            recvcounts[i] = i + rank;
+        }
+        memset(rbuf, -1, size * (2 * size) * sizeof(int));
+        for (i = 0; i < size; i++) {
+            p = rbuf + (rdispls[i] / sizeof(int));
+            for (j = 0; j < recvcounts[i]; ++j) {
+                p[j] = 100 * rank + 10 * i + j;
+            }
         }
-      }
 
-      MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
-      if (MPI_SUCCESS == MPI_Alltoallw(rbuf, recvcounts, rdispls, recvtypes,
-                                       rbuf, recvcounts, rdispls, recvtypes, comm))
-          err++;
+        MPI_Alltoallw(MPI_IN_PLACE, NULL, NULL, NULL, rbuf, recvcounts, rdispls, recvtypes, comm);
+
+        /* Check rbuf */
+        for (i = 0; i < size; i++) {
+            p = rbuf + (rdispls[i] / sizeof(int));
+            for (j = 0; j < recvcounts[i]; j++) {
+                int expected = 100 * i + 10 * rank + j;
+                if (p[j] != expected) {
+                    fprintf(stderr, "[%d] got %d expected %d for block=%d, element=%dth\n",
+                            rank, p[j], expected, i, j);
+                    ++err;
+                }
+            }
+        }
 #endif
 
-      free(recvtypes);
-      free(rdispls);
-      free(recvcounts);
-      free(rbuf);
-      MTestFreeComm( &comm );
+        free(recvtypes);
+        free(rdispls);
+        free(recvcounts);
+        free(rbuf);
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( err );
+    MTest_Finalize(err);
     MPI_Finalize();
     return 0;
 }
index 65e5c9d..632b053 100644 (file)
@@ -46,10 +46,7 @@ int main(int argc, char *argv[])
     recvcounts = malloc(size * sizeof(int));
     sdispls = malloc(size * sizeof(int));
     rdispls = malloc(size * sizeof(int));
-    if (!sendtypes  || !recvtypes ||
-        !sendcounts || !recvcounts ||
-        !sdispls    || !rdispls)
-    {
+    if (!sendtypes || !recvtypes || !sendcounts || !recvcounts || !sdispls || !rdispls) {
         printf("error, unable to allocate memory\n");
         goto fn_exit;
     }
@@ -69,26 +66,34 @@ int main(int argc, char *argv[])
 
 
     /* try zero-counts on both the send and recv side in case only one direction is broken for some reason */
-    MPI_Alltoallw(&sendbuf, sendcounts, sdispls, sendtypes, &recvbuf, recvcounts, rdispls, recvtypes, MPI_COMM_WORLD);
-    MPI_Alltoallw(&sendbuf, recvcounts, rdispls, recvtypes, &recvbuf, sendcounts, sdispls, sendtypes, MPI_COMM_WORLD);
+    MPI_Alltoallw(&sendbuf, sendcounts, sdispls, sendtypes, &recvbuf, recvcounts, rdispls,
+                  recvtypes, MPI_COMM_WORLD);
+    MPI_Alltoallw(&sendbuf, recvcounts, rdispls, recvtypes, &recvbuf, sendcounts, sdispls,
+                  sendtypes, MPI_COMM_WORLD);
 
 #if MTEST_HAVE_MIN_MPI_VERSION(2,2)
     /* pass MPI_IN_PLACE and different but compatible types rank is even/odd */
     if (rank % 2)
-        MPI_Alltoallw(MPI_IN_PLACE, NULL, NULL, NULL, &recvbuf, recvcounts, rdispls, recvtypes, MPI_COMM_WORLD);
+        MPI_Alltoallw(MPI_IN_PLACE, NULL, NULL, NULL, &recvbuf, recvcounts, rdispls, recvtypes,
+                      MPI_COMM_WORLD);
     else
-        MPI_Alltoallw(MPI_IN_PLACE, NULL, NULL, NULL, &recvbuf, sendcounts, sdispls, sendtypes, MPI_COMM_WORLD);
+        MPI_Alltoallw(MPI_IN_PLACE, NULL, NULL, NULL, &recvbuf, sendcounts, sdispls, sendtypes,
+                      MPI_COMM_WORLD);
 #endif
 
     /* now the same for Alltoallv instead of Alltoallw */
-    MPI_Alltoallv(&sendbuf, sendcounts, sdispls, sendtypes[0], &recvbuf, recvcounts, rdispls, recvtypes[0], MPI_COMM_WORLD);
-    MPI_Alltoallv(&sendbuf, recvcounts, rdispls, recvtypes[0], &recvbuf, sendcounts, sdispls, sendtypes[0], MPI_COMM_WORLD);
+    MPI_Alltoallv(&sendbuf, sendcounts, sdispls, sendtypes[0], &recvbuf, recvcounts, rdispls,
+                  recvtypes[0], MPI_COMM_WORLD);
+    MPI_Alltoallv(&sendbuf, recvcounts, rdispls, recvtypes[0], &recvbuf, sendcounts, sdispls,
+                  sendtypes[0], MPI_COMM_WORLD);
 
 #if MTEST_HAVE_MIN_MPI_VERSION(2,2)
     if (rank % 2)
-        MPI_Alltoallv(MPI_IN_PLACE, NULL, NULL, MPI_DATATYPE_NULL, &recvbuf, recvcounts, rdispls, recvtypes[0], MPI_COMM_WORLD);
+        MPI_Alltoallv(MPI_IN_PLACE, NULL, NULL, MPI_DATATYPE_NULL, &recvbuf, recvcounts, rdispls,
+                      recvtypes[0], MPI_COMM_WORLD);
     else
-        MPI_Alltoallv(MPI_IN_PLACE, NULL, NULL, MPI_DATATYPE_NULL, &recvbuf, sendcounts, sdispls, sendtypes[0], MPI_COMM_WORLD);
+        MPI_Alltoallv(MPI_IN_PLACE, NULL, NULL, MPI_DATATYPE_NULL, &recvbuf, sendcounts, sdispls,
+                      sendtypes[0], MPI_COMM_WORLD);
 #endif
 
     MPI_Type_free(&sendtype);
@@ -96,16 +101,21 @@ int main(int argc, char *argv[])
     if (rank == 0)
         printf(" No Errors\n");
 
-fn_exit:
-    if (rdispls)    free(rdispls);
-    if (sdispls)    free(sdispls);
-    if (recvcounts) free(recvcounts);
-    if (sendcounts) free(sendcounts);
-    if (recvtypes)  free(recvtypes);
-    if (sendtypes)  free(sendtypes);
+  fn_exit:
+    if (rdispls)
+        free(rdispls);
+    if (sdispls)
+        free(sdispls);
+    if (recvcounts)
+        free(recvcounts);
+    if (sendcounts)
+        free(sendcounts);
+    if (recvtypes)
+        free(recvtypes);
+    if (sendtypes)
+        free(sendtypes);
 
     MPI_Finalize();
 
     return 0;
 }
-
diff --git a/teshsuite/smpi/mpich3-test/coll/bcast.c b/teshsuite/smpi/mpich3-test/coll/bcast.c
new file mode 100644 (file)
index 0000000..f465d01
--- /dev/null
@@ -0,0 +1,93 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *
+ *  (C) 2003 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+#include "mpi.h"
+#include <stdio.h>
+#include "mpitest.h"
+
+/*
+static char MTEST_Descrip[] = "Test of broadcast with various roots and datatypes";
+*/
+
+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;
+
+#if defined BCAST_COMM_WORLD_ONLY
+        if (comm != MPI_COMM_WORLD) {
+            MTestFreeComm(&comm);
+            continue;
+        }
+#endif /* BCAST_COMM_WORLD_ONLY */
+
+        /* 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);
+
+        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 defined BCAST_MIN_DATATYPES_ONLY
+            MTestInitMinDatatypes();
+#endif /* BCAST_MIN_DATATYPES_ONLY */
+
+            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;
+}
diff --git a/teshsuite/smpi/mpich3-test/coll/bcast2.c b/teshsuite/smpi/mpich3-test/coll/bcast2.c
deleted file mode 100644 (file)
index 91c8878..0000000
+++ /dev/null
@@ -1,81 +0,0 @@
-/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
-/*
- *
- *  (C) 2003 by Argonne National Laboratory.
- *      See COPYRIGHT in top-level directory.
- */
-#include "mpi.h"
-#include <stdio.h>
-#include "mpitest.h"
-
-/*
-static char MTEST_Descrip[] = "Test of broadcast with various roots and datatypes";
-*/
-
-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;
-}
diff --git a/teshsuite/smpi/mpich3-test/coll/bcast3.c b/teshsuite/smpi/mpich3-test/coll/bcast3.c
deleted file mode 100644 (file)
index 3f88c1d..0000000
+++ /dev/null
@@ -1,77 +0,0 @@
-/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
-/*
- *
- *  (C) 2003 by Argonne National Laboratory.
- *      See COPYRIGHT in top-level directory.
- */
-#include "mpi.h"
-#include <stdio.h>
-#include "mpitest.h"
-
-/*
-static char MTEST_Descrip[] = "Test of broadcast with various roots and datatypes and sizes that are not powers of two";
-*/
-
-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;
-       /* This must be very large to ensure that we reach the long message
-          algorithms */
-       for (count = 4; count < 6600; count = count * 4) {
-           while (MTestGetDatatypes( &sendtype, &recvtype, count-1 )) {
-               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;
-}
index d7d9cda..c3d080a 100644 (file)
 #define NUM_REPS  5
 #define NUM_SIZES 4
 
-int main( int argc, char **argv)
+int main(int argc, char **argv)
 {
     int *buf;
     int i, rank, reps, n;
     int bVerify = 1;
-    int sizes[NUM_SIZES] = { 100, 64*1024, 128*1024, 1024*1024 };
-    int num_errors=0;
-    
-    MTest_Init( &argc, &argv );
+    int sizes[NUM_SIZES] = { 100, 64 * 1024, 128 * 1024, 1024 * 1024 };
+    int num_errors = 0;
+
+    MTest_Init(&argc, &argv);
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
-    if (argc > 1)
-    {
-       if (strcmp(argv[1], "-novalidate") == 0 || strcmp(argv[1], "-noverify") == 0)
-           bVerify = 0;
+    if (argc > 1) {
+        if (strcmp(argv[1], "-novalidate") == 0 || strcmp(argv[1], "-noverify") == 0)
+            bVerify = 0;
     }
 
-    buf = (int *) malloc(sizes[NUM_SIZES-1]*sizeof(int));
-    memset(buf, 0, sizes[NUM_SIZES-1]*sizeof(int));
+    buf = (int *) malloc(sizes[NUM_SIZES - 1] * sizeof(int));
+    memset(buf, 0, sizes[NUM_SIZES - 1] * sizeof(int));
 
-    for (n=0; n<NUM_SIZES; n++)
-    {
+    for (n = 0; n < NUM_SIZES; n++) {
 #ifdef DEBUG
-       if (rank == ROOT)
-       {
-           printf("bcasting %d MPI_INTs %d times\n", sizes[n], NUM_REPS);
-           fflush(stdout);
-       }
+        if (rank == ROOT) {
+            printf("bcasting %d MPI_INTs %d times\n", sizes[n], NUM_REPS);
+            fflush(stdout);
+        }
 #endif
-       for (reps=0; reps < NUM_REPS; reps++)
-       {
-           if (bVerify)
-           {
-                if (rank == ROOT)
-                {
-                   for (i=0; i<sizes[n]; i++)
-                   {
-                       buf[i] = 1000000 * (n * NUM_REPS + reps) + i;
-                   }
-               }
-               else
-                {
-                   for (i=0; i<sizes[n]; i++)
-                   {
+        for (reps = 0; reps < NUM_REPS; reps++) {
+            if (bVerify) {
+                if (rank == ROOT) {
+                    for (i = 0; i < sizes[n]; i++) {
+                        buf[i] = 1000000 * (n * NUM_REPS + reps) + i;
+                    }
+                }
+                else {
+                    for (i = 0; i < sizes[n]; i++) {
                         buf[i] = -1 - (n * NUM_REPS + reps);
-                   }
-               }
-           }
+                    }
+                }
+            }
 
 #          ifdef DEBUG
-           {
-               printf("rank=%d, n=%d, reps=%d\n", rank, n, reps);
-           }
+            {
+                printf("rank=%d, n=%d, reps=%d\n", rank, n, reps);
+            }
 #           endif
-           
-           MPI_Bcast(buf, sizes[n], MPI_INT, ROOT, MPI_COMM_WORLD);
 
-           if (bVerify)
-           {
-               num_errors = 0;
-               for (i=0; i<sizes[n]; i++)
-               {
-                   if (buf[i] != 1000000 * (n * NUM_REPS + reps) + i)
-                   {
-                       num_errors++;
-                       if (num_errors < 10)
-                       {
-                           printf("Error: Rank=%d, n=%d, reps=%d, i=%d, buf[i]=%d expected=%d\n", rank, n, reps, i, buf[i],
-                                  1000000 * (n * NUM_REPS + reps) +i);
-                           fflush(stdout);
-                       }
-                   }
-               }
-               if (num_errors >= 10)
-               {
-                   printf("Error: Rank=%d, num_errors = %d\n", rank, num_errors);
-                   fflush(stdout);
-               }
-           }
-       }
+            MPI_Bcast(buf, sizes[n], MPI_INT, ROOT, MPI_COMM_WORLD);
+
+            if (bVerify) {
+                num_errors = 0;
+                for (i = 0; i < sizes[n]; i++) {
+                    if (buf[i] != 1000000 * (n * NUM_REPS + reps) + i) {
+                        num_errors++;
+                        if (num_errors < 10) {
+                            printf("Error: Rank=%d, n=%d, reps=%d, i=%d, buf[i]=%d expected=%d\n",
+                                   rank, n, reps, i, buf[i], 1000000 * (n * NUM_REPS + reps) + i);
+                            fflush(stdout);
+                        }
+                    }
+                }
+                if (num_errors >= 10) {
+                    printf("Error: Rank=%d, num_errors = %d\n", rank, num_errors);
+                    fflush(stdout);
+                }
+            }
+        }
     }
-    
+
     free(buf);
 
-    MTest_Finalize( num_errors );
+    MTest_Finalize(num_errors);
     MPI_Finalize();
     return 0;
 }
index 1666478..d6716d4 100644 (file)
@@ -26,8 +26,8 @@ int main(int argc, char *argv[])
 
     /* a random non-zero sized buffer */
 #define NELEM (10)
-    buf = malloc(NELEM*sizeof(int));
-    assert(buf!=NULL);
+    buf = malloc(NELEM * sizeof(int));
+    assert(buf);
 
     for (i = 0; i < NELEM; i++) {
         buf[i] = wrank * NELEM + i;
@@ -47,6 +47,8 @@ int main(int argc, char *argv[])
         assert(buf[i] == wrank * NELEM + i);
     }
 
+    free(buf);
+
     MPI_Type_free(&type);
     MPI_Finalize();
 
index e93abed..e2a424a 100644 (file)
@@ -9,53 +9,53 @@
 
 #define BAD_ANSWER 100000
 
-int assoc ( int *, int *, int *, MPI_Datatype * );
+int assoc(int *, int *, int *, MPI_Datatype *);
 
 /*
-    The operation is inoutvec[i] = invec[i] op inoutvec[i] 
+    The operation is inoutvec[i] = invec[i] op inoutvec[i]
     (see 4.9.4).  The order is important.
 
     Note that the computation is in process rank (in the communicator)
     order, independant of the root.
  */
-int assoc(int *invec, int *inoutvec, int *len, MPI_Datatype *dtype)
+int assoc(int *invec, int *inoutvec, int *len, MPI_Datatype * dtype)
 {
-  int i;
-  for ( i=0; i<*len; i++ )  {
-    if (inoutvec[i] <= invec[i] ) {
-      int rank;
-      MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-      fprintf( stderr, "[%d] inout[0] = %d, in[0] = %d\n", 
-              rank, inoutvec[0], invec[0] );
-      inoutvec[i] = BAD_ANSWER;
-      }
-    else 
-      inoutvec[i] = invec[i];
-  }
-  return (1);
+    int i;
+    for (i = 0; i < *len; i++) {
+        if (inoutvec[i] <= invec[i]) {
+            int rank;
+            MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+            fprintf(stderr, "[%d] inout[0] = %d, in[0] = %d\n", rank, inoutvec[0], invec[0]);
+            inoutvec[i] = BAD_ANSWER;
+        }
+        else
+            inoutvec[i] = invec[i];
+    }
+    return (1);
 }
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    int              rank, size;
-    int              data;
-    int              errors=0;
-    int              result = -100;
-    MPI_Op           op;
+    int rank, size;
+    int data;
+    int errors = 0;
+    int result = -100;
+    MPI_Op op;
 
-    MTest_Init( &argc, &argv );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
     data = rank;
 
-    MPI_Op_create( (MPI_User_function*)assoc, 0, &op );
-    MPI_Reduce ( &data, &result, 1, MPI_INT, op, size-1, MPI_COMM_WORLD );
-    MPI_Bcast  ( &result, 1, MPI_INT, size-1, MPI_COMM_WORLD );
-    MPI_Op_free( &op );
-    if (result == BAD_ANSWER) errors++;
+    MPI_Op_create((MPI_User_function *) assoc, 0, &op);
+    MPI_Reduce(&data, &result, 1, MPI_INT, op, size - 1, MPI_COMM_WORLD);
+    MPI_Bcast(&result, 1, MPI_INT, size - 1, MPI_COMM_WORLD);
+    MPI_Op_free(&op);
+    if (result == BAD_ANSWER)
+        errors++;
 
-    MTest_Finalize( errors );
+    MTest_Finalize(errors);
     MPI_Finalize();
-    return MTestReturnValue( errors );
+    return MTestReturnValue(errors);
 }
index 9b5ddda..b79482e 100644 (file)
 #include <stdio.h>
 #include "mpitest.h"
 
-void addem ( int *, int *, int *, MPI_Datatype * );
-void assoc ( int *, int *, int *, MPI_Datatype * );
+void addem(int *, int *, int *, MPI_Datatype *);
+void assoc(int *, int *, int *, MPI_Datatype *);
 
-void addem(int *invec, int *inoutvec, int *len, MPI_Datatype *dtype)
+void addem(int *invec, int *inoutvec, int *len, MPI_Datatype * dtype)
 {
-  int i;
-  for ( i=0; i<*len; i++ ) 
-    inoutvec[i] += invec[i];
+    int i;
+    for (i = 0; i < *len; i++)
+        inoutvec[i] += invec[i];
 }
 
 #define BAD_ANSWER 100000
 
 /*
-    The operation is inoutvec[i] = invec[i] op inoutvec[i] 
+    The operation is inoutvec[i] = invec[i] op inoutvec[i]
     (see 4.9.4).  The order is important.
 
     Note that the computation is in process rank (in the communicator)
     order, independant of the root.
  */
-void assoc(int *invec, int *inoutvec, int *len, MPI_Datatype *dtype)
+void assoc(int *invec, int *inoutvec, int *len, MPI_Datatype * dtype)
 {
-  int i;
-  for ( i=0; i<*len; i++ )  {
-    if (inoutvec[i] <= invec[i] ) {
-      int rank;
-      MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-      fprintf( stderr, "[%d] inout[0] = %d, in[0] = %d\n", 
-             rank, inoutvec[0], invec[0] );
-      inoutvec[i] = BAD_ANSWER;
-      }
-    else 
-      inoutvec[i] = invec[i];
-  }
+    int i;
+    for (i = 0; i < *len; i++) {
+        if (inoutvec[i] <= invec[i]) {
+            int rank;
+            MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+            fprintf(stderr, "[%d] inout[0] = %d, in[0] = %d\n", rank, inoutvec[0], invec[0]);
+            inoutvec[i] = BAD_ANSWER;
+        }
+        else
+            inoutvec[i] = invec[i];
+    }
 }
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    int              rank, size, i;
-    int              data;
-    int              errors=0;
-    int              result = -100;
-    int              correct_result;
-    MPI_Op           op_assoc, op_addem;
+    int rank, size, i;
+    int data;
+    int errors = 0;
+    int result = -100;
+    int correct_result;
+    MPI_Op op_assoc, op_addem;
 
-    MTest_Init( &argc, &argv );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
     data = rank;
 
     correct_result = 0;
-    for (i=0;i<=rank;i++)
-      correct_result += i;
+    for (i = 0; i <= rank; i++)
+        correct_result += i;
 
-    MPI_Scan ( &data, &result, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD );
+    MPI_Scan(&data, &result, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
     if (result != correct_result) {
-       fprintf( stderr, "[%d] Error suming ints with scan\n", rank );
-       errors++;
-       }
+        fprintf(stderr, "[%d] Error suming ints with scan\n", rank);
+        errors++;
+    }
 
-    MPI_Scan ( &data, &result, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD );
+    MPI_Scan(&data, &result, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
     if (result != correct_result) {
-       fprintf( stderr, "[%d] Error summing ints with scan (2)\n", rank );
-       errors++;
-       }
+        fprintf(stderr, "[%d] Error summing ints with scan (2)\n", rank);
+        errors++;
+    }
 
     data = rank;
     result = -100;
-    MPI_Op_create( (MPI_User_function *)assoc, 0, &op_assoc );
-    MPI_Op_create( (MPI_User_function *)addem, 1, &op_addem );
-    MPI_Scan ( &data, &result, 1, MPI_INT, op_addem, MPI_COMM_WORLD );
+    MPI_Op_create((MPI_User_function *) assoc, 0, &op_assoc);
+    MPI_Op_create((MPI_User_function *) addem, 1, &op_addem);
+    MPI_Scan(&data, &result, 1, MPI_INT, op_addem, MPI_COMM_WORLD);
     if (result != correct_result) {
-       fprintf( stderr, "[%d] Error summing ints with scan (userop)\n", 
-                rank );
-       errors++;
-       }
+        fprintf(stderr, "[%d] Error summing ints with scan (userop)\n", rank);
+        errors++;
+    }
 
-    MPI_Scan ( &data, &result, 1, MPI_INT, op_addem, MPI_COMM_WORLD );
+    MPI_Scan(&data, &result, 1, MPI_INT, op_addem, MPI_COMM_WORLD);
     if (result != correct_result) {
-       fprintf( stderr, "[%d] Error summing ints with scan (userop2)\n", 
-                rank );
-       errors++;
-       }
+        fprintf(stderr, "[%d] Error summing ints with scan (userop2)\n", rank);
+        errors++;
+    }
     result = -100;
     data = rank;
-    MPI_Scan ( &data, &result, 1, MPI_INT, op_assoc, MPI_COMM_WORLD );
+    MPI_Scan(&data, &result, 1, MPI_INT, op_assoc, MPI_COMM_WORLD);
     if (result == BAD_ANSWER) {
-       fprintf( stderr, "[%d] Error scanning with non-commutative op\n",
-                rank );
-       errors++;
-       }
+        fprintf(stderr, "[%d] Error scanning with non-commutative op\n", rank);
+        errors++;
+    }
 
-    MPI_Op_free( &op_assoc );
-    MPI_Op_free( &op_addem );
+    MPI_Op_free(&op_assoc);
+    MPI_Op_free(&op_addem);
 
-    MTest_Finalize( errors );
+    MTest_Finalize(errors);
     MPI_Finalize();
-    return MTestReturnValue( errors );
+    return MTestReturnValue(errors);
 }
index d493a59..63bd989 100644 (file)
 
 #define TABLE_SIZE 2
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-  int    rank, size;
-  double a[TABLE_SIZE];
-  struct { double a; int b; } in[TABLE_SIZE], out[TABLE_SIZE];
-  int    i;
-  int    errors = 0;
+    int rank, size;
+    double a[TABLE_SIZE];
+    struct {
+        double a;
+        int b;
+    } in[TABLE_SIZE], out[TABLE_SIZE];
+    int i;
+    int errors = 0, toterrors;
 
-  /* Initialize the environment and some variables */
-  MTest_Init( &argc, &argv );
-  MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-  MPI_Comm_size( MPI_COMM_WORLD, &size );
+    /* Initialize the environment and some variables */
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
-  /* Initialize the maxloc data */
-  for ( i=0; i<TABLE_SIZE; i++ ) a[i] = 0;
-  for ( i=rank; i<TABLE_SIZE; i++ ) a[i] = (double)rank + 1.0;
+    /* Initialize the maxloc data */
+    for (i = 0; i < TABLE_SIZE; i++)
+        a[i] = 0;
+    for (i = rank; i < TABLE_SIZE; i++)
+        a[i] = (double) rank + 1.0;
 
-  /* Copy data to the "in" buffer */
-  for (i=0; i<TABLE_SIZE; i++) { 
-       in[i].a = a[i];
-       in[i].b = rank;
-  }
+    /* Copy data to the "in" buffer */
+    for (i = 0; i < TABLE_SIZE; i++) {
+        in[i].a = a[i];
+        in[i].b = rank;
+    }
 
-  /* Reduce it! */
-  MPI_Reduce( in, out, TABLE_SIZE, MPI_DOUBLE_INT, MPI_MAXLOC, 0, MPI_COMM_WORLD );
-  MPI_Bcast ( out, TABLE_SIZE, MPI_DOUBLE_INT, 0, MPI_COMM_WORLD );
+    /* Reduce it! */
+    MPI_Reduce(in, out, TABLE_SIZE, MPI_DOUBLE_INT, MPI_MAXLOC, 0, MPI_COMM_WORLD);
+    MPI_Bcast(out, TABLE_SIZE, MPI_DOUBLE_INT, 0, MPI_COMM_WORLD);
 
-  /* Check to see that we got the right answers */
-  for (i=0; i<TABLE_SIZE; i++) 
-       if (i % size == rank)
-         if (out[i].b != rank) {
-        printf("MAX (ranks[%d] = %d != %d\n", i, out[i].b, rank );
-               errors++;
-      }
+    /* Check to see that we got the right answers */
+    for (i = 0; i < TABLE_SIZE; i++)
+        if (i % size == rank)
+            if (out[i].b != rank) {
+                printf("MAX (ranks[%d] = %d != %d\n", i, out[i].b, rank);
+                errors++;
+            }
 
-  /* Initialize the minloc data */
-  for ( i=0; i<TABLE_SIZE; i++ ) a[i] = 0;
-  for ( i=rank; i<TABLE_SIZE; i++ ) a[i] = -(double)rank - 1.0;
+    /* Initialize the minloc data */
+    for (i = 0; i < TABLE_SIZE; i++)
+        a[i] = 0;
+    for (i = rank; i < TABLE_SIZE; i++)
+        a[i] = -(double) rank - 1.0;
 
-  /* Copy data to the "in" buffer */
-  for (i=0; i<TABLE_SIZE; i++)  {
-       in[i].a = a[i];
-       in[i].b = rank;
-  }
+    /* Copy data to the "in" buffer */
+    for (i = 0; i < TABLE_SIZE; i++) {
+        in[i].a = a[i];
+        in[i].b = rank;
+    }
 
-  /* Reduce it! */
-  MPI_Allreduce( in, out, TABLE_SIZE, MPI_DOUBLE_INT, MPI_MINLOC, MPI_COMM_WORLD );
+    /* Reduce it! */
+    MPI_Allreduce(in, out, TABLE_SIZE, MPI_DOUBLE_INT, MPI_MINLOC, MPI_COMM_WORLD);
 
-  /* Check to see that we got the right answers */
-  for (i=0; i<TABLE_SIZE; i++) 
-       if (i % size == rank)
-         if (out[i].b != rank) {
-        printf("MIN (ranks[%d] = %d != %d\n", i, out[i].b, rank );
-               errors++;
-      }
+    /* Check to see that we got the right answers */
+    for (i = 0; i < TABLE_SIZE; i++)
+        if (i % size == rank)
+            if (out[i].b != rank) {
+                printf("MIN (ranks[%d] = %d != %d\n", i, out[i].b, rank);
+                errors++;
+            }
 
-  /* Finish up! */
-  MTest_Finalize( errors );
-  MPI_Finalize();
-  return MTestReturnValue( errors );
+    /* Finish up! */
+    MTest_Finalize(errors);
+    MPI_Finalize();
+    return MTestReturnValue(errors);
 }
index 6c07269..80c9bfa 100644 (file)
@@ -6,7 +6,7 @@
  */
 #include "mpi.h"
 
-/* 
+/*
 From: hook@nas.nasa.gov (Edward C. Hook)
  */
 
@@ -21,68 +21,62 @@ From: hook@nas.nasa.gov (Edward C. Hook)
 #define EXIT_FAILURE 1
 #endif
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int rank, size;
     int chunk = 128;
     int i;
     int *sb;
     int *rb;
-    int status;
+    int status, gstatus;
 
-    MTest_Init(&argc,&argv);
-    MPI_Comm_rank(MPI_COMM_WORLD,&rank);
-    MPI_Comm_size(MPI_COMM_WORLD,&size);
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
-    for ( i=1 ; i < argc ; ++i ) {
-       if ( argv[i][0] != '-' )
-           continue;
-       switch(argv[i][1]) {
-       case 'm':
-           chunk = atoi(argv[++i]);
-           break;
-       default:
-           fprintf(stderr,"Unrecognized argument %s\n",
-                   argv[i]);
-           MPI_Abort(MPI_COMM_WORLD,EXIT_FAILURE);
-            exit(EXIT_FAILURE);
-       }
+    for (i = 1; i < argc; ++i) {
+        if (argv[i][0] != '-')
+            continue;
+        switch (argv[i][1]) {
+        case 'm':
+            chunk = atoi(argv[++i]);
+            break;
+        default:
+            fprintf(stderr, "Unrecognized argument %s\n", argv[i]);
+            MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
+        }
     }
 
-    sb = (int *)malloc(size*chunk*sizeof(int));
-    if ( !sb ) {
-       perror( "can't allocate send buffer" );
-       MPI_Abort(MPI_COMM_WORLD,EXIT_FAILURE);
-        exit(EXIT_FAILURE);
+    sb = (int *) malloc(size * chunk * sizeof(int));
+    if (!sb) {
+        perror("can't allocate send buffer");
+        MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
     }
-    rb = (int *)malloc(size*chunk*sizeof(int));
-    if ( !rb ) {
-       perror( "can't allocate recv buffer");
-       free(sb);
-       MPI_Abort(MPI_COMM_WORLD,EXIT_FAILURE);
-        exit(EXIT_FAILURE);
+    rb = (int *) malloc(size * chunk * sizeof(int));
+    if (!rb) {
+        perror("can't allocate recv buffer");
+        free(sb);
+        MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
     }
-    for ( i=0 ; i < size*chunk ; ++i ) {
-       sb[i] = rank + 1;
-       rb[i] = 0;
+    for (i = 0; i < size * chunk; ++i) {
+        sb[i] = rank + 1;
+        rb[i] = 0;
     }
 
     /* fputs("Before MPI_Alltoall\n",stdout); */
 
     /* This should really send MPI_CHAR, but since sb and rb were allocated
-       as chunk*size*sizeof(int), the buffers are large enough */
-    status = MPI_Alltoall(sb,chunk,MPI_INT,rb,chunk,MPI_INT,
-                         MPI_COMM_WORLD);
+     * as chunk*size*sizeof(int), the buffers are large enough */
+    status = MPI_Alltoall(sb, chunk, MPI_INT, rb, chunk, MPI_INT, MPI_COMM_WORLD);
 
     /* fputs("Before MPI_Allreduce\n",stdout); */
 
-    MTest_Finalize( status );
+    MTest_Finalize(status);
 
     free(sb);
     free(rb);
 
     MPI_Finalize();
 
-    return MTestReturnValue( status );
+    return MTestReturnValue(status);
 }
-
index 008aa71..1cd4ba1 100644 (file)
@@ -6,63 +6,63 @@
 #include "mpi.h"
 #include <stdio.h>
 #include "mpitest.h"
+#include "mpicolltest.h"
 
 #define MAX_PROCESSES 10
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    int              rank, size, i,j;
-    int              table[MAX_PROCESSES][MAX_PROCESSES];
-    int              errors=0;
-    int              participants;
+    int rank, size, i, j;
+    int table[MAX_PROCESSES][MAX_PROCESSES];
+    int errors = 0;
+    int participants;
 
-    MTest_Init( &argc, &argv );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
     /* A maximum of MAX_PROCESSES processes can participate */
-    if ( size > MAX_PROCESSES ) participants = MAX_PROCESSES;
-    else              participants = size;
+    if (size > MAX_PROCESSES)
+        participants = MAX_PROCESSES;
+    else
+        participants = size;
 
     if (MAX_PROCESSES % participants) {
-       fprintf( stderr, "Number of processors must divide %d\n",
-               MAX_PROCESSES );
-       MPI_Abort( MPI_COMM_WORLD, 1 );
-        exit(1);
-       }
-    if ( (rank < participants) ) {
+        fprintf(stderr, "Number of processors must divide %d\n", MAX_PROCESSES);
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
+    if ((rank < participants)) {
 
-      /* Determine what rows are my responsibility */
-      int block_size = MAX_PROCESSES / participants;
-      int begin_row  = rank * block_size;
-      int end_row    = (rank+1) * block_size;
-      int send_count = block_size * MAX_PROCESSES;
-      int recv_count = send_count;
+        /* Determine what rows are my responsibility */
+        int block_size = MAX_PROCESSES / participants;
+        int begin_row = rank * block_size;
+        int end_row = (rank + 1) * block_size;
+        int send_count = block_size * MAX_PROCESSES;
+        int recv_count = send_count;
 
-      /* Paint my rows my color */
-      for (i=begin_row; i<end_row ;i++)
-       for (j=0; j<MAX_PROCESSES; j++)
-         table[i][j] = rank + 10;
+        /* Paint my rows my color */
+        for (i = begin_row; i < end_row; i++)
+            for (j = 0; j < MAX_PROCESSES; j++)
+                table[i][j] = rank + 10;
 
-      /* Gather everybody's result together - sort of like an */
-      /* inefficient allgather */
-      for (i=0; i<participants; i++) {
-        void *sendbuf = (i == rank ? MPI_IN_PLACE : &table[begin_row][0]);
-       MPI_Gather(sendbuf,              send_count, MPI_INT,
-                  &table[0][0],         recv_count, MPI_INT, i, 
-                  MPI_COMM_WORLD );
-      }
+        /* Gather everybody's result together - sort of like an */
+        /* inefficient allgather */
+        for (i = 0; i < participants; i++) {
+            void *sendbuf = (i == rank ? MPI_IN_PLACE : &table[begin_row][0]);
+            MTest_Gather(sendbuf, send_count, MPI_INT,
+                         &table[0][0], recv_count, MPI_INT, i, MPI_COMM_WORLD);
+        }
 
-      /* Everybody should have the same table now,  */
-      /* This test does not in any way guarantee there are no errors */
-      /* Print out a table or devise a smart test to make sure it's correct */
-      for (i=0; i<MAX_PROCESSES;i++) {
-       if ( (table[i][0] - table[i][MAX_PROCESSES-1] !=0) ) 
-         errors++;
-      }
-    } 
+        /* Everybody should have the same table now,  */
+        /* This test does not in any way guarantee there are no errors */
+        /* Print out a table or devise a smart test to make sure it's correct */
+        for (i = 0; i < MAX_PROCESSES; i++) {
+            if ((table[i][0] - table[i][MAX_PROCESSES - 1] != 0))
+                errors++;
+        }
+    }
 
-    MTest_Finalize( errors );
+    MTest_Finalize(errors);
     MPI_Finalize();
-    return MTestReturnValue( errors );
+    return MTestReturnValue(errors);
 }
index 8fa5cdf..e1a1fbe 100644 (file)
@@ -9,83 +9,83 @@
 
 #define MAX_PROCESSES 10
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    int              rank, size, i,j;
-    int              table[MAX_PROCESSES][MAX_PROCESSES];
-    int              errors=0;
-    int              participants;
-    int              displs[MAX_PROCESSES];
-    int              recv_counts[MAX_PROCESSES];
+    int rank, size, i, j;
+    int table[MAX_PROCESSES][MAX_PROCESSES];
+    int errors = 0;
+    int participants;
+    int displs[MAX_PROCESSES];
+    int recv_counts[MAX_PROCESSES];
 
-    MTest_Init( &argc, &argv );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
     /* A maximum of MAX_PROCESSES processes can participate */
-    if ( size > MAX_PROCESSES ) participants = MAX_PROCESSES;
-    else              participants = size;
+    if (size > MAX_PROCESSES)
+        participants = MAX_PROCESSES;
+    else
+        participants = size;
     /* while (MAX_PROCESSES % participants) participants--; */
     if (MAX_PROCESSES % participants) {
-       fprintf( stderr, "Number of processors must divide %d\n",
-               MAX_PROCESSES );
-       MPI_Abort( MPI_COMM_WORLD, 1 );
-        exit(1);
-       }
-    if ( (rank < participants) ) {
+        fprintf(stderr, "Number of processors must divide %d\n", MAX_PROCESSES);
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
+    if ((rank < participants)) {
 
-      /* Determine what rows are my responsibility */
-      int block_size = MAX_PROCESSES / participants;
-      int begin_row  = rank * block_size;
-      int end_row    = (rank+1) * block_size;
-      int send_count = block_size * MAX_PROCESSES;
-      
-      /* Fill in the displacements and recv_counts */
-      for (i=0; i<participants; i++) {
-       displs[i]      = i * block_size * MAX_PROCESSES;
-       recv_counts[i] = send_count;
-      }
+        /* Determine what rows are my responsibility */
+        int block_size = MAX_PROCESSES / participants;
+        int begin_row = rank * block_size;
+        int end_row = (rank + 1) * block_size;
+        int send_count = block_size * MAX_PROCESSES;
 
-      /* Paint my rows my color */
-      for (i=begin_row; i<end_row ;i++)
-       for (j=0; j<MAX_PROCESSES; j++)
-         table[i][j] = rank + 10;
-      
-      /* Gather everybody's result together - sort of like an */
-      /* inefficient allgather */
-      for (i=0; i<participants; i++) {
-        void *sendbuf = (i == rank ? MPI_IN_PLACE : &table[begin_row][0]);
-        MPI_Gatherv(sendbuf,      send_count, MPI_INT,
-                   &table[0][0], recv_counts, displs, MPI_INT, 
-                   i, MPI_COMM_WORLD);
-      }
+        /* Fill in the displacements and recv_counts */
+        for (i = 0; i < participants; i++) {
+            displs[i] = i * block_size * MAX_PROCESSES;
+            recv_counts[i] = send_count;
+        }
 
+        /* Paint my rows my color */
+        for (i = begin_row; i < end_row; i++)
+            for (j = 0; j < MAX_PROCESSES; j++)
+                table[i][j] = rank + 10;
 
-      /* Everybody should have the same table now.
+        /* Gather everybody's result together - sort of like an */
+        /* inefficient allgather */
+        for (i = 0; i < participants; i++) {
+            void *sendbuf = (i == rank ? MPI_IN_PLACE : &table[begin_row][0]);
+            MPI_Gatherv(sendbuf, send_count, MPI_INT,
+                        &table[0][0], recv_counts, displs, MPI_INT, i, MPI_COMM_WORLD);
+        }
 
-        The entries are:
-        Table[i][j] = (i/block_size) + 10;
-       */
-      for (i=0; i<MAX_PROCESSES;i++) 
-       if ( (table[i][0] - table[i][MAX_PROCESSES-1] !=0) ) 
-         errors++;
-      for (i=0; i<MAX_PROCESSES;i++) {
-         for (j=0; j<MAX_PROCESSES;j++) {
-             if (table[i][j] != (i/block_size) + 10) errors++;
-             }
-         }
-      if (errors) {
-         /* Print out table if there are any errors */
-         for (i=0; i<MAX_PROCESSES;i++) {
-             printf("\n");
-             for (j=0; j<MAX_PROCESSES; j++)
-                 printf("  %d",table[i][j]);
-             }
-         printf("\n");
-         }
-    } 
 
-    MTest_Finalize( errors );
+        /* Everybody should have the same table now.
+         *
+         * The entries are:
+         * Table[i][j] = (i/block_size) + 10;
+         */
+        for (i = 0; i < MAX_PROCESSES; i++)
+            if ((table[i][0] - table[i][MAX_PROCESSES - 1] != 0))
+                errors++;
+        for (i = 0; i < MAX_PROCESSES; i++) {
+            for (j = 0; j < MAX_PROCESSES; j++) {
+                if (table[i][j] != (i / block_size) + 10)
+                    errors++;
+            }
+        }
+        if (errors) {
+            /* Print out table if there are any errors */
+            for (i = 0; i < MAX_PROCESSES; i++) {
+                printf("\n");
+                for (j = 0; j < MAX_PROCESSES; j++)
+                    printf("  %d", table[i][j]);
+            }
+            printf("\n");
+        }
+    }
+
+    MTest_Finalize(errors);
     MPI_Finalize();
-    return MTestReturnValue( errors );
+    return MTestReturnValue(errors);
 }
index cd39065..42afb47 100644 (file)
@@ -9,52 +9,52 @@
 
 #define MAX_PROCESSES 10
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    int              rank, size, i,j;
-    int              table[MAX_PROCESSES][MAX_PROCESSES];
-    int              row[MAX_PROCESSES];
-    int              errors=0;
-    int              participants;
-    MPI_Comm         comm;
+    int rank, size, i, j;
+    int table[MAX_PROCESSES][MAX_PROCESSES];
+    int row[MAX_PROCESSES];
+    int errors = 0;
+    int participants;
+    MPI_Comm comm;
 
-    MTest_Init( &argc, &argv );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
     comm = MPI_COMM_WORLD;
 
     /* A maximum of MAX_PROCESSES processes can participate */
-    if ( size > MAX_PROCESSES ) {
-       participants = MAX_PROCESSES;
-       MPI_Comm_split( MPI_COMM_WORLD, rank < MAX_PROCESSES, rank, &comm );
+    if (size > MAX_PROCESSES) {
+        participants = MAX_PROCESSES;
+        MPI_Comm_split(MPI_COMM_WORLD, rank < MAX_PROCESSES, rank, &comm);
     }
-    else  {
-       participants = size;
-       MPI_Comm_dup( MPI_COMM_WORLD, &comm );
+    else {
+        participants = size;
+        MPI_Comm_dup(MPI_COMM_WORLD, &comm);
     }
-    if ( (rank < participants) ) {
-       int send_count = MAX_PROCESSES;
-       int recv_count = MAX_PROCESSES;
-
-       /* If I'm the root (process 0), then fill out the big table */
-       if (rank == 0) 
-           for ( i=0; i<participants; i++) 
-               for ( j=0; j<MAX_PROCESSES; j++ ) 
-                   table[i][j] = i+j;
-       
-       /* Scatter the big table to everybody's little table */
-       MPI_Scatter(&table[0][0], send_count, MPI_INT, 
-                   &row[0]     , recv_count, MPI_INT, 0, comm );
-       
-       /* Now see if our row looks right */
-       for (i=0; i<MAX_PROCESSES; i++) 
-           if ( row[i] != i+rank ) errors++;
-    } 
-    
-    MPI_Comm_free( &comm );
-
-    MTest_Finalize( errors );
+    if ((rank < participants)) {
+        int send_count = MAX_PROCESSES;
+        int recv_count = MAX_PROCESSES;
+
+        /* If I'm the root (process 0), then fill out the big table */
+        if (rank == 0)
+            for (i = 0; i < participants; i++)
+                for (j = 0; j < MAX_PROCESSES; j++)
+                    table[i][j] = i + j;
+
+        /* Scatter the big table to everybody's little table */
+        MPI_Scatter(&table[0][0], send_count, MPI_INT, &row[0], recv_count, MPI_INT, 0, comm);
+
+        /* Now see if our row looks right */
+        for (i = 0; i < MAX_PROCESSES; i++)
+            if (row[i] != i + rank)
+                errors++;
+    }
+
+    MPI_Comm_free(&comm);
+
+    MTest_Finalize(errors);
     MPI_Finalize();
-    return MTestReturnValue( errors );
+    return MTestReturnValue(errors);
 }
index 980650f..95729ac 100644 (file)
@@ -9,46 +9,49 @@
 
 #define MAX_PROCESSES 10
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    int              rank, size, i,j;
-    int              table[MAX_PROCESSES][MAX_PROCESSES];
-    int              row[MAX_PROCESSES];
-    int              errors=0;
-    int              participants;
-    int              displs[MAX_PROCESSES];
-    int              send_counts[MAX_PROCESSES];
-
-    MTest_Init( &argc, &argv );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
+    int rank, size, i, j;
+    int table[MAX_PROCESSES][MAX_PROCESSES];
+    int row[MAX_PROCESSES];
+    int errors = 0;
+    int participants;
+    int displs[MAX_PROCESSES];
+    int send_counts[MAX_PROCESSES];
+
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
     /* A maximum of MAX_PROCESSES processes can participate */
-    if ( size > MAX_PROCESSES ) participants = MAX_PROCESSES;
-    else              participants = size;
-    if ( (rank < participants) ) {
-      int recv_count = MAX_PROCESSES;
-      
-      /* If I'm the root (process 0), then fill out the big table */
-      /* and setup  send_counts and displs arrays */
-      if (rank == 0) 
-       for ( i=0; i<participants; i++) {
-         send_counts[i] = recv_count;
-         displs[i] = i * MAX_PROCESSES;
-         for ( j=0; j<MAX_PROCESSES; j++ ) 
-           table[i][j] = i+j;
-       }
-      
-      /* Scatter the big table to everybody's little table */
-      MPI_Scatterv(&table[0][0], send_counts, displs, MPI_INT, 
-                  &row[0]     , recv_count, MPI_INT, 0, MPI_COMM_WORLD);
-
-      /* Now see if our row looks right */
-      for (i=0; i<MAX_PROCESSES; i++) 
-       if ( row[i] != i+rank ) errors++;
-    } 
-
-    MTest_Finalize( errors );
+    if (size > MAX_PROCESSES)
+        participants = MAX_PROCESSES;
+    else
+        participants = size;
+    if ((rank < participants)) {
+        int recv_count = MAX_PROCESSES;
+
+        /* If I'm the root (process 0), then fill out the big table */
+        /* and setup  send_counts and displs arrays */
+        if (rank == 0)
+            for (i = 0; i < participants; i++) {
+                send_counts[i] = recv_count;
+                displs[i] = i * MAX_PROCESSES;
+                for (j = 0; j < MAX_PROCESSES; j++)
+                    table[i][j] = i + j;
+            }
+
+        /* Scatter the big table to everybody's little table */
+        MPI_Scatterv(&table[0][0], send_counts, displs, MPI_INT,
+                     &row[0], recv_count, MPI_INT, 0, MPI_COMM_WORLD);
+
+        /* Now see if our row looks right */
+        for (i = 0; i < MAX_PROCESSES; i++)
+            if (row[i] != i + rank)
+                errors++;
+    }
+
+    MTest_Finalize(errors);
     MPI_Finalize();
-    return MTestReturnValue( errors );
+    return MTestReturnValue(errors);
 }
index e0973f9..077cdcd 100644 (file)
@@ -9,87 +9,84 @@
 
 #define MAX_PROCESSES 10
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    int              rank, size, i,j;
-    int              table[MAX_PROCESSES][MAX_PROCESSES];
-    int              errors=0;
-    int              participants;
-    int              displs[MAX_PROCESSES];
-    int              recv_counts[MAX_PROCESSES];
-    MPI_Comm         test_comm;
+    int rank, size, i, j;
+    int table[MAX_PROCESSES][MAX_PROCESSES];
+    int errors = 0;
+    int participants;
+    int displs[MAX_PROCESSES];
+    int recv_counts[MAX_PROCESSES];
+    MPI_Comm test_comm;
 
-    MTest_Init( &argc, &argv );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
     /* A maximum of MAX_PROCESSES processes can participate */
-    participants = ( size > MAX_PROCESSES ) ? MAX_PROCESSES : size;
+    participants = (size > MAX_PROCESSES) ? MAX_PROCESSES : size;
 
     if (MAX_PROCESSES % participants) {
-       fprintf( stderr, "Number of processors must divide %d\n",
-               MAX_PROCESSES );
-       MPI_Abort( MPI_COMM_WORLD, 1 );
-        exit(1);
-       }
-    MPI_Comm_split(MPI_COMM_WORLD, rank<participants, rank, &test_comm);
+        fprintf(stderr, "Number of processors must divide %d\n", MAX_PROCESSES);
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
+    MPI_Comm_split(MPI_COMM_WORLD, rank < participants, rank, &test_comm);
 
-    if ( rank < participants ) {
+    if (rank < participants) {
 
-      /* Determine what rows are my responsibility */
-      int block_size = MAX_PROCESSES / participants;
-      int begin_row  = rank * block_size;
-      int end_row    = (rank+1) * block_size;
-      int send_count = block_size * MAX_PROCESSES;
-      
-      /* Fill in the displacements and recv_counts */
-      for (i=0; i<participants; i++) {
-       displs[i]      = i * block_size * MAX_PROCESSES;
-       recv_counts[i] = send_count;
-      }
+        /* Determine what rows are my responsibility */
+        int block_size = MAX_PROCESSES / participants;
+        int begin_row = rank * block_size;
+        int end_row = (rank + 1) * block_size;
+        int send_count = block_size * MAX_PROCESSES;
 
-      /* Paint my rows my color */
-      for (i=begin_row; i<end_row ;i++)
-       for (j=0; j<MAX_PROCESSES; j++)
-         table[i][j] = rank + 10;
-      
-      /* Everybody gets the gathered data */
-      if ((char *) &table[begin_row][0] != (char *) table + displs[rank]*sizeof(int))
-          MPI_Allgatherv(&table[begin_row][0], send_count, MPI_INT,
-                         &table[0][0], recv_counts, displs,
-                         MPI_INT, test_comm);
-      else
-          MPI_Allgatherv(MPI_IN_PLACE, send_count, MPI_INT,
-                         &table[0][0], recv_counts, displs,
-                         MPI_INT, test_comm);
+        /* Fill in the displacements and recv_counts */
+        for (i = 0; i < participants; i++) {
+            displs[i] = i * block_size * MAX_PROCESSES;
+            recv_counts[i] = send_count;
+        }
 
-      /* Everybody should have the same table now.
+        /* Paint my rows my color */
+        for (i = begin_row; i < end_row; i++)
+            for (j = 0; j < MAX_PROCESSES; j++)
+                table[i][j] = rank + 10;
 
-        The entries are:
-        Table[i][j] = (i/block_size) + 10;
-       */
-      for (i=0; i<MAX_PROCESSES;i++) 
-       if ( (table[i][0] - table[i][MAX_PROCESSES-1] !=0) ) 
-         errors++;
-      for (i=0; i<MAX_PROCESSES;i++) {
-         for (j=0; j<MAX_PROCESSES;j++) {
-             if (table[i][j] != (i/block_size) + 10) errors++;
-             }
-         }
-      if (errors) {
-         /* Print out table if there are any errors */
-         for (i=0; i<MAX_PROCESSES;i++) {
-             printf("\n");
-             for (j=0; j<MAX_PROCESSES; j++)
-                 printf("  %d",table[i][j]);
-             }
-         printf("\n");
-         }
-    } 
+        /* Everybody gets the gathered data */
+        if ((char *) &table[begin_row][0] != (char *) table + displs[rank] * sizeof(int))
+            MPI_Allgatherv(&table[begin_row][0], send_count, MPI_INT,
+                           &table[0][0], recv_counts, displs, MPI_INT, test_comm);
+        else
+            MPI_Allgatherv(MPI_IN_PLACE, send_count, MPI_INT,
+                           &table[0][0], recv_counts, displs, MPI_INT, test_comm);
 
-    MTest_Finalize( errors );
+        /* Everybody should have the same table now.
+         *
+         * The entries are:
+         * Table[i][j] = (i/block_size) + 10;
+         */
+        for (i = 0; i < MAX_PROCESSES; i++)
+            if ((table[i][0] - table[i][MAX_PROCESSES - 1] != 0))
+                errors++;
+        for (i = 0; i < MAX_PROCESSES; i++) {
+            for (j = 0; j < MAX_PROCESSES; j++) {
+                if (table[i][j] != (i / block_size) + 10)
+                    errors++;
+            }
+        }
+        if (errors) {
+            /* Print out table if there are any errors */
+            for (i = 0; i < MAX_PROCESSES; i++) {
+                printf("\n");
+                for (j = 0; j < MAX_PROCESSES; j++)
+                    printf("  %d", table[i][j]);
+            }
+            printf("\n");
+        }
+    }
+
+    MTest_Finalize(errors);
 
     MPI_Comm_free(&test_comm);
     MPI_Finalize();
-    return MTestReturnValue( errors );
+    return MTestReturnValue(errors);
 }
index 7cadace..8aef915 100644 (file)
@@ -9,55 +9,55 @@
 
 #define MAX_PROCESSES 10
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    int              rank, size, i,j;
-    int              table[MAX_PROCESSES][MAX_PROCESSES];
-    int              errors=0;
-    int              participants;
+    int rank, size, i, j;
+    int table[MAX_PROCESSES][MAX_PROCESSES];
+    int errors = 0;
+    int participants;
 
-    MTest_Init( &argc, &argv );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
     /* A maximum of MAX_PROCESSES processes can participate */
-    if ( size > MAX_PROCESSES ) participants = MAX_PROCESSES;
-    else              participants = size;
+    if (size > MAX_PROCESSES)
+        participants = MAX_PROCESSES;
+    else
+        participants = size;
     if (MAX_PROCESSES % participants) {
-       fprintf( stderr, "Number of processors must divide %d\n",
-               MAX_PROCESSES );
-       MPI_Abort( MPI_COMM_WORLD, 1 );
-        exit(1);
-       }
+        fprintf(stderr, "Number of processors must divide %d\n", MAX_PROCESSES);
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
     /* while (MAX_PROCESSES % participants) participants--; */
-    if ( (rank < participants) ) {
-
-      /* Determine what rows are my responsibility */
-      int block_size = MAX_PROCESSES / participants;
-      int begin_row  = rank * block_size;
-      int end_row    = (rank+1) * block_size;
-      int send_count = block_size * MAX_PROCESSES;
-      int recv_count = send_count;
-
-      /* Paint my rows my color */
-      for (i=begin_row; i<end_row ;i++)
-       for (j=0; j<MAX_PROCESSES; j++)
-         table[i][j] = rank + 10;
-
-      /* Everybody gets the gathered table */
-      MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL,
-                    &table[0][0], recv_count, MPI_INT, MPI_COMM_WORLD);
-
-      /* Everybody should have the same table now,  */
-      /* This test does not in any way guarantee there are no errors */
-      /* Print out a table or devise a smart test to make sure it's correct */
-      for (i=0; i<MAX_PROCESSES;i++) {
-       if ( (table[i][0] - table[i][MAX_PROCESSES-1] !=0) ) 
-         errors++;
-      }
-    } 
-
-    MTest_Finalize( errors );
+    if ((rank < participants)) {
+
+        /* Determine what rows are my responsibility */
+        int block_size = MAX_PROCESSES / participants;
+        int begin_row = rank * block_size;
+        int end_row = (rank + 1) * block_size;
+        int send_count = block_size * MAX_PROCESSES;
+        int recv_count = send_count;
+
+        /* Paint my rows my color */
+        for (i = begin_row; i < end_row; i++)
+            for (j = 0; j < MAX_PROCESSES; j++)
+                table[i][j] = rank + 10;
+
+        /* Everybody gets the gathered table */
+        MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL,
+                      &table[0][0], recv_count, MPI_INT, MPI_COMM_WORLD);
+
+        /* Everybody should have the same table now,  */
+        /* This test does not in any way guarantee there are no errors */
+        /* Print out a table or devise a smart test to make sure it's correct */
+        for (i = 0; i < MAX_PROCESSES; i++) {
+            if ((table[i][0] - table[i][MAX_PROCESSES - 1] != 0))
+                errors++;
+        }
+    }
+
+    MTest_Finalize(errors);
     MPI_Finalize();
-    return MTestReturnValue( errors );
+    return MTestReturnValue(errors);
 }
index b05fb18..940cdf1 100644 (file)
@@ -7,36 +7,39 @@
 #include <stdio.h>
 #include "mpitest.h"
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    int              rank, size, i;
-    int              data;
-    int              errors=0;
-    int              result = -100;
-    int              correct_result;
+    int rank, size, i;
+    int data;
+    int errors = 0;
+    int result = -100;
+    int correct_result;
 
-    MTest_Init( &argc, &argv );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
     data = rank;
 
-    MPI_Reduce ( &data, &result, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD );
-    MPI_Bcast  ( &result, 1, MPI_INT, 0, MPI_COMM_WORLD );
+    MPI_Reduce(&data, &result, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
+    MPI_Bcast(&result, 1, MPI_INT, 0, MPI_COMM_WORLD);
     correct_result = 0;
-    for(i=0;i<size;i++) 
-      correct_result += i;
-    if (result != correct_result) errors++;
+    for (i = 0; i < size; i++)
+        correct_result += i;
+    if (result != correct_result)
+        errors++;
 
-    MPI_Reduce ( &data, &result, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD );
-    MPI_Bcast  ( &result, 1, MPI_INT, 0, MPI_COMM_WORLD );
-    if (result != 0) errors++;
+    MPI_Reduce(&data, &result, 1, MPI_INT, MPI_MIN, 0, MPI_COMM_WORLD);
+    MPI_Bcast(&result, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    if (result != 0)
+        errors++;
 
-    MPI_Reduce ( &data, &result, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD );
-    MPI_Bcast  ( &result, 1, MPI_INT, 0, MPI_COMM_WORLD );
-    if (result != (size-1)) errors++;
+    MPI_Reduce(&data, &result, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD);
+    MPI_Bcast(&result, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    if (result != (size - 1))
+        errors++;
 
-    MTest_Finalize( errors );
+    MTest_Finalize(errors);
     MPI_Finalize();
-    return MTestReturnValue( errors );
+    return MTestReturnValue(errors);
 }
index 5fd33c8..7086746 100644 (file)
@@ -7,39 +7,40 @@
 #include <stdio.h>
 #include "mpitest.h"
 
-void addem ( int *, int *, int *, MPI_Datatype * );
+void addem(int *, int *, int *, MPI_Datatype *);
 
-void addem(int *invec, int *inoutvec, int *len, MPI_Datatype *dtype)
+void addem(int *invec, int *inoutvec, int *len, MPI_Datatype * dtype)
 {
-  int i;
-  for ( i=0; i<*len; i++ ) 
-    inoutvec[i] += invec[i];
+    int i;
+    for (i = 0; i < *len; i++)
+        inoutvec[i] += invec[i];
 }
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
-    int              rank, size, i;
-    int              data;
-    int              errors=0;
-    int              result = -100;
-    int              correct_result;
-    MPI_Op           op;
+    int rank, size, i;
+    int data;
+    int errors = 0;
+    int result = -100;
+    int correct_result;
+    MPI_Op op;
 
-    MTest_Init( &argc, &argv );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
     data = rank;
-    MPI_Op_create( (MPI_User_function *)addem, 1, &op );
-    MPI_Reduce ( &data, &result, 1, MPI_INT, op, 0, MPI_COMM_WORLD );
-    MPI_Bcast  ( &result, 1, MPI_INT, 0, MPI_COMM_WORLD );
-    MPI_Op_free( &op );
+    MPI_Op_create((MPI_User_function *) addem, 1, &op);
+    MPI_Reduce(&data, &result, 1, MPI_INT, op, 0, MPI_COMM_WORLD);
+    MPI_Bcast(&result, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    MPI_Op_free(&op);
     correct_result = 0;
-    for(i=0;i<size;i++) 
-      correct_result += i;
-    if (result != correct_result) errors++;
+    for (i = 0; i < size; i++)
+        correct_result += i;
+    if (result != correct_result)
+        errors++;
 
-    MTest_Finalize( errors );
+    MTest_Finalize(errors);
     MPI_Finalize();
-    return MTestReturnValue( errors );
+    return MTestReturnValue(errors);
 }
index 64ab9d5..4667a70 100644 (file)
 static char MTEST_Descrip[] = "Test MPI_Exscan";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0;
     int rank, size;
-    int minsize = 2, count; 
+    int minsize = 2, count;
     int *sendbuf, *recvbuf, i;
-    MPI_Comm      comm;
+    MPI_Comm comm;
 
-    MTest_Init( &argc, &argv );
+    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;
+    /* 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;
 
-       MPI_Comm_rank( comm, &rank );
-       MPI_Comm_size( comm, &size );
-       
-       for (count = 1; count < 65000; count = count * 2) {
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_size(comm, &size);
 
-           sendbuf = (int *)malloc( count * sizeof(int) );
-           recvbuf = (int *)malloc( count * sizeof(int) );
+        for (count = 1; count < 65000; count = count * 2) {
 
-           for (i=0; i<count; i++) {
-               sendbuf[i] = rank + i * size;
-               recvbuf[i] = -1;
-           }
-           
-           MPI_Exscan( sendbuf, recvbuf, count, MPI_INT, MPI_SUM, comm );
+            sendbuf = (int *) malloc(count * sizeof(int));
+            recvbuf = (int *) malloc(count * sizeof(int));
 
-           /* Check the results.  rank 0 has no data */
-           if (rank > 0) {
-               int result;
-               for (i=0; i<count; i++) {
-                   result = rank * i * size + ((rank) * (rank-1))/2;
-                   if (recvbuf[i] != result) {
-                       errs++;
-                       if (errs < 10) {
-                           fprintf( stderr, "Error in recvbuf[%d] = %d on %d, expected %d\n",
-                                    i, recvbuf[i], rank, result );
-                       }
-                   }
-               }
-           }
+            for (i = 0; i < count; i++) {
+                sendbuf[i] = rank + i * size;
+                recvbuf[i] = -1;
+            }
+
+            MPI_Exscan(sendbuf, recvbuf, count, MPI_INT, MPI_SUM, comm);
+
+            /* Check the results.  rank 0 has no data */
+            if (rank > 0) {
+                int result;
+                for (i = 0; i < count; i++) {
+                    result = rank * i * size + ((rank) * (rank - 1)) / 2;
+                    if (recvbuf[i] != result) {
+                        errs++;
+                        if (errs < 10) {
+                            fprintf(stderr, "Error in recvbuf[%d] = %d on %d, expected %d\n",
+                                    i, recvbuf[i], rank, result);
+                        }
+                    }
+                }
+            }
 
 #if MTEST_HAVE_MIN_MPI_VERSION(2,2)
             /* now try the MPI_IN_PLACE flavor */
-            for (i=0; i<count; i++) {
-                sendbuf[i] = -1; /* unused */
+            for (i = 0; i < count; i++) {
+                sendbuf[i] = -1;        /* unused */
                 recvbuf[i] = rank + i * size;
             }
 
-            MPI_Exscan( MPI_IN_PLACE, recvbuf, count, MPI_INT, MPI_SUM, comm );
+            MPI_Exscan(MPI_IN_PLACE, recvbuf, count, MPI_INT, MPI_SUM, comm);
 
             /* Check the results.  rank 0's data must remain unchanged */
-            for (i=0; i<count; i++) {
+            for (i = 0; i < count; i++) {
                 int result;
                 if (rank == 0)
                     result = rank + i * size;
                 else
-                    result = rank * i * size + ((rank) * (rank-1))/2;
+                    result = rank * i * size + ((rank) * (rank - 1)) / 2;
                 if (recvbuf[i] != result) {
                     errs++;
                     if (errs < 10) {
-                        fprintf( stderr, "Error in recvbuf[%d] = %d on %d, expected %d\n",
-                                 i, recvbuf[i], rank, result );
+                        fprintf(stderr, "Error in recvbuf[%d] = %d on %d, expected %d\n",
+                                i, recvbuf[i], rank, result);
                     }
                 }
             }
-
-            MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
-            /* Make sure that we check for buffer aliasing properly */
-            if (MPI_SUCCESS == MPI_Exscan( recvbuf, recvbuf, count, MPI_INT, MPI_SUM, comm ))
-                errs++;
 #endif
 
-           free( sendbuf );
-           free( recvbuf );
-       }
-       MTestFreeComm( &comm );
+            free(sendbuf);
+            free(recvbuf);
+        }
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 50c898d..0084996 100644 (file)
 static char MTEST_Descrip[] = "Test MPI_Exscan (simple test)";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0;
     int rank, size;
     int sendbuf[1], recvbuf[1];
-    MPI_Comm      comm;
+    MPI_Comm comm;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
     comm = MPI_COMM_WORLD;
-    MPI_Comm_rank( comm, &rank );
-    MPI_Comm_size( comm, &size );
-    
+    MPI_Comm_rank(comm, &rank);
+    MPI_Comm_size(comm, &size);
+
     sendbuf[0] = rank;
     recvbuf[0] = -2;
-           
-    MPI_Exscan( sendbuf, recvbuf, 1, MPI_INT, MPI_SUM, comm );
+
+    MPI_Exscan(sendbuf, recvbuf, 1, MPI_INT, MPI_SUM, comm);
 
     /* Check the results.  rank 0 has no data.  Input is
-       0  1  2  3  4  5  6  7  8 ...
-       Output is
-       -  0  1  3  6 10 15 21 28 36
-       (scan, not counting the contribution from the calling process)
-    */
+     * 0  1  2  3  4  5  6  7  8 ...
+     * Output is
+     * -  0  1  3  6 10 15 21 28 36
+     * (scan, not counting the contribution from the calling process)
+     */
     if (rank > 0) {
-       int result = (((rank) * (rank-1))/2);
-       /* printf( "%d: %d\n", rank, result ); */
-       if (recvbuf[0] != result) {
-           errs++;
-           fprintf( stderr, "Error in recvbuf = %d on %d, expected %d\n",
-                        recvbuf[0], rank, result );
-       }
+        int result = (((rank) * (rank - 1)) / 2);
+        /* printf("%d: %d\n", rank, result); */
+        if (recvbuf[0] != result) {
+            errs++;
+            fprintf(stderr, "Error in recvbuf = %d on %d, expected %d\n", recvbuf[0], rank, result);
+        }
     }
     else if (recvbuf[0] != -2) {
-       errs++;
-       fprintf( stderr, "Error in recvbuf on zero, is %d\n", recvbuf[0] );
+        errs++;
+        fprintf(stderr, "Error in recvbuf on zero, is %d\n", recvbuf[0]);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index e14503f..b7152c1 100644 (file)
 
 /* Gather data from a vector to contiguous */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
     MPI_Datatype vec;
-    MPI_Comm     comm;
+    MPI_Comm comm;
     double *vecin, *vecout;
-    int    minsize = 2, count;
-    int    root, i, n, stride, errs = 0;
-    int    rank, size;
+    int minsize = 2, count;
+    int root, i, n, stride, errs = 0;
+    int rank, size;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
-    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 );
-       
-       for (root=0; root<size; root++) {
-           for (count = 1; count < 65000; count = count * 2) {
-               n = 12;
-               stride = 10;
-               vecin = (double *)malloc( n * stride * size * sizeof(double) );
-               vecout = (double *)malloc( size * n * sizeof(double) );
-               
-               MPI_Type_vector( n, 1, stride, MPI_DOUBLE, &vec );
-               MPI_Type_commit( &vec );
-               
-               for (i=0; i<n*stride; i++) vecin[i] =-2;
-               for (i=0; i<n; i++) vecin[i*stride] = rank * n + i;
-               
-               MPI_Gather( vecin, 1, vec, vecout, n, MPI_DOUBLE, root, comm );
-               
-               if (rank == root) {
-                   for (i=0; i<n*size; i++) {
-                       if (vecout[i] != i) {
-                           errs++;
-                           if (errs < 10) {
-                               fprintf( stderr, "vecout[%d]=%d\n",
-                                        i, (int)vecout[i] );
-                           }
-                       }
-                   }
-               }
-               MPI_Type_free( &vec );
-               free( vecin );
-               free( vecout );
-           }
-       }
-       MTestFreeComm( &comm );
+    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);
+
+        for (root = 0; root < size; root++) {
+            for (count = 1; count < 65000; count = count * 2) {
+                n = 12;
+                stride = 10;
+                vecin = (double *) malloc(n * stride * size * sizeof(double));
+                vecout = (double *) malloc(size * n * sizeof(double));
+
+                MPI_Type_vector(n, 1, stride, MPI_DOUBLE, &vec);
+                MPI_Type_commit(&vec);
+
+                for (i = 0; i < n * stride; i++)
+                    vecin[i] = -2;
+                for (i = 0; i < n; i++)
+                    vecin[i * stride] = rank * n + i;
+
+                MPI_Gather(vecin, 1, vec, vecout, n, MPI_DOUBLE, root, comm);
+
+                if (rank == root) {
+                    for (i = 0; i < n * size; i++) {
+                        if (vecout[i] != i) {
+                            errs++;
+                            if (errs < 10) {
+                                fprintf(stderr, "vecout[%d]=%d\n", i, (int) vecout[i]);
+                            }
+                        }
+                    }
+                }
+                MPI_Type_free(&vec);
+                free(vecin);
+                free(vecout);
+            }
+        }
+        MTestFreeComm(&comm);
     }
 
     /* do a zero length gather */
-    MPI_Gather( NULL, 0, MPI_BYTE, NULL, 0, MPI_BYTE, 0, MPI_COMM_WORLD );
-
-#if MTEST_HAVE_MIN_MPI_VERSION(2,2)
-    /* Check to make sure that aliasing is disallowed correctly */
-    MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
-    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-    if (0 == rank)
-        if (MPI_SUCCESS == MPI_Gather(&rank, 1, MPI_INT,
-                                      &rank, 1, MPI_INT, 0, MPI_COMM_WORLD))
-            errs++;
-#endif
+    MPI_Gather(NULL, 0, MPI_BYTE, NULL, 0, MPI_BYTE, 0, MPI_COMM_WORLD);
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
-
-
index 3c47467..f8836f4 100644 (file)
 
 /* Gather data from a vector to contiguous.  Use IN_PLACE */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
     MPI_Datatype vec;
     double *vecin, *vecout;
     MPI_Comm comm;
-    int    count, minsize = 2;
-    int    root, i, n, stride, errs = 0;
-    int    rank, size;
+    int count, minsize = 2;
+    int root, i, n, stride, errs = 0;
+    int rank, size;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
-    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 );
-       
-       for (root=0; root<size; root++) {
-           for (count = 1; count < 65000; count = count * 2) {
-               n = 12;
-               stride = 10;
-               vecin = (double *)malloc( n * stride * size * sizeof(double) );
-               vecout = (double *)malloc( size * n * sizeof(double) );
-               
-               MPI_Type_vector( n, 1, stride, MPI_DOUBLE, &vec );
-               MPI_Type_commit( &vec );
-               
-               for (i=0; i<n*stride; i++) vecin[i] =-2;
-               for (i=0; i<n; i++) vecin[i*stride] = rank * n + i;
-               int errorcode = MPI_SUCCESS;
-               if (rank == root) {
-                   for (i=0; i<n; i++) {
-                       vecout[rank*n+i] = rank*n+i;
-                   }
-                   errorcode = MPI_Gather( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, 
-                               vecout, n, MPI_DOUBLE, root, comm );
-               }
-               else {
-                   errorcode = MPI_Gather( vecin, 1, vec, NULL, -1, MPI_DATATYPE_NULL, 
-                               root, comm );
-               }
+    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);
 
-               if (rank == root) {
-                   for (i=0; i<n*size; i++) {
-                       if (vecout[i] != i) {
-                           errs++;
-                           if (errs < 10) {
-                               fprintf( stderr, "vecout[%d]=%d, err=%d\n",
-                                        i, (int)vecout[i], errorcode );
-                           }
-                       }
-                   }
-               }
-               MPI_Type_free( &vec );
-               free( vecin );
-               free( vecout );
-           }
-       }
-        MTestFreeComm( &comm );
+        for (root = 0; root < size; root++) {
+            for (count = 1; count < 65000; count = count * 2) {
+                n = 12;
+                stride = 10;
+                vecin = (double *) malloc(n * stride * size * sizeof(double));
+                vecout = (double *) malloc(size * n * sizeof(double));
+
+                MPI_Type_vector(n, 1, stride, MPI_DOUBLE, &vec);
+                MPI_Type_commit(&vec);
+
+                for (i = 0; i < n * stride; i++)
+                    vecin[i] = -2;
+                for (i = 0; i < n; i++)
+                    vecin[i * stride] = rank * n + i;
+
+                if (rank == root) {
+                    for (i = 0; i < n; i++) {
+                        vecout[rank * n + i] = rank * n + i;
+                    }
+                    MPI_Gather(MPI_IN_PLACE, -1, MPI_DATATYPE_NULL,
+                               vecout, n, MPI_DOUBLE, root, comm);
+                }
+                else {
+                    MPI_Gather(vecin, 1, vec, NULL, -1, MPI_DATATYPE_NULL, root, comm);
+                }
+                if (rank == root) {
+                    for (i = 0; i < n * size; i++) {
+                        if (vecout[i] != i) {
+                            errs++;
+                            if (errs < 10) {
+                                fprintf(stderr, "vecout[%d]=%d\n", i, (int) vecout[i]);
+                            }
+                        }
+                    }
+                }
+                MPI_Type_free(&vec);
+                free(vecin);
+                free(vecout);
+            }
+        }
+        MTestFreeComm(&comm);
     }
 
     /* do a zero length gather */
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    if ( rank == 0 ) {
-       MPI_Gather( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, NULL, 0, MPI_BYTE, 0,
-                   MPI_COMM_WORLD );
-    else {
-       MPI_Gather( NULL, 0, MPI_BYTE, NULL, 0, MPI_BYTE, 0, MPI_COMM_WORLD );
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    if (rank == 0) {
+        MPI_Gather(MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, NULL, 0, MPI_BYTE, 0, MPI_COMM_WORLD);
+    }
+    else {
+        MPI_Gather(NULL, 0, MPI_BYTE, NULL, 0, MPI_BYTE, 0, MPI_COMM_WORLD);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
-
-
diff --git a/teshsuite/smpi/mpich3-test/coll/gather2_save.c b/teshsuite/smpi/mpich3-test/coll/gather2_save.c
deleted file mode 100644 (file)
index a2ac0bd..0000000
+++ /dev/null
@@ -1,91 +0,0 @@
-/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
-/*
- *
- *  (C) 2003 by Argonne National Laboratory.
- *      See COPYRIGHT in top-level directory.
- */
-
-#include "mpi.h"
-#include "mpitest.h"
-#include <stdlib.h>
-#include <stdio.h>
-
-/* Gather data from a vector to contiguous.  Use IN_PLACE */
-
-int main( int argc, char **argv )
-{
-    MPI_Datatype vec;
-    double *vecin, *vecout;
-    MPI_Comm comm;
-    int    count, minsize = 2;
-    int    root, i, n, stride, errs = 0;
-    int    rank, size;
-
-    MTest_Init( &argc, &argv );
-
-    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 );
-       
-       for (root=0; root<size; root++) {
-           for (count = 1; count < 65000; count = count * 2) {
-               n = 12;
-               stride = 10;
-               vecin = (double *)malloc( n * stride * size * sizeof(double) );
-               vecout = (double *)malloc( size * n * sizeof(double) );
-               
-               MPI_Type_vector( n, 1, stride, MPI_DOUBLE, &vec );
-               MPI_Type_commit( &vec );
-               
-               for (i=0; i<n*stride; i++) vecin[i] =-2;
-               for (i=0; i<n; i++) vecin[i*stride] = rank * n + i;
-               int errorcode = MPI_SUCCESS;
-               if (rank == root) {
-                   for (i=0; i<n; i++) {
-                       vecout[rank*n+i] = rank*n+i;
-                   }
-                   errorcode = MPI_Gather( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, 
-                               vecout, n, MPI_DOUBLE, root, comm );
-               }
-               else {
-                   errorcode = MPI_Gather( vecin, 1, vec, NULL, -1, MPI_DATATYPE_NULL, 
-                               root, comm );
-               }
-
-               if (rank == root) {
-                   for (i=0; i<n*size; i++) {
-                       if (vecout[i] != i) {
-                           errs++;
-                           if (errs < 10) {
-                               fprintf( stderr, "vecout[%d]=%d, err=%d\n",
-                                        i, (int)vecout[i], errorcode );
-                           }
-                       }
-                   }
-               }
-               MPI_Type_free( &vec );
-               free( vecin );
-               free( vecout );
-           }
-       }
-        printf("end with comm size : %d\n", size);     
-        MTestFreeComm( &comm );
-    }
-
-    /* do a zero length gather */
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
-    if ( rank == 0 ) {
-       MPI_Gather( MPI_IN_PLACE, -1, MPI_DATATYPE_NULL, NULL, 0, MPI_BYTE, 0,
-                   MPI_COMM_WORLD );
-    } else {
-       MPI_Gather( NULL, 0, MPI_BYTE, NULL, 0, MPI_BYTE, 0, MPI_COMM_WORLD );
-    }
-
-    MTest_Finalize( errs );
-    MPI_Finalize();
-    return 0;
-}
-
-
diff --git a/teshsuite/smpi/mpich3-test/coll/gather_big.c b/teshsuite/smpi/mpich3-test/coll/gather_big.c
new file mode 100644 (file)
index 0000000..ce37c95
--- /dev/null
@@ -0,0 +1,87 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *  (C) 2015 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+#include "mpi.h"
+#include "mpitest.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#define ROOT 7
+#if 0
+/* Following should always work for -n 8  256, -N 32, using longs */
+#define COUNT 1048576*32
+#endif
+#if 1
+/* Following will fail for -n 8 unless gather path is 64 bit clean */
+#define COUNT (1024*1024*128+1)
+#endif
+#define VERIFY_CONST 100000000L
+
+int main(int argc, char *argv[])
+{
+    int rank, size;
+    int i, j;
+    long *sendbuf = NULL;
+    long *recvbuf = NULL;
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+    if (size < (ROOT+1)) {
+        fprintf(stderr, "At least %d processes required\n", ROOT+1);
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
+
+    sendbuf = malloc(COUNT * sizeof(long));
+    if (sendbuf == NULL) {
+        fprintf(stderr, "PE %d:ERROR: malloc of sendbuf failed\n", rank);
+    }
+    for (i = 0; i < COUNT; i++) {
+        sendbuf[i] = (long) i + (long) rank *VERIFY_CONST;
+    }
+
+    if (rank == ROOT) {
+        recvbuf = malloc(COUNT * sizeof(long) * size);
+        if (recvbuf == NULL) {
+            fprintf(stderr, "PE %d:ERROR: malloc of recvbuf failed\n", rank);
+        }
+        for (i = 0; i < COUNT * size; i++) {
+            recvbuf[i] = -456789L;
+        }
+    }
+
+    MPI_Gather(sendbuf, COUNT, MPI_LONG, recvbuf, COUNT, MPI_LONG, ROOT, MPI_COMM_WORLD);
+
+    int lerr = 0;
+    if (rank == ROOT) {
+        for (i = 0; i < size; i++) {
+            for (j = 0; j < COUNT; j++) {
+                if (recvbuf[i * COUNT + j] != i * VERIFY_CONST + j) {
+                    printf("PE 0: mis-match error");
+                    printf("  recbuf[%d * %d + %d] = ", i, COUNT, j);
+                    printf("  %ld,", recvbuf[i * COUNT + j]);
+                    printf("  should be %ld\n", i * VERIFY_CONST + j);
+                    lerr++;
+                    if (lerr > 10) {
+                        j = COUNT;
+                    }
+                }
+            }
+        }
+        MTest_Finalize(lerr);
+        free(recvbuf);
+    }
+    else {
+        MTest_Finalize(lerr);
+    }
+
+    MPI_Barrier(MPI_COMM_WORLD);
+    MPI_Finalize();
+
+    free(sendbuf);
+    return 0;
+}
index 684fd50..455c22d 100644 (file)
@@ -15,27 +15,20 @@ int main(int argc, char *argv[])
     MPI_Request request;
     int size, rank;
     int one = 1, two = 2, isum, sum;
-    int errs = 0;
 
-    MPI_Init(&argc,&argv);
+    MPI_Init(&argc, &argv);
     MPI_Comm_size(MPI_COMM_WORLD, &size);
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     assert(size == 2);
-    MPI_Iallreduce(&one,&isum,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD,&request);
-    MPI_Allreduce(&two,&sum,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD);
-    MPI_Wait(&request,MPI_STATUS_IGNORE);
+    MPI_Iallreduce(&one, &isum, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &request);
+    MPI_Allreduce(&two, &sum, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
+    MPI_Wait(&request, MPI_STATUS_IGNORE);
 
     assert(isum == 2);
     assert(sum == 4);
-
-    MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
-    if (MPI_SUCCESS == MPI_Iallreduce(&one, &one, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD, &request))
-        errs++;
-
-    if (rank == 0 && errs == 0)
+    if (rank == 0)
         printf(" No errors\n");
 
     MPI_Finalize();
     return 0;
 }
-
index affde1f..a672da0 100644 (file)
 int main(int argc, char *argv[])
 {
     MPI_Request barrier;
-    int rank,i,done;
+    int rank, i, done;
 
-    MPI_Init(&argc,&argv);
-    MPI_Comm_rank(MPI_COMM_WORLD,&rank);
-    MPI_Ibarrier(MPI_COMM_WORLD,&barrier);
-    for (i=0,done=0; !done; i++) {
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    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);
+        /*printf("[%d] MPI_Test: %d\n",rank,i); */
+        MPI_Test(&barrier, &done, MPI_STATUS_IGNORE);
     }
 
     if (rank == 0)
index 987e01a..3418167 100644 (file)
@@ -8,12 +8,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "mpitest.h"
+#include "mpicolltest.h"
 
 /*
 static char MTEST_Descrip[] = "Simple intercomm allgather test";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0, err;
     int *rbuf = 0, *sbuf = 0;
@@ -21,87 +22,89 @@ int main( int argc, char *argv[] )
     MPI_Comm comm;
     MPI_Datatype datatype;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
     datatype = MPI_INT;
     /* Get an intercommunicator */
-    while (MTestGetIntercomm( &comm, &leftGroup, 4 )) {
-       if (comm == MPI_COMM_NULL) continue;
-       MPI_Comm_rank( comm, &rank );
-       MPI_Comm_remote_size( comm, &rsize );
+    while (MTestGetIntercomm(&comm, &leftGroup, 4)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_remote_size(comm, &rsize);
 
-       /* To improve reporting of problems about operations, we
-          change the error handler to errors return */
-       MPI_Errhandler_set( comm, MPI_ERRORS_RETURN );
+        /* To improve reporting of problems about operations, we
+         * change the error handler to errors return */
+        MPI_Errhandler_set(comm, MPI_ERRORS_RETURN);
 
-       for (count = 1; count < 65000; count = 2 * count) {
-           /* The left group will send rank to the right group;
-              The right group will send -rank to the left group */
-           rbuf = (int *)malloc( count * rsize * sizeof(int) );
-           sbuf = (int *)malloc( count * sizeof(int) );
-           for (i=0; i<count*rsize; i++) rbuf[i] = -1;
-           if (leftGroup) {
-               for (i=0; i<count; i++)       sbuf[i] = i + rank*count;
-           }
-           else {
-               for (i=0; i<count; i++)       sbuf[i] = -(i + rank*count);
-           }
-           err = MPI_Allgather( sbuf, count, datatype,
-                                rbuf, count, datatype, comm );
-           if (err) {
-               errs++;
-               MTestPrintError( err );
-           }
-           if (leftGroup) {
-               for (i=0; i<count*rsize; i++) {
-                   if (rbuf[i] != -i) {
-                       errs++;
-                   }
-               }
-           }
-           else {
-               for (i=0; i<count*rsize; i++) {
-                   if (rbuf[i] != i) {
-                       errs++;
-                   }
-               }
-           }
+        for (count = 1; count < 65000; count = 2 * count) {
+            /* The left group will send rank to the right group;
+             * The right group will send -rank to the left group */
+            rbuf = (int *) malloc(count * rsize * sizeof(int));
+            sbuf = (int *) malloc(count * sizeof(int));
+            for (i = 0; i < count * rsize; i++)
+                rbuf[i] = -1;
+            if (leftGroup) {
+                for (i = 0; i < count; i++)
+                    sbuf[i] = i + rank * count;
+            }
+            else {
+                for (i = 0; i < count; i++)
+                    sbuf[i] = -(i + rank * count);
+            }
+            err = MTest_Allgather(sbuf, count, datatype, rbuf, count, datatype, comm);
+            if (err) {
+                errs++;
+                MTestPrintError(err);
+            }
+            if (leftGroup) {
+                for (i = 0; i < count * rsize; i++) {
+                    if (rbuf[i] != -i) {
+                        errs++;
+                    }
+                }
+            }
+            else {
+                for (i = 0; i < count * rsize; i++) {
+                    if (rbuf[i] != i) {
+                        errs++;
+                    }
+                }
+            }
 
-           /* Use Allgather in a unidirectional way */
-           for (i=0; i<count*rsize; i++) rbuf[i] = -1;
-           if (leftGroup) {
-               err = MPI_Allgather( sbuf, 0, datatype,
-                                    rbuf, count, datatype, comm );
-               if (err) {
-                   errs++;
-                   MTestPrintError( err );
-               }
-               for (i=0; i<count*rsize; i++) {
-                   if (rbuf[i] != -i) {
-                       errs++;
-                   }
-               }
-           }
-           else {
-               err = MPI_Allgather( sbuf, count, datatype,
-                                    rbuf, 0, datatype, comm );
-               if (err) {
-                   errs++;
-                   MTestPrintError( err );
-               }
-               for (i=0; i<count*rsize; i++) {
-                   if (rbuf[i] != -1) {
-                       errs++;
-                   }
-               }
-           }
-           free( rbuf );
-           free( sbuf );
-       }
-       MTestFreeComm( &comm );
+            /* Use Allgather in a unidirectional way */
+            for (i = 0; i < count * rsize; i++)
+                rbuf[i] = -1;
+            if (leftGroup) {
+                err = MTest_Allgather(sbuf, 0, datatype, rbuf, count, datatype, comm);
+                if (err) {
+                    errs++;
+                    MTestPrintError(err);
+                }
+                for (i = 0; i < count * rsize; i++) {
+                    if (rbuf[i] != -i) {
+                        errs++;
+                    }
+                }
+            }
+            else {
+                err = MTest_Allgather(sbuf, count, datatype, rbuf, 0, datatype, comm);
+                if (err) {
+                    errs++;
+                    MTestPrintError(err);
+                }
+                for (i = 0; i < count * rsize; i++) {
+                    if (rbuf[i] != -1) {
+                        errs++;
+                    }
+                }
+            }
+            free(rbuf);
+            free(sbuf);
+        }
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index a720ed4..a88cbf7 100644 (file)
@@ -8,12 +8,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "mpitest.h"
+#include "mpicolltest.h"
 
 /*
 static char MTEST_Descrip[] = "Simple intercomm allgatherv test";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0, err;
     int *rbuf = 0, *sbuf = 0;
@@ -22,101 +23,104 @@ int main( int argc, char *argv[] )
     MPI_Comm comm;
     MPI_Datatype datatype;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
     datatype = MPI_INT;
-           /* Get an intercommunicator */
-    while (MTestGetIntercomm( &comm, &leftGroup, 4 )) {
-       if (comm == MPI_COMM_NULL) continue;
-       MPI_Comm_rank( comm, &rank );
-       MPI_Comm_remote_size( comm, &rsize );
+    /* Get an intercommunicator */
+    while (MTestGetIntercomm(&comm, &leftGroup, 4)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_remote_size(comm, &rsize);
 
-       /* To improve reporting of problems about operations, we
-          change the error handler to errors return */
-       MPI_Errhandler_set( comm, MPI_ERRORS_RETURN );
+        /* To improve reporting of problems about operations, we
+         * change the error handler to errors return */
+        MPI_Errhandler_set(comm, MPI_ERRORS_RETURN);
 
-       for (count = 1; count < 65000; count = 2 * count) {
-           /* The left group will send rank to the right group;
-              The right group will send -rank to the left group */
-           rbuf = (int *)malloc( count * rsize * sizeof(int) );
-           sbuf = (int *)malloc( count * sizeof(int) );
-           recvcounts = (int *) malloc( rsize * sizeof(int) );
-           recvdispls = (int *) malloc( rsize * sizeof(int) );
-           for (i=0; i<count*rsize; i++) rbuf[i] = -1;
-           for (i=0; i<rsize; i++) {
-               recvcounts[i] = count;
-               recvdispls[i] = i * count;
-           }
-           if (leftGroup) {
-               for (i=0; i<count; i++)       sbuf[i] = i + rank*count;
-           }
-           else {
-               for (i=0; i<count; i++)       sbuf[i] = -(i + rank*count);
-           }
-           err = MPI_Allgatherv( sbuf, count, datatype,
-                                 rbuf, recvcounts, recvdispls, datatype, 
-                                 comm );
-           if (err) {
-               errs++;
-               MTestPrintError( err );
-           }
-           if (leftGroup) {
-               for (i=0; i<count*rsize; i++) {
-                   if (rbuf[i] != -i) {
-                       errs++;
-                   }
-               }
-           }
-           else {
-               for (i=0; i<count*rsize; i++) {
-                   if (rbuf[i] != i) {
-                       errs++;
-                   }
-               }
-           }
+        for (count = 1; count < 65000; count = 2 * count) {
+            /* The left group will send rank to the right group;
+             * The right group will send -rank to the left group */
+            rbuf = (int *) malloc(count * rsize * sizeof(int));
+            sbuf = (int *) malloc(count * sizeof(int));
+            recvcounts = (int *) malloc(rsize * sizeof(int));
+            recvdispls = (int *) malloc(rsize * sizeof(int));
+            for (i = 0; i < count * rsize; i++)
+                rbuf[i] = -1;
+            for (i = 0; i < rsize; i++) {
+                recvcounts[i] = count;
+                recvdispls[i] = i * count;
+            }
+            if (leftGroup) {
+                for (i = 0; i < count; i++)
+                    sbuf[i] = i + rank * count;
+            }
+            else {
+                for (i = 0; i < count; i++)
+                    sbuf[i] = -(i + rank * count);
+            }
+            err = MTest_Allgatherv(sbuf, count, datatype,
+                                   rbuf, recvcounts, recvdispls, datatype, comm);
+            if (err) {
+                errs++;
+                MTestPrintError(err);
+            }
+            if (leftGroup) {
+                for (i = 0; i < count * rsize; i++) {
+                    if (rbuf[i] != -i) {
+                        errs++;
+                    }
+                }
+            }
+            else {
+                for (i = 0; i < count * rsize; i++) {
+                    if (rbuf[i] != i) {
+                        errs++;
+                    }
+                }
+            }
 
-           /* Use Allgather in a unidirectional way */
-           for (i=0; i<count*rsize; i++) rbuf[i] = -1;
-           if (leftGroup) {
-               err = MPI_Allgatherv( sbuf, 0, datatype,
-                                     rbuf, recvcounts, recvdispls, datatype, 
-                                     comm );
-               if (err) {
-                   errs++;
-                   MTestPrintError( err );
-               }
-               for (i=0; i<count*rsize; i++) {
-                   if (rbuf[i] != -i) {
-                       errs++;
-                   }
-               }
-           }
-           else {
-                for (i=0; i<rsize; i++) {
+            /* Use Allgather in a unidirectional way */
+            for (i = 0; i < count * rsize; i++)
+                rbuf[i] = -1;
+            if (leftGroup) {
+                err = MTest_Allgatherv(sbuf, 0, datatype,
+                                       rbuf, recvcounts, recvdispls, datatype, comm);
+                if (err) {
+                    errs++;
+                    MTestPrintError(err);
+                }
+                for (i = 0; i < count * rsize; i++) {
+                    if (rbuf[i] != -i) {
+                        errs++;
+                    }
+                }
+            }
+            else {
+                for (i = 0; i < rsize; i++) {
                     recvcounts[i] = 0;
                     recvdispls[i] = 0;
                 }
-               err = MPI_Allgatherv( sbuf, count, datatype,
-                                     rbuf, recvcounts, recvdispls, datatype, comm );
-               if (err) {
-                   errs++;
-                   MTestPrintError( err );
-               }
-               for (i=0; i<count*rsize; i++) {
-                   if (rbuf[i] != -1) {
-                       errs++;
-                   }
-               }
-           }
-           free( rbuf );
-           free( sbuf );
-           free( recvcounts );
-           free( recvdispls );
+                err = MTest_Allgatherv(sbuf, count, datatype,
+                                       rbuf, recvcounts, recvdispls, datatype, comm);
+                if (err) {
+                    errs++;
+                    MTestPrintError(err);
+                }
+                for (i = 0; i < count * rsize; i++) {
+                    if (rbuf[i] != -1) {
+                        errs++;
+                    }
+                }
+            }
+            free(rbuf);
+            free(sbuf);
+            free(recvcounts);
+            free(recvdispls);
         }
-       MTestFreeComm( &comm );
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 2ec7614..4014412 100644 (file)
@@ -8,12 +8,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "mpitest.h"
+#include "mpicolltest.h"
 
 /*
 static char MTEST_Descrip[] = "Simple intercomm allreduce test";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0, err;
     int *sendbuf = 0, *recvbuf = 0;
@@ -21,65 +22,68 @@ int main( int argc, char *argv[] )
     MPI_Comm comm;
     MPI_Datatype datatype;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
     datatype = MPI_INT;
     /* Get an intercommunicator */
-    while (MTestGetIntercomm( &comm, &leftGroup, 4 )) {
-       if (comm == MPI_COMM_NULL) continue;
-       MPI_Comm_rank( comm, &rank );
-       MPI_Comm_remote_size( comm, &rsize );
+    while (MTestGetIntercomm(&comm, &leftGroup, 4)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_remote_size(comm, &rsize);
 
-       /* To improve reporting of problems about operations, we
-          change the error handler to errors return */
-       MPI_Errhandler_set( comm, MPI_ERRORS_RETURN );
+        /* To improve reporting of problems about operations, we
+         * change the error handler to errors return */
+        MPI_Errhandler_set(comm, MPI_ERRORS_RETURN);
 
-       for (count = 1; count < 65000; count = 2 * count) {
-           /* printf( "rank = %d(%d)\n", rank, leftGroup ); fflush(stdout); */
-           sendbuf = (int *)malloc( count * sizeof(int) );
-           recvbuf = (int *)malloc( count * sizeof(int) );
-           if (leftGroup) {
-               for (i=0; i<count; i++) sendbuf[i] = i;
-           }
-           else {
-               for (i=0; i<count; i++) sendbuf[i] = -i;
-           }
-           for (i=0; i<count; i++) recvbuf[i] = 0;
-           err = MPI_Allreduce( sendbuf, recvbuf, count, datatype, 
-                                MPI_SUM, comm );
-           if (err) {
-               errs++;
-               MTestPrintError( err );
-           }
-           /* In each process should be the sum of the values from the
-              other process */
-           if (leftGroup) {
-               for (i=0; i<count; i++) {
-                   if (recvbuf[i] != -i * rsize) {
-                       errs++;
-                       if (errs < 10) {
-                           fprintf( stderr, "recvbuf[%d] = %d\n", i, recvbuf[i] );
-                       }
-                   }
-               }
-           }
-           else {
-               for (i=0; i<count; i++) {
-                   if (recvbuf[i] != i * rsize) {
-                       errs++;
-                       if (errs < 10) {
-                           fprintf( stderr, "recvbuf[%d] = %d\n", i, recvbuf[i] );
-                       }
-                   }
-               }
-           }
-            free( sendbuf );
-            free( recvbuf );
-       }
-       MTestFreeComm( &comm );
+        for (count = 1; count < 65000; count = 2 * count) {
+            /* printf("rank = %d(%d)\n", rank, leftGroup); fflush(stdout); */
+            sendbuf = (int *) malloc(count * sizeof(int));
+            recvbuf = (int *) malloc(count * sizeof(int));
+            if (leftGroup) {
+                for (i = 0; i < count; i++)
+                    sendbuf[i] = i;
+            }
+            else {
+                for (i = 0; i < count; i++)
+                    sendbuf[i] = -i;
+            }
+            for (i = 0; i < count; i++)
+                recvbuf[i] = 0;
+            err = MTest_Allreduce(sendbuf, recvbuf, count, datatype, MPI_SUM, comm);
+            if (err) {
+                errs++;
+                MTestPrintError(err);
+            }
+            /* In each process should be the sum of the values from the
+             * other process */
+            if (leftGroup) {
+                for (i = 0; i < count; i++) {
+                    if (recvbuf[i] != -i * rsize) {
+                        errs++;
+                        if (errs < 10) {
+                            fprintf(stderr, "recvbuf[%d] = %d\n", i, recvbuf[i]);
+                        }
+                    }
+                }
+            }
+            else {
+                for (i = 0; i < count; i++) {
+                    if (recvbuf[i] != i * rsize) {
+                        errs++;
+                        if (errs < 10) {
+                            fprintf(stderr, "recvbuf[%d] = %d\n", i, recvbuf[i]);
+                        }
+                    }
+                }
+            }
+            free(sendbuf);
+            free(recvbuf);
+        }
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index a6a55e1..d8ef959 100644 (file)
@@ -8,12 +8,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "mpitest.h"
+#include "mpicolltest.h"
 
 /*
 static char MTEST_Descrip[] = "Simple intercomm alltoall test";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0, err;
     int *sendbuf = 0, *recvbuf = 0;
@@ -21,65 +22,64 @@ int main( int argc, char *argv[] )
     MPI_Comm comm;
     MPI_Datatype datatype;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
     datatype = MPI_INT;
-    while (MTestGetIntercomm( &comm, &leftGroup, 4 )) {
-       if (comm == MPI_COMM_NULL) continue;
-       for (count = 1; count < 66000; count = 2 * count) {
-           /* Get an intercommunicator */
-           MPI_Comm_remote_size( comm, &rsize );
-           MPI_Comm_rank( comm, &rrank );
-           sendbuf = (int *)malloc( rsize * count * sizeof(int) );
-           recvbuf = (int *)malloc( rsize * count * sizeof(int) );
-           for (i=0; i<rsize*count; i++) recvbuf[i] = -1;
-           if (leftGroup) {
-               idx = 0;
-               for (j=0; j<rsize; j++) {
-                   for (i=0; i<count; i++) {
-                       sendbuf[idx++] = i + rrank;
-                   }
-               }
-               err = MPI_Alltoall( sendbuf, count, datatype, 
-                                   NULL, 0, datatype, comm );
-               if (err) {
-                   errs++;
-                   MTestPrintError( err );
-               }
-           }
-           else {
-               int rank, size;
+    while (MTestGetIntercomm(&comm, &leftGroup, 4)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        for (count = 1; count < 66000; count = 2 * count) {
+            /* Get an intercommunicator */
+            MPI_Comm_remote_size(comm, &rsize);
+            MPI_Comm_rank(comm, &rrank);
+            sendbuf = (int *) malloc(rsize * count * sizeof(int));
+            recvbuf = (int *) malloc(rsize * count * sizeof(int));
+            for (i = 0; i < rsize * count; i++)
+                recvbuf[i] = -1;
+            if (leftGroup) {
+                idx = 0;
+                for (j = 0; j < rsize; j++) {
+                    for (i = 0; i < count; i++) {
+                        sendbuf[idx++] = i + rrank;
+                    }
+                }
+                err = MTest_Alltoall(sendbuf, count, datatype, NULL, 0, datatype, comm);
+                if (err) {
+                    errs++;
+                    MTestPrintError(err);
+                }
+            }
+            else {
+                int rank, size;
 
-               MPI_Comm_rank( comm, &rank );
-               MPI_Comm_size( comm, &size );
+                MPI_Comm_rank(comm, &rank);
+                MPI_Comm_size(comm, &size);
 
-               /* In the right group */
-               err = MPI_Alltoall( NULL, 0, datatype, 
-                                   recvbuf, count, datatype, comm );
-               if (err) {
-                   errs++;
-                   MTestPrintError( err );
-               }
-               /* Check that we have received the correct data */
-               idx = 0;
-               for (j=0; j<rsize; j++) {
-                   for (i=0; i<count; i++) {
-                       if (recvbuf[idx++] != i + j) {
-                           errs++;
-                           if (errs < 10) 
-                               fprintf( stderr, "buf[%d] = %d on %d\n", 
-                                        i, recvbuf[i], rank );
-                       }
-                   }
-               }
-           }
-           free( recvbuf );
-           free( sendbuf );
-       }
-       MTestFreeComm( &comm );
+                /* In the right group */
+                err = MTest_Alltoall(NULL, 0, datatype, recvbuf, count, datatype, comm);
+                if (err) {
+                    errs++;
+                    MTestPrintError(err);
+                }
+                /* Check that we have received the correct data */
+                idx = 0;
+                for (j = 0; j < rsize; j++) {
+                    for (i = 0; i < count; i++) {
+                        if (recvbuf[idx++] != i + j) {
+                            errs++;
+                            if (errs < 10)
+                                fprintf(stderr, "buf[%d] = %d on %d\n", i, recvbuf[i], rank);
+                        }
+                    }
+                }
+            }
+            free(recvbuf);
+            free(sendbuf);
+        }
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 2233923..90cf06a 100644 (file)
@@ -7,6 +7,7 @@
 #include "mpitest.h"
 #include <stdlib.h>
 #include <stdio.h>
+#include "mpicolltest.h"
 
 /*
   This program tests MPI_Alltoallv by having processor i send different
 
   Because there are separate send and receive types to alltoallv,
   there need to be tests to rearrange data on the fly.  Not done yet.
-  
+
   The first test sends i items to processor i from all processors.
 
   Currently, the test uses only MPI_INT; this is adequate for testing systems
   that use point-to-point operations
  */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
     MPI_Comm comm;
-    int      *sbuf, *rbuf;
-    int      rank, size, lsize, asize;
-    int      *sendcounts, *recvcounts, *rdispls, *sdispls;
-    int      i, j, *p, err;
-    int      leftGroup;
+    int *sbuf, *rbuf;
+    int rank, size, lsize, asize;
+    int *sendcounts, *recvcounts, *rdispls, *sdispls;
+    int i, j, *p, err;
+    int leftGroup;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
     err = 0;
 
-    while (MTestGetIntercomm( &comm, &leftGroup, 4 )) {
-      if (comm == MPI_COMM_NULL) continue;
+    while (MTestGetIntercomm(&comm, &leftGroup, 4)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
 
-      /* Create the buffer */
-      MPI_Comm_size( comm, &lsize );
-      MPI_Comm_remote_size( comm, &size );
-      asize = (lsize > size) ? lsize : size;
-      MPI_Comm_rank( comm, &rank );
-      sbuf = (int *)malloc( size * size * sizeof(int) );
-      rbuf = (int *)malloc( asize * asize * sizeof(int) );
-      if (!sbuf || !rbuf) {
-       fprintf( stderr, "Could not allocated buffers!\n" );
-       MPI_Abort( comm, 1 );
-        exit(1);
-      }
+        /* Create the buffer */
+        MPI_Comm_size(comm, &lsize);
+        MPI_Comm_remote_size(comm, &size);
+        asize = (lsize > size) ? lsize : size;
+        MPI_Comm_rank(comm, &rank);
+        sbuf = (int *) malloc(size * size * sizeof(int));
+        rbuf = (int *) malloc(asize * asize * sizeof(int));
+        if (!sbuf || !rbuf) {
+            fprintf(stderr, "Could not allocated buffers!\n");
+            MPI_Abort(comm, 1);
+        }
 
-      /* Load up the buffers */
-      for (i=0; i<size*size; i++) {
-       sbuf[i] = i + 100*rank;
-       rbuf[i] = -i;
-      }
+        /* Load up the buffers */
+        for (i = 0; i < size * size; i++) {
+            sbuf[i] = i + 100 * rank;
+            rbuf[i] = -i;
+        }
 
-      /* Create and load the arguments to alltoallv */
-      sendcounts = (int *)malloc( size * sizeof(int) );
-      recvcounts = (int *)malloc( size * sizeof(int) );
-      rdispls    = (int *)malloc( size * sizeof(int) );
-      sdispls    = (int *)malloc( size * sizeof(int) );
-      if (!sendcounts || !recvcounts || !rdispls || !sdispls) {
-       fprintf( stderr, "Could not allocate arg items!\n" );
-       MPI_Abort( comm, 1 );
-        exit(1);
-      }
-      for (i=0; i<size; i++) {
-       sendcounts[i] = i;
-       sdispls[i]    = (i * (i+1))/2;
-       recvcounts[i] = rank;
-       rdispls[i] = i * rank;
-      }
-      MPI_Alltoallv( sbuf, sendcounts, sdispls, MPI_INT,
-                    rbuf, recvcounts, rdispls, MPI_INT, comm );
+        /* Create and load the arguments to alltoallv */
+        sendcounts = (int *) malloc(size * sizeof(int));
+        recvcounts = (int *) malloc(size * sizeof(int));
+        rdispls = (int *) malloc(size * sizeof(int));
+        sdispls = (int *) malloc(size * sizeof(int));
+        if (!sendcounts || !recvcounts || !rdispls || !sdispls) {
+            fprintf(stderr, "Could not allocate arg items!\n");
+            MPI_Abort(comm, 1);
+        }
+        for (i = 0; i < size; i++) {
+            sendcounts[i] = i;
+            sdispls[i] = (i * (i + 1)) / 2;
+            recvcounts[i] = rank;
+            rdispls[i] = i * rank;
+        }
+        MTest_Alltoallv(sbuf, sendcounts, sdispls, MPI_INT,
+                        rbuf, recvcounts, rdispls, MPI_INT, comm);
 
-      /* Check rbuf */
-      for (i=0; i<size; i++) {
-       p = rbuf + rdispls[i];
-       for (j=0; j<rank; j++) {
-         if (p[j] != i * 100 + (rank*(rank+1))/2 + j) {
-           fprintf( stderr, "[%d] got %d expected %d for %dth\n",
-                    rank, p[j],(i*(i+1))/2 + j, j );
-           err++;
-         }
-       }
-      }
+        /* Check rbuf */
+        for (i = 0; i < size; i++) {
+            p = rbuf + rdispls[i];
+            for (j = 0; j < rank; j++) {
+                if (p[j] != i * 100 + (rank * (rank + 1)) / 2 + j) {
+                    fprintf(stderr, "[%d] got %d expected %d for %dth\n",
+                            rank, p[j], (i * (i + 1)) / 2 + j, j);
+                    err++;
+                }
+            }
+        }
 
-      free( sdispls );
-      free( rdispls );
-      free( recvcounts );
-      free( sendcounts );
-      free( rbuf );
-      free( sbuf );
-      MTestFreeComm( &comm );
+        free(sdispls);
+        free(rdispls);
+        free(recvcounts);
+        free(sendcounts);
+        free(rbuf);
+        free(sbuf);
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( err );
+    MTest_Finalize(err);
     MPI_Finalize();
     return 0;
 }
index 745bbb1..7bf1544 100644 (file)
@@ -7,6 +7,7 @@
 #include "mpitest.h"
 #include <stdlib.h>
 #include <stdio.h>
+#include "mpicolltest.h"
 
 /*
   This program tests MPI_Alltoallw by having processor i send different
 
   Because there are separate send and receive types to alltoallw,
   there need to be tests to rearrange data on the fly.  Not done yet.
-  
+
   The first test sends i items to processor i from all processors.
 
   Currently, the test uses only MPI_INT; this is adequate for testing systems
   that use point-to-point operations
  */
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
 
     MPI_Comm comm;
-    int      *sbuf, *rbuf;
-    int      rank, size, lsize, asize;
-    int      *sendcounts, *recvcounts, *rdispls, *sdispls;
-    int      i, j, *p, err;
+    int *sbuf, *rbuf;
+    int rank, size, lsize, asize;
+    int *sendcounts, *recvcounts, *rdispls, *sdispls;
+    int i, j, *p, err;
     MPI_Datatype *sendtypes, *recvtypes;
-    int      leftGroup;
+    int leftGroup;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
     err = 0;
 
-    while (MTestGetIntercomm( &comm, &leftGroup, 4 )) {
-      if (comm == MPI_COMM_NULL) continue;
+    while (MTestGetIntercomm(&comm, &leftGroup, 4)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+
+        /* Create the buffer */
+        MPI_Comm_size(comm, &lsize);
+        MPI_Comm_remote_size(comm, &size);
+        asize = (lsize > size) ? lsize : size;
+        MPI_Comm_rank(comm, &rank);
+        sbuf = (int *) malloc(size * size * sizeof(int));
+        rbuf = (int *) malloc(asize * asize * sizeof(int));
+        if (!sbuf || !rbuf) {
+            fprintf(stderr, "Could not allocated buffers!\n");
+            MPI_Abort(comm, 1);
+        }
+
+        /* Load up the buffers */
+        for (i = 0; i < size * size; i++) {
+            sbuf[i] = i + 100 * rank;
+            rbuf[i] = -i;
+        }
 
-      /* Create the buffer */
-      MPI_Comm_size( comm, &lsize );
-      MPI_Comm_remote_size( comm, &size );
-      asize = (lsize > size) ? lsize : size;
-      MPI_Comm_rank( comm, &rank );
-      sbuf = (int *)malloc( size * size * sizeof(int) );
-      rbuf = (int *)malloc( asize * asize * sizeof(int) );
-      if (!sbuf || !rbuf) {
-       fprintf( stderr, "Could not allocated buffers!\n" );
-       MPI_Abort( comm, 1 );
-        exit(1);
-      }
-      
-      /* Load up the buffers */
-      for (i=0; i<size*size; i++) {
-       sbuf[i] = i + 100*rank;
-       rbuf[i] = -i;
-      }
+        /* Create and load the arguments to alltoallv */
+        sendcounts = (int *) malloc(size * sizeof(int));
+        recvcounts = (int *) malloc(size * sizeof(int));
+        rdispls = (int *) malloc(size * sizeof(int));
+        sdispls = (int *) malloc(size * sizeof(int));
+        sendtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
+        recvtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
+        if (!sendcounts || !recvcounts || !rdispls || !sdispls || !sendtypes || !recvtypes) {
+            fprintf(stderr, "Could not allocate arg items!\n");
+            MPI_Abort(comm, 1);
+        }
+        /* Note that process 0 sends no data (sendcounts[0] = 0) */
+        for (i = 0; i < size; i++) {
+            sendcounts[i] = i;
+            sdispls[i] = (((i + 1) * (i)) / 2) * sizeof(int);
+            sendtypes[i] = MPI_INT;
+            recvcounts[i] = rank;
+            rdispls[i] = i * rank * sizeof(int);
+            recvtypes[i] = MPI_INT;
+        }
+        MTest_Alltoallw(sbuf, sendcounts, sdispls, sendtypes,
+                        rbuf, recvcounts, rdispls, recvtypes, comm);
 
-      /* Create and load the arguments to alltoallv */
-      sendcounts = (int *)malloc( size * sizeof(int) );
-      recvcounts = (int *)malloc( size * sizeof(int) );
-      rdispls    = (int *)malloc( size * sizeof(int) );
-      sdispls    = (int *)malloc( size * sizeof(int) );
-      sendtypes  = (MPI_Datatype *)malloc( size * sizeof(MPI_Datatype) );
-      recvtypes  = (MPI_Datatype *)malloc( size * sizeof(MPI_Datatype) );
-      if (!sendcounts || !recvcounts || !rdispls || !sdispls || !sendtypes || !recvtypes) {
-       fprintf( stderr, "Could not allocate arg items!\n" );
-       MPI_Abort( comm, 1 );
-        exit(1);
-      }
-      /* Note that process 0 sends no data (sendcounts[0] = 0) */
-      for (i=0; i<size; i++) {
-       sendcounts[i] = i;
-       sdispls[i]    = (((i+1) * (i))/2) * sizeof(int);
-        sendtypes[i]  = MPI_INT;
-       recvcounts[i] = rank;
-       rdispls[i]    = i * rank * sizeof(int);
-       recvtypes[i]  = MPI_INT;
-      }
-      MPI_Alltoallw( sbuf, sendcounts, sdispls, sendtypes,
-                    rbuf, recvcounts, rdispls, recvtypes, comm );
-      
-      /* Check rbuf */
-      for (i=0; i<size; i++) {
-       p = rbuf + rdispls[i]/sizeof(int);
-       for (j=0; j<rank; j++) {
-         if (p[j] != i * 100 + (rank*(rank+1))/2 + j) {
-           fprintf( stderr, "[%d] got %d expected %d for %dth\n",
-                    rank, p[j],(i*(i+1))/2 + j, j );
-           err++;
-         }
-       }
-      }
+        /* Check rbuf */
+        for (i = 0; i < size; i++) {
+            p = rbuf + rdispls[i] / sizeof(int);
+            for (j = 0; j < rank; j++) {
+                if (p[j] != i * 100 + (rank * (rank + 1)) / 2 + j) {
+                    fprintf(stderr, "[%d] got %d expected %d for %dth\n",
+                            rank, p[j], (i * (i + 1)) / 2 + j, j);
+                    err++;
+                }
+            }
+        }
 
-      free(sendtypes);
-      free(recvtypes);
-      free( sdispls );
-      free( rdispls );
-      free( recvcounts );
-      free( sendcounts );
-      free( rbuf );
-      free( sbuf );
-      MTestFreeComm( &comm );
+        free(sendtypes);
+        free(recvtypes);
+        free(sdispls);
+        free(rdispls);
+        free(recvcounts);
+        free(sendcounts);
+        free(rbuf);
+        free(sbuf);
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( err );
+    MTest_Finalize(err);
     MPI_Finalize();
     return 0;
 }
index b2d022a..43e48c0 100644 (file)
@@ -8,6 +8,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "mpitest.h"
+#include "mpicolltest.h"
 
 /*
 static char MTEST_Descrip[] = "Simple intercomm barrier test";
@@ -15,45 +16,45 @@ static char MTEST_Descrip[] = "Simple intercomm barrier test";
 
 /* This only checks that the Barrier operation accepts intercommunicators.
    It does not check for the semantics of a intercomm barrier (all processes
-   in the local group can exit when (but not before) all processes in the 
+   in the local group can exit when (but not before) all processes in the
    remote group enter the barrier */
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0, err;
     int leftGroup;
     MPI_Comm comm;
-    /* MPI_Datatype datatype; */
+    MPI_Datatype datatype;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
-    /* datatype = MPI_INT; */
+    datatype = MPI_INT;
     /* Get an intercommunicator */
-    while (MTestGetIntercomm( &comm, &leftGroup, 4 )) {
+    while (MTestGetIntercomm(&comm, &leftGroup, 4)) {
         if (comm == MPI_COMM_NULL)
             continue;
 
-       /* To improve reporting of problems about operations, we
-          change the error handler to errors return */
-       MPI_Comm_set_errhandler( comm, MPI_ERRORS_RETURN );
-       if (leftGroup) {
-           err = MPI_Barrier( comm );
-           if (err) {
-               errs++;
-               MTestPrintError( err );
-           }
-       }
-       else {
-           /* In the right group */
-           err = MPI_Barrier( comm );
-           if (err) {
-               errs++;
-               MTestPrintError( err );
-           }
-       }
-       MTestFreeComm( &comm );
+        /* To improve reporting of problems about operations, we
+         * change the error handler to errors return */
+        MPI_Comm_set_errhandler(comm, MPI_ERRORS_RETURN);
+        if (leftGroup) {
+            err = MTest_Barrier(comm);
+            if (err) {
+                errs++;
+                MTestPrintError(err);
+            }
+        }
+        else {
+            /* In the right group */
+            err = MTest_Barrier(comm);
+            if (err) {
+                errs++;
+                MTestPrintError(err);
+            }
+        }
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 660d861..39d0cda 100644 (file)
@@ -8,12 +8,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "mpitest.h"
+#include "mpicolltest.h"
 
 /*
 static char MTEST_Descrip[] = "Simple intercomm broadcast test";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0, err;
     int *buf = 0;
@@ -21,67 +22,69 @@ int main( int argc, char *argv[] )
     MPI_Comm comm;
     MPI_Datatype datatype;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
     datatype = MPI_INT;
     /* Get an intercommunicator */
-    while (MTestGetIntercomm( &comm, &leftGroup, 4 )) {
+    while (MTestGetIntercomm(&comm, &leftGroup, 4)) {
         if (comm == MPI_COMM_NULL)
             continue;
 
-       MPI_Comm_rank( comm, &rank );
+        MPI_Comm_rank(comm, &rank);
 
-       /* To improve reporting of problems about operations, we
-          change the error handler to errors return */
-       MPI_Comm_set_errhandl