Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Update RMA tests
authordegomme <augustin.degomme@unibas.ch>
Sun, 12 Feb 2017 00:20:37 +0000 (01:20 +0100)
committerdegomme <augustin.degomme@unibas.ch>
Sun, 12 Feb 2017 01:08:28 +0000 (02:08 +0100)
125 files changed:
teshsuite/smpi/mpich3-test/rma/CMakeLists.txt
teshsuite/smpi/mpich3-test/rma/acc-loc.c
teshsuite/smpi/mpich3-test/rma/acc-pairtype.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/accfence1.c
teshsuite/smpi/mpich3-test/rma/accfence2.c
teshsuite/smpi/mpich3-test/rma/accfence2_am.c
teshsuite/smpi/mpich3-test/rma/accpscw1.c
teshsuite/smpi/mpich3-test/rma/adlb_mimic1.c
teshsuite/smpi/mpich3-test/rma/aint.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/allocmem.c
teshsuite/smpi/mpich3-test/rma/at_complete.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/atomic_get.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/atomic_rmw_cas.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/atomic_rmw_fop.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/atomic_rmw_gacc.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/attrorderwin.c
teshsuite/smpi/mpich3-test/rma/baseattrwin.c
teshsuite/smpi/mpich3-test/rma/compare_and_swap.c
teshsuite/smpi/mpich3-test/rma/contention_put.c
teshsuite/smpi/mpich3-test/rma/contention_putget.c
teshsuite/smpi/mpich3-test/rma/contig_displ.c
teshsuite/smpi/mpich3-test/rma/derived-acc-flush_local.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/epochtest.c
teshsuite/smpi/mpich3-test/rma/fence_shm.c
teshsuite/smpi/mpich3-test/rma/fetch_and_op.c
teshsuite/smpi/mpich3-test/rma/fetchandadd.c
teshsuite/smpi/mpich3-test/rma/fetchandadd_am.c
teshsuite/smpi/mpich3-test/rma/fetchandadd_tree.c
teshsuite/smpi/mpich3-test/rma/fetchandadd_tree_am.c
teshsuite/smpi/mpich3-test/rma/fkeyvalwin.c
teshsuite/smpi/mpich3-test/rma/flush.c
teshsuite/smpi/mpich3-test/rma/get-struct.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/get_acc_local.c
teshsuite/smpi/mpich3-test/rma/get_accumulate.c
teshsuite/smpi/mpich3-test/rma/getfence1.c
teshsuite/smpi/mpich3-test/rma/getgroup.c
teshsuite/smpi/mpich3-test/rma/ircpi.c [deleted file]
teshsuite/smpi/mpich3-test/rma/large-acc-flush_local.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/large-small-acc.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/linked_list.c
teshsuite/smpi/mpich3-test/rma/linked_list_bench_lock_all.c
teshsuite/smpi/mpich3-test/rma/linked_list_bench_lock_excl.c
teshsuite/smpi/mpich3-test/rma/linked_list_bench_lock_shr.c
teshsuite/smpi/mpich3-test/rma/linked_list_fop.c
teshsuite/smpi/mpich3-test/rma/linked_list_lockall.c
teshsuite/smpi/mpich3-test/rma/lock_contention_dt.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/lock_dt.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/lock_dt_flush.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/lock_dt_flushlocal.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/lock_nested.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/lockall_dt.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/lockall_dt_flush.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/lockall_dt_flushall.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/lockall_dt_flushlocal.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/lockall_dt_flushlocalall.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/lockcontention.c
teshsuite/smpi/mpich3-test/rma/lockcontention2.c
teshsuite/smpi/mpich3-test/rma/lockcontention3.c
teshsuite/smpi/mpich3-test/rma/locknull.c
teshsuite/smpi/mpich3-test/rma/lockopts.c
teshsuite/smpi/mpich3-test/rma/manyget.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/manyrma2.c
teshsuite/smpi/mpich3-test/rma/mcs-mutex.c
teshsuite/smpi/mpich3-test/rma/mixedsync.c
teshsuite/smpi/mpich3-test/rma/mutex_bench.c
teshsuite/smpi/mpich3-test/rma/nb_test.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/nullpscw.c
teshsuite/smpi/mpich3-test/rma/overlap_wins_rma.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/pscw_ordering.c
teshsuite/smpi/mpich3-test/rma/put_base.c
teshsuite/smpi/mpich3-test/rma/put_bottom.c
teshsuite/smpi/mpich3-test/rma/putfence1.c
teshsuite/smpi/mpich3-test/rma/putfidx.c
teshsuite/smpi/mpich3-test/rma/putpscw1.c
teshsuite/smpi/mpich3-test/rma/racc_local_comp.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/req_example.c
teshsuite/smpi/mpich3-test/rma/reqops.c
teshsuite/smpi/mpich3-test/rma/rget-unlock.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/rmanull.c
teshsuite/smpi/mpich3-test/rma/rmazero.c
teshsuite/smpi/mpich3-test/rma/rput_local_comp.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/selfrma.c
teshsuite/smpi/mpich3-test/rma/strided_acc_indexed.c
teshsuite/smpi/mpich3-test/rma/strided_acc_onelock.c
teshsuite/smpi/mpich3-test/rma/strided_acc_subarray.c
teshsuite/smpi/mpich3-test/rma/strided_get_indexed.c
teshsuite/smpi/mpich3-test/rma/strided_getacc_indexed.c
teshsuite/smpi/mpich3-test/rma/strided_getacc_indexed_shared.c
teshsuite/smpi/mpich3-test/rma/strided_putget_indexed.c
teshsuite/smpi/mpich3-test/rma/strided_putget_indexed_shared.c
teshsuite/smpi/mpich3-test/rma/test1.c
teshsuite/smpi/mpich3-test/rma/test1_am.c
teshsuite/smpi/mpich3-test/rma/test1_dt.c
teshsuite/smpi/mpich3-test/rma/test2.c
teshsuite/smpi/mpich3-test/rma/test2_am.c
teshsuite/smpi/mpich3-test/rma/test3.c
teshsuite/smpi/mpich3-test/rma/test3_am.c
teshsuite/smpi/mpich3-test/rma/test4.c
teshsuite/smpi/mpich3-test/rma/test4_am.c
teshsuite/smpi/mpich3-test/rma/test5.c
teshsuite/smpi/mpich3-test/rma/test5_am.c
teshsuite/smpi/mpich3-test/rma/testlist
teshsuite/smpi/mpich3-test/rma/transpose1.c
teshsuite/smpi/mpich3-test/rma/transpose2.c
teshsuite/smpi/mpich3-test/rma/transpose3.c
teshsuite/smpi/mpich3-test/rma/transpose4.c
teshsuite/smpi/mpich3-test/rma/transpose5.c
teshsuite/smpi/mpich3-test/rma/transpose6.c
teshsuite/smpi/mpich3-test/rma/transpose7.c
teshsuite/smpi/mpich3-test/rma/win_dynamic_acc.c
teshsuite/smpi/mpich3-test/rma/win_flavors.c
teshsuite/smpi/mpich3-test/rma/win_info.c
teshsuite/smpi/mpich3-test/rma/win_large_shm.c
teshsuite/smpi/mpich3-test/rma/win_shared.c
teshsuite/smpi/mpich3-test/rma/win_shared_create.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/win_shared_noncontig.c
teshsuite/smpi/mpich3-test/rma/win_shared_noncontig_put.c
teshsuite/smpi/mpich3-test/rma/win_shared_put_flush_get.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/win_shared_rma_flush_load.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/win_shared_zerobyte.c [new file with mode: 0644]
teshsuite/smpi/mpich3-test/rma/wincall.c
teshsuite/smpi/mpich3-test/rma/window_creation.c
teshsuite/smpi/mpich3-test/rma/winname.c
teshsuite/smpi/mpich3-test/rma/wintest.c
teshsuite/smpi/mpich3-test/rma/wrma_flush_get.c [new file with mode: 0644]

index adf5e2f..4bedbee 100644 (file)
@@ -12,7 +12,9 @@ if(enable_smpi AND enable_smpi_MPICH3_testsuite)
 
   foreach(file accfence1 accfence2_am accfence2 accpscw1 allocmem epochtest getfence1 getgroup manyrma3 nullpscw
           putfence1 putfidx putpscw1 test1_am test1 test1_dt test2_am test2 test3 test5_am test5 transpose1 transpose2
-          transpose3 transpose6 transpose7 window_creation)
+          transpose3 transpose6 transpose7 window_creation  
+          at_complete  acc-pairtype manyget large-small-acc 
+          lock_nested)
     # not compiled files: acc-loc adlb_mimic1 attrorderwin badrma baseattrwin compare_and_swap contention_put
     # contention_putget contig_displ fence_shm fetchandadd_am fetchandadd fetchandadd_tree_am fetchandadd_tree 
     # fetch_and_op fkeyvalwin flush get_acc_local get_accumulate ircpi linked_list_bench_lock_all 
@@ -22,7 +24,8 @@ if(enable_smpi AND enable_smpi_MPICH3_testsuite)
     # strided_acc_onelock strided_acc_subarray strided_getacc_indexed strided_getacc_indexed_shared strided_get_indexed
     # strided_putget_indexed strided_putget_indexed_shared test3_am test4_am test4 transpose4 transpose5 wincall 
     # win_dynamic_acc win_flavors win_info winname win_shared win_shared_noncontig win_shared_noncontig_put 
-    # win_large_shm win_zero wintest
+    # win_large_shm win_zero wintest get-struct atomic_rmw_fop atomic_rmw_gacc rget-unlock atomic_get atomic_rmw_cas
+    # win_shared_zerobyte aint
     add_executable(${file} ${file}.c)
     target_link_libraries(${file} simgrid mtest_c)
     set_target_properties(${file} PROPERTIES COMPILE_FLAGS "${MPICH_FLAGS}")
@@ -46,7 +49,9 @@ foreach(file accfence1 accfence2_am accfence2 accpscw1 allocmem epochtest getfen
           strided_acc_subarray strided_getacc_indexed strided_getacc_indexed_shared strided_get_indexed 
           strided_putget_indexed strided_putget_indexed_shared test3_am test4_am test4 transpose4 transpose5 wincall 
           win_dynamic_acc win_flavors win_info winname win_shared win_shared_noncontig win_shared_noncontig_put 
-          win_large_shm win_zero wintest)
+          win_large_shm win_zero wintest win_shared_zerobyte get-struct
+          at_complete atomic_rmw_fop atomic_rmw_cas atomic_rmw_gacc atomic_get aint acc-pairtype manyget large-small-acc  
+          rget-unlock overlap_wins_rma lock_nested)
   set(examples_src  ${examples_src} ${CMAKE_CURRENT_SOURCE_DIR}/${file}.c)
 endforeach()
 
index 18c3e3a..6e76970 100644 (file)
@@ -20,7 +20,8 @@ typedef struct {
 
 static int errors = 0;
 
-int main(int argc, char **argv) {
+int main(int argc, char **argv)
+{
     int me, nproc;
     twoint_t *data = NULL;
     twoint_t mine;
@@ -76,10 +77,10 @@ int main(int argc, char **argv) {
     MPI_Accumulate(&mine, 1, MPI_2INT, 0, 0, 1, MPI_2INT, MPI_MINLOC, win);
     MPI_Win_fence(0, win);
 
-    if (me == 0 && (data->loc != nproc-1 || data->val != 1)) {
+    if (me == 0 && (data->loc != nproc - 1 || data->val != 1)) {
         errors++;
         printf("Expected: { loc = %d, val = %d }  Actual: { loc = %d, val = %d }\n",
-               nproc-1, 1, data->loc, data->val);
+               nproc - 1, 1, data->loc, data->val);
     }
 
     /* All processes perform MAXLOC and MINLOC operations on a 2INT on rank 0.
diff --git a/teshsuite/smpi/mpich3-test/rma/acc-pairtype.c b/teshsuite/smpi/mpich3-test/rma/acc-pairtype.c
new file mode 100644 (file)
index 0000000..5c23435
--- /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.
+ */
+
+/* This test is going to test when Accumulate operation is working
+ * with pair types. */
+
+#include "mpi.h"
+#include <stdio.h>
+
+#define DATA_SIZE 25
+
+typedef struct long_double_int {
+    long double a;
+    int b;
+} long_double_int_t;
+
+int main(int argc, char *argv[])
+{
+    MPI_Win win;
+    int errors = 0;
+    int rank, nproc, i;
+    long_double_int_t *orig_buf;
+    long_double_int_t *tar_buf;
+    MPI_Datatype vector_dtp;
+
+    MPI_Init(&argc, &argv);
+
+    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    MPI_Alloc_mem(sizeof(long_double_int_t) * DATA_SIZE, MPI_INFO_NULL, &orig_buf);
+    MPI_Alloc_mem(sizeof(long_double_int_t) * DATA_SIZE, MPI_INFO_NULL, &tar_buf);
+
+    for (i = 0; i < DATA_SIZE; i++) {
+        orig_buf[i].a = 1.0;
+        orig_buf[i].b = 1;
+        tar_buf[i].a = 0;
+        tar_buf[i].b = 0;
+    }
+
+    MPI_Type_vector(5 /* count */ , 3 /* blocklength */ , 5 /* stride */ , MPI_LONG_DOUBLE_INT,
+                    &vector_dtp);
+    MPI_Type_commit(&vector_dtp);
+
+    MPI_Win_create(tar_buf, sizeof(long_double_int_t) * DATA_SIZE, sizeof(long_double_int_t),
+                   MPI_INFO_NULL, MPI_COMM_WORLD, &win);
+
+    if (rank == 0) {
+        MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
+        MPI_Accumulate(orig_buf, 1, vector_dtp, 1, 0, 1, vector_dtp, MPI_MAXLOC, win);
+        MPI_Win_unlock(1, win);
+    }
+
+    MPI_Win_free(&win);
+
+    if (rank == 1) {
+        for (i = 0; i < DATA_SIZE; i++) {
+            if (i % 5 < 3) {
+                if (tar_buf[i].a != 1.0 || tar_buf[i].b != 1) {
+                    errors++;
+                }
+            }
+            else {
+                if (tar_buf[i].a != 0.0 || tar_buf[i].b != 0) {
+                    errors++;
+                }
+            }
+        }
+    }
+
+    MPI_Type_free(&vector_dtp);
+
+    MPI_Free_mem(orig_buf);
+    MPI_Free_mem(tar_buf);
+
+    if (rank == 1) {
+        if (errors == 0)
+            printf(" No Errors\n");
+    }
+
+    MPI_Finalize();
+    return 0;
+}
index 91d9f43..f4b8930 100644 (file)
 static char MTEST_Descrip[] = "Accumulate/Replace with Fence";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0, err;
     int rank, size, source, dest;
-    int minsize = 2, count; 
-    MPI_Comm      comm;
-    MPI_Win       win;
-    MPI_Aint      extent;
+    int minsize = 2, count;
+    MPI_Comm comm;
+    MPI_Win win;
+    MPI_Aint extent, lb;
     MTestDatatype 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;
-       /* Determine the sender and receiver */
-       MPI_Comm_rank( comm, &rank );
-       MPI_Comm_size( comm, &size );
-       source = 0;
-       dest   = size - 1;
-       
-       for (count = 1; count < 65000; count = count * 2) {
-           while (MTestGetDatatypes( &sendtype, &recvtype, count )) {
-               /* Make sure that everyone has a recv buffer */
-               recvtype.InitBuf( &recvtype );
+    /* The following illustrates the use of the routines to
+     * run through a selection of communicators and datatypes.
+     * Use subsets of these for tests that do not involve combinations
+     * of communicators, datatypes, and counts of datatypes */
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        /* Determine the sender and receiver */
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_size(comm, &size);
+        source = 0;
+        dest = size - 1;
 
-               MPI_Type_extent( recvtype.datatype, &extent );
-               MPI_Win_create( recvtype.buf, recvtype.count * extent, 
-                               (int)extent, MPI_INFO_NULL, comm, &win );
-               MPI_Win_fence( 0, win );
-               if (rank == source) {
-                   sendtype.InitBuf( &sendtype );
+        MTEST_DATATYPE_FOR_EACH_COUNT(count) {
+            while (MTestGetDatatypes(&sendtype, &recvtype, count)) {
+                /* Make sure that everyone has a recv buffer */
+                recvtype.InitBuf(&recvtype);
 
-                   /* To improve reporting of problems about operations, we
-                      change the error handler to errors return */
-                   MPI_Win_set_errhandler( win, MPI_ERRORS_RETURN );
-                   
-                   /* MPI_REPLACE on accumulate is almost the same 
-                      as MPI_Put; the only difference is in the
-                      handling of overlapping accumulate operations,
-                      which are not tested here */
-                   err = MPI_Accumulate( sendtype.buf, sendtype.count, 
-                                         sendtype.datatype, dest, 0, 
-                                         recvtype.count, recvtype.datatype, 
-                                         MPI_REPLACE, win );
-                   if (err) {
-                       errs++;
-                       if (errs < 10) {
-                           printf( "Accumulate types: send %s, recv %s\n",
-                                   MTestGetDatatypeName( &sendtype ),
-                                   MTestGetDatatypeName( &recvtype ) );
-                           MTestPrintError( err );
-                       }
-                   }
-                   err = MPI_Win_fence( 0, win );
-                   if (err) {
-                       errs++;
-                       if (errs < 10) {
-                           MTestPrintError( err );
-                       }
-                   }
-               }
-               else if (rank == dest) {
-                   MPI_Win_fence( 0, win );
-                   /* This should have the same effect, in terms of
-                      transfering data, as a send/recv pair */
-                   err = MTestCheckRecv( 0, &recvtype );
-                   if (err) {
-                       errs += err;
-                   }
-               }
-               else {
-                   MPI_Win_fence( 0, win );
-               }
-               MPI_Win_free( &win );
-               MTestFreeDatatype( &sendtype );
-               MTestFreeDatatype( &recvtype );
-           }
-       }
+                MPI_Type_extent(recvtype.datatype, &extent);
+                MPI_Type_lb(recvtype.datatype, &lb);
+                MPI_Win_create(recvtype.buf, recvtype.count * extent + lb,
+                               (int) extent, MPI_INFO_NULL, comm, &win);
+                MPI_Win_fence(0, win);
+                if (rank == source) {
+                    sendtype.InitBuf(&sendtype);
+
+                    /* To improve reporting of problems about operations, we
+                     * change the error handler to errors return */
+                    MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+
+                    /* MPI_REPLACE on accumulate is almost the same
+                     * as MPI_Put; the only difference is in the
+                     * handling of overlapping accumulate operations,
+                     * which are not tested here */
+                    err = MPI_Accumulate(sendtype.buf, sendtype.count,
+                                         sendtype.datatype, dest, 0,
+                                         recvtype.count, recvtype.datatype, MPI_REPLACE, win);
+                    if (err) {
+                        errs++;
+                        if (errs < 10) {
+                            printf("Accumulate types: send %s, recv %s\n",
+                                   MTestGetDatatypeName(&sendtype),
+                                   MTestGetDatatypeName(&recvtype));
+                            MTestPrintError(err);
+                        }
+                    }
+                    err = MPI_Win_fence(0, win);
+                    if (err) {
+                        errs++;
+                        if (errs < 10) {
+                            MTestPrintError(err);
+                        }
+                    }
+                }
+                else if (rank == dest) {
+                    MPI_Win_fence(0, win);
+                    /* This should have the same effect, in terms of
+                     * transfering data, as a send/recv pair */
+                    err = MTestCheckRecv(0, &recvtype);
+                    if (err) {
+                        errs += err;
+                    }
+                }
+                else {
+                    MPI_Win_fence(0, win);
+                }
+                MPI_Win_free(&win);
+                MTestFreeDatatype(&sendtype);
+                MTestFreeDatatype(&recvtype);
+            }
+        }
         MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 4366e10..b0bf958 100644 (file)
 static char MTEST_Descrip[] = "Test MPI_Accumulate with fence";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0;
     int rank, size, source;
-    int minsize = 2, count, i; 
-    MPI_Comm      comm;
-    MPI_Win       win;
-    int           *winbuf, *sbuf;
+    int minsize = 2, count, i;
+    MPI_Comm comm;
+    MPI_Win win;
+    int *winbuf, *sbuf;
 
-    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;
-       /* Determine the sender and receiver */
-       MPI_Comm_rank( comm, &rank );
-       MPI_Comm_size( comm, &size );
-       source = 0;
-       
-       for (count = 1; count < 65000; count = count * 2) {
-           /* We compare with an integer value that can be as large as
-              size * (count * count + (1/2)*(size-1))
-              For large machines (size large), this can exceed the 
-              maximum integer for some large values of count.  We check
-              that in advance and break this loop if the above value 
-              would exceed MAX_INT.  Specifically,
+    /* The following illustrates the use of the routines to
+     * run through a selection of communicators and datatypes.
+     * Use subsets of these for tests that do not involve combinations
+     * of communicators, datatypes, and counts of datatypes */
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        /* Determine the sender and receiver */
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_size(comm, &size);
+        source = 0;
 
-              size*count*count + (1/2)*size*(size-1) > MAX_INT
-              count*count > (MAX_INT/size - (1/2)*(size-1))
-           */
-           if (count * count > (MAX_INT/size - (size-1)/2)) break;
-           winbuf = (int *)malloc( count * sizeof(int) );
-           sbuf   = (int *)malloc( count * sizeof(int) );
+        for (count = 1; count < 65000; count = count * 2) {
+            /* We compare with an integer value that can be as large as
+             * size * (count * count + (1/2)*(size-1))
+             * For large machines (size large), this can exceed the
+             * maximum integer for some large values of count.  We check
+             * that in advance and break this loop if the above value
+             * would exceed MAX_INT.  Specifically,
+             *
+             * size*count*count + (1/2)*size*(size-1) > MAX_INT
+             * count*count > (MAX_INT/size - (1/2)*(size-1))
+             */
+            if (count * count > (MAX_INT / size - (size - 1) / 2))
+                break;
+            winbuf = (int *) malloc(count * sizeof(int));
+            sbuf = (int *) malloc(count * sizeof(int));
 
-           for (i=0; i<count; i++) winbuf[i] = 0;
-           for (i=0; i<count; i++) sbuf[i] = rank + i * count;
-           MPI_Win_create( winbuf, count * sizeof(int), sizeof(int),
-                           MPI_INFO_NULL, comm, &win );
-           MPI_Win_fence( 0, win );
-           MPI_Accumulate( sbuf, count, MPI_INT, source, 0, count, MPI_INT,
-                               MPI_SUM, win );
-           MPI_Win_fence( 0, win );
-           if (rank == source) {
-               /* Check the results */
-               for (i=0; i<count; i++) {
-                   int result = i * count * size + (size*(size-1))/2;
-                   if (winbuf[i] != result) {
-                       if (errs < 10) {
-                           fprintf( stderr, "Winbuf[%d] = %d, expected %d (count = %d, size = %d)\n",
-                                    i, winbuf[i], result, count, size );
-                       }
-                       errs++;
-                   }
-               }
-           }
-           free( winbuf );
-           free( sbuf );
-           MPI_Win_free( &win );
-       }
+            for (i = 0; i < count; i++)
+                winbuf[i] = 0;
+            for (i = 0; i < count; i++)
+                sbuf[i] = rank + i * count;
+            MPI_Win_create(winbuf, count * sizeof(int), sizeof(int), MPI_INFO_NULL, comm, &win);
+            MPI_Win_fence(0, win);
+            MPI_Accumulate(sbuf, count, MPI_INT, source, 0, count, MPI_INT, MPI_SUM, win);
+            MPI_Win_fence(0, win);
+            if (rank == source) {
+                /* Check the results */
+                for (i = 0; i < count; i++) {
+                    int result = i * count * size + (size * (size - 1)) / 2;
+                    if (winbuf[i] != result) {
+                        if (errs < 10) {
+                            fprintf(stderr,
+                                    "Winbuf[%d] = %d, expected %d (count = %d, size = %d)\n", i,
+                                    winbuf[i], result, count, size);
+                        }
+                        errs++;
+                    }
+                }
+            }
+            free(winbuf);
+            free(sbuf);
+            MPI_Win_free(&win);
+        }
         MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 96c6516..0d11fb4 100644 (file)
@@ -19,77 +19,79 @@ static char MTEST_Descrip[] = "Test MPI_Accumulate with fence";
 
 /* same as accfence2.c, but uses alloc_mem */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0;
     int rank, size, source;
-    int minsize = 2, count, i; 
-    MPI_Comm      comm;
-    MPI_Win       win;
-    int           *winbuf, *sbuf;
+    int minsize = 2, count, i;
+    MPI_Comm comm;
+    MPI_Win win;
+    int *winbuf, *sbuf;
 
-    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;
-       /* Determine the sender and receiver */
-       MPI_Comm_rank( comm, &rank );
-       MPI_Comm_size( comm, &size );
-       source = 0;
-       
-       for (count = 32768; count < 65000; count = count * 2) {
+    /* The following illustrates the use of the routines to
+     * run through a selection of communicators and datatypes.
+     * Use subsets of these for tests that do not involve combinations
+     * of communicators, datatypes, and counts of datatypes */
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        /* Determine the sender and receiver */
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_size(comm, &size);
+        source = 0;
 
+        for (count = 32768; count < 65000; count = count * 2) {
 
-           /* We compare with an integer value that can be as large as
-              size * (count * count + (1/2)*(size-1))
-              For large machines (size large), this can exceed the 
-              maximum integer for some large values of count.  We check
-              that in advance and break this loop if the above value 
-              would exceed MAX_INT.  Specifically,
+            /* We compare with an integer value that can be as large as
+             * size * (count * count + (1/2)*(size-1))
+             * For large machines (size large), this can exceed the
+             * maximum integer for some large values of count.  We check
+             * that in advance and break this loop if the above value
+             * would exceed MAX_INT.  Specifically,
+             *
+             * size*count*count + (1/2)*size*(size-1) > MAX_INT
+             * count*count > (MAX_INT/size - (1/2)*(size-1))
+             */
+            if (count * count > (MAX_INT / size - (size - 1) / 2))
+                break;
 
-              size*count*count + (1/2)*size*(size-1) > MAX_INT
-              count*count > (MAX_INT/size - (1/2)*(size-1))
-           */
-           if (count * count > (MAX_INT/size - (size-1)/2)) break;
+            MPI_Alloc_mem(count * sizeof(int), MPI_INFO_NULL, &winbuf);
+            MPI_Alloc_mem(count * sizeof(int), MPI_INFO_NULL, &sbuf);
 
-           MPI_Alloc_mem( count * sizeof(int), MPI_INFO_NULL, &winbuf );
-           MPI_Alloc_mem( count * sizeof(int), MPI_INFO_NULL, &sbuf );
+            for (i = 0; i < count; i++)
+                winbuf[i] = 0;
+            for (i = 0; i < count; i++)
+                sbuf[i] = rank + i * count;
+            MPI_Win_create(winbuf, count * sizeof(int), sizeof(int), MPI_INFO_NULL, comm, &win);
+            MPI_Win_fence(0, win);
+            MPI_Accumulate(sbuf, count, MPI_INT, source, 0, count, MPI_INT, MPI_SUM, win);
+            MPI_Win_fence(0, win);
+            if (rank == source) {
+                /* Check the results */
+                for (i = 0; i < count; i++) {
+                    int result = i * count * size + (size * (size - 1)) / 2;
+                    if (winbuf[i] != result) {
+                        if (errs < 10) {
+                            fprintf(stderr,
+                                    "Winbuf[%d] = %d, expected %d (count = %d, size = %d)\n", i,
+                                    winbuf[i], result, count, size);
+                        }
+                        errs++;
+                    }
+                }
+            }
 
-           for (i=0; i<count; i++) winbuf[i] = 0;
-           for (i=0; i<count; i++) sbuf[i] = rank + i * count;
-           MPI_Win_create( winbuf, count * sizeof(int), sizeof(int),
-                           MPI_INFO_NULL, comm, &win );
-           MPI_Win_fence( 0, win );
-           MPI_Accumulate( sbuf, count, MPI_INT, source, 0, count, MPI_INT,
-                               MPI_SUM, win );
-           MPI_Win_fence( 0, win );
-           if (rank == source) {
-               /* Check the results */
-               for (i=0; i<count; i++) {
-                   int result = i * count * size + (size*(size-1))/2;
-                   if (winbuf[i] != result) {
-                       if (errs < 10) {
-                           fprintf( stderr, "Winbuf[%d] = %d, expected %d (count = %d, size = %d)\n",
-                                    i, winbuf[i], result, count, size );
-                       }
-                       errs++;
-                   }
-               }
-           }
-
-           MPI_Win_free( &win );
+            MPI_Win_free(&win);
 
             MPI_Free_mem(winbuf);
             MPI_Free_mem(sbuf);
-       }
+        }
         MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 4b4976e..67ab3b4 100644 (file)
 static char MTEST_Descrip[] = "Accumulate/replace with Post/Start/Complete/Wait";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0, err;
     int rank, size, source, dest;
-    int minsize = 2, count; 
-    MPI_Comm      comm;
-    MPI_Win       win;
-    MPI_Aint      extent;
-    MPI_Group     wingroup, neighbors;
+    int minsize = 2, count;
+    MPI_Comm comm;
+    MPI_Win win;
+    MPI_Aint extent, lb;
+    MPI_Group wingroup, neighbors;
     MTestDatatype 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;
-       /* Determine the sender and receiver */
-       MPI_Comm_rank( comm, &rank );
-       MPI_Comm_size( comm, &size );
-       source = 0;
-       dest   = size - 1;
-       
-       for (count = 1; count < 65000; count = count * 2) {
-           while (MTestGetDatatypes( &sendtype, &recvtype, count )) {
-               /* Make sure that everyone has a recv buffer */
-               recvtype.InitBuf( &recvtype );
+    /* The following illustrates the use of the routines to
+     * run through a selection of communicators and datatypes.
+     * Use subsets of these for tests that do not involve combinations
+     * of communicators, datatypes, and counts of datatypes */
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        /* Determine the sender and receiver */
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_size(comm, &size);
+        source = 0;
+        dest = size - 1;
 
-               MPI_Type_extent( recvtype.datatype, &extent );
-               MPI_Win_create( recvtype.buf, recvtype.count * extent, 
-                               (int)extent, MPI_INFO_NULL, comm, &win );
-               MPI_Win_get_group( win, &wingroup );
-               if (rank == source) {
-                   /* To improve reporting of problems about operations, we
-                      change the error handler to errors return */
-                   MPI_Win_set_errhandler( win, MPI_ERRORS_RETURN );
-                   sendtype.InitBuf( &sendtype );
-                   
-                   /* Neighbor is dest only */
-                   MPI_Group_incl( wingroup, 1, &dest, &neighbors );
-                   err = MPI_Win_start( neighbors, 0, win );
-                   if (err) {
-                       errs++;
-                       if (errs < 10) {
-                           MTestPrintError( err );
-                       }
-                   }
-                   MPI_Group_free( &neighbors );
-                   err = MPI_Accumulate( sendtype.buf, sendtype.count, 
-                                         sendtype.datatype, dest, 0, 
-                                         recvtype.count, recvtype.datatype, 
-                                         MPI_REPLACE, win );
-                   if (err) {
-                       errs++;
-                       MTestPrintError( err );
-                   }
-                   err = MPI_Win_complete( win );
-                   if (err) {
-                       errs++;
-                       if (errs < 10) {
-                           MTestPrintError( err );
-                       }
-                   }
-               }
-               else if (rank == dest) {
-                   MPI_Group_incl( wingroup, 1, &source, &neighbors );
-                   MPI_Win_post( neighbors, 0, win );
-                   MPI_Group_free( &neighbors );
-                   MPI_Win_wait( win );
-                   /* This should have the same effect, in terms of
-                      transfering data, as a send/recv pair */
-                   err = MTestCheckRecv( 0, &recvtype );
-                   if (err) {
-                       errs += errs;
-                   }
-               }
-               else {
-                   /* Nothing; the other processes need not call any 
-                      MPI routines */
-                   ;
-               }
-               MPI_Win_free( &win );
-               MTestFreeDatatype( &sendtype );
-               MTestFreeDatatype( &recvtype );
-               MPI_Group_free( &wingroup );
-           }
-       }
-       MTestFreeComm( &comm );
+        MTEST_DATATYPE_FOR_EACH_COUNT(count) {
+            while (MTestGetDatatypes(&sendtype, &recvtype, count)) {
+                /* Make sure that everyone has a recv buffer */
+                recvtype.InitBuf(&recvtype);
+
+                MPI_Type_extent(recvtype.datatype, &extent);
+                MPI_Type_lb(recvtype.datatype, &lb);
+                MPI_Win_create(recvtype.buf, recvtype.count * extent + lb,
+                               (int) extent, MPI_INFO_NULL, comm, &win);
+                MPI_Win_get_group(win, &wingroup);
+                if (rank == source) {
+                    /* To improve reporting of problems about operations, we
+                     * change the error handler to errors return */
+                    MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+                    sendtype.InitBuf(&sendtype);
+
+                    /* Neighbor is dest only */
+                    MPI_Group_incl(wingroup, 1, &dest, &neighbors);
+                    err = MPI_Win_start(neighbors, 0, win);
+                    if (err) {
+                        errs++;
+                        if (errs < 10) {
+                            MTestPrintError(err);
+                        }
+                    }
+                    MPI_Group_free(&neighbors);
+                    err = MPI_Accumulate(sendtype.buf, sendtype.count,
+                                         sendtype.datatype, dest, 0,
+                                         recvtype.count, recvtype.datatype, MPI_REPLACE, win);
+                    if (err) {
+                        errs++;
+                        MTestPrintError(err);
+                    }
+                    err = MPI_Win_complete(win);
+                    if (err) {
+                        errs++;
+                        if (errs < 10) {
+                            MTestPrintError(err);
+                        }
+                    }
+                }
+                else if (rank == dest) {
+                    MPI_Group_incl(wingroup, 1, &source, &neighbors);
+                    MPI_Win_post(neighbors, 0, win);
+                    MPI_Group_free(&neighbors);
+                    MPI_Win_wait(win);
+                    /* This should have the same effect, in terms of
+                     * transfering data, as a send/recv pair */
+                    err = MTestCheckRecv(0, &recvtype);
+                    if (err) {
+                        errs += errs;
+                    }
+                }
+                else {
+                    /* Nothing; the other processes need not call any
+                     * MPI routines */
+                    ;
+                }
+                MPI_Win_free(&win);
+                MTestFreeDatatype(&sendtype);
+                MTestFreeDatatype(&recvtype);
+                MPI_Group_free(&wingroup);
+            }
+        }
+        MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 22767fb..661f72f 100644 (file)
@@ -12,8 +12,8 @@
 #include "mpitest.h"
 
 #define NUM_TIMES 500
-#define MAX_BUF_SIZE (400 * 1024 * 1024) /* 400 MB */
-#define PUT_SIZE (1024 * 1024) /* 1MB */
+#define MAX_BUF_SIZE (400 * 1024 * 1024)        /* 400 MB */
+#define PUT_SIZE (1024 * 1024)  /* 1MB */
 
 /*
 static char MTEST_Descrip[] = "ADLB mimic test";
@@ -61,36 +61,34 @@ int main(int argc, char **argv)
     MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank);
 
     if (comm_size <= 2) {
-       fprintf( stderr, "This test requires at least 3 processes\n" );
-       MPI_Abort( MPI_COMM_WORLD, 1 );
+        fprintf(stderr, "This test requires at least 3 processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
     }
 
     max_buf_size = comm_size * put_size;
     if (max_buf_size > MAX_BUF_SIZE) {
-       fprintf( stderr, "Too many processes in COMM_WORLD (max is %d)\n",
-                MAX_BUF_SIZE / put_size );
-       MPI_Abort( MPI_COMM_WORLD, 1 );
+        fprintf(stderr, "Too many processes in COMM_WORLD (max is %d)\n", MAX_BUF_SIZE / put_size);
+        MPI_Abort(MPI_COMM_WORLD, 1);
     }
 
     /* If alloc mem returns an error (because too much memory is requested */
-    MPI_Errhandler_set( MPI_COMM_WORLD, MPI_ERRORS_RETURN );
+    MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
 
     rc = MPI_Alloc_mem(max_buf_size, MPI_INFO_NULL, (void *) &rma_win_addr);
     if (rc) {
-       MTestPrintErrorMsg( "Unable to MPI_Alloc_mem space (not an error)", rc );
-       MPI_Abort( MPI_COMM_WORLD, 0 );
+        MTestPrintErrorMsg("Unable to MPI_Alloc_mem space (not an error)", rc);
+        MPI_Abort(MPI_COMM_WORLD, 0);
     }
 
     memset(rma_win_addr, 0, max_buf_size);
-    MPI_Win_create((void *) rma_win_addr, max_buf_size, 1, MPI_INFO_NULL, 
-                  MPI_COMM_WORLD, &win);
+    MPI_Win_create((void *) rma_win_addr, max_buf_size, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
     /* Note that it is not necessary to use MPI_Alloc_mem for the memory that
-       is not part of the MPI_Win.  */
+     * is not part of the MPI_Win.  */
     rc = MPI_Alloc_mem(put_size, MPI_INFO_NULL, (void *) &local_buf);
     if (rc) {
-       MTestPrintErrorMsg( "Unable to MPI_Alloc_mem space (not an error)", rc );
-       MPI_Abort( MPI_COMM_WORLD, 0 );
+        MTestPrintErrorMsg("Unable to MPI_Alloc_mem space (not an error)", rc);
+        MPI_Abort(MPI_COMM_WORLD, 0);
     }
 
     for (i = 0; i < put_size; i++)
@@ -98,7 +96,7 @@ int main(int argc, char **argv)
 
     MPI_Barrier(MPI_COMM_WORLD);
 
-    if (comm_rank == 0) { /* target */
+    if (comm_rank == 0) {       /* target */
         for (i = 0; i < (NUM_TIMES * (comm_size - 2)); i++) {
             /* Wait for a message from the server to notify me that
              * someone put some data in my window */
@@ -108,9 +106,8 @@ int main(int argc, char **argv)
              * data in my local window. Check the last byte to make
              * sure we got it correctly. */
             MPI_Win_lock(MPI_LOCK_SHARED, 0, 0, win);
-            MPI_Get((void *) &check, 1, MPI_CHAR, 0, 
-                   ((by_rank + 1) * put_size) - 1, 1,
-                    MPI_CHAR, win);
+            MPI_Get((void *) &check, 1, MPI_CHAR, 0,
+                    ((by_rank + 1) * put_size) - 1, 1, MPI_CHAR, win);
             MPI_Win_unlock(0, win);
 
             /* If this is not the value I expect, count it as an error */
@@ -125,13 +122,12 @@ int main(int argc, char **argv)
         }
     }
 
-    else if (comm_rank == 1) { /* server */
+    else if (comm_rank == 1) {  /* server */
         for (i = 0; i < (NUM_TIMES * (comm_size - 2)); i++) {
             /* Wait for a message from any of the origin processes
              * informing me that it has put data to the target
              * process */
-            MPI_Recv(NULL, 0, MPI_INT, MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, 
-                    &status);
+            MPI_Recv(NULL, 0, MPI_INT, MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &status);
             by_rank = status.MPI_SOURCE;
 
             /* Tell the target process that it should be seeing some
@@ -140,12 +136,12 @@ int main(int argc, char **argv)
         }
     }
 
-    else { /* origin */
+    else {      /* origin */
         for (i = 0; i < NUM_TIMES; i++) {
             /* Put some data in the target window */
             MPI_Win_lock(MPI_LOCK_SHARED, 0, 0, win);
-            MPI_Put(local_buf, put_size, MPI_CHAR, 0, comm_rank * put_size, 
-                   put_size, MPI_CHAR, win);
+            MPI_Put(local_buf, put_size, MPI_CHAR, 0, comm_rank * put_size,
+                    put_size, MPI_CHAR, win);
             MPI_Win_unlock(0, win);
 
             /* Tell the server that the put has completed */
diff --git a/teshsuite/smpi/mpich3-test/rma/aint.c b/teshsuite/smpi/mpich3-test/rma/aint.c
new file mode 100644 (file)
index 0000000..72c10d2
--- /dev/null
@@ -0,0 +1,82 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *
+ *  (C) 2014 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+/*
+ * This program tests MPI_Aint_add/diff in MPI-3.1.
+ * The two functions are often used in RMA code.
+ * See https://svn.mpi-forum.org/trac/mpi-forum-web/ticket/349
+ */
+
+#include <stdio.h>
+#include <mpi.h>
+#include "mpitest.h"
+
+int main(int argc, char **argv)
+{
+    int rank, nproc;
+    int errs = 0;
+    int array[1024];
+    int val = 0;
+    int target_rank;
+    MPI_Aint bases[2];
+    MPI_Aint disp, offset;
+    MPI_Win win;
+
+    MTest_Init(&argc, &argv);
+
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
+
+    if (rank == 0 && nproc != 2) {
+        MTestError("Must run with 2 ranks\n");
+    }
+
+    /* Get the base address in the middle of the array */
+    if (rank == 0) {
+        target_rank = 1;
+        array[0] = 1234;
+        MPI_Get_address(&array[512], &bases[0]);
+    }
+    else if (rank == 1) {
+        target_rank = 0;
+        array[1023] = 1234;
+        MPI_Get_address(&array[512], &bases[1]);
+    }
+
+    /* Exchange bases */
+    MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, bases, 1, MPI_AINT, MPI_COMM_WORLD);
+
+    MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_WORLD, &win);
+    MPI_Win_attach(win, array, sizeof(int) * 1024);
+
+    /* Do MPI_Aint addressing arithmetic */
+    if (rank == 0) {
+        disp = sizeof(int) * 511;
+        offset = MPI_Aint_add(bases[1], disp);  /* offset points to array[1023] */
+    }
+    else if (rank == 1) {
+        disp = sizeof(int) * 512;
+        offset = MPI_Aint_diff(bases[0], disp); /* offset points to array[0] */
+    }
+
+    /* Get val and verify it */
+    MPI_Win_fence(MPI_MODE_NOPRECEDE, win);
+    MPI_Get(&val, 1, MPI_INT, target_rank, offset, 1, MPI_INT, win);
+    MPI_Win_fence(MPI_MODE_NOSUCCEED, win);
+
+    if (val != 1234) {
+        errs++;
+        printf("%d -- Got %d, expected 1234\n", rank, val);
+    }
+
+    MPI_Win_detach(win, array);
+    MPI_Win_free(&win);
+
+    MTest_Finalize(errs);
+    MPI_Finalize();
+    return 0;
+}
index 1969941..1255628 100644 (file)
 static char MTEST_Descrip[] = "Simple test that alloc_mem and free_mem work together";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0, err;
     int j, count;
     char *ap;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
-    MPI_Errhandler_set( MPI_COMM_WORLD, MPI_ERRORS_RETURN );
-    for (count=1; count < 128000; count *= 2) {
-       
-       err = MPI_Alloc_mem( count, MPI_INFO_NULL, &ap );
-       if (err) {
-           int errclass;
-           /* An error of  MPI_ERR_NO_MEM is allowed */
-           MPI_Error_class( err, &errclass );
-           if (errclass != MPI_ERR_NO_MEM) {
-               errs++;
-               MTestPrintError( err );
-           }
-           
-       }
-       else {
-           /* Access all of this memory */
-           for (j=0; j<count; j++) {
-               ap[j] = (char)(j & 0x7f);
-           }
-           MPI_Free_mem( ap );
-       }
+    MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
+    for (count = 1; count < 128000; count *= 2) {
+
+        err = MPI_Alloc_mem(count, MPI_INFO_NULL, &ap);
+        if (err) {
+            int errclass;
+            /* An error of  MPI_ERR_NO_MEM is allowed */
+            MPI_Error_class(err, &errclass);
+            if (errclass != MPI_ERR_NO_MEM) {
+                errs++;
+                MTestPrintError(err);
+            }
+
+        }
+        else {
+            /* Access all of this memory */
+            for (j = 0; j < count; j++) {
+                ap[j] = (char) (j & 0x7f);
+            }
+            MPI_Free_mem(ap);
+        }
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
diff --git a/teshsuite/smpi/mpich3-test/rma/at_complete.c b/teshsuite/smpi/mpich3-test/rma/at_complete.c
new file mode 100644 (file)
index 0000000..f389a30
--- /dev/null
@@ -0,0 +1,140 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *  (C) 2014 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+#include <stdio.h>
+#include <mpi.h>
+
+#define PUT_SIZE 1
+#define GET_SIZE 100000
+#define WIN_SIZE (PUT_SIZE+GET_SIZE)
+#define LOOP 100
+
+int main(int argc, char **argv)
+{
+    MPI_Win win;
+    int i, k, rank, nproc;
+    int win_buf[WIN_SIZE], orig_get_buf[GET_SIZE], orig_put_buf[PUT_SIZE];
+    int orig_rank = 0, dest_rank = 1;
+    int errors = 0;
+    MPI_Group comm_group, orig_group, dest_group;
+
+    MPI_Init(&argc, &argv);
+
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
+
+    MPI_Comm_group(MPI_COMM_WORLD, &comm_group);
+    MPI_Group_incl(comm_group, 1, &orig_rank, &orig_group);
+    MPI_Group_incl(comm_group, 1, &dest_rank, &dest_group);
+
+    for (i = 0; i < PUT_SIZE; i++)
+        orig_put_buf[i] = 1;
+    for (i = 0; i < GET_SIZE; i++)
+        orig_get_buf[i] = 0;
+    for (i = 0; i < WIN_SIZE; i++)
+        win_buf[i] = 1;
+
+    MPI_Win_create(win_buf, sizeof(int) * WIN_SIZE, sizeof(int), MPI_INFO_NULL,
+                   MPI_COMM_WORLD, &win);
+
+    for (k = 0; k < LOOP; k++) {
+
+        /* test for FENCE */
+
+        if (rank == orig_rank) {
+            MPI_Win_fence(MPI_MODE_NOPRECEDE, win);
+            MPI_Get(orig_get_buf, GET_SIZE, MPI_INT,
+                    dest_rank, PUT_SIZE /*disp */ , GET_SIZE, MPI_INT, win);
+            MPI_Put(orig_put_buf, PUT_SIZE, MPI_INT,
+                    dest_rank, 0 /*disp */ , PUT_SIZE, MPI_INT, win);
+            MPI_Win_fence(MPI_MODE_NOSUCCEED, win);
+
+            /* check GET result values */
+            for (i = 0; i < GET_SIZE; i++) {
+                if (orig_get_buf[i] != 1) {
+                    printf("LOOP=%d, FENCE, orig_get_buf[%d] = %d, expected 1.\n",
+                           k, i, orig_get_buf[i]);
+                    errors++;
+                }
+            }
+        }
+        else if (rank == dest_rank) {
+            MPI_Win_fence(MPI_MODE_NOPRECEDE, win);
+            MPI_Win_fence(MPI_MODE_NOSUCCEED, win);
+
+            /* modify the last element in window */
+            MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+            win_buf[WIN_SIZE - 1] = 2;
+            MPI_Win_unlock(rank, win);
+        }
+
+        MPI_Barrier(MPI_COMM_WORLD);
+        /* reset buffers */
+        for (i = 0; i < PUT_SIZE; i++)
+            orig_put_buf[i] = 1;
+        for (i = 0; i < GET_SIZE; i++)
+            orig_get_buf[i] = 0;
+        MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+        for (i = 0; i < WIN_SIZE; i++)
+            win_buf[i] = 1;
+        MPI_Win_unlock(rank, win);
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        /* test for PSCW */
+
+        if (rank == orig_rank) {
+            MPI_Win_start(dest_group, 0, win);
+            MPI_Get(orig_get_buf, GET_SIZE, MPI_INT,
+                    dest_rank, PUT_SIZE /*disp */ , GET_SIZE, MPI_INT, win);
+            MPI_Put(orig_put_buf, PUT_SIZE, MPI_INT,
+                    dest_rank, 0 /*disp */ , PUT_SIZE, MPI_INT, win);
+            MPI_Win_complete(win);
+
+            /* check GET result values */
+            for (i = 0; i < GET_SIZE; i++) {
+                if (orig_get_buf[i] != 1) {
+                    printf("LOOP=%d, PSCW, orig_get_buf[%d] = %d, expected 1.\n",
+                           k, i, orig_get_buf[i]);
+                    errors++;
+                }
+            }
+        }
+        else if (rank == dest_rank) {
+            MPI_Win_post(orig_group, 0, win);
+            MPI_Win_wait(win);
+
+            /* modify the last element in window */
+            MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+            win_buf[WIN_SIZE - 1] = 2;
+            MPI_Win_unlock(rank, win);
+        }
+
+        MPI_Barrier(MPI_COMM_WORLD);
+        /* reset buffers */
+        for (i = 0; i < PUT_SIZE; i++)
+            orig_put_buf[i] = 1;
+        for (i = 0; i < GET_SIZE; i++)
+            orig_get_buf[i] = 0;
+        MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+        for (i = 0; i < WIN_SIZE; i++)
+            win_buf[i] = 1;
+        MPI_Win_unlock(rank, win);
+        MPI_Barrier(MPI_COMM_WORLD);
+    }
+
+    MPI_Win_free(&win);
+
+    MPI_Group_free(&orig_group);
+    MPI_Group_free(&dest_group);
+    MPI_Group_free(&comm_group);
+
+    if (rank == orig_rank && errors == 0) {
+        printf(" No Errors\n");
+    }
+
+    MPI_Finalize();
+    return 0;
+}
diff --git a/teshsuite/smpi/mpich3-test/rma/atomic_get.c b/teshsuite/smpi/mpich3-test/rma/atomic_get.c
new file mode 100644 (file)
index 0000000..54bffa6
--- /dev/null
@@ -0,0 +1,183 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *  (C) 2015 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+/* This test is going to test atomic GET (GACC/FOP+MPI_NO_OP).
+ *
+ * There are totally three processes involved in this test. Both
+ * rank 1 and rank 2 issue RMA operations to rank 0. Rank 2 issues
+ * atomic PUT (ACC+MPI_REPLACE), whereas rank 1 issues atomic
+ * GET (GACC/FOP+MPI_NO_OP). The datatype used in the test is
+ * pair-type. The initial value of pair-type data in origin buffer
+ * of atomic PUT is set so that the two basic values equal with
+ * each other. Due to the atomicity of GET, the expected resulting
+ * data should also have equivalent basic values. */
+
+#include "mpi.h"
+#include <stdio.h>
+
+#define LOOP 100
+#define DATA_SIZE 100
+#define OPS_NUM 10000
+#define GACC_SZ 10
+
+typedef struct pair_struct {
+    long double a;
+    int b;
+} pair_struct_t;
+
+int main(int argc, char *argv[])
+{
+    int rank, nproc;
+    int i, j, k;
+    int errors = 0, curr_errors = 0;
+    MPI_Win win;
+    pair_struct_t *tar_buf = NULL;
+    pair_struct_t *orig_buf = NULL;
+    pair_struct_t *result_buf = NULL;
+
+    /* This test needs to work with 3 processes. */
+
+    MPI_Init(&argc, &argv);
+
+    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    MPI_Alloc_mem(sizeof(pair_struct_t) * DATA_SIZE, MPI_INFO_NULL, &orig_buf);
+    MPI_Alloc_mem(sizeof(pair_struct_t) * DATA_SIZE, MPI_INFO_NULL, &result_buf);
+
+    MPI_Win_allocate(sizeof(pair_struct_t) * DATA_SIZE, sizeof(pair_struct_t),
+                     MPI_INFO_NULL, MPI_COMM_WORLD, &tar_buf, &win);
+
+    for (j = 0; j < LOOP * 6; j++) {
+
+        MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
+
+        /* initialize data */
+        for (i = 0; i < DATA_SIZE; i++) {
+            tar_buf[i].a = 0.0;
+            tar_buf[i].b = 0;
+            result_buf[i].a = 0.0;
+            result_buf[i].b = 0;
+        }
+
+        MPI_Win_unlock(rank, win);
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        MPI_Win_fence(0, win);
+
+        if (rank == 2) {
+            if (j < 2 * LOOP) {
+                /* Work with FOP test (Test #1 to Test #2) */
+                for (i = 0; i < OPS_NUM; i++) {
+
+                    int curr_val = j * OPS_NUM + i;
+                    orig_buf[0].a = (long double) (curr_val);
+                    orig_buf[0].b = curr_val;
+
+                    MPI_Accumulate(orig_buf, 1, MPI_LONG_DOUBLE_INT,
+                                   0, 0, 1, MPI_LONG_DOUBLE_INT, MPI_REPLACE, win);
+                }
+            }
+            else {
+                /* Work with GACC test (Test #3 to Test #6) */
+                for (i = 0; i < OPS_NUM / GACC_SZ; i++) {
+
+                    for (k = 0; k < GACC_SZ; k++) {
+                        int curr_val = j * OPS_NUM + i * GACC_SZ + k;
+                        orig_buf[k].a = (long double) (curr_val);
+                        orig_buf[k].b = curr_val;
+                    }
+
+                    MPI_Accumulate(orig_buf, GACC_SZ, MPI_LONG_DOUBLE_INT,
+                                   0, 0, GACC_SZ, MPI_LONG_DOUBLE_INT, MPI_REPLACE, win);
+                }
+            }
+        }
+        else if (rank == 1) {
+            /* equals to an atomic GET */
+            if (j < LOOP) {
+                for (i = 0; i < DATA_SIZE; i++) {
+                    /* Test #1: FOP + MPI_NO_OP */
+                    MPI_Fetch_and_op(orig_buf, &(result_buf[i]), MPI_LONG_DOUBLE_INT,
+                                     0, 0, MPI_NO_OP, win);
+                }
+            }
+            else if (j < 2 * LOOP) {
+                for (i = 0; i < DATA_SIZE; i++) {
+                    /* Test #2: FOP + MPI_NO_OP + NULL origin buffer address */
+                    MPI_Fetch_and_op(NULL, &(result_buf[i]), MPI_LONG_DOUBLE_INT,
+                                     0, 0, MPI_NO_OP, win);
+                }
+            }
+            else if (j < 3 * LOOP) {
+                for (i = 0; i < DATA_SIZE / GACC_SZ; i++) {
+                    /* Test #3: GACC + MPI_NO_OP */
+                    MPI_Get_accumulate(orig_buf, GACC_SZ, MPI_LONG_DOUBLE_INT,
+                                       &(result_buf[i * GACC_SZ]), GACC_SZ, MPI_LONG_DOUBLE_INT,
+                                       0, 0, GACC_SZ, MPI_LONG_DOUBLE_INT, MPI_NO_OP, win);
+                }
+            }
+            else if (j < 4 * LOOP) {
+                for (i = 0; i < DATA_SIZE / GACC_SZ; i++) {
+                    /* Test #4: GACC + MPI_NO_OP + NULL origin buffer address */
+                    MPI_Get_accumulate(NULL, GACC_SZ, MPI_LONG_DOUBLE_INT,
+                                       &(result_buf[i * GACC_SZ]), GACC_SZ, MPI_LONG_DOUBLE_INT,
+                                       0, 0, GACC_SZ, MPI_LONG_DOUBLE_INT, MPI_NO_OP, win);
+                }
+            }
+            else if (j < 5 * LOOP) {
+                for (i = 0; i < DATA_SIZE / GACC_SZ; i++) {
+                    /* Test #5: GACC + MPI_NO_OP + zero origin count */
+                    MPI_Get_accumulate(orig_buf, 0, MPI_LONG_DOUBLE_INT,
+                                       &(result_buf[i * GACC_SZ]), GACC_SZ, MPI_LONG_DOUBLE_INT,
+                                       0, 0, GACC_SZ, MPI_LONG_DOUBLE_INT, MPI_NO_OP, win);
+                }
+            }
+            else if (j < 6 * LOOP) {
+                for (i = 0; i < DATA_SIZE / GACC_SZ; i++) {
+                    /* Test #5: GACC + MPI_NO_OP + NULL origin datatype */
+                    MPI_Get_accumulate(orig_buf, GACC_SZ, MPI_DATATYPE_NULL,
+                                       &(result_buf[i * GACC_SZ]), GACC_SZ, MPI_LONG_DOUBLE_INT,
+                                       0, 0, GACC_SZ, MPI_LONG_DOUBLE_INT, MPI_NO_OP, win);
+                }
+            }
+        }
+
+        MPI_Win_fence(0, win);
+
+        /* check results */
+        if (rank == 1) {
+            for (i = 0; i < DATA_SIZE; i++) {
+                if (result_buf[i].a != (long double) (result_buf[i].b)) {
+                    if (curr_errors < 10) {
+                        printf("LOOP %d: result_buf[%d].a = %Lf, result_buf[%d].b = %d\n",
+                               j, i, result_buf[i].a, i, result_buf[i].b);
+                    }
+                    curr_errors++;
+                }
+            }
+        }
+
+        if (j % LOOP == 0) {
+            errors += curr_errors;
+            curr_errors = 0;
+        }
+    }
+
+    MPI_Win_free(&win);
+
+    MPI_Free_mem(orig_buf);
+    MPI_Free_mem(result_buf);
+
+    if (rank == 1) {
+        if (errors == 0)
+            printf(" No Errors\n");
+    }
+
+    MPI_Finalize();
+    return 0;
+}
diff --git a/teshsuite/smpi/mpich3-test/rma/atomic_rmw_cas.c b/teshsuite/smpi/mpich3-test/rma/atomic_rmw_cas.c
new file mode 100644 (file)
index 0000000..dfd7228
--- /dev/null
@@ -0,0 +1,137 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *
+ *  (C) 2015 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+/* This test is going to test the atomicity for "read-modify-write" in CAS
+ * operations */
+
+/* There are three processes involved in this test: P0 (origin_shm), P1 (origin_am),
+ * and P2 (dest). P0 and P1 issues one CAS to P2 via SHM and AM respectively.
+ * For P0, origin value is 1 and compare value is 0; for P1, origin value is 0 and
+ * compare value is 1; for P2, initial target value is 0. The correct results can
+ * only be one of the following cases:
+ *
+ *   (1) result value on P0: 0, result value on P1: 0, target value on P2: 1.
+ *   (2) result value on P0: 0, result value on P1: 1, target value on P2: 0.
+ *
+ * All other results are not correct. */
+
+#include "mpi.h"
+#include <stdio.h>
+
+#define LOOP_SIZE 10000
+#define CHECK_TAG 123
+
+int main(int argc, char *argv[])
+{
+    int rank, size, k;
+    int errors = 0;
+    int origin_shm, origin_am, dest;
+    int *orig_buf = NULL, *result_buf = NULL, *compare_buf = NULL,
+        *target_buf = NULL, *check_buf = NULL;
+    int target_value = 0;
+    MPI_Win win;
+
+    MPI_Init(&argc, &argv);
+
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    if (size != 3) {
+        /* run this test with three processes */
+        goto exit_test;
+    }
+
+    /* this works when MPIR_PARAM_CH3_ODD_EVEN_CLIQUES is set */
+    dest = 2;
+    origin_shm = 0;
+    origin_am = 1;
+
+    if (rank != dest) {
+        MPI_Alloc_mem(sizeof(int), MPI_INFO_NULL, &orig_buf);
+        MPI_Alloc_mem(sizeof(int), MPI_INFO_NULL, &result_buf);
+        MPI_Alloc_mem(sizeof(int), MPI_INFO_NULL, &compare_buf);
+    }
+
+    MPI_Win_allocate(sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_WORLD, &target_buf, &win);
+
+    for (k = 0; k < LOOP_SIZE; k++) {
+
+        /* init buffers */
+        if (rank == origin_shm) {
+            orig_buf[0] = 1;
+            compare_buf[0] = 0;
+            result_buf[0] = 0;
+        }
+        else if (rank == origin_am) {
+            orig_buf[0] = 0;
+            compare_buf[0] = 1;
+            result_buf[0] = 0;
+        }
+        else {
+            MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+            target_buf[0] = 0;
+            MPI_Win_unlock(rank, win);
+        }
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        /* perform FOP */
+        MPI_Win_lock_all(0, win);
+        if (rank != dest) {
+            MPI_Compare_and_swap(orig_buf, compare_buf, result_buf, MPI_INT, dest, 0, win);
+            MPI_Win_flush(dest, win);
+        }
+        MPI_Win_unlock_all(win);
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        /* check results */
+        if (rank != dest) {
+            MPI_Gather(result_buf, 1, MPI_INT, check_buf, 1, MPI_INT, dest, MPI_COMM_WORLD);
+        }
+        else {
+            MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+            target_value = target_buf[0];
+            MPI_Win_unlock(rank, win);
+
+            MPI_Alloc_mem(sizeof(int) * 3, MPI_INFO_NULL, &check_buf);
+            MPI_Gather(&target_value, 1, MPI_INT, check_buf, 1, MPI_INT, dest, MPI_COMM_WORLD);
+
+            if (!(check_buf[dest] == 0 && check_buf[origin_shm] == 0 && check_buf[origin_am] == 1)
+                && !(check_buf[dest] == 1 && check_buf[origin_shm] == 0 &&
+                     check_buf[origin_am] == 0)) {
+
+                printf
+                    ("Wrong results: target result = %d, origin_shm result = %d, origin_am result = %d\n",
+                     check_buf[dest], check_buf[origin_shm], check_buf[origin_am]);
+
+                printf
+                    ("Expected results (1): target result = 1, origin_shm result = 0, origin_am result = 0\n");
+                printf
+                    ("Expected results (2): target result = 0, origin_shm result = 0, origin_am result = 1\n");
+
+                errors++;
+            }
+
+            MPI_Free_mem(check_buf);
+        }
+    }
+
+    MPI_Win_free(&win);
+
+    if (rank == origin_am || rank == origin_shm) {
+        MPI_Free_mem(orig_buf);
+        MPI_Free_mem(result_buf);
+        MPI_Free_mem(compare_buf);
+    }
+
+  exit_test:
+    if (rank == dest && errors == 0)
+        printf(" No Errors\n");
+
+    MPI_Finalize();
+    return 0;
+}
diff --git a/teshsuite/smpi/mpich3-test/rma/atomic_rmw_fop.c b/teshsuite/smpi/mpich3-test/rma/atomic_rmw_fop.c
new file mode 100644 (file)
index 0000000..42875f6
--- /dev/null
@@ -0,0 +1,143 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *
+ *  (C) 2015 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+/* This test is going to test the atomicity for "read-modify-write" in FOP
+ * operations */
+
+/* There are three processes involved in this test: P0 (origin_shm), P1 (origin_am),
+ * and P2 (dest). P0 and P1 issues multiple FOP with MPI_SUM and integer (value 1)
+ * to P2 via SHM and AM respectively. The correct results should be that the
+ * results on P0 and P1 never be the same. */
+
+#include "mpi.h"
+#include <stdio.h>
+
+#define AM_BUF_SIZE  10
+#define SHM_BUF_SIZE 1000
+#define WIN_BUF_SIZE 1
+
+#define LOOP_SIZE 15
+#define CHECK_TAG 123
+
+int main(int argc, char *argv[])
+{
+    int rank, size, i, j, k;
+    int errors = 0, all_errors = 0;
+    int origin_shm, origin_am, dest;
+    int my_buf_size;
+    int *orig_buf = NULL, *result_buf = NULL, *target_buf = NULL, *check_buf = NULL;
+    MPI_Win win;
+    MPI_Status status;
+
+    MPI_Init(&argc, &argv);
+
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    if (size != 3) {
+        /* run this test with three processes */
+        goto exit_test;
+    }
+
+    /* this works when MPIR_PARAM_CH3_ODD_EVEN_CLIQUES is set */
+    dest = 2;
+    origin_shm = 0;
+    origin_am = 1;
+
+    if (rank == origin_am)
+        my_buf_size = AM_BUF_SIZE;
+    else if (rank == origin_shm)
+        my_buf_size = SHM_BUF_SIZE;
+
+    if (rank != dest) {
+        MPI_Alloc_mem(sizeof(int) * my_buf_size, MPI_INFO_NULL, &orig_buf);
+        MPI_Alloc_mem(sizeof(int) * my_buf_size, MPI_INFO_NULL, &result_buf);
+    }
+
+    MPI_Win_allocate(sizeof(int) * WIN_BUF_SIZE, sizeof(int), MPI_INFO_NULL,
+                     MPI_COMM_WORLD, &target_buf, &win);
+
+    for (k = 0; k < LOOP_SIZE; k++) {
+
+        /* init buffers */
+        if (rank != dest) {
+            for (i = 0; i < my_buf_size; i++) {
+                orig_buf[i] = 1;
+                result_buf[i] = 0;
+            }
+        }
+        else {
+            MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+            for (i = 0; i < WIN_BUF_SIZE; i++) {
+                target_buf[i] = 0;
+            }
+            MPI_Win_unlock(rank, win);
+        }
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        /* perform FOP */
+        MPI_Win_lock_all(0, win);
+        if (rank != dest) {
+            for (i = 0; i < my_buf_size; i++) {
+                MPI_Fetch_and_op(&(orig_buf[i]), &(result_buf[i]), MPI_INT, dest, 0, MPI_SUM, win);
+                MPI_Win_flush(dest, win);
+            }
+        }
+        MPI_Win_unlock_all(win);
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        if (rank != dest) {
+            /* check results on P0 and P2 (origin) */
+            if (rank == origin_am) {
+                MPI_Send(result_buf, AM_BUF_SIZE, MPI_INT, origin_shm, CHECK_TAG, MPI_COMM_WORLD);
+            }
+            else if (rank == origin_shm) {
+                MPI_Alloc_mem(sizeof(int) * AM_BUF_SIZE, MPI_INFO_NULL, &check_buf);
+                MPI_Recv(check_buf, AM_BUF_SIZE, MPI_INT, origin_am, CHECK_TAG, MPI_COMM_WORLD,
+                         &status);
+                for (i = 0; i < AM_BUF_SIZE; i++) {
+                    for (j = 0; j < SHM_BUF_SIZE; j++) {
+                        if (check_buf[i] == result_buf[j]) {
+                            printf
+                                ("LOOP=%d, rank=%d, FOP, both check_buf[%d] and result_buf[%d] equal to %d, expected to be different. \n",
+                                 k, rank, i, j, check_buf[i]);
+                            errors++;
+                        }
+                    }
+                }
+                MPI_Free_mem(check_buf);
+            }
+        }
+        else {
+            MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+            /* check results on P1 */
+            if (target_buf[0] != AM_BUF_SIZE + SHM_BUF_SIZE) {
+                printf("LOOP=%d, rank=%d, FOP, target_buf[0] = %d, expected %d. \n",
+                       k, rank, target_buf[0], AM_BUF_SIZE + SHM_BUF_SIZE);
+                errors++;
+            }
+            MPI_Win_unlock(rank, win);
+        }
+    }
+
+    MPI_Win_free(&win);
+
+    if (rank == origin_am || rank == origin_shm) {
+        MPI_Free_mem(orig_buf);
+        MPI_Free_mem(result_buf);
+    }
+
+  exit_test:
+    MPI_Reduce(&errors, &all_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
+
+    if (rank == 0 && all_errors == 0)
+        printf(" No Errors\n");
+
+    MPI_Finalize();
+    return 0;
+}
diff --git a/teshsuite/smpi/mpich3-test/rma/atomic_rmw_gacc.c b/teshsuite/smpi/mpich3-test/rma/atomic_rmw_gacc.c
new file mode 100644 (file)
index 0000000..0e73e2d
--- /dev/null
@@ -0,0 +1,276 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *
+ *  (C) 2015 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+/* This test is going to test the atomicity for "read-modify-write" in GACC
+ * operations */
+
+/* This test is similiar with atomic_rmw_fop.c.
+ * There are three processes involved in this test: P0 (origin_shm), P1 (origin_am),
+ * and P2 (dest). P0 and P1 issues multiple GACC with MPI_SUM and OP_COUNT integers
+ * (value 1) to P2 via SHM and AM respectively. The correct results should be that the
+ * results on P0 and P1 never be the same for intergers on the corresponding index
+ * in [0...OP_COUNT-1].
+ */
+
+#include "mpi.h"
+#include <stdio.h>
+
+#define OP_COUNT 10
+#define AM_BUF_NUM  10
+#define SHM_BUF_NUM 10000
+#define WIN_BUF_NUM 1
+
+#define LOOP_SIZE 15
+#define CHECK_TAG 123
+
+int rank, size;
+int dest, origin_shm, origin_am;
+int *orig_buf = NULL, *result_buf = NULL, *target_buf = NULL, *check_buf = NULL;
+MPI_Win win;
+
+void checkResults(int loop_k, int *errors)
+{
+    int i, j, m;
+    MPI_Status status;
+
+    if (rank != dest) {
+        /* check results on P0 and P2 (origin) */
+        if (rank == origin_am) {
+            MPI_Send(result_buf, AM_BUF_NUM * OP_COUNT, MPI_INT, origin_shm, CHECK_TAG,
+                     MPI_COMM_WORLD);
+        }
+        else if (rank == origin_shm) {
+            MPI_Alloc_mem(sizeof(int) * AM_BUF_NUM * OP_COUNT, MPI_INFO_NULL, &check_buf);
+            MPI_Recv(check_buf, AM_BUF_NUM * OP_COUNT, MPI_INT, origin_am, CHECK_TAG,
+                     MPI_COMM_WORLD, &status);
+            for (i = 0; i < AM_BUF_NUM; i++) {
+                for (j = 0; j < SHM_BUF_NUM; j++) {
+                    for (m = 0; m < OP_COUNT; m++) {
+                        if (check_buf[i * OP_COUNT + m] == result_buf[j * OP_COUNT + m]) {
+                            printf
+                                ("LOOP=%d, rank=%d, FOP, both check_buf[%d] and result_buf[%d] equal to %d, expected to be different. \n",
+                                 loop_k, rank, i * OP_COUNT + m, j * OP_COUNT + m,
+                                 check_buf[i * OP_COUNT + m]);
+                            (*errors)++;
+                        }
+                    }
+                }
+            }
+            MPI_Free_mem(check_buf);
+        }
+    }
+    else {
+        MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+        /* check results on P1 */
+        for (i = 0; i < OP_COUNT; i++) {
+            if (target_buf[i] != AM_BUF_NUM + SHM_BUF_NUM) {
+                printf("LOOP=%d, rank=%d, FOP, target_buf[%d] = %d, expected %d. \n",
+                       loop_k, rank, i, target_buf[i], AM_BUF_NUM + SHM_BUF_NUM);
+                (*errors)++;
+            }
+        }
+        MPI_Win_unlock(rank, win);
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    int i, k;
+    int errors = 0, all_errors = 0;
+    int my_buf_num;
+    MPI_Datatype origin_dtp, target_dtp;
+
+    MPI_Init(&argc, &argv);
+
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    if (size != 3) {
+        /* run this test with three processes */
+        goto exit_test;
+    }
+
+    MPI_Type_contiguous(OP_COUNT, MPI_INT, &origin_dtp);
+    MPI_Type_commit(&origin_dtp);
+    MPI_Type_contiguous(OP_COUNT, MPI_INT, &target_dtp);
+    MPI_Type_commit(&target_dtp);
+
+    /* this works when MPIR_PARAM_CH3_ODD_EVEN_CLIQUES is set */
+    dest = 2;
+    origin_shm = 0;
+    origin_am = 1;
+
+    if (rank == origin_am)
+        my_buf_num = AM_BUF_NUM;
+    else if (rank == origin_shm)
+        my_buf_num = SHM_BUF_NUM;
+
+    if (rank != dest) {
+        MPI_Alloc_mem(sizeof(int) * my_buf_num * OP_COUNT, MPI_INFO_NULL, &orig_buf);
+        MPI_Alloc_mem(sizeof(int) * my_buf_num * OP_COUNT, MPI_INFO_NULL, &result_buf);
+    }
+
+    MPI_Win_allocate(sizeof(int) * WIN_BUF_NUM * OP_COUNT, sizeof(int), MPI_INFO_NULL,
+                     MPI_COMM_WORLD, &target_buf, &win);
+
+    for (k = 0; k < LOOP_SIZE; k++) {
+
+        /* ====== Part 1: test basic datatypes ======== */
+
+        /* init buffers */
+        if (rank != dest) {
+            for (i = 0; i < my_buf_num * OP_COUNT; i++) {
+                orig_buf[i] = 1;
+                result_buf[i] = 0;
+            }
+        }
+        else {
+            MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+            for (i = 0; i < WIN_BUF_NUM * OP_COUNT; i++) {
+                target_buf[i] = 0;
+            }
+            MPI_Win_unlock(rank, win);
+        }
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        MPI_Win_lock_all(0, win);
+        if (rank != dest) {
+            for (i = 0; i < my_buf_num; i++) {
+                MPI_Get_accumulate(&(orig_buf[i * OP_COUNT]), OP_COUNT, MPI_INT,
+                                   &(result_buf[i * OP_COUNT]), OP_COUNT, MPI_INT,
+                                   dest, 0, OP_COUNT, MPI_INT, MPI_SUM, win);
+                MPI_Win_flush(dest, win);
+            }
+        }
+        MPI_Win_unlock_all(win);
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        checkResults(k, &errors);
+
+        /* ====== Part 2: test derived datatypes (origin derived, target derived) ======== */
+
+        /* init buffers */
+        if (rank != dest) {
+            for (i = 0; i < my_buf_num * OP_COUNT; i++) {
+                orig_buf[i] = 1;
+                result_buf[i] = 0;
+            }
+        }
+        else {
+            MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+            for (i = 0; i < WIN_BUF_NUM * OP_COUNT; i++) {
+                target_buf[i] = 0;
+            }
+            MPI_Win_unlock(rank, win);
+        }
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        MPI_Win_lock_all(0, win);
+        if (rank != dest) {
+            for (i = 0; i < my_buf_num; i++) {
+                MPI_Get_accumulate(&(orig_buf[i * OP_COUNT]), 1, origin_dtp,
+                                   &(result_buf[i * OP_COUNT]), 1, origin_dtp,
+                                   dest, 0, 1, target_dtp, MPI_SUM, win);
+                MPI_Win_flush(dest, win);
+            }
+        }
+        MPI_Win_unlock_all(win);
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        checkResults(k, &errors);
+
+        /* ====== Part 3: test derived datatypes (origin basic, target derived) ======== */
+
+        /* init buffers */
+        if (rank != dest) {
+            for (i = 0; i < my_buf_num * OP_COUNT; i++) {
+                orig_buf[i] = 1;
+                result_buf[i] = 0;
+            }
+        }
+        else {
+            MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+            for (i = 0; i < WIN_BUF_NUM * OP_COUNT; i++) {
+                target_buf[i] = 0;
+            }
+            MPI_Win_unlock(rank, win);
+        }
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        MPI_Win_lock_all(0, win);
+        if (rank != dest) {
+            for (i = 0; i < my_buf_num; i++) {
+                MPI_Get_accumulate(&(orig_buf[i * OP_COUNT]), OP_COUNT, MPI_INT,
+                                   &(result_buf[i * OP_COUNT]), OP_COUNT, MPI_INT,
+                                   dest, 0, 1, target_dtp, MPI_SUM, win);
+                MPI_Win_flush(dest, win);
+            }
+        }
+        MPI_Win_unlock_all(win);
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        checkResults(k, &errors);
+
+        /* ====== Part 4: test derived datatypes (origin derived target basic) ======== */
+
+        /* init buffers */
+        if (rank != dest) {
+            for (i = 0; i < my_buf_num * OP_COUNT; i++) {
+                orig_buf[i] = 1;
+                result_buf[i] = 0;
+            }
+        }
+        else {
+            MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
+            for (i = 0; i < WIN_BUF_NUM * OP_COUNT; i++) {
+                target_buf[i] = 0;
+            }
+            MPI_Win_unlock(rank, win);
+        }
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        MPI_Win_lock_all(0, win);
+        if (rank != dest) {
+            for (i = 0; i < my_buf_num; i++) {
+                MPI_Get_accumulate(&(orig_buf[i * OP_COUNT]), 1, origin_dtp,
+                                   &(result_buf[i * OP_COUNT]), 1, origin_dtp,
+                                   dest, 0, OP_COUNT, MPI_INT, MPI_SUM, win);
+                MPI_Win_flush(dest, win);
+            }
+        }
+        MPI_Win_unlock_all(win);
+
+        MPI_Barrier(MPI_COMM_WORLD);
+
+        checkResults(k, &errors);
+    }
+
+    MPI_Win_free(&win);
+
+    if (rank == origin_am || rank == origin_shm) {
+        MPI_Free_mem(orig_buf);
+        MPI_Free_mem(result_buf);
+    }
+
+    MPI_Type_free(&origin_dtp);
+    MPI_Type_free(&target_dtp);
+
+  exit_test:
+    MPI_Reduce(&errors, &all_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
+
+    if (rank == 0 && all_errors == 0)
+        printf(" No Errors\n");
+
+    MPI_Finalize();
+    return 0;
+}
index 972dda7..9d6ef87 100644 (file)
@@ -13,117 +13,113 @@ static char MTestDescrip[] = "Test creating and inserting attributes in \
 different orders to ensure that the list management code handles all cases.";
 */
 
-int checkAttrs( MPI_Win win, int n, int key[], int attrval[] );
-int checkNoAttrs( MPI_Win win, int n, int key[] );
+int checkAttrs(MPI_Win win, int n, int key[], int attrval[]);
+int checkNoAttrs(MPI_Win win, int n, int key[]);
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0;
     int key[3], attrval[3];
     int i;
     int buf[1];
     MPI_Comm comm;
-    MPI_Win  win;
+    MPI_Win win;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
     {
-       comm = MPI_COMM_WORLD;
-       MPI_Win_create( buf, sizeof(int), sizeof(int), MPI_INFO_NULL,
-                       comm, &win );
-
-       /* Create key values */
-       for (i=0; i<3; i++) {
-           MPI_Win_create_keyval( MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN,
-                              &key[i], (void *)0 );
-           attrval[i] = 1024 * i;
-       }
-       
-       /* Insert attribute in several orders.  Test after put with get,
-        then delete, then confirm delete with get. */
-
-       MPI_Win_set_attr( win, key[2], &attrval[2] );
-       MPI_Win_set_attr( win, key[1], &attrval[1] );
-       MPI_Win_set_attr( win, key[0], &attrval[0] );
-
-       errs += checkAttrs( win, 3, key, attrval );
-       
-       MPI_Win_delete_attr( win, key[0] );
-       MPI_Win_delete_attr( win, key[1] );
-       MPI_Win_delete_attr( win, key[2] );
-
-       errs += checkNoAttrs( win, 3, key );
-       
-       MPI_Win_set_attr( win, key[1], &attrval[1] );
-       MPI_Win_set_attr( win, key[2], &attrval[2] );
-       MPI_Win_set_attr( win, key[0], &attrval[0] );
-
-       errs += checkAttrs( win, 3, key, attrval );
-       
-       MPI_Win_delete_attr( win, key[2] );
-       MPI_Win_delete_attr( win, key[1] );
-       MPI_Win_delete_attr( win, key[0] );
-
-       errs += checkNoAttrs( win, 3, key );
-
-       MPI_Win_set_attr( win, key[0], &attrval[0] );
-       MPI_Win_set_attr( win, key[1], &attrval[1] );
-       MPI_Win_set_attr( win, key[2], &attrval[2] );
-
-       errs += checkAttrs( win, 3, key, attrval );
-       
-       MPI_Win_delete_attr( win, key[1] );
-       MPI_Win_delete_attr( win, key[2] );
-       MPI_Win_delete_attr( win, key[0] );
-
-       errs += checkNoAttrs( win, 3, key );
-       
-       for (i=0; i<3; i++) {
-           MPI_Win_free_keyval( &key[i] );
-       }
-       MPI_Win_free( &win );
+        comm = MPI_COMM_WORLD;
+        MPI_Win_create(buf, sizeof(int), sizeof(int), MPI_INFO_NULL, comm, &win);
+
+        /* Create key values */
+        for (i = 0; i < 3; i++) {
+            MPI_Win_create_keyval(MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key[i], (void *) 0);
+            attrval[i] = 1024 * i;
+        }
+
+        /* Insert attribute in several orders.  Test after put with get,
+         * then delete, then confirm delete with get. */
+
+        MPI_Win_set_attr(win, key[2], &attrval[2]);
+        MPI_Win_set_attr(win, key[1], &attrval[1]);
+        MPI_Win_set_attr(win, key[0], &attrval[0]);
+
+        errs += checkAttrs(win, 3, key, attrval);
+
+        MPI_Win_delete_attr(win, key[0]);
+        MPI_Win_delete_attr(win, key[1]);
+        MPI_Win_delete_attr(win, key[2]);
+
+        errs += checkNoAttrs(win, 3, key);
+
+        MPI_Win_set_attr(win, key[1], &attrval[1]);
+        MPI_Win_set_attr(win, key[2], &attrval[2]);
+        MPI_Win_set_attr(win, key[0], &attrval[0]);
+
+        errs += checkAttrs(win, 3, key, attrval);
+
+        MPI_Win_delete_attr(win, key[2]);
+        MPI_Win_delete_attr(win, key[1]);
+        MPI_Win_delete_attr(win, key[0]);
+
+        errs += checkNoAttrs(win, 3, key);
+
+        MPI_Win_set_attr(win, key[0], &attrval[0]);
+        MPI_Win_set_attr(win, key[1], &attrval[1]);
+        MPI_Win_set_attr(win, key[2], &attrval[2]);
+
+        errs += checkAttrs(win, 3, key, attrval);
+
+        MPI_Win_delete_attr(win, key[1]);
+        MPI_Win_delete_attr(win, key[2]);
+        MPI_Win_delete_attr(win, key[0]);
+
+        errs += checkNoAttrs(win, 3, key);
+
+        for (i = 0; i < 3; i++) {
+            MPI_Win_free_keyval(&key[i]);
+        }
+        MPI_Win_free(&win);
     }
-    
-    MTest_Finalize( errs );
+
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
-  
+
 }
 
-int checkAttrs( MPI_Win win, int n, int key[], int attrval[] )
+int checkAttrs(MPI_Win win, int n, int key[], int attrval[])
 {
     int errs = 0;
     int i, flag, *val_p;
 
-    for (i=0; i<n; i++) {
-       MPI_Win_get_attr( win, key[i], &val_p, &flag );
-       if (!flag) {
-           errs++;
-           fprintf( stderr, "Attribute for key %d not set\n", i );
-       }
-       else if (val_p != &attrval[i]) {
-           errs++;
-           fprintf( stderr, "Atribute value for key %d not correct\n",
-                    i );
-       }
+    for (i = 0; i < n; i++) {
+        MPI_Win_get_attr(win, key[i], &val_p, &flag);
+        if (!flag) {
+            errs++;
+            fprintf(stderr, "Attribute for key %d not set\n", i);
+        }
+        else if (val_p != &attrval[i]) {
+            errs++;
+            fprintf(stderr, "Atribute value for key %d not correct\n", i);
+        }
     }
 
     return errs;
 }
 
-int checkNoAttrs( MPI_Win win, int n, int key[] )
+int checkNoAttrs(MPI_Win win, int n, int key[])
 {
     int errs = 0;
     int i, flag, *val_p;
 
-    for (i=0; i<n; i++) {
-       MPI_Win_get_attr( win, key[i], &val_p, &flag );
-       if (flag) {
-           errs++;
-           fprintf( stderr, "Attribute for key %d set but should be deleted\n", i );
-       }
+    for (i = 0; i < n; i++) {
+        MPI_Win_get_attr(win, key[i], &val_p, &flag);
+        if (flag) {
+            errs++;
+            fprintf(stderr, "Attribute for key %d set but should be deleted\n", i);
+        }
     }
 
     return errs;
 }
-       
index fc1ccc9..1ecda21 100644 (file)
@@ -8,73 +8,71 @@
 #include "mpi.h"
 #include "mpitest.h"
 
-int main( int argc, char **argv)
+int main(int argc, char **argv)
 {
-    int    errs = 0;
+    int errs = 0;
     void *v;
-    int  flag;
-    int  rank, size;
+    int flag;
+    int rank, size;
     int base[1024];
     MPI_Aint n;
-    int     disp;
+    int disp;
     MPI_Win win;
 
-    MTest_Init( &argc, &argv );
-    MPI_Comm_size( MPI_COMM_WORLD, &size );
-    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
+    MTest_Init(&argc, &argv);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
     /* Create a window; then extract the values */
-    n    = 1024;
+    n = 1024;
     disp = 4;
-    MPI_Win_create( base, n, disp, MPI_INFO_NULL, MPI_COMM_WORLD, &win );
+    MPI_Win_create(base, n, disp, MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
-    MPI_Win_get_attr( win, MPI_WIN_BASE, &v, &flag );
+    MPI_Win_get_attr(win, MPI_WIN_BASE, &v, &flag);
     if (!flag) {
-       errs++;
-       fprintf( stderr, "Could not get WIN_BASE\n" );
+        errs++;
+        fprintf(stderr, "Could not get WIN_BASE\n");
     }
     else {
-       /* MPI 2.1, section 11.2.2.  v must be a pointer to the start of the 
-        window.  It is not a pointer to a pointer to the start of the window. 
-       */
-       if ((int*)v != base) {
-           errs++;
-           fprintf( stderr, "Got incorrect value for WIN_BASE (%p, should be %p)", 
-                    v, base );
-       }
+        /* MPI 2.1, section 11.2.2.  v must be a pointer to the start of the
+         * window.  It is not a pointer to a pointer to the start of the window.
+         */
+        if ((int *) v != base) {
+            errs++;
+            fprintf(stderr, "Got incorrect value for WIN_BASE (%p, should be %p)", v, base);
+        }
     }
 
-    MPI_Win_get_attr( win, MPI_WIN_SIZE, &v, &flag );
+    MPI_Win_get_attr(win, MPI_WIN_SIZE, &v, &flag);
     if (!flag) {
-       errs++;
-       fprintf( stderr, "Could not get WIN_SIZE\n" );
+        errs++;
+        fprintf(stderr, "Could not get WIN_SIZE\n");
     }
     else {
-       MPI_Aint vval = *(MPI_Aint*)v;
-       if (vval != n) {
-           errs++;
-           fprintf( stderr, "Got wrong value for WIN_SIZE (%ld, should be %ld)\n", 
-                    (long) vval, (long) n );
-       }
+        MPI_Aint vval = *(MPI_Aint *) v;
+        if (vval != n) {
+            errs++;
+            fprintf(stderr, "Got wrong value for WIN_SIZE (%ld, should be %ld)\n",
+                    (long) vval, (long) n);
+        }
     }
 
-    MPI_Win_get_attr( win, MPI_WIN_DISP_UNIT, &v, &flag );
+    MPI_Win_get_attr(win, MPI_WIN_DISP_UNIT, &v, &flag);
     if (!flag) {
-       errs++;
-       fprintf( stderr, "Could not get WIN_DISP_UNIT\n" );
+        errs++;
+        fprintf(stderr, "Could not get WIN_DISP_UNIT\n");
     }
     else {
-       int vval = *(int*)v;
-       if (vval != disp) {
-           errs++;
-           fprintf( stderr, "Got wrong value for WIN_DISP_UNIT (%d, should be %d)\n",
-                    vval, disp );
-       }
+        int vval = *(int *) v;
+        if (vval != disp) {
+            errs++;
+            fprintf(stderr, "Got wrong value for WIN_DISP_UNIT (%d, should be %d)\n", vval, disp);
+        }
     }
 
     MPI_Win_free(&win);
-    MTest_Finalize( errs );
-    MPI_Finalize( );
-    
+    MTest_Finalize(errs);
+    MPI_Finalize();
+
     return 0;
 }
index 96eace1..c9f1696 100644 (file)
 
 #define ITER 100
 
-int main(int argc, char **argv) {
-    int       i, j, rank, nproc;
-    int       errors = 0, all_errors = 0;
-    int      *val_ptr;
-    MPI_Win   win;
+int main(int argc, char **argv)
+{
+    int i, rank, nproc;
+    int errors = 0, all_errors = 0;
+    int *val_ptr;
+    MPI_Win win;
 
     MPI_Init(&argc, &argv);
 
@@ -39,8 +40,8 @@ int main(int argc, char **argv) {
         MPI_Compare_and_swap(&next, &i, &result, MPI_INT, rank, 0, win);
         MPI_Win_unlock(rank, win);
         if (result != i) {
-            SQUELCH( printf("%d->%d -- Error: next=%d compare=%d result=%d val=%d\n", rank,
-                           rank, next, i, result, *val_ptr); );
+            SQUELCH(printf("%d->%d -- Error: next=%d compare=%d result=%d val=%d\n", rank,
+                           rank, next, i, result, *val_ptr););
             errors++;
         }
     }
@@ -55,12 +56,12 @@ int main(int argc, char **argv) {
 
     for (i = 0; i < ITER; i++) {
         int next = i + 1, result = -1;
-        MPI_Win_lock(MPI_LOCK_EXCLUSIVE, (rank+1)%nproc, 0, win);
-        MPI_Compare_and_swap(&next, &i, &result, MPI_INT, (rank+1)%nproc, 0, win);
-        MPI_Win_unlock((rank+1)%nproc, win);
+        MPI_Win_lock(MPI_LOCK_EXCLUSIVE, (rank + 1) % nproc, 0, win);
+        MPI_Compare_and_swap(&next, &i, &result, MPI_INT, (rank + 1) % nproc, 0, win);
+        MPI_Win_unlock((rank + 1) % nproc, win);
         if (result != i) {
-            SQUELCH( printf("%d->%d -- Error: next=%d compare=%d result=%d val=%d\n", rank,
-                           (rank+1)%nproc, next, i, result, *val_ptr); );
+            SQUELCH(printf("%d->%d -- Error: next=%d compare=%d result=%d val=%d\n", rank,
+                           (rank + 1) % nproc, next, i, result, *val_ptr););
             errors++;
         }
     }
@@ -89,7 +90,7 @@ int main(int argc, char **argv) {
 
     if (rank == 0 && nproc > 1) {
         if (*val_ptr != ITER) {
-            SQUELCH( printf("%d - Error: expected=%d val=%d\n", rank, ITER, *val_ptr); );
+            SQUELCH(printf("%d - Error: expected=%d val=%d\n", rank, ITER, *val_ptr););
             errors++;
         }
     }
index 2b2be30..b549c9b 100644 (file)
@@ -26,80 +26,82 @@ int test_put(void);
 
 int test_put(void)
 {
-  MPI_Win  dst_win;
-  double  *dst_buf;
-  double   src_buf[MAXELEMS];
-  int      i, j;
-  int      errs = 0;
+    MPI_Win dst_win;
+    double *dst_buf;
+    double src_buf[MAXELEMS];
+    int i, j;
+    int errs = 0;
 
-  MPI_Alloc_mem(sizeof(double)*nproc*MAXELEMS, MPI_INFO_NULL, &dst_buf);
-  MPI_Win_create(dst_buf, sizeof(double)*nproc*MAXELEMS, 1, MPI_INFO_NULL, 
-                MPI_COMM_WORLD, &dst_win);
+    MPI_Alloc_mem(sizeof(double) * nproc * MAXELEMS, MPI_INFO_NULL, &dst_buf);
+    MPI_Win_create(dst_buf, sizeof(double) * nproc * MAXELEMS, 1, MPI_INFO_NULL,
+                   MPI_COMM_WORLD, &dst_win);
 
-  for (i = 0; i < MAXELEMS; i++)
-    src_buf[i] = me + 1.0;
+    for (i = 0; i < MAXELEMS; i++)
+        src_buf[i] = me + 1.0;
 
-  MPI_Win_lock(MPI_LOCK_EXCLUSIVE, me, 0, dst_win);
+    MPI_Win_lock(MPI_LOCK_EXCLUSIVE, me, 0, dst_win);
 
-  for (i = 0; i < nproc*MAXELEMS; i++)
-    dst_buf[i] = 0.0;
+    for (i = 0; i < nproc * MAXELEMS; i++)
+        dst_buf[i] = 0.0;
 
-  MPI_Win_unlock(me, dst_win);
+    MPI_Win_unlock(me, dst_win);
 
-  MPI_Barrier(MPI_COMM_WORLD);
+    MPI_Barrier(MPI_COMM_WORLD);
 
-  for(i = 0; i < nproc; i++) {
-    /* int target = (me + i) % nproc; */
-    int target = i;
-    for(j = 0; j < COUNT; j++) {
-      if (verbose) printf("%2d -> %2d [%2d]\n", me, target, j); 
-      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, dst_win);
-      MPI_Put(&src_buf[j], sizeof(double), MPI_BYTE, target, 
-             (me*MAXELEMS+j)*sizeof(double), sizeof(double), MPI_BYTE, dst_win);
-      MPI_Win_unlock(target, dst_win);
+    for (i = 0; i < nproc; i++) {
+        /* int target = (me + i) % nproc; */
+        int target = i;
+        for (j = 0; j < COUNT; j++) {
+            if (verbose)
+                printf("%2d -> %2d [%2d]\n", me, target, j);
+            MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, dst_win);
+            MPI_Put(&src_buf[j], sizeof(double), MPI_BYTE, target,
+                    (me * MAXELEMS + j) * sizeof(double), sizeof(double), MPI_BYTE, dst_win);
+            MPI_Win_unlock(target, dst_win);
+        }
     }
-  }
-
-  MPI_Barrier(MPI_COMM_WORLD);
-
-  /* Check that the correct data was returned.  This assumes that the 
-     systems have the same data representations */
-  for (i=0; i<nproc; i++) {
-      for (j=0; j<COUNT; j++) {
-         if (dst_buf[i*MAXELEMS+j] != 1.0 + i) {
-             errs++;
-             printf( "dst_buf[%d] = %e, expected %e\n",
-                     i*MAXELEMS+j, dst_buf[i*MAXELEMS+j], 1.0 + i );
-         }
-      }
-  }
-
-  MPI_Win_free(&dst_win);
-  MPI_Free_mem(dst_buf);
-
-  return errs;
+
+    MPI_Barrier(MPI_COMM_WORLD);
+
+    /* Check that the correct data was returned.  This assumes that the
+     * systems have the same data representations */
+    for (i = 0; i < nproc; i++) {
+        for (j = 0; j < COUNT; j++) {
+            if (dst_buf[i * MAXELEMS + j] != 1.0 + i) {
+                errs++;
+                printf("dst_buf[%d] = %e, expected %e\n",
+                       i * MAXELEMS + j, dst_buf[i * MAXELEMS + j], 1.0 + i);
+            }
+        }
+    }
+
+    MPI_Win_free(&dst_win);
+    MPI_Free_mem(dst_buf);
+
+    return errs;
 }
 
 
-int main(int argc, char* argv[]) {
+int main(int argc, char *argv[])
+{
     int errs = 0;
 
     MTest_Init(&argc, &argv);
     MPI_Comm_size(MPI_COMM_WORLD, &nproc);
     MPI_Comm_rank(MPI_COMM_WORLD, &me);
-    
+
     assert(COUNT <= MAXELEMS);
-    
+
     if (me == 0 && verbose) {
-       printf("Test starting on %d processes\n", nproc); 
-       fflush(stdout);
+        printf("Test starting on %d processes\n", nproc);
+        fflush(stdout);
     }
-    
+
     errs = test_put();
-    
+
     MPI_Barrier(MPI_COMM_WORLD);
-    
-    MTest_Finalize( errs );
+
+    MTest_Finalize(errs);
     MPI_Finalize();
-    return MTestReturnValue( errs );
+    return MTestReturnValue(errs);
 }
index 6a539a0..312cf31 100644 (file)
@@ -24,76 +24,82 @@ static const int verbose = 0;
 void test_put(void);
 void test_put(void)
 {
-  MPI_Win  dst_win;
-  double  *dst_buf;
-  double   src_buf[MAXELEMS];
-  int      i, j;
-
-  MPI_Alloc_mem(sizeof(double)*nproc*MAXELEMS, MPI_INFO_NULL, &dst_buf);
-  MPI_Win_create(dst_buf, sizeof(double)*nproc*MAXELEMS, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &dst_win);
-
-  for (i = 0; i < MAXELEMS; i++)
-    src_buf[i] = me + 1.0;
-
-  MPI_Win_lock(MPI_LOCK_EXCLUSIVE, me, 0, dst_win);
-
-  for (i = 0; i < nproc*MAXELEMS; i++)
-    dst_buf[i] = 0.0;
-
-  MPI_Win_unlock(me, dst_win);
-
-  MPI_Barrier(MPI_COMM_WORLD);
-
-  for(i = 0; i < nproc; i++) {
-    int target = i;
-
-    for(j = 0; j < COUNT; j++) {
-      if (verbose) printf("%2d -> %2d [%2d]\n", me, target, j); 
-      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, dst_win);
-      MPI_Put(&src_buf[j], sizeof(double), MPI_BYTE, target, (me*MAXELEMS+j)*sizeof(double), sizeof(double), MPI_BYTE, dst_win);
-      MPI_Win_unlock(target, dst_win);
-    }
-
-    for(j = 0; j < COUNT; j++) {
-      if (verbose) printf("%2d <- %2d [%2d]\n", me, target, j); 
-      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, dst_win);
-      MPI_Get(&src_buf[j], sizeof(double), MPI_BYTE, target, (me*MAXELEMS+j)*sizeof(double), sizeof(double), MPI_BYTE, dst_win);
-      MPI_Win_unlock(target, dst_win);
+    MPI_Win dst_win;
+    double *dst_buf;
+    double src_buf[MAXELEMS];
+    int i, j;
+
+    MPI_Alloc_mem(sizeof(double) * nproc * MAXELEMS, MPI_INFO_NULL, &dst_buf);
+    MPI_Win_create(dst_buf, sizeof(double) * nproc * MAXELEMS, 1, MPI_INFO_NULL, MPI_COMM_WORLD,
+                   &dst_win);
+
+    for (i = 0; i < MAXELEMS; i++)
+        src_buf[i] = me + 1.0;
+
+    MPI_Win_lock(MPI_LOCK_EXCLUSIVE, me, 0, dst_win);
+
+    for (i = 0; i < nproc * MAXELEMS; i++)
+        dst_buf[i] = 0.0;
+
+    MPI_Win_unlock(me, dst_win);
+
+    MPI_Barrier(MPI_COMM_WORLD);
+
+    for (i = 0; i < nproc; i++) {
+        int target = i;
+
+        for (j = 0; j < COUNT; j++) {
+            if (verbose)
+                printf("%2d -> %2d [%2d]\n", me, target, j);
+            MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, dst_win);
+            MPI_Put(&src_buf[j], sizeof(double), MPI_BYTE, target,
+                    (me * MAXELEMS + j) * sizeof(double), sizeof(double), MPI_BYTE, dst_win);
+            MPI_Win_unlock(target, dst_win);
+        }
+
+        for (j = 0; j < COUNT; j++) {
+            if (verbose)
+                printf("%2d <- %2d [%2d]\n", me, target, j);
+            MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, dst_win);
+            MPI_Get(&src_buf[j], sizeof(double), MPI_BYTE, target,
+                    (me * MAXELEMS + j) * sizeof(double), sizeof(double), MPI_BYTE, dst_win);
+            MPI_Win_unlock(target, dst_win);
+        }
     }
-  }
 
-  MPI_Barrier(MPI_COMM_WORLD);
+    MPI_Barrier(MPI_COMM_WORLD);
 
-  MPI_Win_free(&dst_win);
-  MPI_Free_mem(dst_buf);
+    MPI_Win_free(&dst_win);
+    MPI_Free_mem(dst_buf);
 }
 
 
-int main(int argc, char* argv[]) {
-  MPI_Init(&argc, &argv);
-  MPI_Comm_size(MPI_COMM_WORLD, &nproc);
-  MPI_Comm_rank(MPI_COMM_WORLD, &me);
+int main(int argc, char *argv[])
+{
+    MPI_Init(&argc, &argv);
+    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
+    MPI_Comm_rank(MPI_COMM_WORLD, &me);
 
-  assert(COUNT <= MAXELEMS);
+    assert(COUNT <= MAXELEMS);
 
-  if (me == 0 && verbose) {
-    printf("Test starting on %d processes\n", nproc); 
-    fflush(stdout);
-  }
+    if (me == 0 && verbose) {
+        printf("Test starting on %d processes\n", nproc);
+        fflush(stdout);
+    }
 
-  test_put();
+    test_put();
 
-  MPI_Barrier(MPI_COMM_WORLD);
+    MPI_Barrier(MPI_COMM_WORLD);
 
-  MPI_Finalize();
+    MPI_Finalize();
 
-  if (me == 0 && verbose) {
-    printf("Test completed.\n");
-    fflush(stdout);
-  }
+    if (me == 0 && verbose) {
+        printf("Test completed.\n");
+        fflush(stdout);
+    }
 
-  if (me == 0)
-    printf(" No Errors\n");
+    if (me == 0)
+        printf(" No Errors\n");
 
-  return 0;
+    return 0;
 }
index 9d37da6..459c8b6 100644 (file)
 /* Run with 1 process.
 
    This program does an MPI_Get with an indexed datatype. The datatype
-   comprises a single integer at an initial displacement of 1 integer. 
+   comprises a single integer at an initial displacement of 1 integer.
    That is, the first integer in the array is to be skipped.
 
    This program found a bug in IBM's MPI in which MPI_Get ignored the
-   displacement and got the first integer instead of the second. 
+   displacement and got the first integer instead of the second.
 */
 
 int main(int argc, char **argv)
 {
     int rank, nprocs, mpi_err, *array;
-    int getval, disp, errs=0;
+    int getval, disp, errs = 0;
     MPI_Win win;
     MPI_Datatype type;
-    
-    MTest_Init(&argc,&argv); 
+
+    MTest_Init(&argc, &argv);
 
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
 
     if (rank == 0) {
         /* To improve reporting of problems about operations, we
-           change the error handler to errors return */
-        MPI_Comm_set_errhandler( MPI_COMM_SELF, MPI_ERRORS_RETURN );
-        /* create an indexed datatype that points to the second integer 
-           in an array (the first integer is skipped). */
-        disp  =  1;
+         * change the error handler to errors return */
+        MPI_Comm_set_errhandler(MPI_COMM_SELF, MPI_ERRORS_RETURN);
+
+        /* create an indexed datatype that points to the second integer
+         * in an array (the first integer is skipped). */
+        disp = 1;
         mpi_err = MPI_Type_create_indexed_block(1, 1, &disp, MPI_INT, &type);
-        if (mpi_err != MPI_SUCCESS) goto err_return;
+        if (mpi_err != MPI_SUCCESS)
+            goto err_return;
         mpi_err = MPI_Type_commit(&type);
-        if (mpi_err != MPI_SUCCESS) goto err_return;
-        /* allocate window of size 2 integers*/
-        mpi_err = MPI_Alloc_mem(2*sizeof(int), MPI_INFO_NULL, &array);
-        if (mpi_err != MPI_SUCCESS) goto err_return;
+        if (mpi_err != MPI_SUCCESS)
+            goto err_return;
+
+        /* allocate window of size 2 integers */
+        mpi_err = MPI_Alloc_mem(2 * sizeof(int), MPI_INFO_NULL, &array);
+        if (mpi_err != MPI_SUCCESS)
+            goto err_return;
+
         /* create window object */
-        mpi_err = MPI_Win_create(array, 2*sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_SELF, &win);
-        if (mpi_err != MPI_SUCCESS) goto err_return;
-  
+        mpi_err =
+            MPI_Win_create(array, 2 * sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_SELF, &win);
+        if (mpi_err != MPI_SUCCESS)
+            goto err_return;
+
         /* initialize array */
         array[0] = 100;
         array[1] = 200;
+
         getval = 0;
-        
+
         /* To improve reporting of problems about operations, we
-           change the error handler to errors return */
-        MPI_Win_set_errhandler( win, MPI_ERRORS_RETURN );
+         * change the error handler to errors return */
+        MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+
         mpi_err = MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, win);
-        if (mpi_err != MPI_SUCCESS) goto err_return;
+        if (mpi_err != MPI_SUCCESS)
+            goto err_return;
+
         /* get the current value of element array[1] */
         mpi_err = MPI_Get(&getval, 1, MPI_INT, 0, 0, 1, type, win);
-        if (mpi_err != MPI_SUCCESS) goto err_return;
+        if (mpi_err != MPI_SUCCESS)
+            goto err_return;
+
         mpi_err = MPI_Win_unlock(0, win);
-        if (mpi_err != MPI_SUCCESS) goto err_return;
+        if (mpi_err != MPI_SUCCESS)
+            goto err_return;
+
         /* getval should contain the value of array[1] */
         if (getval != array[1]) {
             errs++;
             printf("getval=%d, should be %d\n", getval, array[1]);
         }
+
         MPI_Free_mem(array);
         MPI_Win_free(&win);
         MPI_Type_free(&type);
@@ -86,13 +94,11 @@ int main(int argc, char **argv)
     MPI_Finalize();
     return 0;
 
- err_return:
 err_return:
     printf("MPI function error returned an error\n");
-    MTestPrintError( mpi_err );
+    MTestPrintError(mpi_err);
     errs++;
     MTest_Finalize(errs);
     MPI_Finalize();
     return 1;
 }
-
-
diff --git a/teshsuite/smpi/mpich3-test/rma/derived-acc-flush_local.c b/teshsuite/smpi/mpich3-test/rma/derived-acc-flush_local.c
new file mode 100644 (file)
index 0000000..032a022
--- /dev/null
@@ -0,0 +1,130 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *  (C) 2015 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+/* This code tests the case when one process issues large number
+ * of MPI_Accumulate operations (with large derived datatype) and
+ * issues a MPI_Win_flush_local at end. */
+
+/* FIXME: we should merge this into a comprehensive test for RMA
+ * operations + MPI_Win_flush_local. */
+
+#include "mpi.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define DATA_SIZE 1000000
+#define COUNT 5000
+#define BLOCKLENGTH (DATA_SIZE/COUNT)
+#define STRIDE BLOCKLENGTH
+#define OPS_NUM 500
+
+int main(int argc, char *argv[])
+{
+    int rank, nproc;
+    int i;
+    MPI_Win win;
+    int *tar_buf = NULL;
+    int *orig_buf = NULL;
+    MPI_Datatype derived_dtp;
+    int errors = 0;
+
+    MPI_Init(&argc, &argv);
+
+    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    if (nproc < 3) {
+        fprintf(stderr, "Run this program with at least 3 processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
+
+    MPI_Alloc_mem(sizeof(int) * DATA_SIZE, MPI_INFO_NULL, &orig_buf);
+    MPI_Alloc_mem(sizeof(int) * DATA_SIZE, MPI_INFO_NULL, &tar_buf);
+
+    for (i = 0; i < DATA_SIZE; i++) {
+        orig_buf[i] = 1;
+        tar_buf[i] = 0;
+    }
+
+    MPI_Type_vector(COUNT, BLOCKLENGTH - 1, STRIDE, MPI_INT, &derived_dtp);
+    MPI_Type_commit(&derived_dtp);
+
+    MPI_Win_create(tar_buf, sizeof(int) * DATA_SIZE, sizeof(int),
+                   MPI_INFO_NULL, MPI_COMM_WORLD, &win);
+
+    /***** test between rank 0 and rank 1 *****/
+
+    if (rank == 1) {
+        MPI_Win_lock(MPI_LOCK_SHARED, 0, 0, win);
+
+        for (i = 0; i < OPS_NUM; i++) {
+            MPI_Accumulate(orig_buf, 1, derived_dtp,
+                           0, 0, DATA_SIZE - COUNT, MPI_INT, MPI_SUM, win);
+            MPI_Win_flush_local(0, win);
+        }
+
+        MPI_Win_unlock(0, win);
+    }
+
+    MPI_Barrier(MPI_COMM_WORLD);
+
+    /* check results */
+    if (rank == 0) {
+        for (i = 0; i < DATA_SIZE - COUNT; i++) {
+            if (tar_buf[i] != OPS_NUM) {
+                printf("tar_buf[%d] = %d, expected %d\n", i, tar_buf[i], OPS_NUM);
+                errors++;
+            }
+        }
+    }
+
+    for (i = 0; i < DATA_SIZE; i++) {
+        tar_buf[i] = 0;
+    }
+
+    MPI_Barrier(MPI_COMM_WORLD);
+
+    /***** test between rank 0 and rank 2 *****/
+
+    if (rank == 2) {
+        MPI_Win_lock(MPI_LOCK_SHARED, 0, 0, win);
+
+        for (i = 0; i < OPS_NUM; i++) {
+            MPI_Accumulate(orig_buf, 1, derived_dtp,
+                           0, 0, DATA_SIZE - COUNT, MPI_INT, MPI_SUM, win);
+            MPI_Win_flush_local(0, win);
+        }
+
+        MPI_Win_unlock(0, win);
+    }
+
+    MPI_Barrier(MPI_COMM_WORLD);
+
+    /* check results */
+    if (rank == 0) {
+        for (i = 0; i < DATA_SIZE - COUNT; i++) {
+            if (tar_buf[i] != OPS_NUM) {
+                printf("tar_buf[%d] = %d, expected %d\n", i, tar_buf[i], OPS_NUM);
+                errors++;
+            }
+        }
+
+        if (errors == 0)
+            printf(" No Errors\n");
+    }
+
+    MPI_Win_free(&win);
+
+    MPI_Type_free(&derived_dtp);
+
+    MPI_Free_mem(orig_buf);
+    MPI_Free_mem(tar_buf);
+
+    MPI_Finalize();
+
+    return 0;
+}
index 7a3222a..bd07732 100644 (file)
@@ -6,7 +6,7 @@
  */
 
 /*
- * This test looks at the behavior of MPI_Win_fence and epochs.  Each 
+ * This test looks at the behavior of MPI_Win_fence and epochs.  Each
  * MPI_Win_fence may both begin and end both the exposure and access epochs.
  * Thus, it is not necessary to use MPI_Win_fence in pairs.
  *
@@ -32,160 +32,192 @@ static char MTEST_Descrip[] = "Put with Fences used to separate epochs";
 
 #define MAX_PERR 10
 
-int PrintRecvedError( const char *, MTestDatatype *, MTestDatatype * );
+int PrintRecvedError(const char *, MTestDatatype *, MTestDatatype *);
 
-int main( int argc, char **argv )
+int main(int argc, char **argv)
 {
     int errs = 0, err;
     int rank, size, source, dest;
-    int minsize = 2, count; 
-    MPI_Comm      comm;
-    MPI_Win       win;
-    MPI_Aint      extent;
+    int minsize = 2, count;
+    MPI_Comm comm;
+    MPI_Win win;
+    MPI_Aint extent,lb;
     MTestDatatype sendtype, recvtype;
-    int           onlyInt = 0;
+    int onlyInt = 0;
 
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
     /* Check for a simple choice of communicator and datatypes */
-    if (getenv( "MTEST_SIMPLE" )) onlyInt = 1;
-
-    while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
-       if (comm == MPI_COMM_NULL) continue;
-       /* Determine the sender and receiver */
-       MPI_Comm_rank( comm, &rank );
-       MPI_Comm_size( comm, &size );
-       source = 0;
-       dest   = size - 1;
-       
-       for (count = 1; count < 65000; count = count * 2) {
-           while (MTestGetDatatypes( &sendtype, &recvtype, count )) {
-
-               MTestPrintfMsg( 1, 
-                      "Putting count = %d of sendtype %s receive type %s\n", 
-                               count, MTestGetDatatypeName( &sendtype ),
-                               MTestGetDatatypeName( &recvtype ) );
-
-               /* Make sure that everyone has a recv buffer */
-               recvtype.InitBuf( &recvtype );
-
-               MPI_Type_extent( recvtype.datatype, &extent );
-               MPI_Win_create( recvtype.buf, recvtype.count * extent, 
-                               extent, MPI_INFO_NULL, comm, &win );
-               /* To improve reporting of problems about operations, we
-                  change the error handler to errors return */
-               MPI_Win_set_errhandler( win, MPI_ERRORS_RETURN );
-
-               /* At this point, we have all of the elements that we 
-                  need to begin the multiple fence and put tests */
-               /* Fence 1 */
-               err = MPI_Win_fence( MPI_MODE_NOPRECEDE, win ); 
-               if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
-               /* Source puts */
-               if (rank == source) {
-                   sendtype.InitBuf( &sendtype );
-                   
-                   err = MPI_Put( sendtype.buf, sendtype.count, 
-                                  sendtype.datatype, dest, 0, 
-                                  recvtype.count, recvtype.datatype, win );
-                   if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
-               }
-
-               /* Fence 2 */
-               err = MPI_Win_fence( 0, win );
-               if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
-               /* dest checks data, then Dest puts */
-               if (rank == dest) {
-                   err = MTestCheckRecv( 0, &recvtype );
-                   if (err) { if (errs++ < MAX_PERR) { 
-                           PrintRecvedError( "fence 2", &sendtype, &recvtype );
-                       }
-                   }
-                   sendtype.InitBuf( &sendtype );
-                   
-                   err = MPI_Put( sendtype.buf, sendtype.count, 
-                                  sendtype.datatype, source, 0, 
-                                  recvtype.count, recvtype.datatype, win );
-                   if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
-               }
-
-               /* Fence 3 */
-               err = MPI_Win_fence( 0, win );
-               if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
-               /* src checks data, then Src and dest puts*/
-               if (rank == source) {
-                   err = MTestCheckRecv( 0, &recvtype );
-                   if (err) { if (errs++ < MAX_PERR) { 
-                           PrintRecvedError( "fence 3", &sendtype, &recvtype );
-                       }
-                   }
-                   sendtype.InitBuf( &sendtype );
-                   
-                   err = MPI_Put( sendtype.buf, sendtype.count, 
-                                  sendtype.datatype, dest, 0, 
-                                  recvtype.count, recvtype.datatype, win );
-                   if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
-               }
-               if (rank == dest) {
-                   sendtype.InitBuf( &sendtype );
-                   
-                   err = MPI_Put( sendtype.buf, sendtype.count, 
-                                  sendtype.datatype, source, 0, 
-                                  recvtype.count, recvtype.datatype, win );
-                   if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
-               }
-
-               /* Fence 4 */
-               err = MPI_Win_fence( MPI_MODE_NOSUCCEED, win );
-               if (err) { if (errs++ < MAX_PERR) MTestPrintError(err); }
-               /* src and dest checks data */
-               if (rank == source) {
-                   err = MTestCheckRecv( 0, &recvtype );
-                   if (err) { if (errs++ < MAX_PERR) { 
-                           PrintRecvedError( "src fence4", &sendtype, &recvtype );
-                       }
-                   }
-               }
-               if (rank == dest) {
-                   err = MTestCheckRecv( 0, &recvtype );
-                   if (err) { if (errs++ < MAX_PERR) { 
-                           PrintRecvedError( "dest fence4", &sendtype, &recvtype );
-                       }
-                   }
-               }
-
-               MPI_Win_free( &win );
-               MTestFreeDatatype( &sendtype );
-               MTestFreeDatatype( &recvtype );
-
-               /* Only do one datatype in the simple case */
-               if (onlyInt) break;
-           }
-           /* Only do one count in the simple case */
-           if (onlyInt) break;
-       }
+    if (getenv("MTEST_SIMPLE"))
+        onlyInt = 1;
+
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        /* Determine the sender and receiver */
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_size(comm, &size);
+        source = 0;
+        dest = size - 1;
+
+        MTEST_DATATYPE_FOR_EACH_COUNT(count) {
+            while (MTestGetDatatypes(&sendtype, &recvtype, count)) {
+
+                MTestPrintfMsg(1,
+                               "Putting count = %d of sendtype %s receive type %s\n",
+                               count, MTestGetDatatypeName(&sendtype),
+                               MTestGetDatatypeName(&recvtype));
+
+                /* Make sure that everyone has a recv buffer */
+                recvtype.InitBuf(&recvtype);
+
+                MPI_Type_extent(recvtype.datatype, &extent);
+                MPI_Type_lb(recvtype.datatype, &lb);
+                MPI_Win_create(recvtype.buf, recvtype.count * extent + lb,
+                               extent, MPI_INFO_NULL, comm, &win);
+                /* To improve reporting of problems about operations, we
+                 * change the error handler to errors return */
+                MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+
+                /* At this point, we have all of the elements that we
+                 * need to begin the multiple fence and put tests */
+                /* Fence 1 */
+                err = MPI_Win_fence(MPI_MODE_NOPRECEDE, win);
+                if (err) {
+                    if (errs++ < MAX_PERR)
+                        MTestPrintError(err);
+                }
+                /* Source puts */
+                if (rank == source) {
+                    sendtype.InitBuf(&sendtype);
+
+                    err = MPI_Put(sendtype.buf, sendtype.count,
+                                  sendtype.datatype, dest, 0,
+                                  recvtype.count, recvtype.datatype, win);
+                    if (err) {
+                        if (errs++ < MAX_PERR)
+                            MTestPrintError(err);
+                    }
+                }
+
+                /* Fence 2 */
+                err = MPI_Win_fence(0, win);
+                if (err) {
+                    if (errs++ < MAX_PERR)
+                        MTestPrintError(err);
+                }
+                /* dest checks data, then Dest puts */
+                if (rank == dest) {
+                    err = MTestCheckRecv(0, &recvtype);
+                    if (err) {
+                        if (errs++ < MAX_PERR) {
+                            PrintRecvedError("fence 2", &sendtype, &recvtype);
+                        }
+                    }
+                    sendtype.InitBuf(&sendtype);
+
+                    err = MPI_Put(sendtype.buf, sendtype.count,
+                                  sendtype.datatype, source, 0,
+                                  recvtype.count, recvtype.datatype, win);
+                    if (err) {
+                        if (errs++ < MAX_PERR)
+                            MTestPrintError(err);
+                    }
+                }
+
+                /* Fence 3 */
+                err = MPI_Win_fence(0, win);
+                if (err) {
+                    if (errs++ < MAX_PERR)
+                        MTestPrintError(err);
+                }
+                /* src checks data, then Src and dest puts */
+                if (rank == source) {
+                    err = MTestCheckRecv(0, &recvtype);
+                    if (err) {
+                        if (errs++ < MAX_PERR) {
+                            PrintRecvedError("fence 3", &sendtype, &recvtype);
+                        }
+                    }
+                    sendtype.InitBuf(&sendtype);
+
+                    err = MPI_Put(sendtype.buf, sendtype.count,
+                                  sendtype.datatype, dest, 0,
+                                  recvtype.count, recvtype.datatype, win);
+                    if (err) {
+                        if (errs++ < MAX_PERR)
+                            MTestPrintError(err);
+                    }
+                }
+                if (rank == dest) {
+                    sendtype.InitBuf(&sendtype);
+
+                    err = MPI_Put(sendtype.buf, sendtype.count,
+                                  sendtype.datatype, source, 0,
+                                  recvtype.count, recvtype.datatype, win);
+                    if (err) {
+                        if (errs++ < MAX_PERR)
+                            MTestPrintError(err);
+                    }
+                }
+
+                /* Fence 4 */
+                err = MPI_Win_fence(MPI_MODE_NOSUCCEED, win);
+                if (err) {
+                    if (errs++ < MAX_PERR)
+                        MTestPrintError(err);
+                }
+                /* src and dest checks data */
+                if (rank == source) {
+                    err = MTestCheckRecv(0, &recvtype);
+                    if (err) {
+                        if (errs++ < MAX_PERR) {
+                            PrintRecvedError("src fence4", &sendtype, &recvtype);
+                        }
+                    }
+                }
+                if (rank == dest) {
+                    err = MTestCheckRecv(0, &recvtype);
+                    if (err) {
+                        if (errs++ < MAX_PERR) {
+                            PrintRecvedError("dest fence4", &sendtype, &recvtype);
+                        }
+                    }
+                }
+
+                MPI_Win_free(&win);
+                MTestFreeDatatype(&sendtype);
+                MTestFreeDatatype(&recvtype);
+
+                /* Only do one datatype in the simple case */
+                if (onlyInt)
+                    break;
+            }
+            /* Only do one count in the simple case */
+            if (onlyInt)
+                break;
+        }
         MTestFreeComm(&comm);
-       /* Only do one communicator in the simple case */
-       if (onlyInt) break;
+        /* Only do one communicator in the simple case */
+        if (onlyInt)
+            break;
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
+
+
 
-    
-    
     MPI_Finalize();
     return 0;
 }
 
 
-int PrintRecvedError( const char *msg, 
-                     MTestDatatype *sendtypePtr, MTestDatatype *recvtypePtr )
+int PrintRecvedError(const char *msg, MTestDatatype * sendtypePtr, MTestDatatype * recvtypePtr)
 {
-    printf( "At step %s, Data in target buffer did not match for destination datatype %s (put with source datatype %s)\n", 
-           msg, 
-           MTestGetDatatypeName( recvtypePtr ),
-           MTestGetDatatypeName( sendtypePtr ) );
+    printf
+        ("At step %s, Data in target buffer did not match for destination datatype %s (put with source datatype %s)\n",
+         msg, MTestGetDatatypeName(recvtypePtr), MTestGetDatatypeName(sendtypePtr));
     /* Redo the test, with the errors printed */
     recvtypePtr->printErrors = 1;
-    (void)MTestCheckRecv( 0, recvtypePtr );
+    (void) MTestCheckRecv(0, recvtypePtr);
     return 0;
 }
index d3f53c0..ac50128 100644 (file)
@@ -78,8 +78,7 @@ int main(int argc, char *argv[])
 
             if (result_data != one) {
                 errors++;
-                printf("Expected: result_data = %d   Actual: result_data = %d\n",
-                       one, result_data);
+                printf("Expected: result_data = %d   Actual: result_data = %d\n", one, result_data);
             }
         }
 
index f8b7fb2..bd10bb6 100644 (file)
@@ -42,7 +42,8 @@
 
 #define CMP(x, y) ((x - ((TYPE_C) (y))) > 1.0e-9)
 
-void reset_vars(TYPE_C *val_ptr, TYPE_C *res_ptr, MPI_Win win) {
+void reset_vars(TYPE_C * val_ptr, TYPE_C * res_ptr, MPI_Win win)
+{
     int i, rank, nproc;
 
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
@@ -58,24 +59,28 @@ void reset_vars(TYPE_C *val_ptr, TYPE_C *res_ptr, MPI_Win win) {
     MPI_Barrier(MPI_COMM_WORLD);
 }
 
-int main(int argc, char **argv) {
-    int       i, rank, nproc, mpi_type_size;
-    int       errors = 0, all_errors = 0;
-    TYPE_C   *val_ptr, *res_ptr;
-    MPI_Win   win;
+int main(int argc, char **argv)
+{
+    int i, rank, nproc, mpi_type_size;
+    int errors = 0, all_errors = 0;
+    TYPE_C *val_ptr, *res_ptr;
+    MPI_Win win;
 
     MPI_Init(&argc, &argv);
 
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     MPI_Comm_size(MPI_COMM_WORLD, &nproc);
+
     MPI_Type_size(TYPE_MPI, &mpi_type_size);
     assert(mpi_type_size == sizeof(TYPE_C));
 
-    val_ptr = malloc(sizeof(TYPE_C)*nproc);
-    res_ptr = malloc(sizeof(TYPE_C)*nproc);
+    val_ptr = malloc(sizeof(TYPE_C) * nproc);
+    res_ptr = malloc(sizeof(TYPE_C) * nproc);
+    MTEST_VG_MEM_INIT(val_ptr, sizeof(TYPE_C) * nproc);
+    MTEST_VG_MEM_INIT(res_ptr, sizeof(TYPE_C) * nproc);
 
-    MPI_Win_create(val_ptr, sizeof(TYPE_C)*nproc, sizeof(TYPE_C), MPI_INFO_NULL, MPI_COMM_WORLD, &win);
+    MPI_Win_create(val_ptr, sizeof(TYPE_C) * nproc, sizeof(TYPE_C), MPI_INFO_NULL, MPI_COMM_WORLD,
+                   &win);
 
     /* Test self communication */
 
@@ -89,8 +94,10 @@ int main(int argc, char **argv) {
     }
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
-    if ( CMP(val_ptr[0], ITER) ) {
-        SQUELCH( printf("%d->%d -- SELF: expected "TYPE_FMT", got "TYPE_FMT"\n", rank, rank, (TYPE_C) ITER, val_ptr[0]); );
+    if (CMP(val_ptr[0], ITER)) {
+        SQUELCH(printf
+                ("%d->%d -- SELF: expected " TYPE_FMT ", got " TYPE_FMT "\n", rank, rank,
+                 (TYPE_C) ITER, val_ptr[0]););
         errors++;
     }
     MPI_Win_unlock(rank, win);
@@ -101,11 +108,13 @@ int main(int argc, char **argv) {
 
     for (i = 0; i < ITER; i++) {
         TYPE_C one = 1, result = -1;
-        MPI_Win_lock(MPI_LOCK_EXCLUSIVE, (rank+1)%nproc, 0, win);
-        MPI_Fetch_and_op(&one, &result, TYPE_MPI, (rank+1)%nproc, 0, MPI_SUM, win);
-        MPI_Win_unlock((rank+1)%nproc, win);
-        if ( CMP(result, i) ) {
-            SQUELCH( printf("%d->%d -- NEIGHBOR[%d]: expected result "TYPE_FMT", got "TYPE_FMT"\n", (rank+1)%nproc, rank, i, (TYPE_C) i, result); );
+        MPI_Win_lock(MPI_LOCK_EXCLUSIVE, (rank + 1) % nproc, 0, win);
+        MPI_Fetch_and_op(&one, &result, TYPE_MPI, (rank + 1) % nproc, 0, MPI_SUM, win);
+        MPI_Win_unlock((rank + 1) % nproc, win);
+        if (CMP(result, i)) {
+            SQUELCH(printf
+                    ("%d->%d -- NEIGHBOR[%d]: expected result " TYPE_FMT ", got " TYPE_FMT "\n",
+                     (rank + 1) % nproc, rank, i, (TYPE_C) i, result););
             errors++;
         }
     }
@@ -113,8 +122,10 @@ int main(int argc, char **argv) {
     MPI_Barrier(MPI_COMM_WORLD);
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
-    if ( CMP(val_ptr[0], ITER) ) {
-        SQUELCH( printf("%d->%d -- NEIGHBOR: expected "TYPE_FMT", got "TYPE_FMT"\n", (rank+1)%nproc, rank, (TYPE_C) ITER, val_ptr[0]); );
+    if (CMP(val_ptr[0], ITER)) {
+        SQUELCH(printf
+                ("%d->%d -- NEIGHBOR: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                 (rank + 1) % nproc, rank, (TYPE_C) ITER, val_ptr[0]););
         errors++;
     }
     MPI_Win_unlock(rank, win);
@@ -136,8 +147,10 @@ int main(int argc, char **argv) {
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
     if (rank == 0 && nproc > 1) {
-        if ( CMP(val_ptr[0], ITER*(nproc-1)) ) {
-            SQUELCH( printf("*->%d - CONTENTION: expected="TYPE_FMT" val="TYPE_FMT"\n", rank, (TYPE_C) ITER*(nproc-1), val_ptr[0]); );
+        if (CMP(val_ptr[0], ITER * (nproc - 1))) {
+            SQUELCH(printf
+                    ("*->%d - CONTENTION: expected=" TYPE_FMT " val=" TYPE_FMT "\n", rank,
+                     (TYPE_C) ITER * (nproc - 1), val_ptr[0]););
             errors++;
         }
     }
@@ -159,8 +172,10 @@ int main(int argc, char **argv) {
         MPI_Barrier(MPI_COMM_WORLD);
 
         for (j = 0; j < nproc; j++) {
-            if ( CMP(res_ptr[j], i*rank) ) {
-                SQUELCH( printf("%d->%d -- ALL-TO-ALL (FENCE) [%d]: expected result "TYPE_FMT", got "TYPE_FMT"\n", rank, j, i, (TYPE_C) i*rank, res_ptr[j]); );
+            if (CMP(res_ptr[j], i * rank)) {
+                SQUELCH(printf
+                        ("%d->%d -- ALL-TO-ALL (FENCE) [%d]: expected result " TYPE_FMT ", got "
+                         TYPE_FMT "\n", rank, j, i, (TYPE_C) i * rank, res_ptr[j]););
                 errors++;
             }
         }
@@ -169,8 +184,10 @@ int main(int argc, char **argv) {
     MPI_Barrier(MPI_COMM_WORLD);
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
     for (i = 0; i < nproc; i++) {
-        if ( CMP(val_ptr[i], ITER*i) ) {
-            SQUELCH( printf("%d->%d -- ALL-TO-ALL (FENCE): expected "TYPE_FMT", got "TYPE_FMT"\n", i, rank, (TYPE_C) ITER*i, val_ptr[i]); );
+        if (CMP(val_ptr[i], ITER * i)) {
+            SQUELCH(printf
+                    ("%d->%d -- ALL-TO-ALL (FENCE): expected " TYPE_FMT ", got " TYPE_FMT "\n", i,
+                     rank, (TYPE_C) ITER * i, val_ptr[i]););
             errors++;
         }
     }
@@ -192,8 +209,10 @@ int main(int argc, char **argv) {
         MPI_Barrier(MPI_COMM_WORLD);
 
         for (j = 0; j < nproc; j++) {
-            if ( CMP(res_ptr[j], i*rank) ) {
-                SQUELCH( printf("%d->%d -- ALL-TO-ALL (LOCK-ALL) [%d]: expected result "TYPE_FMT", got "TYPE_FMT"\n", rank, j, i, (TYPE_C) i*rank, res_ptr[j]); );
+            if (CMP(res_ptr[j], i * rank)) {
+                SQUELCH(printf
+                        ("%d->%d -- ALL-TO-ALL (LOCK-ALL) [%d]: expected result " TYPE_FMT ", got "
+                         TYPE_FMT "\n", rank, j, i, (TYPE_C) i * rank, res_ptr[j]););
                 errors++;
             }
         }
@@ -202,8 +221,10 @@ int main(int argc, char **argv) {
     MPI_Barrier(MPI_COMM_WORLD);
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
     for (i = 0; i < nproc; i++) {
-        if ( CMP(val_ptr[i], ITER*i) ) {
-            SQUELCH( printf("%d->%d -- ALL-TO-ALL (LOCK-ALL): expected "TYPE_FMT", got "TYPE_FMT"\n", i, rank, (TYPE_C) ITER*i, val_ptr[i]); );
+        if (CMP(val_ptr[i], ITER * i)) {
+            SQUELCH(printf
+                    ("%d->%d -- ALL-TO-ALL (LOCK-ALL): expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                     i, rank, (TYPE_C) ITER * i, val_ptr[i]););
             errors++;
         }
     }
@@ -226,8 +247,10 @@ int main(int argc, char **argv) {
         MPI_Barrier(MPI_COMM_WORLD);
 
         for (j = 0; j < nproc; j++) {
-            if ( CMP(res_ptr[j], i*rank) ) {
-                SQUELCH( printf("%d->%d -- ALL-TO-ALL (LOCK-ALL+FLUSH) [%d]: expected result "TYPE_FMT", got "TYPE_FMT"\n", rank, j, i, (TYPE_C) i*rank, res_ptr[j]); );
+            if (CMP(res_ptr[j], i * rank)) {
+                SQUELCH(printf
+                        ("%d->%d -- ALL-TO-ALL (LOCK-ALL+FLUSH) [%d]: expected result " TYPE_FMT
+                         ", got " TYPE_FMT "\n", rank, j, i, (TYPE_C) i * rank, res_ptr[j]););
                 errors++;
             }
         }
@@ -236,8 +259,10 @@ int main(int argc, char **argv) {
     MPI_Barrier(MPI_COMM_WORLD);
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
     for (i = 0; i < nproc; i++) {
-        if ( CMP(val_ptr[i], ITER*i) ) {
-            SQUELCH( printf("%d->%d -- ALL-TO-ALL (LOCK-ALL+FLUSH): expected "TYPE_FMT", got "TYPE_FMT"\n", i, rank, (TYPE_C) ITER*i, val_ptr[i]); );
+        if (CMP(val_ptr[i], ITER * i)) {
+            SQUELCH(printf
+                    ("%d->%d -- ALL-TO-ALL (LOCK-ALL+FLUSH): expected " TYPE_FMT ", got " TYPE_FMT
+                     "\n", i, rank, (TYPE_C) ITER * i, val_ptr[i]););
             errors++;
         }
     }
@@ -255,15 +280,15 @@ int main(int argc, char **argv) {
     MPI_Barrier(MPI_COMM_WORLD);
 
     for (i = 0; i < ITER; i++) {
-        int target = (rank+1) % nproc;
+        int target = (rank + 1) % nproc;
 
         MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, win);
         MPI_Fetch_and_op(NULL, res_ptr, TYPE_MPI, target, 0, MPI_NO_OP, win);
         MPI_Win_unlock(target, win);
 
         if (res_ptr[0] != (TYPE_C) target) {
-            SQUELCH( printf("%d->%d -- NOP[%d]: expected "TYPE_FMT", got "TYPE_FMT"\n",
-                            target, rank, i, (TYPE_C) target, res_ptr[0]); );
+            SQUELCH(printf("%d->%d -- NOP[%d]: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                           target, rank, i, (TYPE_C) target, res_ptr[0]););
             errors++;
         }
     }
@@ -287,8 +312,8 @@ int main(int argc, char **argv) {
         MPI_Win_unlock(target, win);
 
         if (res_ptr[0] != (TYPE_C) target) {
-            SQUELCH( printf("%d->%d -- NOP_SELF[%d]: expected "TYPE_FMT", got "TYPE_FMT"\n",
-                            target, rank, i, (TYPE_C) target, res_ptr[0]); );
+            SQUELCH(printf("%d->%d -- NOP_SELF[%d]: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                           target, rank, i, (TYPE_C) target, res_ptr[0]););
             errors++;
         }
     }
index dd12a4c..493e158 100644 (file)
@@ -3,64 +3,62 @@
  *  (C) 2001 by Argonne National Laboratory.
  *      See COPYRIGHT in top-level directory.
  */
-#include "mpi.h" 
+#include "mpi.h"
 #include "stdio.h"
 #include "stdlib.h"
 #include "mpitest.h"
 
 /* Fetch and add example from Using MPI-2 (the non-scalable version,
-   Fig. 6.12). */ 
+   Fig. 6.12). */
 
 
-#define NTIMES 20  /* no of times each process calls the counter
-                      routine */
+#define NTIMES 20       /* no of times each process calls the counter
+                         * routine */
 
-int localvalue=0;  /* contribution of this process to the counter. We
-                    define it as a global variable because attribute
-                    caching on the window is not enabled yet. */ 
+int localvalue = 0;             /* contribution of this process to the counter. We
+                                 * define it as a global variable because attribute
+                                 * caching on the window is not enabled yet. */
 
 void Get_nextval(MPI_Win win, int *val_array, MPI_Datatype get_type,
                  int rank, int nprocs, int *value);
 
 int compar(const void *a, const void *b);
 
-int main(int argc, char *argv[]) 
-{ 
-    int rank, nprocs, i, blens[2], disps[2], *counter_mem, *val_array,
-        *results, *counter_vals;
+int main(int argc, char *argv[])
+{
+    int rank, nprocs, i, blens[2], disps[2], *counter_mem, *val_array, *results, *counter_vals;
     MPI_Datatype get_type;
     MPI_Win win;
     int errs = 0;
-    MTest_Init(&argc,&argv); 
-    MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
-    MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
+
+    MTest_Init(&argc, &argv);
+    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
     if (rank == 0) {
         /* allocate counter memory and initialize to 0 */
         counter_mem = (int *) calloc(nprocs, sizeof(int));
-        MPI_Win_create(counter_mem, nprocs*sizeof(int), sizeof(int),
+        MPI_Win_create(counter_mem, nprocs * sizeof(int), sizeof(int),
                        MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
-        MPI_Win_free(&win); 
+        MPI_Win_free(&win);
         free(counter_mem);
 
-        /* gather the results from other processes, sort them, and check 
-           whether they represent a counter being incremented by 1 */
+        /* gather the results from other processes, sort them, and check
+         * whether they represent a counter being incremented by 1 */
 
-        results = (int *) malloc(NTIMES*nprocs*sizeof(int));
-        for (i=0; i<NTIMES*nprocs; i++)
+        results = (int *) malloc(NTIMES * nprocs * sizeof(int));
+        for (i = 0; i < NTIMES * nprocs; i++)
             results[i] = -1;
 
-        MPI_Gather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, results, NTIMES, MPI_INT, 
-                   0, MPI_COMM_WORLD);
+        MPI_Gather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, results, NTIMES, MPI_INT, 0, MPI_COMM_WORLD);
 
-        qsort(results+NTIMES, NTIMES*(nprocs-1), sizeof(int), compar);
+        qsort(results + NTIMES, NTIMES * (nprocs - 1), sizeof(int), compar);
 
-        for (i=NTIMES+1; i<(NTIMES*nprocs); i++)
-            if (results[i] != results[i-1] + 1)
+        for (i = NTIMES + 1; i < (NTIMES * nprocs); i++)
+            if (results[i] != results[i - 1] + 1)
                 errs++;
-        
+
         free(results);
     }
     else {
@@ -74,14 +72,14 @@ int main(int argc, char *argv[])
 
         val_array = (int *) malloc(nprocs * sizeof(int));
 
-        /* allocate array to store the values obtained from the 
-           fetch-and-add counter */
+        /* allocate array to store the values obtained from the
+         * fetch-and-add counter */
         counter_vals = (int *) malloc(NTIMES * sizeof(int));
 
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
-        for (i=0; i<NTIMES; i++) {
-            Get_nextval(win, val_array, get_type, rank, nprocs, counter_vals+i);
+        for (i = 0; i < NTIMES; i++) {
+            Get_nextval(win, val_array, get_type, rank, nprocs, counter_vals + i);
             /* printf("Rank %d, counter %d\n", rank, value); */
         }
 
@@ -91,30 +89,29 @@ int main(int argc, char *argv[])
         MPI_Type_free(&get_type);
 
         /* gather the results to the root */
-        MPI_Gather(counter_vals, NTIMES, MPI_INT, NULL, 0, MPI_DATATYPE_NULL, 
-                   0, MPI_COMM_WORLD);
+        MPI_Gather(counter_vals, NTIMES, MPI_INT, NULL, 0, MPI_DATATYPE_NULL, 0, MPI_COMM_WORLD);
         free(counter_vals);
     }
 
     MTest_Finalize(errs);
-    MPI_Finalize(); 
-    return 0; 
-} 
+    MPI_Finalize();
+    return 0;
+}
 
 
 void Get_nextval(MPI_Win win, int *val_array, MPI_Datatype get_type,
-                 int rank, int nprocs, int *value) 
+                 int rank, int nprocs, int *value)
 {
-    int one=1, i;
+    int one = 1, i;
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, win);
     MPI_Accumulate(&one, 1, MPI_INT, 0, rank, 1, MPI_INT, MPI_SUM, win);
-    MPI_Get(val_array, 1, get_type, 0, 0, 1, get_type, win); 
+    MPI_Get(val_array, 1, get_type, 0, 0, 1, get_type, win);
     MPI_Win_unlock(0, win);
 
     *value = 0;
     val_array[rank] = localvalue;
-    for (i=0; i<nprocs; i++)
+    for (i = 0; i < nprocs; i++)
         *value = *value + val_array[i];
 
     localvalue++;
@@ -122,6 +119,5 @@ void Get_nextval(MPI_Win win, int *val_array, MPI_Datatype get_type,
 
 int compar(const void *a, const void *b)
 {
-    return (*((int *)a) - *((int *)b));
+    return (*((int *) a) - *((int *) b));
 }
-
index 0ecde99..0a70155 100644 (file)
@@ -3,74 +3,73 @@
  *  (C) 2001 by Argonne National Laboratory.
  *      See COPYRIGHT in top-level directory.
  */
-#include "mpi.h" 
+#include "mpi.h"
 #include "stdio.h"
 #include "stdlib.h"
 #include "mpitest.h"
 
 /* Fetch and add example from Using MPI-2 (the non-scalable version,
-   Fig. 6.12). */ 
+   Fig. 6.12). */
 
 /* same as fetchandadd.c but uses alloc_mem */
 
-#define NTIMES 20  /* no of times each process calls the counter
-                      routine */
+#define NTIMES 20       /* no of times each process calls the counter
+                         * routine */
 
-int localvalue=0;  /* contribution of this process to the counter. We
-                    define it as a global variable because attribute
-                    caching on the window is not enabled yet. */ 
+int localvalue = 0;             /* contribution of this process to the counter. We
+                                 * define it as a global variable because attribute
+                                 * caching on the window is not enabled yet. */
 
 void Get_nextval(MPI_Win win, int *val_array, MPI_Datatype get_type,
                  int rank, int nprocs, int *value);
 
 int compar(const void *a, const void *b);
 
-int main(int argc, char *argv[]) 
-{ 
-    int rank, nprocs, i, blens[2], disps[2], *counter_mem, *val_array,
-        *results, *counter_vals;
+int main(int argc, char *argv[])
+{
+    int rank, nprocs, i, blens[2], disps[2], *counter_mem, *val_array, *results, *counter_vals;
     MPI_Datatype get_type;
     MPI_Win win;
     int errs = 0;
-    MTest_Init(&argc,&argv); 
-    MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
-    MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
+
+    MTest_Init(&argc, &argv);
+    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
     if (rank == 0) {
         /* allocate counter memory and initialize to 0 */
         /* counter_mem = (int *) calloc(nprocs, sizeof(int)); */
 
-        i = MPI_Alloc_mem(nprocs*sizeof(int), MPI_INFO_NULL, &counter_mem);
+        i = MPI_Alloc_mem(nprocs * sizeof(int), MPI_INFO_NULL, &counter_mem);
         if (i) {
             printf("Can't allocate memory in test program\n");
             MPI_Abort(MPI_COMM_WORLD, 1);
         }
 
-        for (i=0; i<nprocs; i++) counter_mem[i] = 0;
+        for (i = 0; i < nprocs; i++)
+            counter_mem[i] = 0;
 
-        MPI_Win_create(counter_mem, nprocs*sizeof(int), sizeof(int),
+        MPI_Win_create(counter_mem, nprocs * sizeof(int), sizeof(int),
                        MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
-        MPI_Win_free(&win); 
+        MPI_Win_free(&win);
         MPI_Free_mem(counter_mem);
 
-        /* gather the results from other processes, sort them, and check 
-           whether they represent a counter being incremented by 1 */
+        /* gather the results from other processes, sort them, and check
+         * whether they represent a counter being incremented by 1 */
 
-        results = (int *) malloc(NTIMES*nprocs*sizeof(int));
-        for (i=0; i<NTIMES*nprocs; i++)
+        results = (int *) malloc(NTIMES * nprocs * sizeof(int));
+        for (i = 0; i < NTIMES * nprocs; i++)
             results[i] = -1;
 
-        MPI_Gather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, results, NTIMES, MPI_INT, 
-                   0, MPI_COMM_WORLD);
+        MPI_Gather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, results, NTIMES, MPI_INT, 0, MPI_COMM_WORLD);
 
-        qsort(results+NTIMES, NTIMES*(nprocs-1), sizeof(int), compar);
+        qsort(results + NTIMES, NTIMES * (nprocs - 1), sizeof(int), compar);
 
-        for (i=NTIMES+1; i<(NTIMES*nprocs); i++)
-            if (results[i] != results[i-1] + 1)
+        for (i = NTIMES + 1; i < (NTIMES * nprocs); i++)
+            if (results[i] != results[i - 1] + 1)
                 errs++;
-        
+
         free(results);
     }
     else {
@@ -84,14 +83,14 @@ int main(int argc, char *argv[])
 
         val_array = (int *) malloc(nprocs * sizeof(int));
 
-        /* allocate array to store the values obtained from the 
-           fetch-and-add counter */
+        /* allocate array to store the values obtained from the
+         * fetch-and-add counter */
         counter_vals = (int *) malloc(NTIMES * sizeof(int));
 
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
-        for (i=0; i<NTIMES; i++) {
-            Get_nextval(win, val_array, get_type, rank, nprocs, counter_vals+i);
+        for (i = 0; i < NTIMES; i++) {
+            Get_nextval(win, val_array, get_type, rank, nprocs, counter_vals + i);
             /* printf("Rank %d, counter %d\n", rank, value); */
         }
 
@@ -101,30 +100,29 @@ int main(int argc, char *argv[])
         MPI_Type_free(&get_type);
 
         /* gather the results to the root */
-        MPI_Gather(counter_vals, NTIMES, MPI_INT, NULL, 0, MPI_DATATYPE_NULL, 
-                   0, MPI_COMM_WORLD);
+        MPI_Gather(counter_vals, NTIMES, MPI_INT, NULL, 0, MPI_DATATYPE_NULL, 0, MPI_COMM_WORLD);
         free(counter_vals);
     }
 
     MTest_Finalize(errs);
-    MPI_Finalize(); 
-    return 0; 
-} 
+    MPI_Finalize();
+    return 0;
+}
 
 
 void Get_nextval(MPI_Win win, int *val_array, MPI_Datatype get_type,
-                 int rank, int nprocs, int *value) 
+                 int rank, int nprocs, int *value)
 {
-    int one=1, i;
+    int one = 1, i;
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, win);
     MPI_Accumulate(&one, 1, MPI_INT, 0, rank, 1, MPI_INT, MPI_SUM, win);
-    MPI_Get(val_array, 1, get_type, 0, 0, 1, get_type, win); 
+    MPI_Get(val_array, 1, get_type, 0, 0, 1, get_type, win);
     MPI_Win_unlock(0, win);
 
     *value = 0;
     val_array[rank] = localvalue;
-    for (i=0; i<nprocs; i++)
+    for (i = 0; i < nprocs; i++)
         *value = *value + val_array[i];
 
     localvalue++;
@@ -132,6 +130,5 @@ void Get_nextval(MPI_Win win, int *val_array, MPI_Datatype get_type,
 
 int compar(const void *a, const void *b)
 {
-    return (*((int *)a) - *((int *)b));
+    return (*((int *) a) - *((int *) b));
 }
-
index 8b3c8f3..4229a9e 100644 (file)
@@ -3,78 +3,78 @@
  *  (C) 2001 by Argonne National Laboratory.
  *      See COPYRIGHT in top-level directory.
  */
-#include "mpi.h" 
+#include "mpi.h"
 #include "stdio.h"
 #include "stdlib.h"
 #include "mpitest.h"
 
 /* This is the tree-based scalable version of the fetch-and-add
    example from Using MPI-2, pg 206-207. The code in the book (Fig
-   6.16) has bugs that are fixed below. */ 
+   6.16) has bugs that are fixed below. */
 
 
-#define NTIMES 20  /* no of times each process calls the counter
-                      routine */
+#define NTIMES 20       /* no of times each process calls the counter
+                         * routine */
 
-int localvalue=0;  /* contribution of this process to the counter. We
-                    define it as a global variable because attribute
-                    caching on the window is not enabled yet. */ 
+int localvalue = 0;             /* contribution of this process to the counter. We
+                                 * define it as a global variable because attribute
+                                 * caching on the window is not enabled yet. */
 
 void Get_nextval_tree(MPI_Win win, int *get_array, MPI_Datatype get_type,
-                 MPI_Datatype acc_type, int nlevels, int *value);
+                      MPI_Datatype acc_type, int nlevels, int *value);
 
 int compar(const void *a, const void *b);
 
-int main(int argc, char *argv[]) 
-{ 
+int main(int argc, char *argv[])
+{
     int rank, nprocs, i, *counter_mem, *get_array, *get_idx, *acc_idx,
         mask, nlevels, level, idx, tmp_rank, pof2;
     MPI_Datatype get_type, acc_type;
     MPI_Win win;
     int errs = 0, *results, *counter_vals;
-    MTest_Init(&argc,&argv); 
-    MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
-    MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
+
+    MTest_Init(&argc, &argv);
+    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
     if (rank == 0) {
         /* allocate counter memory and initialize to 0 */
 
         /* find the next power-of-two >= nprocs */
         pof2 = 1;
-        while (pof2 < nprocs) pof2 *= 2;
+        while (pof2 < nprocs)
+            pof2 *= 2;
 
-        counter_mem = (int *) calloc(pof2*2, sizeof(int));
-        MPI_Win_create(counter_mem, pof2*2*sizeof(int), sizeof(int),
+        counter_mem = (int *) calloc(pof2 * 2, sizeof(int));
+        MPI_Win_create(counter_mem, pof2 * 2 * sizeof(int), sizeof(int),
                        MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
-        MPI_Win_free(&win); 
+        MPI_Win_free(&win);
         free(counter_mem);
 
-        /* gather the results from other processes, sort them, and check 
-           whether they represent a counter being incremented by 1 */
+        /* gather the results from other processes, sort them, and check
+         * whether they represent a counter being incremented by 1 */
 
-        results = (int *) malloc(NTIMES*nprocs*sizeof(int));
-        for (i=0; i<NTIMES*nprocs; i++)
+        results = (int *) malloc(NTIMES * nprocs * sizeof(int));
+        for (i = 0; i < NTIMES * nprocs; i++)
             results[i] = -1;
 
-        MPI_Gather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, results, NTIMES, MPI_INT, 
-                   0, MPI_COMM_WORLD);
+        MPI_Gather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, results, NTIMES, MPI_INT, 0, MPI_COMM_WORLD);
 
-        qsort(results+NTIMES, NTIMES*(nprocs-1), sizeof(int), compar);
+        qsort(results + NTIMES, NTIMES * (nprocs - 1), sizeof(int), compar);
 
-        for (i=NTIMES+1; i<(NTIMES*nprocs); i++)
-            if (results[i] != results[i-1] + 1)
+        for (i = NTIMES + 1; i < (NTIMES * nprocs); i++)
+            if (results[i] != results[i - 1] + 1)
                 errs++;
-        
+
         free(results);
     }
     else {
-        /* Get the largest power of two smaller than nprocs */ 
-        mask = 1; 
+        /* Get the largest power of two smaller than nprocs */
+        mask = 1;
         nlevels = 0;
         while (mask < nprocs) {
-            mask <<= 1; 
+            mask <<= 1;
             nlevels++;
         }
         mask >>= 1;
@@ -83,28 +83,28 @@ int main(int argc, char *argv[])
         get_idx = (int *) malloc(nlevels * sizeof(int));
         acc_idx = (int *) malloc(nlevels * sizeof(int));
 
-        level = 0; 
-        idx   = 0; 
+        level = 0;
+        idx = 0;
         tmp_rank = rank;
-        while (mask >= 1) { 
-            if (tmp_rank < mask) { 
+        while (mask >= 1) {
+            if (tmp_rank < mask) {
                 /* go to left for acc_idx, go to right for
-                   get_idx. set idx=acc_idx for next iteration */ 
-                acc_idx[level] = idx + 1; 
-                get_idx[level] = idx + mask*2; 
-                idx            = idx + 1; 
-            } 
-            else { 
+                 * get_idx. set idx=acc_idx for next iteration */
+                acc_idx[level] = idx + 1;
+                get_idx[level] = idx + mask * 2;
+                idx = idx + 1;
+            }
+            else {
                 /* go to right for acc_idx, go to left for
-                   get_idx. set idx=acc_idx for next iteration */ 
-                acc_idx[level] = idx + mask*2; 
-                get_idx[level] = idx + 1; 
-                idx            = idx + mask*2; 
-            } 
+                 * get_idx. set idx=acc_idx for next iteration */
+                acc_idx[level] = idx + mask * 2;
+                get_idx[level] = idx + 1;
+                idx = idx + mask * 2;
+            }
             level++;
             tmp_rank = tmp_rank % mask;
-            mask >>= 1; 
-        } 
+            mask >>= 1;
+        }
 
 /*        for (i=0; i<nlevels; i++)
             printf("Rank %d, acc_idx[%d]=%d, get_idx[%d]=%d\n", rank,
@@ -116,15 +116,14 @@ int main(int argc, char *argv[])
         MPI_Type_commit(&get_type);
         MPI_Type_commit(&acc_type);
 
-        /* allocate array to store the values obtained from the 
-           fetch-and-add counter */
+        /* allocate array to store the values obtained from the
+         * fetch-and-add counter */
         counter_vals = (int *) malloc(NTIMES * sizeof(int));
 
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
-        for (i=0; i<NTIMES; i++) {
-            Get_nextval_tree(win, get_array, get_type, acc_type,
-                             nlevels, counter_vals+i); 
+        for (i = 0; i < NTIMES; i++) {
+            Get_nextval_tree(win, get_array, get_type, acc_type, nlevels, counter_vals + i);
             /* printf("Rank %d, counter %d\n", rank, value); */
         }
 
@@ -135,16 +134,15 @@ int main(int argc, char *argv[])
         MPI_Type_free(&get_type);
         MPI_Type_free(&acc_type);
 
-         /* gather the results to the root */
-        MPI_Gather(counter_vals, NTIMES, MPI_INT, NULL, 0, MPI_DATATYPE_NULL, 
-                   0, MPI_COMM_WORLD);
+        /* gather the results to the root */
+        MPI_Gather(counter_vals, NTIMES, MPI_INT, NULL, 0, MPI_DATATYPE_NULL, 0, MPI_COMM_WORLD);
         free(counter_vals);
-   }
+    }
 
     MTest_Finalize(errs);
-    MPI_Finalize(); 
-    return MTestReturnValue( errs );
-} 
+    MPI_Finalize();
+    return MTestReturnValue(errs);
+}
 
 
 void Get_nextval_tree(MPI_Win win, int *get_array, MPI_Datatype get_type,
@@ -152,17 +150,17 @@ void Get_nextval_tree(MPI_Win win, int *get_array, MPI_Datatype get_type,
 {
     int *one, i;
 
-    one = (int *) malloc(nlevels*sizeof(int));
-    for (i=0; i<nlevels; i++) one[i] = 1;
+    one = (int *) malloc(nlevels * sizeof(int));
+    for (i = 0; i < nlevels; i++)
+        one[i] = 1;
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, win);
-    MPI_Accumulate(one, nlevels, MPI_INT, 0, 0, 1, acc_type,
-                   MPI_SUM, win);
+    MPI_Accumulate(one, nlevels, MPI_INT, 0, 0, 1, acc_type, MPI_SUM, win);
     MPI_Get(get_array, nlevels, MPI_INT, 0, 0, 1, get_type, win);
     MPI_Win_unlock(0, win);
 
     *value = localvalue;
-    for (i=0; i<nlevels; i++)
+    for (i = 0; i < nlevels; i++)
         *value = *value + get_array[i];
 
     localvalue++;
@@ -172,5 +170,5 @@ void Get_nextval_tree(MPI_Win win, int *get_array, MPI_Datatype get_type,
 
 int compar(const void *a, const void *b)
 {
-    return (*((int *)a) - *((int *)b));
+    return (*((int *) a) - *((int *) b));
 }
index f5ca1e0..1205bdd 100644 (file)
@@ -3,90 +3,91 @@
  *  (C) 2001 by Argonne National Laboratory.
  *      See COPYRIGHT in top-level directory.
  */
-#include "mpi.h" 
+#include "mpi.h"
 #include "stdio.h"
 #include "stdlib.h"
 #include "mpitest.h"
 
 /* This is the tree-based scalable version of the fetch-and-add
    example from Using MPI-2, pg 206-207. The code in the book (Fig
-   6.16) has bugs that are fixed below. */ 
+   6.16) has bugs that are fixed below. */
 
 /* same as fetchandadd_tree.c but uses alloc_mem */
 
-#define NTIMES 20  /* no of times each process calls the counter
-                      routine */
+#define NTIMES 20       /* no of times each process calls the counter
+                         * routine */
 
-int localvalue=0;  /* contribution of this process to the counter. We
-                    define it as a global variable because attribute
-                    caching on the window is not enabled yet. */ 
+int localvalue = 0;             /* contribution of this process to the counter. We
+                                 * define it as a global variable because attribute
+                                 * caching on the window is not enabled yet. */
 
 void Get_nextval_tree(MPI_Win win, int *get_array, MPI_Datatype get_type,
-                 MPI_Datatype acc_type, int nlevels, int *value);
+                      MPI_Datatype acc_type, int nlevels, int *value);
 
 int compar(const void *a, const void *b);
 
-int main(int argc, char *argv[]) 
-{ 
+int main(int argc, char *argv[])
+{
     int rank, nprocs, i, *counter_mem, *get_array, *get_idx, *acc_idx,
         mask, nlevels, level, idx, tmp_rank, pof2;
     MPI_Datatype get_type, acc_type;
     MPI_Win win;
     int errs = 0, *results, *counter_vals;
-    MTest_Init(&argc,&argv); 
-    MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
-    MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
+
+    MTest_Init(&argc, &argv);
+    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
     if (rank == 0) {
         /* allocate counter memory and initialize to 0 */
 
         /* find the next power-of-two >= nprocs */
         pof2 = 1;
-        while (pof2 < nprocs) pof2 *= 2;
+        while (pof2 < nprocs)
+            pof2 *= 2;
 
         /* counter_mem = (int *) calloc(pof2*2, sizeof(int)); */
 
-        i = MPI_Alloc_mem(pof2*2*sizeof(int), MPI_INFO_NULL, &counter_mem);
+        i = MPI_Alloc_mem(pof2 * 2 * sizeof(int), MPI_INFO_NULL, &counter_mem);
         if (i) {
             printf("Can't allocate memory in test program\n");
             MPI_Abort(MPI_COMM_WORLD, 1);
         }
 
-        for (i=0; i<(pof2*2); i++) counter_mem[i] = 0;
+        for (i = 0; i < (pof2 * 2); i++)
+            counter_mem[i] = 0;
 
-        MPI_Win_create(counter_mem, pof2*2*sizeof(int), sizeof(int),
+        MPI_Win_create(counter_mem, pof2 * 2 * sizeof(int), sizeof(int),
                        MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
-        MPI_Win_free(&win); 
+        MPI_Win_free(&win);
 
         /* free(counter_mem) */
         MPI_Free_mem(counter_mem);
 
-        /* gather the results from other processes, sort them, and check 
-           whether they represent a counter being incremented by 1 */
+        /* gather the results from other processes, sort them, and check
+         * whether they represent a counter being incremented by 1 */
 
-        results = (int *) malloc(NTIMES*nprocs*sizeof(int));
-        for (i=0; i<NTIMES*nprocs; i++)
+        results = (int *) malloc(NTIMES * nprocs * sizeof(int));
+        for (i = 0; i < NTIMES * nprocs; i++)
             results[i] = -1;
 
-        MPI_Gather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, results, NTIMES, MPI_INT, 
-                   0, MPI_COMM_WORLD);
+        MPI_Gather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, results, NTIMES, MPI_INT, 0, MPI_COMM_WORLD);
 
-        qsort(results+NTIMES, NTIMES*(nprocs-1), sizeof(int), compar);
+        qsort(results + NTIMES, NTIMES * (nprocs - 1), sizeof(int), compar);
 
-        for (i=NTIMES+1; i<(NTIMES*nprocs); i++)
-            if (results[i] != results[i-1] + 1)
+        for (i = NTIMES + 1; i < (NTIMES * nprocs); i++)
+            if (results[i] != results[i - 1] + 1)
                 errs++;
-        
+
         free(results);
     }
     else {
-        /* Get the largest power of two smaller than nprocs */ 
-        mask = 1; 
+        /* Get the largest power of two smaller than nprocs */
+        mask = 1;
         nlevels = 0;
         while (mask < nprocs) {
-            mask <<= 1; 
+            mask <<= 1;
             nlevels++;
         }
         mask >>= 1;
@@ -95,28 +96,28 @@ int main(int argc, char *argv[])
         get_idx = (int *) malloc(nlevels * sizeof(int));
         acc_idx = (int *) malloc(nlevels * sizeof(int));
 
-        level = 0; 
-        idx   = 0; 
+        level = 0;
+        idx = 0;
         tmp_rank = rank;
-        while (mask >= 1) { 
-            if (tmp_rank < mask) { 
+        while (mask >= 1) {
+            if (tmp_rank < mask) {
                 /* go to left for acc_idx, go to right for
-                   get_idx. set idx=acc_idx for next iteration */ 
-                acc_idx[level] = idx + 1; 
-                get_idx[level] = idx + mask*2; 
-                idx            = idx + 1; 
-            } 
-            else { 
+                 * get_idx. set idx=acc_idx for next iteration */
+                acc_idx[level] = idx + 1;
+                get_idx[level] = idx + mask * 2;
+                idx = idx + 1;
+            }
+            else {
                 /* go to right for acc_idx, go to left for
-                   get_idx. set idx=acc_idx for next iteration */ 
-                acc_idx[level] = idx + mask*2; 
-                get_idx[level] = idx + 1; 
-                idx            = idx + mask*2; 
-            } 
+                 * get_idx. set idx=acc_idx for next iteration */
+                acc_idx[level] = idx + mask * 2;
+                get_idx[level] = idx + 1;
+                idx = idx + mask * 2;
+            }
             level++;
             tmp_rank = tmp_rank % mask;
-            mask >>= 1; 
-        } 
+            mask >>= 1;
+        }
 
 /*        for (i=0; i<nlevels; i++)
             printf("Rank %d, acc_idx[%d]=%d, get_idx[%d]=%d\n", rank,
@@ -128,15 +129,14 @@ int main(int argc, char *argv[])
         MPI_Type_commit(&get_type);
         MPI_Type_commit(&acc_type);
 
-        /* allocate array to store the values obtained from the 
-           fetch-and-add counter */
+        /* allocate array to store the values obtained from the
+         * fetch-and-add counter */
         counter_vals = (int *) malloc(NTIMES * sizeof(int));
 
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
-        for (i=0; i<NTIMES; i++) {
-            Get_nextval_tree(win, get_array, get_type, acc_type,
-                             nlevels, counter_vals+i); 
+        for (i = 0; i < NTIMES; i++) {
+            Get_nextval_tree(win, get_array, get_type, acc_type, nlevels, counter_vals + i);
             /* printf("Rank %d, counter %d\n", rank, value); */
         }
 
@@ -147,16 +147,15 @@ int main(int argc, char *argv[])
         MPI_Type_free(&get_type);
         MPI_Type_free(&acc_type);
 
-         /* gather the results to the root */
-        MPI_Gather(counter_vals, NTIMES, MPI_INT, NULL, 0, MPI_DATATYPE_NULL, 
-                   0, MPI_COMM_WORLD);
+        /* gather the results to the root */
+        MPI_Gather(counter_vals, NTIMES, MPI_INT, NULL, 0, MPI_DATATYPE_NULL, 0, MPI_COMM_WORLD);
         free(counter_vals);
-   }
+    }
 
     MTest_Finalize(errs);
-    MPI_Finalize(); 
-    return MTestReturnValue( errs );
-} 
+    MPI_Finalize();
+    return MTestReturnValue(errs);
+}
 
 
 void Get_nextval_tree(MPI_Win win, int *get_array, MPI_Datatype get_type,
@@ -164,17 +163,17 @@ void Get_nextval_tree(MPI_Win win, int *get_array, MPI_Datatype get_type,
 {
     int *one, i;
 
-    one = (int *) malloc(nlevels*sizeof(int));
-    for (i=0; i<nlevels; i++) one[i] = 1;
+    one = (int *) malloc(nlevels * sizeof(int));
+    for (i = 0; i < nlevels; i++)
+        one[i] = 1;
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, win);
-    MPI_Accumulate(one, nlevels, MPI_INT, 0, 0, 1, acc_type,
-                   MPI_SUM, win);
+    MPI_Accumulate(one, nlevels, MPI_INT, 0, 0, 1, acc_type, MPI_SUM, win);
     MPI_Get(get_array, nlevels, MPI_INT, 0, 0, 1, get_type, win);
     MPI_Win_unlock(0, win);
 
     *value = localvalue;
-    for (i=0; i<nlevels; i++)
+    for (i = 0; i < nlevels; i++)
         *value = *value + get_array[i];
 
     localvalue++;
@@ -184,5 +183,5 @@ void Get_nextval_tree(MPI_Win win, int *get_array, MPI_Datatype get_type,
 
 int compar(const void *a, const void *b)
 {
-    return (*((int *)a) - *((int *)b));
+    return (*((int *) a) - *((int *) b));
 }
index 7aed170..620eb61 100644 (file)
@@ -21,72 +21,66 @@ executed";
 
 /* Copy increments the attribute value */
 /* Note that we can really ignore this because there is no win dup */
-int copy_fn( MPI_Win oldwin, int keyval, void *extra_state,
-            void *attribute_val_in, void *attribute_val_out, 
-            int *flag);
-int copy_fn( MPI_Win oldwin, int keyval, void *extra_state,
-            void *attribute_val_in, void *attribute_val_out, 
-            int *flag)
+int copy_fn(MPI_Win oldwin, int keyval, void *extra_state,
+            void *attribute_val_in, void *attribute_val_out, int *flag);
+int copy_fn(MPI_Win oldwin, int keyval, void *extra_state,
+            void *attribute_val_in, void *attribute_val_out, int *flag)
 {
     /* Copy the address of the attribute */
-    *(void **)attribute_val_out = attribute_val_in;
+    *(void **) attribute_val_out = attribute_val_in;
     /* Change the value */
-    *(int *)attribute_val_in = *(int *)attribute_val_in + 1;
+    *(int *) attribute_val_in = *(int *) attribute_val_in + 1;
     *flag = 1;
     return MPI_SUCCESS;
 }
 
 /* Delete decrements the attribute value */
-int delete_fn( MPI_Win win, int keyval, void *attribute_val, 
-              void *extra_state);
-int delete_fn( MPI_Win win, int keyval, void *attribute_val, 
-              void *extra_state)
+int delete_fn(MPI_Win win, int keyval, void *attribute_val, void *extra_state);
+int delete_fn(MPI_Win win, int keyval, void *attribute_val, void *extra_state)
 {
-    *(int *)attribute_val = *(int *)attribute_val - 1;
+    *(int *) attribute_val = *(int *) attribute_val - 1;
     return MPI_SUCCESS;
 }
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0;
     int attrval;
-    int i, key[32], keyval, saveKeyval;
+    int i, key[32], keyval;
     MPI_Win win;
-    MTest_Init( &argc, &argv );
+    MTest_Init(&argc, &argv);
 
-    while (MTestGetWin( &win, 0 )) {
-       if (win == MPI_WIN_NULL) continue;
+    while (MTestGetWin(&win, 0)) {
+        if (win == MPI_WIN_NULL)
+            continue;
 
-       MPI_Win_create_keyval( copy_fn, delete_fn, &keyval, (void *)0 );
-       saveKeyval = keyval;   /* in case we need to free explicitly */
-       attrval = 1;
-       MPI_Win_set_attr( win, keyval, (void*)&attrval );
-       /* See MPI-1, 5.7.1.  Freeing the keyval does not remove it if it
-          is in use in an attribute */
-       MPI_Win_free_keyval( &keyval );
-       
-       /* We create some dummy keyvals here in case the same keyval
-          is reused */
-       for (i=0; i<32; i++) {
-           MPI_Win_create_keyval( MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN,
-                              &key[i], (void *)0 );
-       }
+        MPI_Win_create_keyval(copy_fn, delete_fn, &keyval, (void *) 0);
+        attrval = 1;
+        MPI_Win_set_attr(win, keyval, (void *) &attrval);
+        /* See MPI-1, 5.7.1.  Freeing the keyval does not remove it if it
+         * is in use in an attribute */
+        MPI_Win_free_keyval(&keyval);
+
+        /* We create some dummy keyvals here in case the same keyval
+         * is reused */
+        for (i = 0; i < 32; i++) {
+            MPI_Win_create_keyval(MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key[i], (void *) 0);
+        }
 
         MTestFreeWin(&win);
 
-       /* Check that the original attribute was freed */
-       if (attrval != 0) {
-           errs++;
-           printf( "Attribute not decremented when win %s freed\n",
-                   MTestGetWinName() );
-       }
-       /* Free those other keyvals */
-       for (i=0; i<32; i++) {
-           MPI_Win_free_keyval( &key[i] );
-       }
+        /* Check that the original attribute was freed */
+        if (attrval != 0) {
+            errs++;
+            printf("Attribute not decremented when win %s freed\n", MTestGetWinName());
+        }
+        /* Free those other keyvals */
+        for (i = 0; i < 32; i++) {
+            MPI_Win_free_keyval(&key[i]);
+        }
 
     }
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
 
     return 0;
index 1f21470..502db11 100644 (file)
@@ -10,7 +10,7 @@
 
 #define ITER 100
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int rank, nproc, i;
     int errors = 0, all_errors = 0;
@@ -22,19 +22,21 @@ int main( int argc, char *argv[] )
     MPI_Comm_size(MPI_COMM_WORLD, &nproc);
 
     if (nproc < 2) {
-        if (rank == 0) printf("Error: must be run with two or more processes\n");
+        if (rank == 0)
+            printf("Error: must be run with two or more processes\n");
         MPI_Abort(MPI_COMM_WORLD, 1);
     }
 
     /** Create using MPI_Win_create() **/
 
     if (rank == 0) {
-      MPI_Alloc_mem(sizeof(int), MPI_INFO_NULL, &buf);
-      *buf = nproc-1;
-    } else
-      buf = NULL;
+        MPI_Alloc_mem(sizeof(int), MPI_INFO_NULL, &buf);
+        *buf = nproc - 1;
+    }
+    else
+        buf = NULL;
 
-    MPI_Win_create(buf, sizeof(int)*(rank == 0), 1, MPI_INFO_NULL, MPI_COMM_WORLD, &window);
+    MPI_Win_create(buf, sizeof(int) * (rank == 0), 1, MPI_INFO_NULL, MPI_COMM_WORLD, &window);
 
     /* Test flush of an empty epoch */
     MPI_Win_lock(MPI_LOCK_SHARED, 0, 0, window);
@@ -53,21 +55,22 @@ int main( int argc, char *argv[] )
          * to the right.  Each process, in turn, performs third-party
          * communication via process 0's window. */
         if (rank > 0) {
-            MPI_Recv(NULL, 0, MPI_BYTE, rank-1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+            MPI_Recv(NULL, 0, MPI_BYTE, rank - 1, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
         }
 
-        MPI_Get_accumulate(&rank, 1, MPI_INT, &val, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_REPLACE, window);
+        MPI_Get_accumulate(&rank, 1, MPI_INT, &val, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_REPLACE,
+                           window);
         MPI_Win_flush(0, window);
 
-        exp = (rank + nproc-1) % nproc;
+        exp = (rank + nproc - 1) % nproc;
 
         if (val != exp) {
             printf("%d - Got %d, expected %d\n", rank, val, exp);
             errors++;
         }
 
-        if (rank < nproc-1) {
-            MPI_Send(NULL, 0, MPI_BYTE, rank+1, 0, MPI_COMM_WORLD);
+        if (rank < nproc - 1) {
+            MPI_Send(NULL, 0, MPI_BYTE, rank + 1, 0, MPI_COMM_WORLD);
         }
 
         MPI_Barrier(MPI_COMM_WORLD);
@@ -76,7 +79,8 @@ int main( int argc, char *argv[] )
     MPI_Win_unlock(0, window);
 
     MPI_Win_free(&window);
-    if (buf) MPI_Free_mem(buf);
+    if (buf)
+        MPI_Free_mem(buf);
 
     MPI_Reduce(&errors, &all_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
 
diff --git a/teshsuite/smpi/mpich3-test/rma/get-struct.c b/teshsuite/smpi/mpich3-test/rma/get-struct.c
new file mode 100644 (file)
index 0000000..b85cfe5
--- /dev/null
@@ -0,0 +1,173 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *  (C) 2014 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+#include "mpi.h"
+#include "mpitest.h"
+#include <stdio.h>
+#include <string.h>
+
+/* Communicating a datatype built out of structs
+ * This test was motivated by the failure of an example program for
+ * RMA involving simple operations on a struct that included a struct
+ *
+ * The observed failure was a SEGV in the MPI_Get
+ *
+ *
+ */
+#define MAX_KEY_SIZE 64
+#define MAX_VALUE_SIZE 256
+typedef struct {
+    MPI_Aint disp;
+    int rank;
+    void *lptr;
+} Rptr;
+typedef struct {
+    Rptr next;
+    char key[MAX_KEY_SIZE], value[MAX_VALUE_SIZE];
+} ListElm;
+Rptr nullDptr = { 0, -1, 0 };
+
+int testCases = -1;
+#define BYTE_ONLY 0x1
+#define TWO_STRUCT 0x2
+int isOneLevel = 0;
+
+int main(int argc, char **argv)
+{
+    int errors = 0;
+    Rptr headDptr;
+    ListElm *headLptr = 0;
+    int i, wrank;
+    MPI_Datatype dptrType, listelmType;
+    MPI_Win listwin;
+
+    MTest_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &wrank);
+
+    for (i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "-byteonly") == 0) {
+            testCases = BYTE_ONLY;
+        }
+        else if (strcmp(argv[i], "-twostruct") == 0) {
+            testCases = TWO_STRUCT;
+        }
+        else if (strcmp(argv[i], "-onelevel") == 0) {
+            isOneLevel = 1;
+        }
+        else {
+            printf("Unrecognized argument %s\n", argv[i]);
+        }
+    }
+
+    /* Create the datatypes that we will use to move the data */
+    {
+        int blens[3];
+        MPI_Aint displ[3];
+        MPI_Datatype dtypes[3];
+        ListElm sampleElm;
+
+        blens[0] = 1;
+        blens[1] = 1;
+        MPI_Get_address(&nullDptr.disp, &displ[0]);
+        MPI_Get_address(&nullDptr.rank, &displ[1]);
+        displ[1] = displ[1] - displ[0];
+        displ[0] = 0;
+        dtypes[0] = MPI_AINT;
+        dtypes[1] = MPI_INT;
+        MPI_Type_create_struct(2, blens, displ, dtypes, &dptrType);
+        MPI_Type_commit(&dptrType);
+
+        if (isOneLevel) {
+            blens[0] = sizeof(nullDptr);
+            dtypes[0] = MPI_BYTE;
+        }
+        else {
+            blens[0] = 1;
+            dtypes[0] = dptrType;
+        }
+        blens[1] = MAX_KEY_SIZE;
+        dtypes[1] = MPI_CHAR;
+        blens[2] = MAX_VALUE_SIZE;
+        dtypes[2] = MPI_CHAR;
+        MPI_Get_address(&sampleElm.next, &displ[0]);
+        MPI_Get_address(&sampleElm.key[0], &displ[1]);
+        MPI_Get_address(&sampleElm.value[0], &displ[2]);
+        displ[2] -= displ[0];
+        displ[1] -= displ[0];
+        displ[0] = 0;
+        for (i = 0; i < 3; i++) {
+            MTestPrintfMsg(0, "%d:count=%d,disp=%ld\n", i, blens[i], displ[i]);
+        }
+        MPI_Type_create_struct(3, blens, displ, dtypes, &listelmType);
+        MPI_Type_commit(&listelmType);
+    }
+
+    MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_WORLD, &listwin);
+
+    headDptr.rank = 0;
+    if (wrank == 0) {
+        /* Create 1 list element (the head) and initialize it */
+        MPI_Alloc_mem(sizeof(ListElm), MPI_INFO_NULL, &headLptr);
+        MPI_Get_address(headLptr, &headDptr.disp);
+        headLptr->next.rank = -1;
+        headLptr->next.disp = (MPI_Aint) MPI_BOTTOM;
+        headLptr->next.lptr = 0;
+        strncpy(headLptr->key, "key1", MAX_KEY_SIZE);
+        strncpy(headLptr->value, "value1", MAX_VALUE_SIZE);
+        MPI_Win_attach(listwin, headLptr, sizeof(ListElm));
+    }
+    MPI_Bcast(&headDptr.disp, 1, MPI_AINT, 0, MPI_COMM_WORLD);
+
+    MPI_Barrier(MPI_COMM_WORLD);
+
+    if (wrank == 1) {
+        ListElm headcopy;
+
+        MPI_Win_lock_all(0, listwin);
+        /* Get head element with simple get of BYTES */
+        if (testCases & BYTE_ONLY) {
+            headcopy.next.rank = 100;
+            headcopy.next.disp = 0xefefefef;
+            MPI_Get(&headcopy, sizeof(ListElm), MPI_BYTE,
+                    headDptr.rank, headDptr.disp, sizeof(ListElm), MPI_BYTE, listwin);
+            MPI_Win_flush(headDptr.rank, listwin);
+            if (headcopy.next.rank != -1 && headcopy.next.disp != (MPI_Aint) MPI_BOTTOM) {
+                errors++;
+                printf("MPI_BYTE: headcopy contains incorrect next:<%d,%ld>\n",
+                       headcopy.next.rank, (long) headcopy.next.disp);
+            }
+        }
+
+        if (testCases & TWO_STRUCT) {
+            headcopy.next.rank = 100;
+            headcopy.next.disp = 0xefefefef;
+            /* Get head element using struct of struct type.  This is
+             * not an identical get to the simple BYTE one above but should
+             * work */
+            MPI_Get(&headcopy, 1, listelmType, headDptr.rank, headDptr.disp,
+                    1, listelmType, listwin);
+            MPI_Win_flush(headDptr.rank, listwin);
+            if (headcopy.next.rank != -1 && headcopy.next.disp != (MPI_Aint) MPI_BOTTOM) {
+                errors++;
+                printf("ListelmType: headcopy contains incorrect next:<%d,%ld>\n",
+                       headcopy.next.rank, (long) headcopy.next.disp);
+            }
+        }
+
+        MPI_Win_unlock_all(listwin);
+    }
+    MPI_Barrier(MPI_COMM_WORLD);
+    if (wrank == 0) {
+        MPI_Win_detach(listwin, headLptr);
+        MPI_Free_mem(headLptr);
+    }
+    MPI_Win_free(&listwin);
+    MPI_Type_free(&dptrType);
+    MPI_Type_free(&listelmType);
+
+    MTest_Finalize(errors);
+    MPI_Finalize();
+    return MTestReturnValue(errors);
+}
index ecf3258..c1a38db 100644 (file)
 
 #include "mpitest.h"
 
-int       errors  = 0;
-const int NITER   = 1000;
+int errors = 0;
+const int NITER = 1000;
 const int acc_val = 3;
 
 int main(int argc, char **argv)
 {
-    int         rank, nproc;
-    int         out_val, i, counter = 0;
-    MPI_Win     win;
+    int rank, nproc;
+    int out_val, i, counter = 0;
+    MPI_Win win;
 
     MPI_Init(&argc, &argv);
 
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     MPI_Comm_size(MPI_COMM_WORLD, &nproc);
 
-    MPI_Win_create(&counter, sizeof(int), sizeof(int), MPI_INFO_NULL,
-                   MPI_COMM_WORLD, &win);
+    MPI_Win_create(&counter, sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
     for (i = 0; i < NITER; i++) {
         MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win);
         MPI_Get_accumulate(&acc_val, 1, MPI_INT, &out_val, 1, MPI_INT,
-                            rank, 0, 1, MPI_INT, MPI_SUM, win);
+                           rank, 0, 1, MPI_INT, MPI_SUM, win);
         MPI_Win_unlock(rank, win);
 
-        if (out_val != acc_val*i) {
+        if (out_val != acc_val * i) {
             errors++;
-            printf("Error: got %d, expected %d at iter %d\n", out_val, acc_val*i, i);
+            printf("Error: got %d, expected %d at iter %d\n", out_val, acc_val * i, i);
             break;
         }
     }
index 5a533fe..0ffee69 100644 (file)
@@ -39,7 +39,9 @@
 #  define TYPE_MPI TYPE_MPI_BASE
 #endif
 
-void reset_bufs(TYPE_C *win_ptr, TYPE_C *res_ptr, TYPE_C *val_ptr, TYPE_C value, MPI_Win win) {
+static void reset_bufs(TYPE_C * win_ptr, TYPE_C * res_ptr, TYPE_C * val_ptr, TYPE_C value,
+                       MPI_Win win)
+{
     int rank, nproc, i;
 
     MPI_Barrier(MPI_COMM_WORLD);
@@ -48,10 +50,10 @@ void reset_bufs(TYPE_C *win_ptr, TYPE_C *res_ptr, TYPE_C *val_ptr, TYPE_C value,
     MPI_Comm_size(MPI_COMM_WORLD, &nproc);
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
-    memset(win_ptr, 0, sizeof(TYPE_C)*nproc*COUNT);
+    memset(win_ptr, 0, sizeof(TYPE_C) * nproc * COUNT);
     MPI_Win_unlock(rank, win);
 
-    memset(res_ptr, -1, sizeof(TYPE_C)*nproc*COUNT);
+    memset(res_ptr, -1, sizeof(TYPE_C) * nproc * COUNT);
 
     for (i = 0; i < COUNT; i++)
         val_ptr[i] = value;
@@ -59,11 +61,12 @@ void reset_bufs(TYPE_C *win_ptr, TYPE_C *res_ptr, TYPE_C *val_ptr, TYPE_C value,
     MPI_Barrier(MPI_COMM_WORLD);
 }
 
-int main(int argc, char **argv) {
-    int       i, rank, nproc;
-    int       errors = 0, all_errors = 0;
-    TYPE_C   *win_ptr, *res_ptr, *val_ptr;
-    MPI_Win   win;
+int main(int argc, char **argv)
+{
+    int i, rank, nproc;
+    int errors = 0, all_errors = 0;
+    TYPE_C *win_ptr, *res_ptr, *val_ptr;
+    MPI_Win win;
 #if defined (GACC_TYPE_DERIVED)
     MPI_Datatype derived_type;
 #endif
@@ -73,16 +76,16 @@ int main(int argc, char **argv) {
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     MPI_Comm_size(MPI_COMM_WORLD, &nproc);
 
-    win_ptr = malloc(sizeof(TYPE_C)*nproc*COUNT);
-    res_ptr = malloc(sizeof(TYPE_C)*nproc*COUNT);
-    val_ptr = malloc(sizeof(TYPE_C)*COUNT);
+    win_ptr = malloc(sizeof(TYPE_C) * nproc * COUNT);
+    res_ptr = malloc(sizeof(TYPE_C) * nproc * COUNT);
+    val_ptr = malloc(sizeof(TYPE_C) * COUNT);
 
 #if defined (GACC_TYPE_DERIVED)
     MPI_Type_contiguous(1, TYPE_MPI_BASE, &derived_type);
     MPI_Type_commit(&derived_type);
 #endif
 
-    MPI_Win_create(win_ptr, sizeof(TYPE_C)*nproc*COUNT, sizeof(TYPE_C),
+    MPI_Win_create(win_ptr, sizeof(TYPE_C) * nproc * COUNT, sizeof(TYPE_C),
                    MPI_INFO_NULL, MPI_COMM_WORLD, &win);
 
     /* Test self communication */
@@ -91,16 +94,16 @@ int main(int argc, char **argv) {
 
     for (i = 0; i < ITER; i++) {
         MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
-        MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, res_ptr, COUNT, TYPE_MPI, 
-                            rank, 0, COUNT, TYPE_MPI, MPI_SUM, win);
+        MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, res_ptr, COUNT, TYPE_MPI,
+                           rank, 0, COUNT, TYPE_MPI, MPI_SUM, win);
         MPI_Win_unlock(rank, win);
     }
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
     for (i = 0; i < COUNT; i++) {
         if (win_ptr[i] != ITER) {
-            SQUELCH( printf("%d->%d -- SELF[%d]: expected "TYPE_FMT", got "TYPE_FMT"\n",
-                            rank, rank, i, (TYPE_C) ITER, win_ptr[i]); );
+            SQUELCH(printf("%d->%d -- SELF[%d]: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                           rank, rank, i, (TYPE_C) ITER, win_ptr[i]););
             errors++;
         }
     }
@@ -111,10 +114,10 @@ int main(int argc, char **argv) {
     reset_bufs(win_ptr, res_ptr, val_ptr, 1, win);
 
     for (i = 0; i < ITER; i++) {
-        MPI_Win_lock(MPI_LOCK_EXCLUSIVE, (rank+1)%nproc, 0, win);
-        MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, res_ptr, COUNT, TYPE_MPI, 
-                            (rank+1)%nproc, 0, COUNT, TYPE_MPI, MPI_SUM, win);
-        MPI_Win_unlock((rank+1)%nproc, win);
+        MPI_Win_lock(MPI_LOCK_EXCLUSIVE, (rank + 1) % nproc, 0, win);
+        MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, res_ptr, COUNT, TYPE_MPI,
+                           (rank + 1) % nproc, 0, COUNT, TYPE_MPI, MPI_SUM, win);
+        MPI_Win_unlock((rank + 1) % nproc, win);
     }
 
     MPI_Barrier(MPI_COMM_WORLD);
@@ -122,8 +125,8 @@ int main(int argc, char **argv) {
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
     for (i = 0; i < COUNT; i++) {
         if (win_ptr[i] != ITER) {
-            SQUELCH( printf("%d->%d -- NEIGHBOR[%d]: expected "TYPE_FMT", got "TYPE_FMT"\n",
-                            (rank+1)%nproc, rank, i, (TYPE_C) ITER, win_ptr[i]); );
+            SQUELCH(printf("%d->%d -- NEIGHBOR[%d]: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                           (rank + 1) % nproc, rank, i, (TYPE_C) ITER, win_ptr[i]););
             errors++;
         }
     }
@@ -136,8 +139,8 @@ int main(int argc, char **argv) {
     if (rank != 0) {
         for (i = 0; i < ITER; i++) {
             MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, win);
-            MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, res_ptr, COUNT, TYPE_MPI, 
-                                0, 0, COUNT, TYPE_MPI, MPI_SUM, win);
+            MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, res_ptr, COUNT, TYPE_MPI,
+                               0, 0, COUNT, TYPE_MPI, MPI_SUM, win);
             MPI_Win_unlock(0, win);
         }
     }
@@ -147,9 +150,9 @@ int main(int argc, char **argv) {
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
     if (rank == 0 && nproc > 1) {
         for (i = 0; i < COUNT; i++) {
-            if (win_ptr[i] != ITER*(nproc-1)) {
-                SQUELCH( printf("*->%d - CONTENTION[%d]: expected="TYPE_FMT" val="TYPE_FMT"\n",
-                                rank, i, (TYPE_C) ITER*(nproc-1), win_ptr[i]); );
+            if (win_ptr[i] != ITER * (nproc - 1)) {
+                SQUELCH(printf("*->%d - CONTENTION[%d]: expected=" TYPE_FMT " val=" TYPE_FMT "\n",
+                               rank, i, (TYPE_C) ITER * (nproc - 1), win_ptr[i]););
                 errors++;
             }
         }
@@ -165,8 +168,8 @@ int main(int argc, char **argv) {
 
         MPI_Win_fence(MPI_MODE_NOPRECEDE, win);
         for (j = 0; j < nproc; j++) {
-            MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, &res_ptr[j*COUNT], COUNT, TYPE_MPI,
-                                j, rank*COUNT, COUNT, TYPE_MPI, MPI_SUM, win);
+            MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, &res_ptr[j * COUNT], COUNT, TYPE_MPI,
+                               j, rank * COUNT, COUNT, TYPE_MPI, MPI_SUM, win);
         }
         MPI_Win_fence(MPI_MODE_NOSUCCEED, win);
         MPI_Barrier(MPI_COMM_WORLD);
@@ -174,9 +177,11 @@ int main(int argc, char **argv) {
         for (j = 0; j < nproc; j++) {
             int c;
             for (c = 0; c < COUNT; c++) {
-                if (res_ptr[j*COUNT+c] != i*rank) {
-                    SQUELCH( printf("%d->%d -- ALL-TO-ALL (FENCE) [%d]: iter %d, expected result "TYPE_FMT", got "TYPE_FMT"\n", 
-                                    rank, j, c, i, (TYPE_C) i*rank, res_ptr[j*COUNT+c]); );
+                if (res_ptr[j * COUNT + c] != i * rank) {
+                    SQUELCH(printf
+                            ("%d->%d -- ALL-TO-ALL (FENCE) [%d]: iter %d, expected result " TYPE_FMT
+                             ", got " TYPE_FMT "\n", rank, j, c, i, (TYPE_C) i * rank,
+                             res_ptr[j * COUNT + c]););
                     errors++;
                 }
             }
@@ -188,9 +193,10 @@ int main(int argc, char **argv) {
     for (i = 0; i < nproc; i++) {
         int c;
         for (c = 0; c < COUNT; c++) {
-            if (win_ptr[i*COUNT+c] != ITER*i) {
-                SQUELCH( printf("%d->%d -- ALL-TO-ALL (FENCE): expected "TYPE_FMT", got "TYPE_FMT"\n", 
-                                i, rank, (TYPE_C) ITER*i, win_ptr[i*COUNT+c]); );
+            if (win_ptr[i * COUNT + c] != ITER * i) {
+                SQUELCH(printf
+                        ("%d->%d -- ALL-TO-ALL (FENCE): expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                         i, rank, (TYPE_C) ITER * i, win_ptr[i * COUNT + c]););
                 errors++;
             }
         }
@@ -206,8 +212,8 @@ int main(int argc, char **argv) {
 
         MPI_Win_lock_all(0, win);
         for (j = 0; j < nproc; j++) {
-            MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, &res_ptr[j*COUNT], COUNT, TYPE_MPI,
-                                j, rank*COUNT, COUNT, TYPE_MPI, MPI_SUM, win);
+            MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, &res_ptr[j * COUNT], COUNT, TYPE_MPI,
+                               j, rank * COUNT, COUNT, TYPE_MPI, MPI_SUM, win);
         }
         MPI_Win_unlock_all(win);
         MPI_Barrier(MPI_COMM_WORLD);
@@ -215,9 +221,11 @@ int main(int argc, char **argv) {
         for (j = 0; j < nproc; j++) {
             int c;
             for (c = 0; c < COUNT; c++) {
-                if (res_ptr[j*COUNT+c] != i*rank) {
-                    SQUELCH( printf("%d->%d -- ALL-TO-ALL (LOCK-ALL) [%d]: iter %d, expected result "TYPE_FMT", got "TYPE_FMT"\n", 
-                                    rank, j, c, i, (TYPE_C) i*rank, res_ptr[j*COUNT+c]); );
+                if (res_ptr[j * COUNT + c] != i * rank) {
+                    SQUELCH(printf
+                            ("%d->%d -- ALL-TO-ALL (LOCK-ALL) [%d]: iter %d, expected result "
+                             TYPE_FMT ", got " TYPE_FMT "\n", rank, j, c, i, (TYPE_C) i * rank,
+                             res_ptr[j * COUNT + c]););
                     errors++;
                 }
             }
@@ -229,9 +237,10 @@ int main(int argc, char **argv) {
     for (i = 0; i < nproc; i++) {
         int c;
         for (c = 0; c < COUNT; c++) {
-            if (win_ptr[i*COUNT+c] != ITER*i) {
-                SQUELCH( printf("%d->%d -- ALL-TO-ALL (LOCK-ALL): expected "TYPE_FMT", got "TYPE_FMT"\n", 
-                                i, rank, (TYPE_C) ITER*i, win_ptr[i*COUNT+c]); );
+            if (win_ptr[i * COUNT + c] != ITER * i) {
+                SQUELCH(printf
+                        ("%d->%d -- ALL-TO-ALL (LOCK-ALL): expected " TYPE_FMT ", got " TYPE_FMT
+                         "\n", i, rank, (TYPE_C) ITER * i, win_ptr[i * COUNT + c]););
                 errors++;
             }
         }
@@ -247,8 +256,8 @@ int main(int argc, char **argv) {
 
         MPI_Win_lock_all(0, win);
         for (j = 0; j < nproc; j++) {
-            MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, &res_ptr[j*COUNT], COUNT, TYPE_MPI,
-                                j, rank*COUNT, COUNT, TYPE_MPI, MPI_SUM, win);
+            MPI_Get_accumulate(val_ptr, COUNT, TYPE_MPI, &res_ptr[j * COUNT], COUNT, TYPE_MPI,
+                               j, rank * COUNT, COUNT, TYPE_MPI, MPI_SUM, win);
             MPI_Win_flush(j, win);
         }
         MPI_Win_unlock_all(win);
@@ -257,9 +266,11 @@ int main(int argc, char **argv) {
         for (j = 0; j < nproc; j++) {
             int c;
             for (c = 0; c < COUNT; c++) {
-                if (res_ptr[j*COUNT+c] != i*rank) {
-                    SQUELCH( printf("%d->%d -- ALL-TO-ALL (LOCK-ALL+FLUSH) [%d]: iter %d, expected result "TYPE_FMT", got "TYPE_FMT"\n", 
-                                    rank, j, c, i, (TYPE_C) i*rank, res_ptr[j*COUNT+c]); );
+                if (res_ptr[j * COUNT + c] != i * rank) {
+                    SQUELCH(printf
+                            ("%d->%d -- ALL-TO-ALL (LOCK-ALL+FLUSH) [%d]: iter %d, expected result "
+                             TYPE_FMT ", got " TYPE_FMT "\n", rank, j, c, i, (TYPE_C) i * rank,
+                             res_ptr[j * COUNT + c]););
                     errors++;
                 }
             }
@@ -271,9 +282,10 @@ int main(int argc, char **argv) {
     for (i = 0; i < nproc; i++) {
         int c;
         for (c = 0; c < COUNT; c++) {
-            if (win_ptr[i*COUNT+c] != ITER*i) {
-                SQUELCH( printf("%d->%d -- ALL-TO-ALL (LOCK-ALL+FLUSH): expected "TYPE_FMT", got "TYPE_FMT"\n", 
-                                i, rank, (TYPE_C) ITER*i, win_ptr[i*COUNT+c]); );
+            if (win_ptr[i * COUNT + c] != ITER * i) {
+                SQUELCH(printf
+                        ("%d->%d -- ALL-TO-ALL (LOCK-ALL+FLUSH): expected " TYPE_FMT ", got "
+                         TYPE_FMT "\n", i, rank, (TYPE_C) ITER * i, win_ptr[i * COUNT + c]););
                 errors++;
             }
         }
@@ -285,52 +297,58 @@ int main(int argc, char **argv) {
     reset_bufs(win_ptr, res_ptr, val_ptr, 1, win);
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
-    for (i = 0; i < COUNT*nproc; i++)
+    for (i = 0; i < COUNT * nproc; i++)
         win_ptr[i] = (TYPE_C) rank;
     MPI_Win_unlock(rank, win);
     MPI_Barrier(MPI_COMM_WORLD);
 
     for (i = 0; i < ITER; i++) {
-        int j, target = (rank+1) % nproc;
+        int j, target = (rank + 1) % nproc;
 
         /* Test: origin_buf = NULL */
+        memset(res_ptr, -1, sizeof(TYPE_C) * nproc * COUNT); /* reset result buffer. */
+
         MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, win);
         MPI_Get_accumulate(NULL, COUNT, TYPE_MPI, res_ptr, COUNT, TYPE_MPI,
-                            target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
+                           target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
         MPI_Win_unlock(target, win);
 
         for (j = 0; j < COUNT; j++) {
             if (res_ptr[j] != (TYPE_C) target) {
-                SQUELCH( printf("%d->%d -- NOP(1)[%d]: expected "TYPE_FMT", got "TYPE_FMT"\n",
-                                target, rank, i, (TYPE_C) target, res_ptr[i]); );
+                SQUELCH(printf("%d->%d -- NOP(1)[%d]: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                               target, rank, i, (TYPE_C) target, res_ptr[i]););
                 errors++;
             }
         }
 
         /* Test: origin_buf = NULL, origin_count = 0 */
+        memset(res_ptr, -1, sizeof(TYPE_C) * nproc * COUNT);
+
         MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, win);
         MPI_Get_accumulate(NULL, 0, TYPE_MPI, res_ptr, COUNT, TYPE_MPI,
-                            target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
+                           target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
         MPI_Win_unlock(target, win);
 
         for (j = 0; j < COUNT; j++) {
             if (res_ptr[j] != (TYPE_C) target) {
-                SQUELCH( printf("%d->%d -- NOP(2)[%d]: expected "TYPE_FMT", got "TYPE_FMT"\n",
-                                target, rank, i, (TYPE_C) target, res_ptr[i]); );
+                SQUELCH(printf("%d->%d -- NOP(2)[%d]: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                               target, rank, i, (TYPE_C) target, res_ptr[i]););
                 errors++;
             }
         }
 
         /* Test: origin_buf = NULL, origin_count = 0, origin_dtype = NULL */
+        memset(res_ptr, -1, sizeof(TYPE_C) * nproc * COUNT);
+
         MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, win);
         MPI_Get_accumulate(NULL, 0, MPI_DATATYPE_NULL, res_ptr, COUNT, TYPE_MPI,
-                            target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
+                           target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
         MPI_Win_unlock(target, win);
 
         for (j = 0; j < COUNT; j++) {
             if (res_ptr[j] != (TYPE_C) target) {
-                SQUELCH( printf("%d->%d -- NOP(2)[%d]: expected "TYPE_FMT", got "TYPE_FMT"\n",
-                                target, rank, i, (TYPE_C) target, res_ptr[i]); );
+                SQUELCH(printf("%d->%d -- NOP(2)[%d]: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                               target, rank, i, (TYPE_C) target, res_ptr[i]););
                 errors++;
             }
         }
@@ -341,7 +359,7 @@ int main(int argc, char **argv) {
     reset_bufs(win_ptr, res_ptr, val_ptr, 1, win);
 
     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, win);
-    for (i = 0; i < COUNT*nproc; i++)
+    for (i = 0; i < COUNT * nproc; i++)
         win_ptr[i] = (TYPE_C) rank;
     MPI_Win_unlock(rank, win);
     MPI_Barrier(MPI_COMM_WORLD);
@@ -350,43 +368,52 @@ int main(int argc, char **argv) {
         int j, target = rank;
 
         /* Test: origin_buf = NULL */
+        memset(res_ptr, -1, sizeof(TYPE_C) * nproc * COUNT);
+
         MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, win);
         MPI_Get_accumulate(NULL, COUNT, TYPE_MPI, res_ptr, COUNT, TYPE_MPI,
-                            target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
+                           target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
         MPI_Win_unlock(target, win);
 
         for (j = 0; j < COUNT; j++) {
             if (res_ptr[j] != (TYPE_C) target) {
-                SQUELCH( printf("%d->%d -- NOP_SELF(1)[%d]: expected "TYPE_FMT", got "TYPE_FMT"\n",
-                                target, rank, i, (TYPE_C) target, res_ptr[i]); );
+                SQUELCH(printf
+                        ("%d->%d -- NOP_SELF(1)[%d]: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                         target, rank, i, (TYPE_C) target, res_ptr[i]););
                 errors++;
             }
         }
 
         /* Test: origin_buf = NULL, origin_count = 0 */
+        memset(res_ptr, -1, sizeof(TYPE_C) * nproc * COUNT);
+
         MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, win);
         MPI_Get_accumulate(NULL, 0, TYPE_MPI, res_ptr, COUNT, TYPE_MPI,
-                            target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
+                           target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
         MPI_Win_unlock(target, win);
 
         for (j = 0; j < COUNT; j++) {
             if (res_ptr[j] != (TYPE_C) target) {
-                SQUELCH( printf("%d->%d -- NOP_SELF(2)[%d]: expected "TYPE_FMT", got "TYPE_FMT"\n",
-                                target, rank, i, (TYPE_C) target, res_ptr[i]); );
+                SQUELCH(printf
+                        ("%d->%d -- NOP_SELF(2)[%d]: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                         target, rank, i, (TYPE_C) target, res_ptr[i]););
                 errors++;
             }
         }
 
         /* Test: origin_buf = NULL, origin_count = 0, origin_dtype = NULL */
+        memset(res_ptr, -1, sizeof(TYPE_C) * nproc * COUNT);
+
         MPI_Win_lock(MPI_LOCK_EXCLUSIVE, target, 0, win);
         MPI_Get_accumulate(NULL, 0, MPI_DATATYPE_NULL, res_ptr, COUNT, TYPE_MPI,
-                            target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
+                           target, 0, COUNT, TYPE_MPI, MPI_NO_OP, win);
         MPI_Win_unlock(target, win);
 
         for (j = 0; j < COUNT; j++) {
             if (res_ptr[j] != (TYPE_C) target) {
-                SQUELCH( printf("%d->%d -- NOP_SELF(2)[%d]: expected "TYPE_FMT", got "TYPE_FMT"\n",
-                                target, rank, i, (TYPE_C) target, res_ptr[i]); );
+                SQUELCH(printf
+                        ("%d->%d -- NOP_SELF(2)[%d]: expected " TYPE_FMT ", got " TYPE_FMT "\n",
+                         target, rank, i, (TYPE_C) target, res_ptr[i]););
                 errors++;
             }
         }
index 2aaba82..6b06893 100644 (file)
  */
 #include "mpi.h"
 #include <stdio.h>
+#include <string.h>
+#include <limits.h>
 #include "mpitest.h"
 
+#define LARGE_CNT_CONTIG    5500000
+#define LARGE_CNT_NONCONTIG 1500000
+
 /*
 static char MTEST_Descrip[] = "Get with Fence";
 */
 
-int main( int argc, char *argv[] )
+static inline int test(MPI_Comm comm, int rank, int source, int dest,
+                       MTestDatatype * sendtype, MTestDatatype * recvtype)
 {
     int errs = 0, err;
+    int disp_unit;
+    MPI_Aint extent, lb;
+    MPI_Win win;
+
+    MTestPrintfMsg(1,
+                   "Getting count = %ld of sendtype %s - count = %ld receive type %s\n",
+                   sendtype->count, MTestGetDatatypeName(sendtype), recvtype->count,
+                   MTestGetDatatypeName(recvtype));
+    /* Make sure that everyone has a recv buffer */
+    recvtype->InitBuf(recvtype);
+    sendtype->InitBuf(sendtype);
+    /* By default, print information about errors */
+    recvtype->printErrors = 1;
+    sendtype->printErrors = 1;
+
+    MPI_Type_extent(sendtype->datatype, &extent);
+    MPI_Type_lb(sendtype->datatype, &lb);
+    disp_unit = extent < INT_MAX ? extent : 1;
+    MPI_Win_create(sendtype->buf, sendtype->count * extent + lb, disp_unit, MPI_INFO_NULL, comm, &win);
+    MPI_Win_fence(0, win);
+    if (rank == source) {
+        /* The source does not need to do anything besides the
+         * fence */
+        MPI_Win_fence(0, win);
+    }
+    else if (rank == dest) {
+        /* To improve reporting of problems about operations, we
+         * change the error handler to errors return */
+        MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+
+        /* This should have the same effect, in terms of
+         * transfering data, as a send/recv pair */
+        err = MPI_Get(recvtype->buf, recvtype->count,
+                      recvtype->datatype, source, 0, sendtype->count, sendtype->datatype, win);
+        if (err) {
+            errs++;
+            if (errs < 10) {
+                MTestPrintError(err);
+            }
+        }
+        err = MPI_Win_fence(0, win);
+        if (err) {
+            errs++;
+            if (errs < 10) {
+                MTestPrintError(err);
+            }
+        }
+        err = MTestCheckRecv(0, recvtype);
+        if (err) {
+            errs += err;
+        }
+    }
+    else {
+        MPI_Win_fence(0, win);
+    }
+    MPI_Win_free(&win);
+
+    return errs;
+}
+
+
+int main(int argc, char *argv[])
+{
+    int errs = 0;
     int rank, size, source, dest;
-    int minsize = 2, count; 
-    MPI_Comm      comm;
-    MPI_Win       win;
-    MPI_Aint      extent;
+    int minsize = 2, count;
+    MPI_Comm comm;
     MTestDatatype sendtype, recvtype;
 
-    MTest_Init( &argc, &argv );
-
-    /* The following illustrates the use of the routines to 
-       run through a selection of communicators and datatypes.
-       Use subsets of these for tests that do not involve combinations 
-       of communicators, datatypes, and counts of datatypes */
-    while (MTestGetIntracommGeneral( &comm, minsize, 1 )) {
-       if (comm == MPI_COMM_NULL) continue;
-       /* Determine the sender and receiver */
-       MPI_Comm_rank( comm, &rank );
-       MPI_Comm_size( comm, &size );
-       source = 0;
-       dest   = size - 1;
-       
-       for (count = 1; count < 65000; count = count * 2) {
-           while (MTestGetDatatypes( &sendtype, &recvtype, count )) {
-               /* Make sure that everyone has a recv buffer */
-               recvtype.InitBuf( &recvtype );
-               sendtype.InitBuf( &sendtype );
-               /* By default, print information about errors */
-               recvtype.printErrors = 1;
-               sendtype.printErrors = 1;
-
-               MPI_Type_extent( sendtype.datatype, &extent );
-               MPI_Win_create( sendtype.buf, sendtype.count * extent, 
-                               (int)extent, MPI_INFO_NULL, comm, &win );
-               MPI_Win_fence( 0, win );
-               if (rank == source) {
-                   /* The source does not need to do anything besides the
-                      fence */
-                   MPI_Win_fence( 0, win );
-               }
-               else if (rank == dest) {
-                   /* To improve reporting of problems about operations, we
-                      change the error handler to errors return */
-                   MPI_Win_set_errhandler( win, MPI_ERRORS_RETURN );
-
-                   /* This should have the same effect, in terms of
-                      transfering data, as a send/recv pair */
-                   err = MPI_Get( recvtype.buf, recvtype.count, 
-                                  recvtype.datatype, source, 0, 
-                                  sendtype.count, sendtype.datatype, win );
-                   if (err) {
-                       errs++;
-                       if (errs < 10) {
-                           MTestPrintError( err );
-                       }
-                   }
-                   err = MPI_Win_fence( 0, win );
-                   if (err) {
-                       errs++;
-                       if (errs < 10) {
-                           MTestPrintError( err );
-                       }
-                   }
-                   err = MTestCheckRecv( 0, &recvtype );
-                   if (err) {
-                       errs += err;
-                   }
-               }
-               else {
-                   MPI_Win_fence( 0, win );
-               }
-               MPI_Win_free( &win );
-               MTestFreeDatatype( &recvtype );
-               MTestFreeDatatype( &sendtype );
-           }
-       }
+    MTest_Init(&argc, &argv);
+
+    /* The following illustrates the use of the routines to
+     * run through a selection of communicators and datatypes.
+     * Use subsets of these for tests that do not involve combinations
+     * of communicators, datatypes, and counts of datatypes */
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+        if (comm == MPI_COMM_NULL)
+            continue;
+        /* Determine the sender and receiver */
+        MPI_Comm_rank(comm, &rank);
+        MPI_Comm_size(comm, &size);
+        source = 0;
+        dest = size - 1;
+
+        MTEST_DATATYPE_FOR_EACH_COUNT(count) {
+            while (MTestGetDatatypes(&sendtype, &recvtype, count)) {
+                errs += test(comm, rank, source, dest, &sendtype, &recvtype);
+                MTestFreeDatatype(&sendtype);
+                MTestFreeDatatype(&recvtype);
+            }
+        }
         MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    /* Part #2: simple large size test - contiguous and noncontiguous */
+    if (sizeof(void *) > 4) {   /* Only if > 32-bit architecture */
+        MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+        MPI_Comm_size(MPI_COMM_WORLD, &size);
+        source = 0;
+        dest = size - 1;
+
+        MTestGetDatatypes(&sendtype, &recvtype, LARGE_CNT_CONTIG);
+        errs += test(MPI_COMM_WORLD, rank, source, dest, &sendtype, &recvtype);
+
+        do {
+            MTestFreeDatatype(&sendtype);
+            MTestFreeDatatype(&recvtype);
+            MTestGetDatatypes(&sendtype, &recvtype, LARGE_CNT_NONCONTIG);
+        } while (strstr(MTestGetDatatypeName(&sendtype), "vector") == NULL);
+        errs += test(MPI_COMM_WORLD, rank, source, dest, &sendtype, &recvtype);
+        MTestFreeDatatype(&sendtype);
+        MTestFreeDatatype(&recvtype);
+    }
+
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
index 4dd0c0d..051bb5f 100644 (file)
 static char MTEST_Descrip[] = "Test of Win_get_group";
 */
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int errs = 0;
     int result;
     int buf[10];
-    MPI_Win   win;
+    MPI_Win win;
     MPI_Group group, wingroup;
     int minsize = 2;
-    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_Win_create( buf, sizeof(int) * 10, sizeof(int), 
-                       MPI_INFO_NULL, comm, &win );
-       MPI_Win_get_group( win, &wingroup );
-       MPI_Comm_group( comm, &group );
-       MPI_Group_compare( group, wingroup, &result );
-       if (result != MPI_IDENT) {
-           errs++;
-           fprintf( stderr, "Group returned by Win_get_group not the same as the input group\n" );
-       }
-       MPI_Group_free( &wingroup );
-       MPI_Group_free( &group );
-       MPI_Win_free( &win );
+        MPI_Win_create(buf, sizeof(int) * 10, sizeof(int), MPI_INFO_NULL, comm, &win);
+        MPI_Win_get_group(win, &wingroup);
+        MPI_Comm_group(comm, &group);
+        MPI_Group_compare(group, wingroup, &result);
+        if (result != MPI_IDENT) {
+            errs++;
+            fprintf(stderr, "Group returned by Win_get_group not the same as the input group\n");
+        }
+        MPI_Group_free(&wingroup);
+        MPI_Group_free(&group);
+        MPI_Win_free(&win);
         MTestFreeComm(&comm);
     }
 
-    MTest_Finalize( errs );
+    MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
 }
diff --git a/teshsuite/smpi/mpich3-test/rma/ircpi.c b/teshsuite/smpi/mpich3-test/rma/ircpi.c
deleted file mode 100644 (file)
index 99a83ed..0000000
+++ /dev/null
@@ -1,71 +0,0 @@
-/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
-/*
- *  (C) 2001 by Argonne National Laboratory.
- *      See COPYRIGHT in top-level directory.
- */
-#include "mpi.h" 
-#include "stdio.h"
-#include <math.h> 
-
-/* From Using MPI-2 */
-
-int main(int argc, char *argv[]) 
-{ 
-    int n, myid, numprocs, i, ierr; 
-    double PI25DT = 3.141592653589793238462643; 
-    double mypi, pi, h, sum, x; 
-    MPI_Win nwin, piwin; 
-    MPI_Init(&argc,&argv); 
-    MPI_Comm_size(MPI_COMM_WORLD,&numprocs); 
-    MPI_Comm_rank(MPI_COMM_WORLD,&myid); 
-    if (myid == 0) { 
-       MPI_Win_create(&n, sizeof(int), 1, MPI_INFO_NULL, 
-                      MPI_COMM_WORLD, &nwin); 
-       MPI_Win_create(&pi, sizeof(double), 1, MPI_INFO_NULL, 
-                      MPI_COMM_WORLD, &piwin);  
-    } 
-    else { 
-       MPI_Win_create(MPI_BOTTOM, 0, 1, MPI_INFO_NULL, 
-                      MPI_COMM_WORLD, &nwin); 
-       MPI_Win_create(MPI_BOTTOM, 0, 1, MPI_INFO_NULL, 
-                      MPI_COMM_WORLD, &piwin); 
-    } 
-    while (1) { 
-        if (myid == 0) { 
-            fprintf(stdout, "Enter the number of intervals: (0 quits) ");
-           fflush(stdout); 
-            ierr=scanf("%d",&n); 
-           pi = 0.0;                    
-        } 
-       MPI_Win_fence(0, nwin); 
-       if (myid != 0)  
-           MPI_Get(&n, 1, MPI_INT, 0, 0, 1, MPI_INT, nwin); 
-       MPI_Win_fence(0, nwin); 
-        if (n == 0) 
-            break; 
-        else { 
-            h   = 1.0 / (double) n; 
-            sum = 0.0; 
-            for (i = myid + 1; i <= n; i += numprocs) { 
-                x = h * ((double)i - 0.5); 
-                sum += (4.0 / (1.0 + x*x)); 
-            } 
-            mypi = h * sum; 
-           MPI_Win_fence( 0, piwin); 
-           MPI_Accumulate(&mypi, 1, MPI_DOUBLE, 0, 0, 1, MPI_DOUBLE, 
-                          MPI_SUM, piwin); 
-           MPI_Win_fence(0, piwin); 
-            if (myid == 0) { 
-                fprintf(stdout, "pi is approximately %.16f, Error is %.16f\n", 
-                       pi, fabs(pi - PI25DT)); 
-               fflush(stdout);
-           }
-        } 
-    } 
-    MPI_Win_free(&nwin); 
-    MPI_Win_free(&piwin); 
-    MPI_Finalize(); 
-    return 0; 
-} 
diff --git a/teshsuite/smpi/mpich3-test/rma/large-acc-flush_local.c b/teshsuite/smpi/mpich3-test/rma/large-acc-flush_local.c
new file mode 100644 (file)
index 0000000..fd0a4fa
--- /dev/null
@@ -0,0 +1,73 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *  (C) 2015 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+/* This code tests the case when origin process issues 10 ACC
+ * operations for each data size to the target process, and each
+ * operation is followed by a MPI_Win_flush_local. */
+
+/* FIXME: we should merge this into a comprehensive test for RMA
+ * operations + MPI_Win_flush_local. */
+
+#include "mpi.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define MIN_DATA_SIZE (262144)
+#define MAX_DATA_SIZE (8 * 262144)
+#define OPS_NUM 10
+#define LOOP 500
+
+int main(int argc, char *argv[])
+{
+    int rank, nproc, i, j;
+    MPI_Win win;
+    int *tar_buf = NULL;
+    int *orig_buf = NULL;
+    int data_size;
+
+    MPI_Init(&argc, &argv);
+
+    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    MPI_Alloc_mem(MAX_DATA_SIZE, MPI_INFO_NULL, &orig_buf);
+    MPI_Alloc_mem(MAX_DATA_SIZE, MPI_INFO_NULL, &tar_buf);
+
+    /* run this test for LOOP times */
+
+    for (j = 0; j < LOOP; j++) {
+
+        MPI_Win_create(tar_buf, MAX_DATA_SIZE, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win);
+
+        MPI_Win_lock_all(0, win);
+
+        if (rank != 0) {
+            for (data_size = MIN_DATA_SIZE; data_size <= MAX_DATA_SIZE; data_size *= 2) {
+                for (i = 0; i < OPS_NUM; i++) {
+                    MPI_Accumulate(orig_buf, data_size, MPI_BYTE,
+                                   0, 0, data_size, MPI_BYTE, MPI_SUM, win);
+                    MPI_Win_flush_local(0, win);
+                }
+                MPI_Win_flush(0, win);
+            }
+        }
+
+        MPI_Win_unlock_all(win);
+
+        MPI_Win_free(&win);
+    }
+
+    if (rank == 0)
+        printf(" No Errors\n");
+
+    MPI_Free_mem(orig_buf);
+    MPI_Free_mem(tar_buf);
+
+    MPI_Finalize();
+
+    return 0;
+}
diff --git a/teshsuite/smpi/mpich3-test/rma/large-small-acc.c b/teshsuite/smpi/mpich3-test/rma/large-small-acc.c
new file mode 100644 (file)
index 0000000..de5b08f
--- /dev/null
@@ -0,0 +1,88 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
+/*
+ *  (C) 2015 by Argonne National Laboratory.
+ *      See COPYRIGHT in top-level directory.
+ */
+
+/* This code tests the case when a large ACC is issued, and then
+ * several small ACCs is issued between the same origin and target.
+ * The purpose of this test is to check if the ordering of ACCs
+ * is guaranteed. */
+
+#include "mpi.h"
+#include <stdio.h>
+#include <stdint.h>
+
+#define LOOP 5
+#define DATA_COUNT 8192
+
+int main(int argc, char *argv[])
+{
+    int rank, nprocs;
+    MPI_Win win;
+    uint64_t buf[DATA_COUNT], orig_buf[DATA_COUNT];
+    uint64_t small_orig_buf_1 = 2, small_orig_buf_2[2] = { 3, 3 };
+    int i, j, error = 0;
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    for (j = 0; j < LOOP; j++) {
+
+        error = 0;
+
+        for (i = 0; i < DATA_COUNT; i++) {
+            buf[i] = 0;
+            orig_buf[i] = 1;
+        }
+
+        MPI_Win_create(buf, sizeof(uint64_t) * DATA_COUNT, sizeof(uint64_t),
+                       MPI_INFO_NULL, MPI_COMM_WORLD, &win);
+
+        MPI_Win_fence(0, win);
+
+        if (rank == 0) {
+            /* ACC (atomic PUT) to win_buf[0...DATA_COUNT-1] */
+            MPI_Accumulate(orig_buf, DATA_COUNT, MPI_UINT64_T, 1, 0, DATA_COUNT, MPI_UINT64_T,
+                           MPI_REPLACE, win);
+            /* ACC (atomic PUT) to win_buf[0] */
+            MPI_Accumulate(&small_orig_buf_1, 1, MPI_UINT64_T, 1, 0, 1, MPI_UINT64_T, MPI_REPLACE,
+                           win);
+            /* ACC (atomic PUT) to win_buf[1,2] */
+            MPI_Accumulate(&small_orig_buf_2, 2, MPI_UINT64_T, 1, 1, 2, MPI_UINT64_T, MPI_REPLACE,
+                           win);
+        }
+
+        MPI_Win_fence(0, win);
+
+        if (rank == 1) {
+            for (i = 0; i < DATA_COUNT; i++) {
+                if (i == 0) {
+                    if (buf[i] != 2) {
+                        error++;
+                    }
+                }
+                else if (i == 1 || i == 2) {
+                    if (buf[i] != 3) {
+                        error++;
+                    }
+                }
+                else {
+                    if (buf[i] != 1) {
+                        error++;
+                    }
+                }
+            }
+        }
+
+        MPI_Win_free(&win);
+    }
+
+    if (rank == 1 && error == 0) {
+        printf(" No Errors\n");
+    }
+
+    MPI_Finalize();
+    return 0;
+}
index 7b59c90..126ab62 100644 (file)
@@ -7,7 +7,7 @@
 
 /*            MPI-3 distributed linked list construction example
  *            --------------------------------------------------
- * 
+ *
  * Construct a distributed shared linked list using proposed MPI-3 dynamic
  * windows.  Initially process 0 creates the head of the list, attaches it to
  * the window, and broadcasts the pointer to all processes.  All processes then
@@ -23,7 +23,7 @@
 #include <assert.h>
 #include "mpitest.h"
 
-#if HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
@@ -33,7 +33,7 @@
 
 /* Linked list pointer */
 typedef struct {
-    int      rank;
+    int rank;
     MPI_Aint disp;
 } llist_ptr_t;
 
@@ -44,28 +44,30 @@ typedef struct {
 } llist_elem_t;
 
 static const llist_ptr_t nil = { -1, (MPI_Aint) MPI_BOTTOM };
+
 static const int verbose = 0;
 
 /* List of locally allocated list elements. */
 static llist_elem_t **my_elems = NULL;
-static int my_elems_size  = 0;
+static int my_elems_size = 0;
 static int my_elems_count = 0;
 
 /* Allocate a new shared linked list element */
-MPI_Aint alloc_elem(int value, MPI_Win win) {
+MPI_Aint alloc_elem(int value, MPI_Win win)
+{
     MPI_Aint disp;
     llist_elem_t *elem_ptr;
 
     /* Allocate the new element and register it with the window */
     MPI_Alloc_mem(sizeof(llist_elem_t), MPI_INFO_NULL, &elem_ptr);
     elem_ptr->value = value;
-    elem_ptr->next  = nil;
+    elem_ptr->next = nil;
     MPI_Win_attach(win, elem_ptr, sizeof(llist_elem_t));
 
     /* Add the element to the list of local elements so we can free it later. */
     if (my_elems_size == my_elems_count) {
         my_elems_size += 100;
-        my_elems = realloc(my_elems, my_elems_size*sizeof(void*));
+        my_elems = realloc(my_elems, my_elems_size * sizeof(void *));
     }
     my_elems[my_elems_count] = elem_ptr;
     my_elems_count++;
@@ -74,10 +76,11 @@ MPI_Aint alloc_elem(int value, MPI_Win win) {
     return disp;
 }
 
-int main(int argc, char **argv) {
-    int           procid, nproc, i;
-    MPI_Win       llist_win;
-    llist_ptr_t   head_ptr, tail_ptr;
+int main(int argc, char **argv)
+{
+    int procid, nproc, i;
+    MPI_Win llist_win;
+    llist_ptr_t head_ptr, tail_ptr;
 
     MPI_Init(&argc, &argv);
 
@@ -105,15 +108,16 @@ int main(int argc, char **argv) {
         new_elem_ptr.disp = alloc_elem(procid, llist_win);
 
         /* Append the new node to the list.  This might take multiple attempts if
-           others have already appended and our tail pointer is stale. */
+         * others have already appended and our tail pointer is stale. */
         do {
             llist_ptr_t next_tail_ptr = nil;
 
             MPI_Win_lock(MPI_LOCK_EXCLUSIVE, tail_ptr.rank, 0, llist_win);
 
-            MPI_Compare_and_swap((void*) &new_elem_ptr.rank, (void*) &nil.rank,
-                                  (void*) &next_tail_ptr.rank, MPI_INT, tail_ptr.rank,
-                                  (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.rank), llist_win);
+            MPI_Compare_and_swap((void *) &new_elem_ptr.rank, (void *) &nil.rank,
+                                 (void *) &next_tail_ptr.rank, MPI_INT, tail_ptr.rank,
+                                 (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next.rank),
+                                 llist_win);
 
             MPI_Win_unlock(tail_ptr.rank, llist_win);
             success = (next_tail_ptr.rank == nil.rank);
@@ -124,26 +128,28 @@ int main(int argc, char **argv) {
                 MPI_Win_lock(MPI_LOCK_EXCLUSIVE, tail_ptr.rank, 0, llist_win);
 
                 MPI_Put(&new_elem_ptr.disp, 1, MPI_AINT, tail_ptr.rank,
-                        (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.disp), 1,
+                        (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next.disp), 1,
                         MPI_AINT, llist_win);
 
                 MPI_Win_unlock(tail_ptr.rank, llist_win);
                 tail_ptr = new_elem_ptr;
 
                 /* For implementations that use pt-to-pt messaging, force progress for other threads'
-                   RMA operations. */
+                 * RMA operations. */
                 for (i = 0; i < NPROBE; i++)
-                    MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
+                    MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag,
+                               MPI_STATUS_IGNORE);
 
-            } else {
+            }
+            else {
                 /* Tail pointer is stale, fetch the displacement.  May take multiple tries
-                   if it is being updated. */
+                 * if it is being updated. */
                 do {
                     MPI_Win_lock(MPI_LOCK_EXCLUSIVE, tail_ptr.rank, 0, llist_win);
 
-                    MPI_Get( &next_tail_ptr.disp, 1, MPI_AINT, tail_ptr.rank,
-                             (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.disp),
-                             1, MPI_AINT, llist_win);
+                    MPI_Get(&next_tail_ptr.disp, 1, MPI_AINT, tail_ptr.rank,
+                            (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next.disp),
+                            1, MPI_AINT, llist_win);
 
                     MPI_Win_unlock(tail_ptr.rank, llist_win);
                 } while (next_tail_ptr.disp == nil.disp);
@@ -155,13 +161,13 @@ int main(int argc, char **argv) {
     MPI_Barrier(MPI_COMM_WORLD);
 
     /* Traverse the list and verify that all processes inserted exactly the correct
-       number of elements. */
+     * number of elements. */
     if (procid == 0) {
-        int  have_root = 0;
-        int  errors    = 0;
+        int have_root = 0;
+        int errors = 0;
         int *counts, count = 0;
 
-        counts = (int*) malloc(sizeof(int) * nproc);
+        counts = (int *) malloc(sizeof(int) * nproc);
         assert(counts != NULL);
 
         for (i = 0; i < nproc; i++)
@@ -204,14 +210,15 @@ int main(int argc, char **argv) {
         }
 
         if (verbose)
-          printf("\n\n");
+            printf("\n\n");
 
         /* Verify the counts we collected */
         for (i = 0; i < nproc; i++) {
             int expected = NUM_ELEMS;
 
             if (counts[i] != expected) {
-                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i], expected);
+                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i],
+                       expected);
                 errors++;
             }
         }
@@ -223,8 +230,8 @@ int main(int argc, char **argv) {
     MPI_Win_free(&llist_win);
 
     /* Free all the elements in the list */
-    for ( ; my_elems_count > 0; my_elems_count--)
-        MPI_Free_mem(my_elems[my_elems_count-1]);
+    for (; my_elems_count > 0; my_elems_count--)
+        MPI_Free_mem(my_elems[my_elems_count - 1]);
 
     MPI_Finalize();
     return 0;
index 304ac47..5e0dfa4 100644 (file)
@@ -19,7 +19,7 @@
 #include <assert.h>
 #include "mpitest.h"
 
-#if HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
@@ -33,7 +33,7 @@
 
 /* Linked list pointer */
 typedef struct {
-    int      rank;
+    int rank;
     MPI_Aint disp;
 } llist_ptr_t;
 
@@ -44,29 +44,31 @@ typedef struct {
 } llist_elem_t;
 
 static const llist_ptr_t nil = { -1, (MPI_Aint) MPI_BOTTOM };
+
 static const int verbose = 0;
 static const int print_perf = 0;
 
 /* List of locally allocated list elements. */
 static llist_elem_t **my_elems = NULL;
-static int my_elems_size  = 0;
+static int my_elems_size = 0;
 static int my_elems_count = 0;
 
 /* Allocate a new shared linked list element */
-MPI_Aint alloc_elem(int value, MPI_Win win) {
+MPI_Aint alloc_elem(int value, MPI_Win win)
+{
     MPI_Aint disp;
     llist_elem_t *elem_ptr;
 
     /* Allocate the new element and register it with the window */
     MPI_Alloc_mem(sizeof(llist_elem_t), MPI_INFO_NULL, &elem_ptr);
     elem_ptr->value = value;
-    elem_ptr->next  = nil;
+    elem_ptr->next = nil;
     MPI_Win_attach(win, elem_ptr, sizeof(llist_elem_t));
 
     /* Add the element to the list of local elements so we can free it later. */
     if (my_elems_size == my_elems_count) {
         my_elems_size += 100;
-        my_elems = realloc(my_elems, my_elems_size*sizeof(void*));
+        my_elems = realloc(my_elems, my_elems_size * sizeof(void *));
     }
     my_elems[my_elems_count] = elem_ptr;
     my_elems_count++;
@@ -75,12 +77,13 @@ MPI_Aint alloc_elem(int value, MPI_Win win) {
     return disp;
 }
 
-int main(int argc, char **argv) {
-    int           procid, nproc, i, j, my_nelem;
-    int           pollint = 0;
-    double        time;
-    MPI_Win       llist_win;
-    llist_ptr_t   head_ptr, tail_ptr;
+int main(int argc, char **argv)
+{
+    int procid, nproc, i, j, my_nelem;
+    int pollint = 0;
+    double time;
+    MPI_Win llist_win;
+    llist_ptr_t head_ptr, tail_ptr;
 
     MPI_Init(&argc, &argv);
 
@@ -105,7 +108,7 @@ int main(int argc, char **argv) {
     else
         i = 0;
 
-    my_nelem = NUM_ELEMS/nproc;
+    my_nelem = NUM_ELEMS / nproc;
     if (procid < NUM_ELEMS % nproc)
         my_nelem++;
 
@@ -115,31 +118,33 @@ int main(int argc, char **argv) {
     /* Lock the window for shared access to all targets */
     MPI_Win_lock_all(0, llist_win);
 
-    for ( ; i < my_nelem; i++) {
+    for (; i < my_nelem; i++) {
         llist_ptr_t new_elem_ptr;
         int success = 0;
 
+        MTEST_VG_MEM_INIT(&new_elem_ptr, sizeof(llist_ptr_t));
+
         /* Create a new list element and register it with the window */
         new_elem_ptr.rank = procid;
         new_elem_ptr.disp = alloc_elem(procid, llist_win);
 
         /* Append the new node to the list.  This might take multiple attempts if
-           others have already appended and our tail pointer is stale. */
+         * others have already appended and our tail pointer is stale. */
         do {
             int flag;
 
             /* The tail is at my left neighbor, append my element. */
-            if (tail_ptr.rank == (procid + nproc-1) % nproc)
-            {
+            if (tail_ptr.rank == (procid + nproc - 1) % nproc) {
                 if (verbose)
-                    printf("%d: Appending to <%d, %p>\n", procid, tail_ptr.rank, (void*) tail_ptr.disp);
+                    printf("%d: Appending to <%d, %p>\n", procid, tail_ptr.rank,
+                           (void *) tail_ptr.disp);
 #if 1
                 MPI_Accumulate(&new_elem_ptr, sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
-                               (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next), sizeof(llist_ptr_t),
-                               MPI_BYTE, MPI_REPLACE, llist_win);
+                               (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next),
+                               sizeof(llist_ptr_t), MPI_BYTE, MPI_REPLACE, llist_win);
 #else
                 MPI_Put(&new_elem_ptr, sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
-                        (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next), sizeof(llist_ptr_t),
+                        (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next), sizeof(llist_ptr_t),
                         MPI_BYTE, llist_win);
 #endif
                 MPI_Win_flush(tail_ptr.rank, llist_win);
@@ -149,28 +154,29 @@ int main(int argc, char **argv) {
             }
 
             /* Otherwise, chase the tail. */
-            else
-            {
+            else {
                 llist_ptr_t next_tail_ptr;
 
-                MPI_Get_accumulate( NULL, 0, MPI_DATATYPE_NULL, &next_tail_ptr,
-                                    sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
-                                    (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next),
-                                    sizeof(llist_ptr_t), MPI_BYTE, MPI_NO_OP, llist_win);
+                MPI_Get_accumulate(NULL, 0, MPI_DATATYPE_NULL, &next_tail_ptr,
+                                   sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
+                                   (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next),
+                                   sizeof(llist_ptr_t), MPI_BYTE, MPI_NO_OP, llist_win);
 
                 MPI_Win_flush(tail_ptr.rank, llist_win);
 
                 if (next_tail_ptr.rank != nil.rank) {
                     if (verbose)
-                        printf("%d: Chasing to <%d, %p>\n", procid, next_tail_ptr.rank, (void*) next_tail_ptr.disp);
+                        printf("%d: Chasing to <%d, %p>\n", procid, next_tail_ptr.rank,
+                               (void *) next_tail_ptr.disp);
                     tail_ptr = next_tail_ptr;
-                    pollint = MAX(MIN_NPROBE, pollint/2);
+                    pollint = MAX(MIN_NPROBE, pollint / 2);
                 }
                 else {
                     for (j = 0; j < pollint; j++)
-                        MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
+                        MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag,
+                                   MPI_STATUS_IGNORE);
 
-                    pollint = MIN(MAX_NPROBE, pollint*2);
+                    pollint = MIN(MAX_NPROBE, pollint * 2);
                 }
             }
         } while (!success);
@@ -181,12 +187,12 @@ int main(int argc, char **argv) {
     time = MPI_Wtime() - time;
 
     /* Traverse the list and verify that all processes inserted exactly the correct
-       number of elements. */
+     * number of elements. */
     if (procid == 0) {
-        int  errors    = 0;
+        int errors = 0;
         int *counts, count = 0;
 
-        counts = (int*) malloc(sizeof(int) * nproc);
+        counts = (int *) malloc(sizeof(int) * nproc);
         assert(counts != NULL);
 
         for (i = 0; i < nproc; i++)
@@ -222,18 +228,19 @@ int main(int argc, char **argv) {
         MPI_Win_unlock_all(llist_win);
 
         if (verbose)
-          printf("\n\n");
+            printf("\n\n");
 
         /* Verify the counts we collected */
         for (i = 0; i < nproc; i++) {
             int expected;
 
-            expected = NUM_ELEMS/nproc;
+            expected = NUM_ELEMS / nproc;
             if (i < NUM_ELEMS % nproc)
                 expected++;
 
             if (counts[i] != expected) {
-                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i], expected);
+                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i],
+                       expected);
                 errors++;
             }
         }
@@ -248,15 +255,16 @@ int main(int argc, char **argv) {
         MPI_Reduce(&time, &max_time, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
 
         if (procid == 0) {
-            printf("Total time = %0.2f sec, elem/sec = %0.2f, sec/elem = %0.2f usec\n", max_time, NUM_ELEMS/max_time, max_time/NUM_ELEMS*1.0e6);
+            printf("Total time = %0.2f sec, elem/sec = %0.2f, sec/elem = %0.2f usec\n", max_time,
+                   NUM_ELEMS / max_time, max_time / NUM_ELEMS * 1.0e6);
         }
     }
 
     MPI_Win_free(&llist_win);
 
     /* Free all the elements in the list */
-    for ( ; my_elems_count > 0; my_elems_count--)
-        MPI_Free_mem(my_elems[my_elems_count-1]);
+    for (; my_elems_count > 0; my_elems_count--)
+        MPI_Free_mem(my_elems[my_elems_count - 1]);
 
     MPI_Finalize();
     return 0;
index 288be5d..c52208e 100644 (file)
@@ -19,7 +19,7 @@
 #include <assert.h>
 #include "mpitest.h"
 
-#if HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
@@ -33,7 +33,7 @@
 
 /* Linked list pointer */
 typedef struct {
-    int      rank;
+    int rank;
     MPI_Aint disp;
 } llist_ptr_t;
 
@@ -44,29 +44,31 @@ typedef struct {
 } llist_elem_t;
 
 static const llist_ptr_t nil = { -1, (MPI_Aint) MPI_BOTTOM };
+
 static const int verbose = 0;
 static const int print_perf = 0;
 
 /* List of locally allocated list elements. */
 static llist_elem_t **my_elems = NULL;
-static int my_elems_size  = 0;
+static int my_elems_size = 0;
 static int my_elems_count = 0;
 
 /* Allocate a new shared linked list element */
-MPI_Aint alloc_elem(int value, MPI_Win win) {
+MPI_Aint alloc_elem(int value, MPI_Win win)
+{
     MPI_Aint disp;
     llist_elem_t *elem_ptr;
 
     /* Allocate the new element and register it with the window */
     MPI_Alloc_mem(sizeof(llist_elem_t), MPI_INFO_NULL, &elem_ptr);
     elem_ptr->value = value;
-    elem_ptr->next  = nil;
+    elem_ptr->next = nil;
     MPI_Win_attach(win, elem_ptr, sizeof(llist_elem_t));
 
     /* Add the element to the list of local elements so we can free it later. */
     if (my_elems_size == my_elems_count) {
         my_elems_size += 100;
-        my_elems = realloc(my_elems, my_elems_size*sizeof(void*));
+        my_elems = realloc(my_elems, my_elems_size * sizeof(void *));
     }
     my_elems[my_elems_count] = elem_ptr;
     my_elems_count++;
@@ -75,12 +77,13 @@ MPI_Aint alloc_elem(int value, MPI_Win win) {
     return disp;
 }
 
-int main(int argc, char **argv) {
-    int           procid, nproc, i, j, my_nelem;
-    int           pollint = 0;
-    double        time;
-    MPI_Win       llist_win;
-    llist_ptr_t   head_ptr, tail_ptr;
+int main(int argc, char **argv)
+{
+    int procid, nproc, i, j, my_nelem;
+    int pollint = 0;
+    double time;
+    MPI_Win llist_win;
+    llist_ptr_t head_ptr, tail_ptr;
 
     MPI_Init(&argc, &argv);
 
@@ -104,40 +107,42 @@ int main(int argc, char **argv) {
         i = 1;
     else
         i = 0;
-    my_nelem = NUM_ELEMS/nproc;
+    my_nelem = NUM_ELEMS / nproc;
     if (procid < NUM_ELEMS % nproc)
         my_nelem++;
 
     MPI_Barrier(MPI_COMM_WORLD);
     time = MPI_Wtime();
 
-    for ( ; i < my_nelem; i++) {
+    for (; i < my_nelem; i++) {
         llist_ptr_t new_elem_ptr;
         int success = 0;
 
+        MTEST_VG_MEM_INIT(&new_elem_ptr, sizeof(llist_ptr_t));
+
         /* Create a new list element and register it with the window */
         new_elem_ptr.rank = procid;
         new_elem_ptr.disp = alloc_elem(procid, llist_win);
 
         /* Append the new node to the list.  This might take multiple attempts if
-           others have already appended and our tail pointer is stale. */
+         * others have already appended and our tail pointer is stale. */
         do {
             int flag;
 
             /* The tail is at my left neighbor, append my element. */
-            if (tail_ptr.rank == (procid + nproc-1) % nproc)
-            {
+            if (tail_ptr.rank == (procid + nproc - 1) % nproc) {
                 if (verbose)
-                    printf("%d: Appending to <%d, %p>\n", procid, tail_ptr.rank, (void*) tail_ptr.disp);
+                    printf("%d: Appending to <%d, %p>\n", procid, tail_ptr.rank,
+                           (void *) tail_ptr.disp);
 
                 MPI_Win_lock(MPI_LOCK_EXCLUSIVE, tail_ptr.rank, 0, llist_win);
 #if USE_ACC
                 MPI_Accumulate(&new_elem_ptr, sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
-                               (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next), sizeof(llist_ptr_t),
-                               MPI_BYTE, MPI_REPLACE, llist_win);
+                               (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next),
+                               sizeof(llist_ptr_t), MPI_BYTE, MPI_REPLACE, llist_win);
 #else
                 MPI_Put(&new_elem_ptr, sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
-                        (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next), sizeof(llist_ptr_t),
+                        (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next), sizeof(llist_ptr_t),
                         MPI_BYTE, llist_win);
 #endif
                 MPI_Win_unlock(tail_ptr.rank, llist_win);
@@ -147,34 +152,35 @@ int main(int argc, char **argv) {
             }
 
             /* Otherwise, chase the tail. */
-            else
-            {
+            else {
                 llist_ptr_t next_tail_ptr;
 
                 MPI_Win_lock(MPI_LOCK_EXCLUSIVE, tail_ptr.rank, 0, llist_win);
 #if USE_ACC
-                MPI_Get_accumulate( NULL, 0, MPI_DATATYPE_NULL, &next_tail_ptr,
-                                    sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
-                                    (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next),
-                                    sizeof(llist_ptr_t), MPI_BYTE, MPI_NO_OP, llist_win);
+                MPI_Get_accumulate(NULL, 0, MPI_DATATYPE_NULL, &next_tail_ptr,
+                                   sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
+                                   (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next),
+                                   sizeof(llist_ptr_t), MPI_BYTE, MPI_NO_OP, llist_win);
 #else
                 MPI_Get(&next_tail_ptr, sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
-                        (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next),
+                        (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next),
                         sizeof(llist_ptr_t), MPI_BYTE, llist_win);
 #endif
                 MPI_Win_unlock(tail_ptr.rank, llist_win);
 
                 if (next_tail_ptr.rank != nil.rank) {
                     if (verbose)
-                        printf("%d: Chasing to <%d, %p>\n", procid, next_tail_ptr.rank, (void*) next_tail_ptr.disp);
+                        printf("%d: Chasing to <%d, %p>\n", procid, next_tail_ptr.rank,
+                               (void *) next_tail_ptr.disp);
                     tail_ptr = next_tail_ptr;
-                    pollint = MAX(MIN_NPROBE, pollint/2);
+                    pollint = MAX(MIN_NPROBE, pollint / 2);
                 }
                 else {
                     for (j = 0; j < pollint; j++)
-                        MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
+                        MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag,
+                                   MPI_STATUS_IGNORE);
 
-                    pollint = MIN(MAX_NPROBE, pollint*2);
+                    pollint = MIN(MAX_NPROBE, pollint * 2);
                 }
             }
         } while (!success);
@@ -184,12 +190,12 @@ int main(int argc, char **argv) {
     time = MPI_Wtime() - time;
 
     /* Traverse the list and verify that all processes inserted exactly the correct
-       number of elements. */
+     * number of elements. */
     if (procid == 0) {
-        int  errors    = 0;
+        int errors = 0;
         int *counts, count = 0;
 
-        counts = (int*) malloc(sizeof(int) * nproc);
+        counts = (int *) malloc(sizeof(int) * nproc);
         assert(counts != NULL);
 
         for (i = 0; i < nproc; i++)
@@ -225,18 +231,19 @@ int main(int argc, char **argv) {
         MPI_Win_unlock_all(llist_win);
 
         if (verbose)
-          printf("\n\n");
+            printf("\n\n");
 
         /* Verify the counts we collected */
         for (i = 0; i < nproc; i++) {
             int expected;
 
-            expected = NUM_ELEMS/nproc;
+            expected = NUM_ELEMS / nproc;
             if (i < NUM_ELEMS % nproc)
                 expected++;
 
             if (counts[i] != expected) {
-                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i], expected);
+                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i],
+                       expected);
                 errors++;
             }
         }
@@ -251,15 +258,16 @@ int main(int argc, char **argv) {
         MPI_Reduce(&time, &max_time, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
 
         if (procid == 0) {
-            printf("Total time = %0.2f sec, elem/sec = %0.2f, sec/elem = %0.2f usec\n", max_time, NUM_ELEMS/max_time, max_time/NUM_ELEMS*1.0e6);
+            printf("Total time = %0.2f sec, elem/sec = %0.2f, sec/elem = %0.2f usec\n", max_time,
+                   NUM_ELEMS / max_time, max_time / NUM_ELEMS * 1.0e6);
         }
     }
 
     MPI_Win_free(&llist_win);
 
     /* Free all the elements in the list */
-    for ( ; my_elems_count > 0; my_elems_count--)
-        MPI_Free_mem(my_elems[my_elems_count-1]);
+    for (; my_elems_count > 0; my_elems_count--)
+        MPI_Free_mem(my_elems[my_elems_count - 1]);
 
     MPI_Finalize();
     return 0;
index 662cbc8..9577b16 100644 (file)
@@ -19,7 +19,7 @@
 #include <assert.h>
 #include "mpitest.h"
 
-#if HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
@@ -33,7 +33,7 @@
 
 /* Linked list pointer */
 typedef struct {
-    int      rank;
+    int rank;
     MPI_Aint disp;
 } llist_ptr_t;
 
@@ -44,29 +44,31 @@ typedef struct {
 } llist_elem_t;
 
 static const llist_ptr_t nil = { -1, (MPI_Aint) MPI_BOTTOM };
+
 static const int verbose = 0;
 static const int print_perf = 0;
 
 /* List of locally allocated list elements. */
 static llist_elem_t **my_elems = NULL;
-static int my_elems_size  = 0;
+static int my_elems_size = 0;
 static int my_elems_count = 0;
 
 /* Allocate a new shared linked list element */
-MPI_Aint alloc_elem(int value, MPI_Win win) {
+MPI_Aint alloc_elem(int value, MPI_Win win)
+{
     MPI_Aint disp;
     llist_elem_t *elem_ptr;
 
     /* Allocate the new element and register it with the window */
     MPI_Alloc_mem(sizeof(llist_elem_t), MPI_INFO_NULL, &elem_ptr);
     elem_ptr->value = value;
-    elem_ptr->next  = nil;
+    elem_ptr->next = nil;
     MPI_Win_attach(win, elem_ptr, sizeof(llist_elem_t));
 
     /* Add the element to the list of local elements so we can free it later. */
     if (my_elems_size == my_elems_count) {
         my_elems_size += 100;
-        my_elems = realloc(my_elems, my_elems_size*sizeof(void*));
+        my_elems = realloc(my_elems, my_elems_size * sizeof(void *));
     }
     my_elems[my_elems_count] = elem_ptr;
     my_elems_count++;
@@ -75,12 +77,13 @@ MPI_Aint alloc_elem(int value, MPI_Win win) {
     return disp;
 }
 
-int main(int argc, char **argv) {
-    int           procid, nproc, i, j, my_nelem;
-    int           pollint = 0;
-    double        time;
-    MPI_Win       llist_win;
-    llist_ptr_t   head_ptr, tail_ptr;
+int main(int argc, char **argv)
+{
+    int procid, nproc, i, j, my_nelem;
+    int pollint = 0;
+    double time;
+    MPI_Win llist_win;
+    llist_ptr_t head_ptr, tail_ptr;
 
     MPI_Init(&argc, &argv);
 
@@ -105,31 +108,33 @@ int main(int argc, char **argv) {
     else
         i = 0;
 
-    my_nelem = NUM_ELEMS/nproc;
+    my_nelem = NUM_ELEMS / nproc;
     if (procid < NUM_ELEMS % nproc)
         my_nelem++;
 
     MPI_Barrier(MPI_COMM_WORLD);
     time = MPI_Wtime();
 
-    for ( ; i < my_nelem; i++) {
+    for (; i < my_nelem; i++) {
         llist_ptr_t new_elem_ptr;
         int success = 0;
 
+        MTEST_VG_MEM_INIT(&new_elem_ptr, sizeof(llist_ptr_t));
+
         /* Create a new list element and register it with the window */
         new_elem_ptr.rank = procid;
         new_elem_ptr.disp = alloc_elem(procid, llist_win);
 
         /* Append the new node to the list.  This might take multiple attempts if
-           others have already appended and our tail pointer is stale. */
+         * others have already appended and our tail pointer is stale. */
         do {
             int flag;
 
             /* The tail is at my left neighbor, append my element. */
-            if (tail_ptr.rank == (procid + nproc-1) % nproc)
-            {
+            if (tail_ptr.rank == (procid + nproc - 1) % nproc) {
                 if (verbose)
-                    printf("%d: Appending to <%d, %p>\n", procid, tail_ptr.rank, (void*) tail_ptr.disp);
+                    printf("%d: Appending to <%d, %p>\n", procid, tail_ptr.rank,
+                           (void *) tail_ptr.disp);
 
 #ifdef USE_MODE_NOCHECK
                 MPI_Win_lock(MPI_LOCK_SHARED, tail_ptr.rank, MPI_MODE_NOCHECK, llist_win);
@@ -137,8 +142,8 @@ int main(int argc, char **argv) {
                 MPI_Win_lock(MPI_LOCK_SHARED, tail_ptr.rank, 0, llist_win);
 #endif
                 MPI_Accumulate(&new_elem_ptr, sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
-                               (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next), sizeof(llist_ptr_t),
-                               MPI_BYTE, MPI_REPLACE, llist_win);
+                               (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next),
+                               sizeof(llist_ptr_t), MPI_BYTE, MPI_REPLACE, llist_win);
                 MPI_Win_unlock(tail_ptr.rank, llist_win);
 
                 success = 1;
@@ -146,8 +151,7 @@ int main(int argc, char **argv) {
             }
 
             /* Otherwise, chase the tail. */
-            else
-            {
+            else {
                 llist_ptr_t next_tail_ptr;
 
 #ifdef USE_MODE_NOCHECK
@@ -155,23 +159,25 @@ int main(int argc, char **argv) {
 #else
                 MPI_Win_lock(MPI_LOCK_SHARED, tail_ptr.rank, 0, llist_win);
 #endif
-                MPI_Get_accumulate( NULL, 0, MPI_DATATYPE_NULL, &next_tail_ptr,
-                                    sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
-                                    (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next),
-                                    sizeof(llist_ptr_t), MPI_BYTE, MPI_NO_OP, llist_win);
+                MPI_Get_accumulate(NULL, 0, MPI_DATATYPE_NULL, &next_tail_ptr,
+                                   sizeof(llist_ptr_t), MPI_BYTE, tail_ptr.rank,
+                                   (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next),
+                                   sizeof(llist_ptr_t), MPI_BYTE, MPI_NO_OP, llist_win);
                 MPI_Win_unlock(tail_ptr.rank, llist_win);
 
                 if (next_tail_ptr.rank != nil.rank) {
                     if (verbose)
-                        printf("%d: Chasing to <%d, %p>\n", procid, next_tail_ptr.rank, (void*) next_tail_ptr.disp);
+                        printf("%d: Chasing to <%d, %p>\n", procid, next_tail_ptr.rank,
+                               (void *) next_tail_ptr.disp);
                     tail_ptr = next_tail_ptr;
-                    pollint = MAX(MIN_NPROBE, pollint/2);
+                    pollint = MAX(MIN_NPROBE, pollint / 2);
                 }
                 else {
                     for (j = 0; j < pollint; j++)
-                        MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
+                        MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag,
+                                   MPI_STATUS_IGNORE);
 
-                    pollint = MIN(MAX_NPROBE, pollint*2);
+                    pollint = MIN(MAX_NPROBE, pollint * 2);
                 }
             }
         } while (!success);
@@ -181,12 +187,12 @@ int main(int argc, char **argv) {
     time = MPI_Wtime() - time;
 
     /* Traverse the list and verify that all processes inserted exactly the correct
-       number of elements. */
+     * number of elements. */
     if (procid == 0) {
-        int  errors    = 0;
+        int errors = 0;
         int *counts, count = 0;
 
-        counts = (int*) malloc(sizeof(int) * nproc);
+        counts = (int *) malloc(sizeof(int) * nproc);
         assert(counts != NULL);
 
         for (i = 0; i < nproc; i++)
@@ -222,18 +228,19 @@ int main(int argc, char **argv) {
         MPI_Win_unlock_all(llist_win);
 
         if (verbose)
-          printf("\n\n");
+            printf("\n\n");
 
         /* Verify the counts we collected */
         for (i = 0; i < nproc; i++) {
             int expected;
 
-            expected = NUM_ELEMS/nproc;
+            expected = NUM_ELEMS / nproc;
             if (i < NUM_ELEMS % nproc)
                 expected++;
 
             if (counts[i] != expected) {
-                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i], expected);
+                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i],
+                       expected);
                 errors++;
             }
         }
@@ -248,15 +255,16 @@ int main(int argc, char **argv) {
         MPI_Reduce(&time, &max_time, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
 
         if (procid == 0) {
-            printf("Total time = %0.2f sec, elem/sec = %0.2f, sec/elem = %0.2f usec\n", max_time, NUM_ELEMS/max_time, max_time/NUM_ELEMS*1.0e6);
+            printf("Total time = %0.2f sec, elem/sec = %0.2f, sec/elem = %0.2f usec\n", max_time,
+                   NUM_ELEMS / max_time, max_time / NUM_ELEMS * 1.0e6);
         }
     }
 
     MPI_Win_free(&llist_win);
 
     /* Free all the elements in the list */
-    for ( ; my_elems_count > 0; my_elems_count--)
-        MPI_Free_mem(my_elems[my_elems_count-1]);
+    for (; my_elems_count > 0; my_elems_count--)
+        MPI_Free_mem(my_elems[my_elems_count - 1]);
 
     MPI_Finalize();
     return 0;
index 82a3ec2..61b7618 100644 (file)
@@ -7,7 +7,7 @@
 
 /*            MPI-3 distributed linked list construction example
  *            --------------------------------------------------
- * 
+ *
  * Construct a distributed shared linked list using proposed MPI-3 dynamic
  * windows.  Initially process 0 creates the head of the list, attaches it to
  * the window, and broadcasts the pointer to all processes.  All processes then
@@ -23,7 +23,7 @@
 #include <assert.h>
 #include "mpitest.h"
 
-#if HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
@@ -33,7 +33,7 @@
 
 /* Linked list pointer */
 typedef struct {
-    int      rank;
+    int rank;
     MPI_Aint disp;
 } llist_ptr_t;
 
@@ -44,28 +44,30 @@ typedef struct {
 } llist_elem_t;
 
 static const llist_ptr_t nil = { -1, (MPI_Aint) MPI_BOTTOM };
+
 static const int verbose = 0;
 
 /* List of locally allocated list elements. */
 static llist_elem_t **my_elems = NULL;
-static int my_elems_size  = 0;
+static int my_elems_size = 0;
 static int my_elems_count = 0;
 
 /* Allocate a new shared linked list element */
-MPI_Aint alloc_elem(int value, MPI_Win win) {
+MPI_Aint alloc_elem(int value, MPI_Win win)
+{
     MPI_Aint disp;
     llist_elem_t *elem_ptr;
 
     /* Allocate the new element and register it with the window */
     MPI_Alloc_mem(sizeof(llist_elem_t), MPI_INFO_NULL, &elem_ptr);
     elem_ptr->value = value;
-    elem_ptr->next  = nil;
+    elem_ptr->next = nil;
     MPI_Win_attach(win, elem_ptr, sizeof(llist_elem_t));
 
     /* Add the element to the list of local elements so we can free it later. */
     if (my_elems_size == my_elems_count) {
         my_elems_size += 100;
-        my_elems = realloc(my_elems, my_elems_size*sizeof(void*));
+        my_elems = realloc(my_elems, my_elems_size * sizeof(void *));
     }
     my_elems[my_elems_count] = elem_ptr;
     my_elems_count++;
@@ -74,10 +76,11 @@ MPI_Aint alloc_elem(int value, MPI_Win win) {
     return disp;
 }
 
-int main(int argc, char **argv) {
-    int           procid, nproc, i;
-    MPI_Win       llist_win;
-    llist_ptr_t   head_ptr, tail_ptr;
+int main(int argc, char **argv)
+{
+    int procid, nproc, i;
+    MPI_Win llist_win;
+    llist_ptr_t head_ptr, tail_ptr;
 
     MPI_Init(&argc, &argv);
 
@@ -105,15 +108,16 @@ int main(int argc, char **argv) {
         new_elem_ptr.disp = alloc_elem(procid, llist_win);
 
         /* Append the new node to the list.  This might take multiple attempts if
-           others have already appended and our tail pointer is stale. */
+         * others have already appended and our tail pointer is stale. */
         do {
             llist_ptr_t next_tail_ptr = nil;
 
             MPI_Win_lock(MPI_LOCK_SHARED, tail_ptr.rank, MPI_MODE_NOCHECK, llist_win);
 
-            MPI_Compare_and_swap((void*) &new_elem_ptr.rank, (void*) &nil.rank,
-                                  (void*) &next_tail_ptr.rank, MPI_INT, tail_ptr.rank,
-                                  (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.rank), llist_win);
+            MPI_Compare_and_swap((void *) &new_elem_ptr.rank, (void *) &nil.rank,
+                                 (void *) &next_tail_ptr.rank, MPI_INT, tail_ptr.rank,
+                                 (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next.rank),
+                                 llist_win);
 
             MPI_Win_unlock(tail_ptr.rank, llist_win);
             success = (next_tail_ptr.rank == nil.rank);
@@ -125,36 +129,36 @@ int main(int argc, char **argv) {
                 MPI_Win_lock(MPI_LOCK_SHARED, tail_ptr.rank, MPI_MODE_NOCHECK, llist_win);
 
                 MPI_Fetch_and_op(&new_elem_ptr.disp, &result, MPI_AINT, tail_ptr.rank,
-                                  (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.disp),
-                                  MPI_REPLACE, llist_win);
+                                 (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next.disp),
+                                 MPI_REPLACE, llist_win);
 
                 /* Note: accumulate is faster, since we don't need the result.  Replacing with
-                   Fetch_and_op to create a more complete test case. */
+                 * Fetch_and_op to create a more complete test case. */
                 /*
-                MPI_Accumulate(&new_elem_ptr.disp, 1, MPI_AINT, tail_ptr.rank,
-                               (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.disp), 1,
-                               MPI_AINT, MPI_REPLACE, llist_win);
-                */
+                 * MPI_Accumulate(&new_elem_ptr.disp, 1, MPI_AINT, tail_ptr.rank,
+                 * (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.disp), 1,
+                 * MPI_AINT, MPI_REPLACE, llist_win);
+                 */
 
                 MPI_Win_unlock(tail_ptr.rank, llist_win);
                 tail_ptr = new_elem_ptr;
 
                 /* For implementations that use pt-to-pt messaging, force progress for other threads'
-                   RMA operations. */
+                 * RMA operations. */
                 for (i = 0; i < NPROBE; i++)
-                    MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
+                    MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag,
+                               MPI_STATUS_IGNORE);
 
-            } else {
+            }
+            else {
                 /* Tail pointer is stale, fetch the displacement.  May take multiple tries
-                   if it is being updated. */
+                 * if it is being updated. */
                 do {
-                    MPI_Aint junk = 0;
-
                     MPI_Win_lock(MPI_LOCK_SHARED, tail_ptr.rank, MPI_MODE_NOCHECK, llist_win);
 
                     MPI_Fetch_and_op(NULL, &next_tail_ptr.disp, MPI_AINT, tail_ptr.rank,
-                                      (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.disp),
-                                      MPI_NO_OP, llist_win);
+                                     (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next.disp),
+                                     MPI_NO_OP, llist_win);
 
                     MPI_Win_unlock(tail_ptr.rank, llist_win);
                 } while (next_tail_ptr.disp == nil.disp);
@@ -166,13 +170,13 @@ int main(int argc, char **argv) {
     MPI_Barrier(MPI_COMM_WORLD);
 
     /* Traverse the list and verify that all processes inserted exactly the correct
-       number of elements. */
+     * number of elements. */
     if (procid == 0) {
-        int  have_root = 0;
-        int  errors    = 0;
+        int have_root = 0;
+        int errors = 0;
         int *counts, count = 0;
 
-        counts = (int*) malloc(sizeof(int) * nproc);
+        counts = (int *) malloc(sizeof(int) * nproc);
         assert(counts != NULL);
 
         for (i = 0; i < nproc; i++)
@@ -215,14 +219,15 @@ int main(int argc, char **argv) {
         }
 
         if (verbose)
-          printf("\n\n");
+            printf("\n\n");
 
         /* Verify the counts we collected */
         for (i = 0; i < nproc; i++) {
             int expected = NUM_ELEMS;
 
             if (counts[i] != expected) {
-                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i], expected);
+                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i],
+                       expected);
                 errors++;
             }
         }
@@ -234,8 +239,8 @@ int main(int argc, char **argv) {
     MPI_Win_free(&llist_win);
 
     /* Free all the elements in the list */
-    for ( ; my_elems_count > 0; my_elems_count--)
-        MPI_Free_mem(my_elems[my_elems_count-1]);
+    for (; my_elems_count > 0; my_elems_count--)
+        MPI_Free_mem(my_elems[my_elems_count - 1]);
 
     MPI_Finalize();
     return 0;
index 2690692..699623c 100644 (file)
@@ -23,7 +23,7 @@
 #include <assert.h>
 #include "mpitest.h"
 
-#if HAVE_UNISTD_H
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
@@ -33,7 +33,7 @@
 
 /* Linked list pointer */
 typedef struct {
-    int      rank;
+    int rank;
     MPI_Aint disp;
 } llist_ptr_t;
 
@@ -44,28 +44,30 @@ typedef struct {
 } llist_elem_t;
 
 static const llist_ptr_t nil = { -1, (MPI_Aint) MPI_BOTTOM };
+
 static const int verbose = 0;
 
 /* List of locally allocated list elements. */
 static llist_elem_t **my_elems = NULL;
-static int my_elems_size  = 0;
+static int my_elems_size = 0;
 static int my_elems_count = 0;
 
 /* Allocate a new shared linked list element */
-MPI_Aint alloc_elem(int value, MPI_Win win) {
+MPI_Aint alloc_elem(int value, MPI_Win win)
+{
     MPI_Aint disp;
     llist_elem_t *elem_ptr;
 
     /* Allocate the new element and register it with the window */
     MPI_Alloc_mem(sizeof(llist_elem_t), MPI_INFO_NULL, &elem_ptr);
     elem_ptr->value = value;
-    elem_ptr->next  = nil;
+    elem_ptr->next = nil;
     MPI_Win_attach(win, elem_ptr, sizeof(llist_elem_t));
 
     /* Add the element to the list of local elements so we can free it later. */
     if (my_elems_size == my_elems_count) {
         my_elems_size += 100;
-        my_elems = realloc(my_elems, my_elems_size*sizeof(void*));
+        my_elems = realloc(my_elems, my_elems_size * sizeof(void *));
     }
     my_elems[my_elems_count] = elem_ptr;
     my_elems_count++;
@@ -74,10 +76,11 @@ MPI_Aint alloc_elem(int value, MPI_Win win) {
     return disp;
 }
 
-int main(int argc, char **argv) {
-    int           procid, nproc, i;
-    MPI_Win       llist_win;
-    llist_ptr_t   head_ptr, tail_ptr;
+int main(int argc, char **argv)
+{
+    int procid, nproc, i;
+    MPI_Win llist_win;
+    llist_ptr_t head_ptr, tail_ptr;
 
     MPI_Init(&argc, &argv);
 
@@ -108,13 +111,14 @@ int main(int argc, char **argv) {
         new_elem_ptr.disp = alloc_elem(procid, llist_win);
 
         /* Append the new node to the list.  This might take multiple attempts if
-           others have already appended and our tail pointer is stale. */
+         * others have already appended and our tail pointer is stale. */
         do {
             llist_ptr_t next_tail_ptr = nil;
 
-            MPI_Compare_and_swap((void*) &new_elem_ptr.rank, (void*) &nil.rank,
-                                  (void*) &next_tail_ptr.rank, MPI_INT, tail_ptr.rank,
-                                  (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.rank), llist_win);
+            MPI_Compare_and_swap((void *) &new_elem_ptr.rank, (void *) &nil.rank,
+                                 (void *) &next_tail_ptr.rank, MPI_INT, tail_ptr.rank,
+                                 (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next.rank),
+                                 llist_win);
 
             MPI_Win_flush(tail_ptr.rank, llist_win);
             success = (next_tail_ptr.rank == nil.rank);
@@ -123,25 +127,27 @@ int main(int argc, char **argv) {
                 int i, flag;
 
                 MPI_Accumulate(&new_elem_ptr.disp, 1, MPI_AINT, tail_ptr.rank,
-                               (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.disp), 1,
+                               (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next.disp), 1,
                                MPI_AINT, MPI_REPLACE, llist_win);
 
                 MPI_Win_flush(tail_ptr.rank, llist_win);
                 tail_ptr = new_elem_ptr;
 
                 /* For implementations that use pt-to-pt messaging, force progress for other threads'
-                   RMA operations. */
+                 * RMA operations. */
                 for (i = 0; i < NPROBE; i++)
-                    MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
+                    MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag,
+                               MPI_STATUS_IGNORE);
 
-            } else {
+            }
+            else {
                 /* Tail pointer is stale, fetch the displacement.  May take multiple tries
-                   if it is being updated. */
+                 * if it is being updated. */
                 do {
-                    MPI_Get_accumulate( NULL, 0, MPI_DATATYPE_NULL, &next_tail_ptr.disp,
-                                        1, MPI_AINT, tail_ptr.rank,
-                                        (MPI_Aint) &(((llist_elem_t*)tail_ptr.disp)->next.disp),
-                                        1, MPI_AINT, MPI_NO_OP, llist_win);
+                    MPI_Get_accumulate(NULL, 0, MPI_DATATYPE_NULL, &next_tail_ptr.disp,
+                                       1, MPI_AINT, tail_ptr.rank,
+                                       (MPI_Aint) & (((llist_elem_t *) tail_ptr.disp)->next.disp),
+                                       1, MPI_AINT, MPI_NO_OP, llist_win);
                     MPI_Win_flush(tail_ptr.rank, llist_win);
                 } while (next_tail_ptr.disp == nil.disp);
                 tail_ptr = next_tail_ptr;
@@ -153,13 +159,13 @@ int main(int argc, char **argv) {
     MPI_Barrier(MPI_COMM_WORLD);
 
     /* Traverse the list and verify that all processes inserted exactly the correct
-       number of elements. */
+     * number of elements. */
     if (procid == 0) {
-        int  have_root = 0;
-        int  errors    = 0;
+        int have_root = 0;
+        int errors = 0;
         int *counts, count = 0;
 
-        counts = (int*) malloc(sizeof(int) * nproc);
+        counts = (int *) malloc(sizeof(int) * nproc);
         assert(counts != NULL);
 
         for (i = 0; i < nproc; i++)
@@ -204,14 +210,15 @@ int main(int argc, char **argv) {
         MPI_Win_unlock_all(llist_win);
 
         if (verbose)
-          printf("\n\n");
+            printf("\n\n");
 
         /* Verify the counts we collected */
         for (i = 0; i < nproc; i++) {
             int expected = NUM_ELEMS;
 
             if (counts[i] != expected) {
-                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i], expected);
+                printf("Error: Rank %d inserted %d elements, expected %d\n", i, counts[i],
+                       expected);
                 errors++;
             }
         }
@@ -223,8 +230,8 @@ int main(int argc, char **argv) {
     MPI_Win_free(&llist_win);
 
     /* Free all the elements in the list */
-    for ( ; my_elems_count > 0; my_elems_count--)
-        MPI_Free_mem(my_elems[my_elems_count-1]);
+    for (; my_elems_count > 0; my_elems_count--)
+        MPI_Free_mem(my_elems[my_elems_count - 1]);
 
     MPI_Finalize();
     return 0;
diff --git a/teshsuite/smpi/mpich3-test/rma/lock_contention_dt.c b/teshsuite/smpi/mpich3-test/rma/lock_contention_dt.c
new file mode 100644 (file)
index 0000000..394f799
--- /dev/null
@@ -0,0 +1,99 @@
+/* -*- 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 <stdio.h>
+#include <stdlib.h>
+#include "mpitest.h"
+
+/*
+static char MTEST_Descrip[] = "Test lock contention while streaming ACC-like operations";
+*/
+
+int main(int argc, char *argv[])
+{
+    int errs = 0;
+    int rank, size;
+    int target = 1;
+    int minsize = 2, count;
+    MPI_Comm comm;
+    MPI_Win win;
+    MPI_Aint lb, extent;
+    MTestDatatype sendtype, recvtype;
+
+    MTest_Init(&argc, &argv);
+
+    while (MTestGetIntracommGeneral(&comm, minsize, 1)) {
+    &