Index: test1_am.c
===================================================================
--- test1_am.c	(revision 9830)
+++ test1_am.c	(working copy)
@@ -15,8 +15,8 @@
 
 int main(int argc, char *argv[]) 
 { 
-/*    int rank, nprocs, A[SIZE], B[SIZE], i; */
     int rank, nprocs, i;
+    MPI_Comm CommDeuce;
     int *A, *B;
 
     MPI_Win win;
@@ -26,70 +26,78 @@
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &A);
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce);
     if (i) {
-        printf("Can't allocate memory in test program\n");
+        printf("Can't create a subcommunicator of two processes\n");
         MPI_Abort(MPI_COMM_WORLD, 1);
     }
-    i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &B);
-    if (i) {
-        printf("Can't allocate memory in test program\n");
-        MPI_Abort(MPI_COMM_WORLD, 1);
-    }
-    
-    if (rank == 0) {
-        for (i=0; i<SIZE; i++)
-            A[i] = B[i] = i;
-    }
-    else {
-        for (i=0; i<SIZE; i++) {
-            A[i] = (-3)*i;
-            B[i] = (-4)*i;
+
+    if (rank==0 || rank==1)
+    {
+        i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &A);
+        if (i) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
         }
-    }
+        i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &B);
+        if (i) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
+        
+        if (rank == 0) {
+            for (i=0; i<SIZE; i++)
+                A[i] = B[i] = i;
+        }
+        else {
+            for (i=0; i<SIZE; i++) {
+                A[i] = (-3)*i;
+                B[i] = (-4)*i;
+            }
+        }
 
-    MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                   MPI_COMM_WORLD, &win); 
+        MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win); 
 
-    MPI_Win_fence(0, win); 
+        MPI_Win_fence(0, win); 
+ 
+        if (rank == 0) {
+            for (i=0; i<SIZE-1; i++)
+                MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win);
+        }        
+        else {
+            for (i=0; i<SIZE-1; i++)
+                MPI_Get(A+i, 1, MPI_INT, 0, i, 1, MPI_INT, win);
+ 
+            MPI_Accumulate(A+i, 1, MPI_INT, 0, i, 1, MPI_INT, MPI_SUM, win);
+        }
+        MPI_Win_fence(0, win); 
+ 
+        if (rank == 1) {
+            for (i=0; i<SIZE-1; i++) {
+                if (A[i] != B[i]) {
+                    printf("Put/Get Error: A[i]=%d, B[i]=%d\n", A[i], B[i]);
+                    errs++;
+ 	       }
+            }
+        }
+        else {
+            if (B[SIZE-1] != SIZE - 1 - 3*(SIZE-1)) {
+                printf("Accumulate Error: B[SIZE-1] is %d, should be %d\n", B[SIZE-1], SIZE - 1 - 3*(SIZE-1));
+                errs++;
+            }
+ 	    }
+        MPI_Win_free(&win); 
 
-    if (rank == 0) {
-        for (i=0; i<SIZE-1; i++)
-            MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win);
-    }        
-    else {
-        for (i=0; i<SIZE-1; i++)
-            MPI_Get(A+i, 1, MPI_INT, 0, i, 1, MPI_INT, win);
-
-        MPI_Accumulate(A+i, 1, MPI_INT, 0, i, 1, MPI_INT, MPI_SUM, win);
+        MPI_Free_mem(A);
+        MPI_Free_mem(B);
     }
-    MPI_Win_fence(0, win); 
+    MPI_Comm_free(&CommDeuce);
 
-    if (rank == 1) {
-        for (i=0; i<SIZE-1; i++) {
-            if (A[i] != B[i]) {
-                printf("Put/Get Error: A[i]=%d, B[i]=%d\n", A[i], B[i]);
-                errs++;
-	    }
-        }
-    }
-    else {
-        if (B[SIZE-1] != SIZE - 1 - 3*(SIZE-1)) {
-            printf("Accumulate Error: B[SIZE-1] is %d, should be %d\n", B[SIZE-1], SIZE - 1 - 3*(SIZE-1));
-            errs++;
-	}
-    }
-
-    MPI_Win_free(&win); 
-
-    MPI_Free_mem(A);
-    MPI_Free_mem(B);
-
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: contig_displ.c
===================================================================
--- contig_displ.c	(revision 9830)
+++ contig_displ.c	(working copy)
@@ -20,71 +20,74 @@
 
 int main(int argc, char **argv)
 {
-    int nprocs, mpi_err, *array;
+    int rank, nprocs, mpi_err, *array;
     int getval, disp, errs=0;
     MPI_Win win;
     MPI_Datatype type;
     
     MTest_Init(&argc,&argv); 
 
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
 
-    if (nprocs != 1) {
-        printf("Run this program with 1 process\n");
+    if (nprocs < 1) {
+        printf("Run this program with 1 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    /* To improve reporting of problems about operations, we
-       change the error handler to errors return */
-    MPI_Comm_set_errhandler( MPI_COMM_WORLD, 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;
-    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;
-
-    /* create window object */
-    mpi_err = MPI_Win_create(array, 2*sizeof(int), sizeof(int), 
-                             MPI_INFO_NULL, MPI_COMM_WORLD, &win);
-    if (mpi_err != MPI_SUCCESS) goto err_return;
+    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 );
  
-    /* 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 );
-
-    mpi_err = MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, win);
-    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;
-
-    mpi_err = MPI_Win_unlock(0, win);
-    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]);
+        /* 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;
+        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;
+ 
+        /* 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;
+  
+        /* 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 );
+ 
+        mpi_err = MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, win);
+        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;
+ 
+        mpi_err = MPI_Win_unlock(0, win);
+        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);
     }
 
-    MPI_Free_mem(array);
-    MPI_Win_free(&win);
-    MPI_Type_free(&type);
-
     MTest_Finalize(errs);
     MPI_Finalize();
     return 0;
Index: test3_am.c
===================================================================
--- test3_am.c	(revision 9830)
+++ test3_am.c	(working copy)
@@ -22,85 +22,82 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, destrank, nprocs, *A, *B, i;
+    MPI_Comm CommDeuce;
     MPI_Group comm_group, group;
     MPI_Win win;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-/*    A = (int *) malloc(SIZE * sizeof(int));
-    if (!A) {
-        printf("Can't allocate memory in test program\n");
-        MPI_Abort(MPI_COMM_WORLD, 1);
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
+        MPI_Abort(MPI_COMM_WORLD,1);
     }
-    B = (int *) malloc(SIZE * sizeof(int));
-    if (!B) {
-        printf("Can't allocate memory in test program\n");
-        MPI_Abort(MPI_COMM_WORLD, 1);
-    }
-*/
-    
-    i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &A);
+
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
     if (i) {
-        printf("Can't allocate memory in test program\n");
+        printf("Can't create a subcommunicator of two processes\n");
         MPI_Abort(MPI_COMM_WORLD, 1);
     }
-    i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &B);
-    if (i) {
-        printf("Can't allocate memory in test program\n");
-        MPI_Abort(MPI_COMM_WORLD, 1);
-    }
-    
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
-        MPI_Abort(MPI_COMM_WORLD,1);
-    }
 
-    MPI_Comm_group(MPI_COMM_WORLD, &comm_group);
+    if (rank == 0 || rank == 1)
+    {
+        i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &A);
+        if (i) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
+        i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &B);
+        if (i) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
 
-    if (rank == 0) {
-        for (i=0; i<SIZE; i++) {
-            A[i] = i;
-            B[i] = SIZE + i;
+        MPI_Comm_group(CommDeuce, &comm_group);
+
+        if (rank == 0) {
+            for (i=0; i<SIZE; i++) {
+                A[i] = i;
+                B[i] = SIZE + i;
+            }
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 1;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_start(group, 0, win);
+            MPI_Put(A, SIZE, MPI_INT, 1, 0, SIZE, MPI_INT, win);
+            MPI_Win_complete(win);
+            MPI_Send(B, SIZE, MPI_INT, 1, 100, MPI_COMM_WORLD);
         }
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
-        destrank = 1;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_start(group, 0, win); 
-        MPI_Put(A, SIZE, MPI_INT, 1, 0, SIZE, MPI_INT, win); 
-        MPI_Win_complete(win); 
-        MPI_Send(B, SIZE, MPI_INT, 1, 100, MPI_COMM_WORLD); 
-    }
+        else if ( rank==1 ) {
+            for (i=0; i<SIZE; i++) A[i] = B[i] = (-4)*i;
+            MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 0;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_post(group, 0, win);
+            MPI_Recv(A, SIZE, MPI_INT, 0, 100, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+            MPI_Win_wait(win);
 
-    else {  /* rank=1 */
-        for (i=0; i<SIZE; i++) A[i] = B[i] = (-4)*i;
-        MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win);
-        destrank = 0;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_post(group, 0, win);
-        MPI_Recv(A, SIZE, MPI_INT, 0, 100, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-        MPI_Win_wait(win);
-        
-        for (i=0; i<SIZE; i++) {
-            if (B[i] != i) {
-                printf("Rank 1: Put Error: B[i] is %d, should be %d\n", B[i], i);
-                errs++;
+            for (i=0; i<SIZE; i++) {
+                if (B[i] != i) {
+                    printf("Rank 1: Put Error: B[i] is %d, should be %d\n", B[i], i);
+                    errs++;
+                }
+                if (A[i] != SIZE + i) {
+                    printf("Rank 1: Send/Recv Error: A[i] is %d, should be %d\n", A[i], SIZE+i);
+                    errs++;
+                }
             }
-            if (A[i] != SIZE + i) {
-                printf("Rank 1: Send/Recv Error: A[i] is %d, should be %d\n", A[i], SIZE+i);
-                errs++;
-            }
         }
-    }
 
-    MPI_Group_free(&group);
-    MPI_Group_free(&comm_group);
-    MPI_Win_free(&win); 
-    MPI_Free_mem(A);
-    MPI_Free_mem(B);
+        MPI_Group_free(&group);
+        MPI_Group_free(&comm_group);
+        MPI_Win_free(&win);
+        MPI_Free_mem(A);
+        MPI_Free_mem(B);
+    }
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: test5_am.c
===================================================================
--- test5_am.c	(revision 9830)
+++ test5_am.c	(working copy)
@@ -15,73 +15,81 @@
 
 int main(int argc, char *argv[]) 
 { 
-/*    int rank, nprocs, i, A[SIZE], B[SIZE]; */
     int rank, nprocs, i, *A, *B;
+    MPI_Comm CommDeuce;
     MPI_Win win;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD, &rank); 
-  
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &A);
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
     if (i) {
-        printf("Can't allocate memory in test program\n");
+        printf("Can't create a subcommunicator of two processes\n");
         MPI_Abort(MPI_COMM_WORLD, 1);
     }
-    i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &B);
-    if (i) {
-        printf("Can't allocate memory in test program\n");
-        MPI_Abort(MPI_COMM_WORLD, 1);
-    }
-    
-    if (rank == 0) {
-        for (i=0; i<SIZE; i++)
-            B[i] = 500 + i;
-        MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win); 
-        MPI_Win_fence(0, win); 
-        for (i=0; i<SIZE; i++) {
-            A[i] = i+100;
-            MPI_Get(&A[i], 1, MPI_INT, 1, i, 1, MPI_INT, win);
+
+    if (rank == 0 || rank == 1)
+    {
+        i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &A);
+        if (i) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
         }
-        MPI_Win_fence(0, win); 
-        for (i=0; i<SIZE; i++)
-            if (A[i] != 1000 + i) {
-                printf("Rank 0: A[%d] is %d, should be %d\n", i, A[i], 1000+i);
-                errs++;
+        i = MPI_Alloc_mem(SIZE * sizeof(int), MPI_INFO_NULL, &B);
+        if (i) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
+
+        if (rank == 0) {
+            for (i=0; i<SIZE; i++)
+                B[i] = 500 + i;
+            MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            MPI_Win_fence(0, win);
+            for (i=0; i<SIZE; i++) {
+                A[i] = i+100;
+                MPI_Get(&A[i], 1, MPI_INT, 1, i, 1, MPI_INT, win);
             }
-    }
-
-    if (rank == 1) {
-        for (i=0; i<SIZE; i++)
-            A[i] = 1000 + i;
-        MPI_Win_create(A, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                   MPI_COMM_WORLD, &win); 
-        MPI_Win_fence(0, win); 
-        for (i=0; i<SIZE; i++) {
-            B[i] = i+200;
-            MPI_Get(&B[i], 1, MPI_INT, 0, i, 1, MPI_INT, win);
+            MPI_Win_fence(0, win);
+            for (i=0; i<SIZE; i++)
+                if (A[i] != 1000 + i) {
+                    printf("Rank 0: A[%d] is %d, should be %d\n", i, A[i], 1000+i);
+                    errs++;
+                }
         }
-        MPI_Win_fence(0, win); 
-        for (i=0; i<SIZE; i++)
-            if (B[i] != 500 + i) {
-                printf("Rank 1: B[%d] is %d, should be %d\n", i, B[i], 500+i);
-                errs++;
+        if (rank == 1) {
+            for (i=0; i<SIZE; i++)
+                A[i] = 1000 + i;
+            MPI_Win_create(A, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            MPI_Win_fence(0, win);
+            for (i=0; i<SIZE; i++) {
+                B[i] = i+200;
+                MPI_Get(&B[i], 1, MPI_INT, 0, i, 1, MPI_INT, win);
             }
-    }
+            MPI_Win_fence(0, win);
+            for (i=0; i<SIZE; i++)
+                if (B[i] != 500 + i) {
+                    printf("Rank 1: B[%d] is %d, should be %d\n", i, B[i], 500+i);
+                    errs++;
+                }
+        }
 
-    MPI_Win_free(&win); 
+        MPI_Win_free(&win);
 
-    MPI_Free_mem(A);
-    MPI_Free_mem(B);
+        MPI_Free_mem(A);
+        MPI_Free_mem(B);
 
+    }
+
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: wintest.c
===================================================================
--- wintest.c	(revision 9830)
+++ wintest.c	(working copy)
@@ -16,63 +16,73 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, destrank, nprocs, A[SIZE2], B[SIZE2], i;
+    MPI_Comm CommDeuce;
     MPI_Group comm_group, group;
     MPI_Win win;
     int errs = 0, flag;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    MPI_Comm_group(MPI_COMM_WORLD, &comm_group);
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
 
-    if (rank == 0) {
-        for (i=0; i<SIZE2; i++) A[i] = B[i] = i;
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
-        destrank = 1;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_start(group, 0, win);
-        for (i=0; i<SIZE1; i++)
-            MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win); 
-        for (i=0; i<SIZE1; i++)
-            MPI_Get(B+i, 1, MPI_INT, 1, SIZE1+i, 1, MPI_INT, win);
+    if (rank == 0 || rank == 1) 
+    {
+        MPI_Comm_group(CommDeuce, &comm_group);
 
-        MPI_Win_complete(win);
+        if (rank == 0) {
+            for (i=0; i<SIZE2; i++) A[i] = B[i] = i;
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 1;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_start(group, 0, win);
+            for (i=0; i<SIZE1; i++)
+                MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win); 
+            for (i=0; i<SIZE1; i++)
+                MPI_Get(B+i, 1, MPI_INT, 1, SIZE1+i, 1, MPI_INT, win);
 
-        for (i=0; i<SIZE1; i++) 
-            if (B[i] != (-4)*(i+SIZE1)) {
-                printf("Get Error: B[i] is %d, should be %d\n", B[i], (-4)*(i+SIZE1));
-                errs++;
-            }
-    }
+            MPI_Win_complete(win);
 
-    else {  /* rank=1 */
-        for (i=0; i<SIZE2; i++) B[i] = (-4)*i;
-        MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win);
-        destrank = 0;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_post(group, 0, win);
-        flag = 0;
-        while (!flag)
-            MPI_Win_test(win, &flag);
-    
-        for (i=0; i<SIZE1; i++) {
-            if (B[i] != i) {
-                printf("Put Error: B[i] is %d, should be %d\n", B[i], i);
-	        errs++;
+            for (i=0; i<SIZE1; i++) 
+                if (B[i] != (-4)*(i+SIZE1)) {
+                    printf("Get Error: B[i] is %d, should be %d\n", B[i], (-4)*(i+SIZE1));
+                    errs++;
+                }
+        }
+        else if (rank == 1) 
+        {
+            for (i=0; i<SIZE2; i++) B[i] = (-4)*i;
+            MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 0;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_post(group, 0, win);
+            flag = 0;
+            while (!flag)
+                MPI_Win_test(win, &flag);
+
+            for (i=0; i<SIZE1; i++) {
+                if (B[i] != i) {
+                    printf("Put Error: B[i] is %d, should be %d\n", B[i], i);
+                    errs++;
+                }
             }
         }
+
+        MPI_Group_free(&group);
+        MPI_Group_free(&comm_group);
+        MPI_Win_free(&win); 
     }
-
-    MPI_Group_free(&group);
-    MPI_Group_free(&comm_group);
-    MPI_Win_free(&win); 
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize();
     return 0; 
Index: transpose1.c
===================================================================
--- transpose1.c	(revision 9830)
+++ transpose1.c	(working copy)
@@ -18,87 +18,96 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, **A, *A_data, i, j;
+    MPI_Comm CommDeuce;
     MPI_Win win;
     MPI_Datatype column, xpose;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    A_data = (int *) malloc(NROWS * NCOLS * sizeof(int));
-    A = (int **) malloc(NROWS * sizeof(int *));
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
 
-    A[0] = A_data;
-    for (i=1; i<NROWS; i++)
-	A[i] = A[i-1] + NCOLS;
-
-    if (rank == 0)
+    if (rank == 0 || rank == 1)
     {
-        for (i=0; i<NROWS; i++)
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = i*NCOLS + j;
+        A_data = (int *) malloc(NROWS * NCOLS * sizeof(int));
+        A = (int **) malloc(NROWS * sizeof(int *));
 
-        /* create datatype for one column */
-        MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
-        /* create datatype for matrix in column-major order */
-        MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
-        MPI_Type_commit(&xpose);
- 
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+        A[0] = A_data;
+        for (i=1; i<NROWS; i++)
+            A[i] = A[i-1] + NCOLS;
 
-        MPI_Win_fence(0, win); 
+        if (rank == 0)
+        {
+            for (i=0; i<NROWS; i++)
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = i*NCOLS + j;
 
-        MPI_Put(&A[0][0], NROWS*NCOLS, MPI_INT, 1, 0, 1, xpose, win);
-    
-        MPI_Type_free(&column);
-        MPI_Type_free(&xpose);
+            /* create datatype for one column */
+            MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
+            /* create datatype for matrix in column-major order */
+            MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
+            MPI_Type_commit(&xpose);
 
-        MPI_Win_fence(0, win); 
-    }        
-    else
-    {  /* rank = 1 */
-        for (i=0; i<NROWS; i++) 
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = -1;
-        MPI_Win_create(&A[0][0], NROWS*NCOLS*sizeof(int), sizeof(int), 
-		       MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win); 
-        MPI_Win_fence(0, win); 
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
 
-        MPI_Win_fence(0, win); 
+            MPI_Win_fence(0, win);
 
-        for (j=0; j<NCOLS; j++)
-	{
+            MPI_Put(&A[0][0], NROWS*NCOLS, MPI_INT, 1, 0, 1, xpose, win);
+
+            MPI_Type_free(&column);
+            MPI_Type_free(&xpose);
+
+            MPI_Win_fence(0, win);
+        }
+        else if (rank == 1)
+        {
             for (i=0; i<NROWS; i++)
-	    {
-                if (A[j][i] != i*NCOLS + j)
-		{
-		    if (errs < 50)
-		    {
-			printf("Error: A[%d][%d]=%d should be %d\n", j, i,
-			    A[j][i], i*NCOLS + j);
-		    }
-		    errs++;
-		}
-	    }
-	}
-	if (errs >= 50)
-	{
-	    printf("Total number of errors: %d\n", errs);
-	}
-    }
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = -1;
+            MPI_Win_create(&A[0][0], NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            MPI_Win_fence(0, win);
 
-    MPI_Win_free(&win); 
+            MPI_Win_fence(0, win);
 
-    free(A_data);
-    free(A);
+            for (j=0; j<NCOLS; j++)
+            {
+                for (i=0; i<NROWS; i++)
+                {
+                    if (A[j][i] != i*NCOLS + j)
+                    {
+                        if (errs < 50)
+                        {
+                            printf("Error: A[%d][%d]=%d should be %d\n", j, i,
+                                   A[j][i], i*NCOLS + j);
+                        }
+                        errs++;
+                    }
+                }
+            }
+            if (errs >= 50)
+            {
+                printf("Total number of errors: %d\n", errs);
+            }
+        }
 
+        MPI_Win_free(&win);
+
+        free(A_data);
+        free(A);
+
+    }
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: transpose2.c
===================================================================
--- transpose2.c	(revision 9830)
+++ transpose2.c	(working copy)
@@ -18,85 +18,94 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, A[NROWS][NCOLS], i, j, blocklen[2];
+    MPI_Comm CommDeuce;
     MPI_Aint disp[2];
     MPI_Win win;
     MPI_Datatype column, column1, type[2];
     int errs=0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2)
-    {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    if (rank == 0)
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
+
+    if (rank == 0 || rank == 1)
     {
-        for (i=0; i<NROWS; i++)
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = i*NCOLS + j;
+        if (rank == 0)
+        {
+            for (i=0; i<NROWS; i++)
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = i*NCOLS + j;
 
-        /* create datatype for one column */
-        MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
- 
-        /* create datatype for one column, with the extent of one
+            /* create datatype for one column */
+            MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
+
+            /* create datatype for one column, with the extent of one
            integer. we could use type_create_resized instead. */
-        disp[0] = 0;
-        disp[1] = sizeof(int);
-        type[0]  = column;
-        type[1]  = MPI_UB;
-        blocklen[0]  = 1;
-        blocklen[1]  = 1; 
-        MPI_Type_struct(2, blocklen, disp, type, &column1);
-        MPI_Type_commit(&column1);
- 
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+            disp[0] = 0;
+            disp[1] = sizeof(int);
+            type[0]  = column;
+            type[1]  = MPI_UB;
+            blocklen[0]  = 1;
+            blocklen[1]  = 1;
+            MPI_Type_struct(2, blocklen, disp, type, &column1);
+            MPI_Type_commit(&column1);
 
-        MPI_Win_fence(0, win); 
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
 
-        MPI_Put(A, NROWS*NCOLS, MPI_INT, 1, 0, NCOLS, column1, win);
+            MPI_Win_fence(0, win);
 
-        MPI_Type_free(&column);
-        MPI_Type_free(&column1);
+            MPI_Put(A, NROWS*NCOLS, MPI_INT, 1, 0, NCOLS, column1, win);
 
-        MPI_Win_fence(0, win); 
-    }        
-    else
-    { /* rank = 1 */
-        for (i=0; i<NROWS; i++) 
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = -1;
-        MPI_Win_create(A, NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win); 
-        MPI_Win_fence(0, win); 
+            MPI_Type_free(&column);
+            MPI_Type_free(&column1);
 
-        MPI_Win_fence(0, win); 
+            MPI_Win_fence(0, win);
+        }
+        else if (rank == 1)
+        {
+            for (i=0; i<NROWS; i++)
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = -1;
+            MPI_Win_create(A, NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            MPI_Win_fence(0, win);
 
-        for (j=0; j<NCOLS; j++)
-	{
-            for (i=0; i<NROWS; i++)
-	    {
-                if (A[j][i] != i*NCOLS + j)
-		{
-		    if (errs < 50)
-		    {
-			printf("Error: A[%d][%d]=%d should be %d\n", j, i,
-			    A[j][i], i*NCOLS + j);
-		    }
-                    errs++;
+            MPI_Win_fence(0, win);
+
+            for (j=0; j<NCOLS; j++)
+            {
+                for (i=0; i<NROWS; i++)
+                {
+                    if (A[j][i] != i*NCOLS + j)
+                    {
+                        if (errs < 50)
+                        {
+                            printf("Error: A[%d][%d]=%d should be %d\n", j, i,
+                                   A[j][i], i*NCOLS + j);
+                        }
+                        errs++;
+                    }
                 }
-	    }
-	}
-	if (errs >= 50)
-	{
-	    printf("Total number of errors: %d\n", errs);
-	}
+            }
+            if (errs >= 50)
+            {
+                printf("Total number of errors: %d\n", errs);
+            }
+        }
+        MPI_Win_free(&win);
     }
 
-    MPI_Win_free(&win); 
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: test1.c
===================================================================
--- test1.c	(revision 9830)
+++ test1.c	(working copy)
@@ -14,6 +14,7 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, A[SIZE], B[SIZE], i;
+    MPI_Comm CommDeuce;
     MPI_Win win;
     int errs = 0;
  
@@ -21,55 +22,63 @@
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    if (rank == 0) {
-        for (i=0; i<SIZE; i++)
-            A[i] = B[i] = i;
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
     }
-    else {
-        for (i=0; i<SIZE; i++) {
-            A[i] = (-3)*i;
-            B[i] = (-4)*i;
+
+    if (rank==0 || rank==1)
+    {
+        if (rank == 0) {
+            for (i=0; i<SIZE; i++)
+                A[i] = B[i] = i;
         }
-    }
-
-    MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                   MPI_COMM_WORLD, &win); 
-
-    MPI_Win_fence(0, win); 
-
-    if (rank == 0) {
-        for (i=0; i<SIZE-1; i++)
-            MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win);
-    }        
-    else {
-        for (i=0; i<SIZE-1; i++)
-            MPI_Get(A+i, 1, MPI_INT, 0, i, 1, MPI_INT, win);
-
-        MPI_Accumulate(A+i, 1, MPI_INT, 0, i, 1, MPI_INT, MPI_SUM, win);
-    }
-    MPI_Win_fence(0, win); 
-
-    if (rank == 1) {
-        for (i=0; i<SIZE-1; i++) {
-            if (A[i] != B[i]) {
-                printf("Put/Get Error: A[i]=%d, B[i]=%d\n", A[i], B[i]);
+        else {
+            for (i=0; i<SIZE; i++) {
+                A[i] = (-3)*i;
+                B[i] = (-4)*i;
+            }
+        }
+ 
+        MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win); 
+ 
+        MPI_Win_fence(0, win); 
+ 
+        if (rank == 0) {
+            for (i=0; i<SIZE-1; i++)
+                MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win);
+        }        
+        else {
+            for (i=0; i<SIZE-1; i++)
+                MPI_Get(A+i, 1, MPI_INT, 0, i, 1, MPI_INT, win);
+ 
+            MPI_Accumulate(A+i, 1, MPI_INT, 0, i, 1, MPI_INT, MPI_SUM, win);
+        }
+        MPI_Win_fence(0, win); 
+ 
+        if (rank == 1) {
+            for (i=0; i<SIZE-1; i++) {
+                if (A[i] != B[i]) {
+                    printf("Put/Get Error: A[i]=%d, B[i]=%d\n", A[i], B[i]);
+                    errs++;
+ 	            }
+            }
+        }
+        else {
+            if (B[SIZE-1] != SIZE - 1 - 3*(SIZE-1)) {
+                printf("Accumulate Error: B[SIZE-1] is %d, should be %d\n", B[SIZE-1], SIZE - 1 - 3*(SIZE-1));
                 errs++;
-	    }
-        }
+            }
+ 	   }
+       MPI_Win_free(&win); 
     }
-    else {
-        if (B[SIZE-1] != SIZE - 1 - 3*(SIZE-1)) {
-            printf("Accumulate Error: B[SIZE-1] is %d, should be %d\n", B[SIZE-1], SIZE - 1 - 3*(SIZE-1));
-            errs++;
-	}
-    }
-
-    MPI_Win_free(&win); 
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: transpose3.c
===================================================================
--- transpose3.c	(revision 9830)
+++ transpose3.c	(working copy)
@@ -17,84 +17,93 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, A[NROWS][NCOLS], i, j, destrank;
+    MPI_Comm CommDeuce;
     MPI_Win win;
     MPI_Datatype column, xpose;
     MPI_Group comm_group, group;
     int errs=0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2)
-    {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    MPI_Comm_group(MPI_COMM_WORLD, &comm_group);
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
 
-    if (rank == 0)
+    if (rank == 0 || rank == 1)
     {
-        for (i=0; i<NROWS; i++)
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = i*NCOLS + j;
+        MPI_Comm_group(CommDeuce, &comm_group);
 
-        /* create datatype for one column */
-        MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
-         /* create datatype for matrix in column-major order */
-        MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
-        MPI_Type_commit(&xpose);
- 
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+        if (rank == 0)
+        {
+            for (i=0; i<NROWS; i++)
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = i*NCOLS + j;
 
-        destrank = 1;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_start(group, 0, win);
+            /* create datatype for one column */
+            MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
+            /* create datatype for matrix in column-major order */
+            MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
+            MPI_Type_commit(&xpose);
 
-        MPI_Put(A, NROWS*NCOLS, MPI_INT, 1, 0, 1, xpose, win);
-    
-        MPI_Type_free(&column);
-        MPI_Type_free(&xpose);
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
 
-        MPI_Win_complete(win);
-    }        
-    else
-    {  /* rank = 1 */
-        for (i=0; i<NROWS; i++) 
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = -1;
-        MPI_Win_create(A, NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win); 
-        destrank = 0;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_post(group, 0, win);
-        MPI_Win_wait(win);
+            destrank = 1;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_start(group, 0, win);
 
-        for (j=0; j<NCOLS; j++)
-	{
+            MPI_Put(A, NROWS*NCOLS, MPI_INT, 1, 0, 1, xpose, win);
+
+            MPI_Type_free(&column);
+            MPI_Type_free(&xpose);
+
+            MPI_Win_complete(win);
+        }
+        else if (rank == 1)
+        {
             for (i=0; i<NROWS; i++)
-	    {
-		if (A[j][i] != i*NCOLS + j)
-		{
-		    if (errs < 50)
-		    {
-			printf("Error: A[%d][%d]=%d should be %d\n", j, i,
-			    A[j][i], i*NCOLS + j);
-		    }
-                    errs++;
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = -1;
+            MPI_Win_create(A, NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 0;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_post(group, 0, win);
+            MPI_Win_wait(win);
+
+            for (j=0; j<NCOLS; j++)
+            {
+                for (i=0; i<NROWS; i++)
+                {
+                    if (A[j][i] != i*NCOLS + j)
+                    {
+                        if (errs < 50)
+                        {
+                            printf("Error: A[%d][%d]=%d should be %d\n", j, i,
+                                   A[j][i], i*NCOLS + j);
+                        }
+                        errs++;
+                    }
                 }
-	    }
-	}
-	if (errs >= 50)
-	{
-	    printf("Total number of errors: %d\n", errs);
-	}
+            }
+            if (errs >= 50)
+            {
+                printf("Total number of errors: %d\n", errs);
+            }
+        }
+
+        MPI_Group_free(&group);
+        MPI_Group_free(&comm_group);
+        MPI_Win_free(&win);
     }
-
-    MPI_Group_free(&group);
-    MPI_Group_free(&comm_group);
-    MPI_Win_free(&win); 
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: test2.c
===================================================================
--- test2.c	(revision 9830)
+++ test2.c	(working copy)
@@ -15,61 +15,70 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, destrank, nprocs, A[SIZE2], B[SIZE2], i;
+    MPI_Comm CommDeuce;
     MPI_Group comm_group, group;
     MPI_Win win;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    MPI_Comm_group(MPI_COMM_WORLD, &comm_group);
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
 
-    if (rank == 0) {
-        for (i=0; i<SIZE2; i++) A[i] = B[i] = i;
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
-        destrank = 1;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_start(group, 0, win);
-        for (i=0; i<SIZE1; i++)
-            MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win); 
-        for (i=0; i<SIZE1; i++)
-            MPI_Get(B+i, 1, MPI_INT, 1, SIZE1+i, 1, MPI_INT, win);
+    if (rank == 0 || rank == 1)
+    {
+        MPI_Comm_group(CommDeuce, &comm_group);
 
-        MPI_Win_complete(win);
+        if (rank == 0) {
+            for (i=0; i<SIZE2; i++) A[i] = B[i] = i;
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 1;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_start(group, 0, win);
+            for (i=0; i<SIZE1; i++)
+                MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win);
+            for (i=0; i<SIZE1; i++)
+                MPI_Get(B+i, 1, MPI_INT, 1, SIZE1+i, 1, MPI_INT, win);
 
-        for (i=0; i<SIZE1; i++) 
-            if (B[i] != (-4)*(i+SIZE1)) {
-                printf("Get Error: B[i] is %d, should be %d\n", B[i], (-4)*(i+SIZE1));
-                errs++;
-            }
-    }
+            MPI_Win_complete(win);
 
-    else {  /* rank=1 */
-        for (i=0; i<SIZE2; i++) B[i] = (-4)*i;
-        MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win);
-        destrank = 0;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_post(group, 0, win);
-        MPI_Win_wait(win);
-    
-        for (i=0; i<SIZE1; i++) {
-            if (B[i] != i) {
-                printf("Put Error: B[i] is %d, should be %d\n", B[i], i);
-	        errs++;
+            for (i=0; i<SIZE1; i++)
+                if (B[i] != (-4)*(i+SIZE1)) {
+                    printf("Get Error: B[i] is %d, should be %d\n", B[i], (-4)*(i+SIZE1));
+                    errs++;
+                }
+        }
+        else if (rank == 1) {
+            for (i=0; i<SIZE2; i++) B[i] = (-4)*i;
+            MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 0;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_post(group, 0, win);
+            MPI_Win_wait(win);
+
+            for (i=0; i<SIZE1; i++) {
+                if (B[i] != i) {
+                    printf("Put Error: B[i] is %d, should be %d\n", B[i], i);
+                    errs++;
+                }
             }
         }
+
+        MPI_Group_free(&group);
+        MPI_Group_free(&comm_group);
+        MPI_Win_free(&win);
     }
-
-    MPI_Group_free(&group);
-    MPI_Group_free(&comm_group);
-    MPI_Win_free(&win); 
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize();
     return 0; 
Index: transpose4.c
===================================================================
--- transpose4.c	(revision 9830)
+++ transpose4.c	(working copy)
@@ -17,61 +17,71 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, A[NROWS][NCOLS], i, j;
+    MPI_Comm CommDeuce;
     MPI_Win win;
     MPI_Datatype column, xpose;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    if (rank == 0) {
-        for (i=0; i<NROWS; i++)
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = i*NCOLS + j;
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
 
-        /* create datatype for one column */
-        MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
-         /* create datatype for matrix in column-major order */
-        MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
-        MPI_Type_commit(&xpose);
- 
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+    if (rank == 0 || rank == 1)
+    {
+        if (rank == 0) {
+            for (i=0; i<NROWS; i++)
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = i*NCOLS + j;
 
-        MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
+            /* create datatype for one column */
+            MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
+            /* create datatype for matrix in column-major order */
+            MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
+            MPI_Type_commit(&xpose);
 
-        MPI_Put(A, NROWS*NCOLS, MPI_INT, 1, 0, 1, xpose, win);
-    
-        MPI_Type_free(&column);
-        MPI_Type_free(&xpose);
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
 
-        MPI_Win_unlock(1, win);
-        MPI_Win_free(&win); 
-    }        
-    else {  /* rank = 1 */
-        for (i=0; i<NROWS; i++) 
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = -1;
-        MPI_Win_create(A, NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win); 
+            MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
 
-        MPI_Win_free(&win); 
+            MPI_Put(A, NROWS*NCOLS, MPI_INT, 1, 0, 1, xpose, win);
 
-        for (j=0; j<NCOLS; j++)
+            MPI_Type_free(&column);
+            MPI_Type_free(&xpose);
+
+            MPI_Win_unlock(1, win);
+            MPI_Win_free(&win);
+        }
+        else if (rank == 1)
+        {
             for (i=0; i<NROWS; i++) 
-                if (A[j][i] != i*NCOLS + j) {
-                    printf("Error: A[%d][%d]=%d should be %d\n", j, i,
-                           A[j][i], i*NCOLS + j);
-                    errs++;
-                }
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = -1;
+            MPI_Win_create(A, NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+
+            MPI_Win_free(&win);
+
+            for (j=0; j<NCOLS; j++)
+                for (i=0; i<NROWS; i++)
+                    if (A[j][i] != i*NCOLS + j) {
+                        printf("Error: A[%d][%d]=%d should be %d\n", j, i,
+                               A[j][i], i*NCOLS + j);
+                        errs++;
+                    }
+        }
     }
 
-    /* if (rank==0) printf("Done\n"); */
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: test3.c
===================================================================
--- test3.c	(revision 9830)
+++ test3.c	(working copy)
@@ -20,73 +20,83 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, destrank, nprocs, *A, *B, i;
+    MPI_Comm CommDeuce;
     MPI_Group comm_group, group;
     MPI_Win win;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    A = (int *) malloc(SIZE * sizeof(int));
-    if (!A) {
-        printf("Can't allocate memory in test program\n");
-        MPI_Abort(MPI_COMM_WORLD, 1);
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
+        MPI_Abort(MPI_COMM_WORLD,1);
     }
-    B = (int *) malloc(SIZE * sizeof(int));
-    if (!B) {
-        printf("Can't allocate memory in test program\n");
+
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
         MPI_Abort(MPI_COMM_WORLD, 1);
     }
-    
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
-        MPI_Abort(MPI_COMM_WORLD,1);
-    }
 
-    MPI_Comm_group(MPI_COMM_WORLD, &comm_group);
+    if (rank == 0 || rank == 1)
+    {
+        A = (int *) malloc(SIZE * sizeof(int));
+        if (!A) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(CommDeuce, 1);
+        }
+        B = (int *) malloc(SIZE * sizeof(int));
+        if (!B) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(CommDeuce, 1);
+        }
 
-    if (rank == 0) {
-        for (i=0; i<SIZE; i++) {
-            A[i] = i;
-            B[i] = SIZE + i;
+        MPI_Comm_group(CommDeuce, &comm_group);
+
+        if (rank == 0) {
+            for (i=0; i<SIZE; i++) {
+                A[i] = i;
+                B[i] = SIZE + i;
+            }
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 1;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_start(group, 0, win);
+            MPI_Put(A, SIZE, MPI_INT, 1, 0, SIZE, MPI_INT, win);
+            MPI_Win_complete(win);
+            MPI_Send(B, SIZE, MPI_INT, 1, 100, MPI_COMM_WORLD);
         }
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
-        destrank = 1;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_start(group, 0, win);
-        MPI_Put(A, SIZE, MPI_INT, 1, 0, SIZE, MPI_INT, win);
-        MPI_Win_complete(win);
-        MPI_Send(B, SIZE, MPI_INT, 1, 100, MPI_COMM_WORLD);
-    }
 
-    else {  /* rank=1 */
-        for (i=0; i<SIZE; i++) A[i] = B[i] = (-4)*i;
-        MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win);
-        destrank = 0;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_post(group, 0, win);
-        MPI_Recv(A, SIZE, MPI_INT, 0, 100, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-        MPI_Win_wait(win);
-        
-        for (i=0; i<SIZE; i++) {
-            if (B[i] != i) {
-                printf("Rank 1: Put Error: B[i] is %d, should be %d\n", B[i], i);
-                errs++;
+        else if (rank == 1) {
+            for (i=0; i<SIZE; i++) A[i] = B[i] = (-4)*i;
+            MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 0;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_post(group, 0, win);
+            MPI_Recv(A, SIZE, MPI_INT, 0, 100, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+            MPI_Win_wait(win);
+
+            for (i=0; i<SIZE; i++) {
+                if (B[i] != i) {
+                    printf("Rank 1: Put Error: B[i] is %d, should be %d\n", B[i], i);
+                    errs++;
+                }
+                if (A[i] != SIZE + i) {
+                    printf("Rank 1: Send/Recv Error: A[i] is %d, should be %d\n", A[i], SIZE+i);
+                    errs++;
+                }
             }
-            if (A[i] != SIZE + i) {
-                printf("Rank 1: Send/Recv Error: A[i] is %d, should be %d\n", A[i], SIZE+i);
-                errs++;
-            }
         }
+
+        MPI_Group_free(&group);
+        MPI_Group_free(&comm_group);
+        MPI_Win_free(&win);
+        free(A);
+        free(B);
     }
-
-    MPI_Group_free(&group);
-    MPI_Group_free(&comm_group);
-    MPI_Win_free(&win); 
-    free(A);
-    free(B);
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: test4.c
===================================================================
--- test4.c	(revision 9830)
+++ test4.c	(working copy)
@@ -17,59 +17,66 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, A[SIZE2], B[SIZE2], i;
+    MPI_Comm CommDeuce;
     MPI_Win win;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    if (rank == 0) {
-        for (i=0; i<SIZE2; i++) A[i] = B[i] = i;
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
 
-        for (i=0; i<SIZE1; i++) {
-            MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
-            MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win);
-            MPI_Win_unlock(1, win);
-        }
+    if (rank == 0 || rank == 1)
+    {
+        if (rank == 0) {
+            for (i=0; i<SIZE2; i++) A[i] = B[i] = i;
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
 
-        for (i=0; i<SIZE1; i++) {
-            MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
-            MPI_Get(B+i, 1, MPI_INT, 1, SIZE1+i, 1, MPI_INT, win);
-            MPI_Win_unlock(1, win);
+            for (i=0; i<SIZE1; i++) {
+                MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
+                MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win);
+                MPI_Win_unlock(1, win);
+            }
+
+            for (i=0; i<SIZE1; i++) {
+                MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
+                MPI_Get(B+i, 1, MPI_INT, 1, SIZE1+i, 1, MPI_INT, win);
+                MPI_Win_unlock(1, win);
+            }
+
+            MPI_Win_free(&win);
+
+            for (i=0; i<SIZE1; i++)
+                if (B[i] != (-4)*(i+SIZE1)) {
+                    printf("Get Error: B[%d] is %d, should be %d\n", i, B[i], (-4)*(i+SIZE1));
+                    errs++;
+                }
         }
+        else if (rank == 1) {
+            for (i=0; i<SIZE2; i++) B[i] = (-4)*i;
+            MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
 
-        MPI_Win_free(&win);
+            MPI_Win_free(&win);
 
-        for (i=0; i<SIZE1; i++) 
-            if (B[i] != (-4)*(i+SIZE1)) {
-                printf("Get Error: B[%d] is %d, should be %d\n", i, B[i], (-4)*(i+SIZE1));
-                errs++;
+            for (i=0; i<SIZE1; i++) {
+                if (B[i] != i) {
+                    printf("Put Error: B[%d] is %d, should be %d\n", i, B[i], i);
+                    errs++;
+                }
             }
-    }
- 
-    else {  /* rank=1 */
-        for (i=0; i<SIZE2; i++) B[i] = (-4)*i;
-        MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win);
-
-        MPI_Win_free(&win); 
-        
-        for (i=0; i<SIZE1; i++) {
-            if (B[i] != i) {
-                printf("Put Error: B[%d] is %d, should be %d\n", i, B[i], i);
-                errs++;
-            }
         }
     }
-
-/*    if (rank==0) printf("Done\n");*/
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: transpose5.c
===================================================================
--- transpose5.c	(revision 9830)
+++ transpose5.c	(working copy)
@@ -18,87 +18,97 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, **A, *A_data, i, j;
+    MPI_Comm CommDeuce;
     MPI_Win win;
     MPI_Datatype column, xpose;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2)
-    {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    A_data = (int *) malloc(NROWS * NCOLS * sizeof(int));
-    A = (int **) malloc(NROWS * sizeof(int *));
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
 
-    A[0] = A_data;
-    for (i=1; i<NROWS; i++)
-	A[i] = A[i-1] + NCOLS;
-
-    if (rank == 0)
+    if (rank == 0 || rank == 1)
     {
-        for (i=0; i<NROWS; i++)
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = i*NCOLS + j;
+        A_data = (int *) malloc(NROWS * NCOLS * sizeof(int));
+        A = (int **) malloc(NROWS * sizeof(int *));
 
-        /* create datatype for one column */
-        MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
-        /* create datatype for matrix in column-major order */
-        MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
-        MPI_Type_commit(&xpose);
- 
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+        A[0] = A_data;
+        for (i=1; i<NROWS; i++)
+            A[i] = A[i-1] + NCOLS;
 
-        MPI_Win_fence(0, win); 
+        if (rank == 0)
+        {
+            for (i=0; i<NROWS; i++)
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = i*NCOLS + j;
 
-        MPI_Accumulate(&A[0][0], NROWS*NCOLS, MPI_INT, 1, 0, 1, xpose, MPI_SUM, win);
-    
-        MPI_Type_free(&column);
-        MPI_Type_free(&xpose);
+            /* create datatype for one column */
+            MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
+            /* create datatype for matrix in column-major order */
+            MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
+            MPI_Type_commit(&xpose);
 
-        MPI_Win_fence(0, win); 
-    }        
-    else
-    {  /* rank = 1 */
-        for (i=0; i<NROWS; i++) 
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = i*NCOLS + j;
-        MPI_Win_create(&A[0][0], NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win); 
-        MPI_Win_fence(0, win); 
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
 
-        MPI_Win_fence(0, win); 
+            MPI_Win_fence(0, win);
 
-        for (j=0; j<NCOLS; j++)
-	{
+            MPI_Accumulate(&A[0][0], NROWS*NCOLS, MPI_INT, 1, 0, 1, xpose, MPI_SUM, win);
+
+            MPI_Type_free(&column);
+            MPI_Type_free(&xpose);
+
+            MPI_Win_fence(0, win);
+        }
+        else if (rank == 1)
+        {
             for (i=0; i<NROWS; i++)
-	    {
-                if (A[j][i] != i*NCOLS + j + j*NCOLS + i)
-		{
-		    if (errs < 50)
-		    {
-			printf("Error: A[%d][%d]=%d should be %d\n", j, i,
-			    A[j][i], i*NCOLS + j + j*NCOLS + i);
-		    }
-                    errs++;
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = i*NCOLS + j;
+            MPI_Win_create(&A[0][0], NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            MPI_Win_fence(0, win);
+
+            MPI_Win_fence(0, win);
+
+            for (j=0; j<NCOLS; j++)
+            {
+                for (i=0; i<NROWS; i++)
+                {
+                    if (A[j][i] != i*NCOLS + j + j*NCOLS + i)
+                    {
+                        if (errs < 50)
+                        {
+                            printf("Error: A[%d][%d]=%d should be %d\n", j, i,
+                                   A[j][i], i*NCOLS + j + j*NCOLS + i);
+                        }
+                        errs++;
+                    }
                 }
-	    }
-	}
-	if (errs >= 50)
-	{
-	    printf("Total number of errors: %d\n", errs);
-	}
-    }
+            }
+            if (errs >= 50)
+            {
+                printf("Total number of errors: %d\n", errs);
+            }
+        }
 
-    MPI_Win_free(&win);
+        MPI_Win_free(&win);
 
-    free(A_data);
-    free(A);
+        free(A_data);
+        free(A);
 
+    }
+
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: test5.c
===================================================================
--- test5.c	(revision 9830)
+++ test5.c	(working copy)
@@ -14,57 +14,64 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, i, A[SIZE], B[SIZE];
+    MPI_Comm CommDeuce;
     MPI_Win win;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD, &rank); 
-  
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    if (rank == 0) {
-        for (i=0; i<SIZE; i++)
-            B[i] = 500 + i;
-        MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win); 
-        MPI_Win_fence(0, win); 
-        for (i=0; i<SIZE; i++) {
-            A[i] = i+100;
-            MPI_Get(&A[i], 1, MPI_INT, 1, i, 1, MPI_INT, win);
-        }
-        MPI_Win_fence(0, win); 
-        for (i=0; i<SIZE; i++)
-            if (A[i] != 1000 + i) {
-                printf("Rank 0: A[%d] is %d, should be %d\n", i, A[i], 1000+i);
-                errs++;
-            }
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
     }
 
-    if (rank == 1) {
-        for (i=0; i<SIZE; i++)
-            A[i] = 1000 + i;
-        MPI_Win_create(A, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                   MPI_COMM_WORLD, &win); 
-        MPI_Win_fence(0, win); 
-        for (i=0; i<SIZE; i++) {
-            B[i] = i+200;
-            MPI_Get(&B[i], 1, MPI_INT, 0, i, 1, MPI_INT, win);
+    if (rank == 0 || rank == 1)
+    {
+        if (rank == 0) {
+            for (i=0; i<SIZE; i++)
+                B[i] = 500 + i;
+            MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            MPI_Win_fence(0, win);
+            for (i=0; i<SIZE; i++) {
+                A[i] = i+100;
+                MPI_Get(&A[i], 1, MPI_INT, 1, i, 1, MPI_INT, win);
+            }
+            MPI_Win_fence(0, win);
+            for (i=0; i<SIZE; i++)
+                if (A[i] != 1000 + i) {
+                    printf("Rank 0: A[%d] is %d, should be %d\n", i, A[i], 1000+i);
+                    errs++;
+                }
         }
-        MPI_Win_fence(0, win); 
-        for (i=0; i<SIZE; i++)
-            if (B[i] != 500 + i) {
-                printf("Rank 1: B[%d] is %d, should be %d\n", i, B[i], 500+i);
-                errs++;
+        if (rank == 1) {
+            for (i=0; i<SIZE; i++)
+                A[i] = 1000 + i;
+            MPI_Win_create(A, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            MPI_Win_fence(0, win);
+            for (i=0; i<SIZE; i++) {
+                B[i] = i+200;
+                MPI_Get(&B[i], 1, MPI_INT, 0, i, 1, MPI_INT, win);
             }
+            MPI_Win_fence(0, win);
+            for (i=0; i<SIZE; i++)
+                if (B[i] != 500 + i) {
+                    printf("Rank 1: B[%d] is %d, should be %d\n", i, B[i], 500+i);
+                    errs++;
+                }
+        }
+
+        MPI_Win_free(&win);
     }
-
-    MPI_Win_free(&win); 
-
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: transpose6.c
===================================================================
--- transpose6.c	(revision 9830)
+++ transpose6.c	(working copy)
@@ -16,63 +16,66 @@
 
 int main(int argc, char *argv[]) 
 { 
-    int nprocs, A[NROWS][NCOLS], B[NROWS][NCOLS], i, j;
+    int rank, nprocs, A[NROWS][NCOLS], B[NROWS][NCOLS], i, j;
     MPI_Win win;
     MPI_Datatype column, xpose;
     int errs = 0;
  
     MTest_Init(&argc,&argv); 
+    MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
 
-    if (nprocs != 1)
+    if (nprocs < 1)
     {
-        printf("Run this program with 1 process\n");
+        printf("Run this program with 1 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    for (i=0; i<NROWS; i++)
-        for (j=0; j<NCOLS; j++)
-            A[i][j] = B[i][j] = i*NCOLS + j;
-    
-    /* create datatype for one column */
-    MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
-    /* create datatype for matrix in column-major order */
-    MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
-    MPI_Type_commit(&xpose);
-    
-    MPI_Win_create(B, NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                   MPI_COMM_WORLD, &win); 
-    
-    MPI_Win_fence(0, win); 
-    
-    MPI_Accumulate(A, NROWS*NCOLS, MPI_INT, 0, 0, 1, xpose, MPI_SUM, win);
-    
-    MPI_Type_free(&column);
-    MPI_Type_free(&xpose);
-    
-    MPI_Win_fence(0, win); 
-    
-    for (j=0; j<NCOLS; j++)
+    if (rank==0)
     {
         for (i=0; i<NROWS; i++)
-	{
-            if (B[j][i] != i*NCOLS + j + j*NCOLS + i)
-	    {
-		if (errs < 20)
-		{
-		    printf("Error: B[%d][%d]=%d should be %d\n", j, i,
-			B[j][i], i*NCOLS + j + j*NCOLS + i);
-		}
-                errs++;
-            }
-	}
+            for (j=0; j<NCOLS; j++)
+                A[i][j] = B[i][j] = i*NCOLS + j;
+        
+        /* create datatype for one column */
+        MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
+        /* create datatype for matrix in column-major order */
+        MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
+        MPI_Type_commit(&xpose);
+        
+        MPI_Win_create(B, NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_SELF, &win); 
+        
+        MPI_Win_fence(0, win); 
+        
+        MPI_Accumulate(A, NROWS*NCOLS, MPI_INT, 0, 0, 1, xpose, MPI_SUM, win);
+        
+        MPI_Type_free(&column);
+        MPI_Type_free(&xpose);
+        
+        MPI_Win_fence(0, win); 
+        
+        for (j=0; j<NCOLS; j++)
+        {
+            for (i=0; i<NROWS; i++)
+ 	   {
+                if (B[j][i] != i*NCOLS + j + j*NCOLS + i)
+ 	       {
+ 	   	if (errs < 20)
+ 	   	{
+ 	   	    printf("Error: B[%d][%d]=%d should be %d\n", j, i,
+ 	   		B[j][i], i*NCOLS + j + j*NCOLS + i);
+ 	   	}
+                    errs++;
+                }
+ 	   }
+        }
+        if (errs >= 20)
+        {
+ 	   printf("Total number of errors: %d\n", errs);
+        }
+ 
+        MPI_Win_free(&win); 
     }
-    if (errs >= 20)
-    {
-	printf("Total number of errors: %d\n", errs);
-    }
-
-    MPI_Win_free(&win); 
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: transpose7.c
===================================================================
--- transpose7.c	(revision 9830)
+++ transpose7.c	(working copy)
@@ -18,82 +18,91 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, **A, *A_data, i, j;
+    MPI_Comm CommDeuce;
     MPI_Win win;
     MPI_Datatype column, xpose;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    A_data = (int *) malloc(NROWS * NCOLS * sizeof(int));
-    A = (int **) malloc(NROWS * sizeof(int *));
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
+    }
 
-    A[0] = A_data;
-    for (i=1; i<NROWS; i++)
-	A[i] = A[i-1] + NCOLS;
-
-    if (rank == 0)
+    if (rank == 0 || rank == 1)
     {
-        for (i=0; i<NROWS; i++)
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = -1;
+        A_data = (int *) malloc(NROWS * NCOLS * sizeof(int));
+        A = (int **) malloc(NROWS * sizeof(int *));
 
-        /* create datatype for one column */
-        MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
-        /* create datatype for matrix in column-major order */
-        MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
-        MPI_Type_commit(&xpose);
- 
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
+        A[0] = A_data;
+        for (i=1; i<NROWS; i++)
+            A[i] = A[i-1] + NCOLS;
 
-        MPI_Win_fence(0, win); 
+        if (rank == 0)
+        {
+            for (i=0; i<NROWS; i++)
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = -1;
 
-        MPI_Get(&A[0][0], NROWS*NCOLS, MPI_INT, 1, 0, 1, xpose, win);
-    
-        MPI_Type_free(&column);
-        MPI_Type_free(&xpose);
+            /* create datatype for one column */
+            MPI_Type_vector(NROWS, 1, NCOLS, MPI_INT, &column);
+            /* create datatype for matrix in column-major order */
+            MPI_Type_hvector(NCOLS, 1, sizeof(int), column, &xpose);
+            MPI_Type_commit(&xpose);
 
-        MPI_Win_fence(0, win); 
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
 
-        for (j=0; j<NCOLS; j++)
-	{
+            MPI_Win_fence(0, win);
+
+            MPI_Get(&A[0][0], NROWS*NCOLS, MPI_INT, 1, 0, 1, xpose, win);
+
+            MPI_Type_free(&column);
+            MPI_Type_free(&xpose);
+
+            MPI_Win_fence(0, win);
+
+            for (j=0; j<NCOLS; j++)
+            {
+                for (i=0; i<NROWS; i++)
+                {
+                    if (A[j][i] != i*NCOLS + j)
+                    {
+                        if (errs < 50)
+                        {
+                            printf("Error: A[%d][%d]=%d should be %d\n", j, i,
+                                   A[j][i], i*NCOLS + j);
+                        }
+                        errs++;
+                    }
+                }
+            }
+            if (errs >= 50)
+            {
+                printf("Total number of errors: %d\n", errs);
+            }
+        }
+        else
+        {
             for (i=0; i<NROWS; i++)
-	    {
-                if (A[j][i] != i*NCOLS + j)
-		{
-		    if (errs < 50)
-		    {
-			printf("Error: A[%d][%d]=%d should be %d\n", j, i,
-			    A[j][i], i*NCOLS + j);
-		    }
-		    errs++;
-		}
-	    }
-	}
-	if (errs >= 50)
-	{
-	    printf("Total number of errors: %d\n", errs);
-	}
-    }        
-    else
-    {  /* rank = 1 */
-        for (i=0; i<NROWS; i++) 
-            for (j=0; j<NCOLS; j++)
-                A[i][j] = i*NCOLS + j;
-        MPI_Win_create(&A[0][0], NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win); 
-        MPI_Win_fence(0, win); 
+                for (j=0; j<NCOLS; j++)
+                    A[i][j] = i*NCOLS + j;
 
-        MPI_Win_fence(0, win); 
+            MPI_Win_create(&A[0][0], NROWS*NCOLS*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            MPI_Win_fence(0, win);
+            MPI_Win_fence(0, win);
+        }
+        MPI_Win_free(&win);
     }
-
-    MPI_Win_free(&win); 
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: test2_am.c
===================================================================
--- test2_am.c	(revision 9830)
+++ test2_am.c	(working copy)
@@ -16,77 +16,86 @@
 
 int main(int argc, char *argv[]) 
 { 
-/*    int rank, destrank, nprocs, A[SIZE2], B[SIZE2], i; */
     int rank, destrank, nprocs, *A, *B, i;
+    MPI_Comm CommDeuce;
     MPI_Group comm_group, group;
     MPI_Win win;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    i = MPI_Alloc_mem(SIZE2 * sizeof(int), MPI_INFO_NULL, &A);
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
     if (i) {
-        printf("Can't allocate memory in test program\n");
+        printf("Can't create a subcommunicator of two processes\n");
         MPI_Abort(MPI_COMM_WORLD, 1);
     }
-    i = MPI_Alloc_mem(SIZE2 * sizeof(int), MPI_INFO_NULL, &B);
-    if (i) {
-        printf("Can't allocate memory in test program\n");
-        MPI_Abort(MPI_COMM_WORLD, 1);
-    }
-    
-    MPI_Comm_group(MPI_COMM_WORLD, &comm_group);
 
-    if (rank == 0) {
-        for (i=0; i<SIZE2; i++) A[i] = B[i] = i;
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
-        destrank = 1;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_start(group, 0, win);
-        for (i=0; i<SIZE1; i++)
-            MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win); 
-        for (i=0; i<SIZE1; i++)
-            MPI_Get(B+i, 1, MPI_INT, 1, SIZE1+i, 1, MPI_INT, win);
+    if (rank == 0 || rank == 1)
+    {
 
-        MPI_Win_complete(win);
+        i = MPI_Alloc_mem(SIZE2 * sizeof(int), MPI_INFO_NULL, &A);
+        if (i) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
+        i = MPI_Alloc_mem(SIZE2 * sizeof(int), MPI_INFO_NULL, &B);
+        if (i) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
 
-        for (i=0; i<SIZE1; i++) 
-            if (B[i] != (-4)*(i+SIZE1)) {
-                printf("Get Error: B[i] is %d, should be %d\n", B[i], (-4)*(i+SIZE1));
-                errs++;
-            }
-    }
+        MPI_Comm_group(CommDeuce, &comm_group);
 
-    else {  /* rank=1 */
-        for (i=0; i<SIZE2; i++) B[i] = (-4)*i;
-        MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win);
-        destrank = 0;
-        MPI_Group_incl(comm_group, 1, &destrank, &group);
-        MPI_Win_post(group, 0, win);
-        MPI_Win_wait(win);
-    
-        for (i=0; i<SIZE1; i++) {
-            if (B[i] != i) {
-                printf("Put Error: B[i] is %d, should be %d\n", B[i], i);
-	        errs++;
+        if (rank == 0) {
+            for (i=0; i<SIZE2; i++) A[i] = B[i] = i;
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 1;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_start(group, 0, win);
+            for (i=0; i<SIZE1; i++)
+                MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win);
+            for (i=0; i<SIZE1; i++)
+                MPI_Get(B+i, 1, MPI_INT, 1, SIZE1+i, 1, MPI_INT, win);
+
+            MPI_Win_complete(win);
+
+            for (i=0; i<SIZE1; i++)
+                if (B[i] != (-4)*(i+SIZE1)) {
+                    printf("Get Error: B[i] is %d, should be %d\n", B[i], (-4)*(i+SIZE1));
+                    errs++;
+                }
+        }
+        else if (rank == 1) {
+            for (i=0; i<SIZE2; i++) B[i] = (-4)*i;
+            MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+            destrank = 0;
+            MPI_Group_incl(comm_group, 1, &destrank, &group);
+            MPI_Win_post(group, 0, win);
+            MPI_Win_wait(win);
+
+            for (i=0; i<SIZE1; i++) {
+                if (B[i] != i) {
+                    printf("Put Error: B[i] is %d, should be %d\n", B[i], i);
+                    errs++;
+                }
             }
         }
+
+        MPI_Group_free(&group);
+        MPI_Group_free(&comm_group);
+        MPI_Win_free(&win);
+        MPI_Free_mem(A);
+        MPI_Free_mem(B);
     }
 
-    MPI_Group_free(&group);
-    MPI_Group_free(&comm_group);
-    MPI_Win_free(&win); 
-    MPI_Free_mem(A);
-    MPI_Free_mem(B);
-
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize();
     return 0; 
Index: test4_am.c
===================================================================
--- test4_am.c	(revision 9830)
+++ test4_am.c	(working copy)
@@ -18,74 +18,81 @@
 
 int main(int argc, char *argv[]) 
 { 
-/*    int rank, nprocs, A[SIZE2], B[SIZE2], i; */
     int rank, nprocs, *A, *B, i; 
+    MPI_Comm CommDeuce;
     MPI_Win win;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    i = MPI_Alloc_mem(SIZE2 * sizeof(int), MPI_INFO_NULL, &A);
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
     if (i) {
-        printf("Can't allocate memory in test program\n");
+        printf("Can't create a subcommunicator of two processes\n");
         MPI_Abort(MPI_COMM_WORLD, 1);
     }
-    i = MPI_Alloc_mem(SIZE2 * sizeof(int), MPI_INFO_NULL, &B);
-    if (i) {
-        printf("Can't allocate memory in test program\n");
-        MPI_Abort(MPI_COMM_WORLD, 1);
-    }
-    
-    if (rank == 0) {
-        for (i=0; i<SIZE2; i++) A[i] = B[i] = i;
-        MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
 
-        for (i=0; i<SIZE1; i++) {
-            MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
-            MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win);
-            MPI_Win_unlock(1, win);
+    if (rank == 0 || rank == 1)
+    {
+        i = MPI_Alloc_mem(SIZE2 * sizeof(int), MPI_INFO_NULL, &A);
+        if (i) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
         }
-
-        for (i=0; i<SIZE1; i++) {
-            MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
-            MPI_Get(B+i, 1, MPI_INT, 1, SIZE1+i, 1, MPI_INT, win);
-            MPI_Win_unlock(1, win);
+        i = MPI_Alloc_mem(SIZE2 * sizeof(int), MPI_INFO_NULL, &B);
+        if (i) {
+            printf("Can't allocate memory in test program\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
         }
 
-        MPI_Win_free(&win);
+        if (rank == 0) {
+            for (i=0; i<SIZE2; i++) A[i] = B[i] = i;
+            MPI_Win_create(NULL, 0, 1, MPI_INFO_NULL, CommDeuce, &win);
 
-        for (i=0; i<SIZE1; i++) 
-            if (B[i] != (-4)*(i+SIZE1)) {
-                printf("Get Error: B[%d] is %d, should be %d\n", i, B[i], (-4)*(i+SIZE1));
-                errs++;
+            for (i=0; i<SIZE1; i++) {
+                MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
+                MPI_Put(A+i, 1, MPI_INT, 1, i, 1, MPI_INT, win);
+                MPI_Win_unlock(1, win);
             }
-    }
- 
-    else {  /* rank=1 */
-        for (i=0; i<SIZE2; i++) B[i] = (-4)*i;
-        MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                       MPI_COMM_WORLD, &win);
 
-        MPI_Win_free(&win); 
-        
-        for (i=0; i<SIZE1; i++) {
-            if (B[i] != i) {
-                printf("Put Error: B[%d] is %d, should be %d\n", i, B[i], i);
-                errs++;
+            for (i=0; i<SIZE1; i++) {
+                MPI_Win_lock(MPI_LOCK_SHARED, 1, 0, win);
+                MPI_Get(B+i, 1, MPI_INT, 1, SIZE1+i, 1, MPI_INT, win);
+                MPI_Win_unlock(1, win);
             }
+
+            MPI_Win_free(&win);
+
+            for (i=0; i<SIZE1; i++)
+                if (B[i] != (-4)*(i+SIZE1)) {
+                    printf("Get Error: B[%d] is %d, should be %d\n", i, B[i], (-4)*(i+SIZE1));
+                    errs++;
+                }
         }
+        else if (rank == 1) {
+            for (i=0; i<SIZE2; i++) B[i] = (-4)*i;
+            MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
+
+            MPI_Win_free(&win);
+
+            for (i=0; i<SIZE1; i++) {
+                if (B[i] != i) {
+                    printf("Put Error: B[%d] is %d, should be %d\n", i, B[i], i);
+                    errs++;
+                }
+            }
+        }
+
+        MPI_Free_mem(A);
+        MPI_Free_mem(B);
     }
-
-    MPI_Free_mem(A);
-    MPI_Free_mem(B);
-/*    if (rank==0) printf("Done\n");*/
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: test1_dt.c
===================================================================
--- test1_dt.c	(revision 9830)
+++ test1_dt.c	(working copy)
@@ -15,67 +15,78 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, A[SIZE], B[SIZE], i;
+    MPI_Comm CommDeuce;
     MPI_Win win;
     MPI_Datatype contig_2ints;
     int errs = 0;
- 
+
     MTest_Init(&argc,&argv); 
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 2) {
-        printf("Run this program with 2 processes\n");
+    if (nprocs < 2) {
+        printf("Run this program with 2 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    if (rank == 0) {
-        for (i=0; i<SIZE; i++)
-            A[i] = B[i] = i;
+    i = MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1, rank, &CommDeuce); 
+    if (i) {
+        printf("Can't create a subcommunicator of two processes\n");
+        MPI_Abort(MPI_COMM_WORLD, 1);
     }
-    else {
-        for (i=0; i<SIZE; i++) {
-            A[i] = (-3)*i;
-            B[i] = (-4)*i;
+
+    if (rank == 0 || rank == 1)
+    {
+
+        if (rank == 0) {
+            for (i=0; i<SIZE; i++)
+                A[i] = B[i] = i;
         }
-    }
+        else {
+            for (i=0; i<SIZE; i++) {
+                A[i] = (-3)*i;
+                B[i] = (-4)*i;
+            }
+        }
 
-    MPI_Type_contiguous(2, MPI_INT, &contig_2ints);
-    MPI_Type_commit(&contig_2ints);
+        MPI_Type_contiguous(2, MPI_INT, &contig_2ints);
+        MPI_Type_commit(&contig_2ints);
 
-    MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, 
-                   MPI_COMM_WORLD, &win); 
+        MPI_Win_create(B, SIZE*sizeof(int), sizeof(int), MPI_INFO_NULL, CommDeuce, &win);
 
-    MPI_Win_fence(0, win); 
+        MPI_Win_fence(0, win);
 
-    if (rank == 0) {
-        for (i=0; i<SIZE-2; i+=2)
-            MPI_Put(A+i, 2, MPI_INT, 1, i, 1, contig_2ints, win);
-    }        
-    else {
-        for (i=0; i<SIZE-2; i+=2)
-            MPI_Get(A+i, 2, MPI_INT, 0, i, 1, contig_2ints, win);
+        if (rank == 0) {
+            for (i=0; i<SIZE-2; i+=2)
+                MPI_Put(A+i, 2, MPI_INT, 1, i, 1, contig_2ints, win);
+        }
+        else {
+            for (i=0; i<SIZE-2; i+=2)
+                MPI_Get(A+i, 2, MPI_INT, 0, i, 1, contig_2ints, win);
 
-        MPI_Accumulate(A+SIZE-2, 2, MPI_INT, 0, SIZE-2, 1, contig_2ints, MPI_SUM, win);
-    }
-    MPI_Win_fence(0, win); 
+            MPI_Accumulate(A+SIZE-2, 2, MPI_INT, 0, SIZE-2, 1, contig_2ints, MPI_SUM, win);
+        }
+        MPI_Win_fence(0, win);
 
-    if (rank == 1) {
-        for (i=0; i<SIZE-2; i++) {
-            if (A[i] != B[i]) {
-                printf("Put/Get Error: A[i]=%d, B[i]=%d\n", A[i], B[i]);
+        if (rank == 1) {
+            for (i=0; i<SIZE-2; i++) {
+                if (A[i] != B[i]) {
+                    printf("Put/Get Error: A[i]=%d, B[i]=%d\n", A[i], B[i]);
+                    errs++;
+                }
+            }
+        }
+        else {
+            if (B[SIZE-1] != SIZE - 1 - 3*(SIZE-1)) {
+                printf("Accumulate Error: B[SIZE-1] is %d, should be %d\n", B[SIZE-1], SIZE - 1 - 3*(SIZE-1));
                 errs++;
-	    }
+            }
         }
+
+        MPI_Win_free(&win);
+        MPI_Type_free(&contig_2ints);
     }
-    else {
-        if (B[SIZE-1] != SIZE - 1 - 3*(SIZE-1)) {
-            printf("Accumulate Error: B[SIZE-1] is %d, should be %d\n", B[SIZE-1], SIZE - 1 - 3*(SIZE-1));
-            errs++;
-	}
-    }
-
-    MPI_Win_free(&win); 
-    MPI_Type_free(&contig_2ints);
+    MPI_Comm_free(&CommDeuce);
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0; 
Index: lockcontention.c
===================================================================
--- lockcontention.c	(revision 9830)
+++ lockcontention.c	(working copy)
@@ -20,6 +20,7 @@
 int main(int argc, char *argv[]) 
 { 
     int rank, nprocs, A[SIZE2], B[SIZE2], i;
+    MPI_Comm CommThree;
     MPI_Win win;
     int errs = 0;
 	int trank = 1;
@@ -28,68 +29,72 @@
     MPI_Comm_size(MPI_COMM_WORLD,&nprocs); 
     MPI_Comm_rank(MPI_COMM_WORLD,&rank); 
 
-    if (nprocs != 3) {
-        fprintf(stderr, "Run this program with 3 processes\n");
+    if (nprocs < 3) {
+        fprintf(stderr, "Run this program with 3 or more processes\n");
         MPI_Abort(MPI_COMM_WORLD,1);
     }
 
-    if (rank == 0) {
-        for (i=0; i<SIZE2; i++) {
-			A[i] = B[i] = i;
+    MPI_Comm_split(MPI_COMM_WORLD, rank==0 || rank==1 || rank==2, rank, &CommThree); 
+
+    if (rank == 0 || rank==1 || rank==2) 
+    {
+        if (rank == 0) {
+            for (i=0; i<SIZE2; i++) {
+ 	   		A[i] = B[i] = i;
+            }
         }
-    }
-    else if (rank == 2) {
-		for (i=0; i<SIZE2; i++) {
-			A[i] = B[i] = -1;
-		}
-    }
-    else if (rank == 1) {
-        for (i=0; i<SIZE2; i++) {
-			B[i] = (-4)*i;
+        else if (rank == 2) {
+ 	   	for (i=0; i<SIZE2; i++) {
+ 	   		A[i] = B[i] = -1;
+ 	   	}
         }
-    }
-
-	MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_WORLD, &win); 
-
-    if (rank == 0) {
-        for (i=0; i<SIZE1; i++) {
-            MPI_Win_lock(MPI_LOCK_EXCLUSIVE, trank, 0, win);
-            MPI_Put(A+i, 1, MPI_INT, trank, i, 1, MPI_INT, win);
-        /*  MPI_Put(A+i, 1, MPI_INT, trank, i, 1, MPI_INT, win);
-	    MPI_Put(A+i, 1, MPI_INT, trank, i, 1, MPI_INT, win); */
-            MPI_Win_unlock(trank, win);
+        else if (rank == 1) {
+            for (i=0; i<SIZE2; i++) {
+ 	   		B[i] = (-4)*i;
+            }
         }
-		
-        MPI_Win_free(&win);
-    }
-	else if (rank == 2) {		
-        for (i=0; i<SIZE1; i++) {
-            MPI_Win_lock(MPI_LOCK_EXCLUSIVE, trank, 0, win);
-            MPI_Get(A+i, 1, MPI_INT, trank, SIZE1+i, 1, MPI_INT, win);
-            MPI_Win_unlock(trank, win);
+ 
+ 	   MPI_Win_create(B, SIZE2*sizeof(int), sizeof(int), MPI_INFO_NULL, CommThree, &win); 
+ 
+        if (rank == 0) {
+            for (i=0; i<SIZE1; i++) {
+                MPI_Win_lock(MPI_LOCK_EXCLUSIVE, trank, 0, win);
+                MPI_Put(A+i, 1, MPI_INT, trank, i, 1, MPI_INT, win);
+            /*  MPI_Put(A+i, 1, MPI_INT, trank, i, 1, MPI_INT, win);
+ 	       MPI_Put(A+i, 1, MPI_INT, trank, i, 1, MPI_INT, win); */
+                MPI_Win_unlock(trank, win);
+            }
+ 	   	
+            MPI_Win_free(&win);
         }
-
-        MPI_Win_free(&win);
-
-        for (i=0; i<SIZE1; i++) 
-            if (A[i] != (-4)*(i+SIZE1)) {
-                printf("Get Error: A[%d] is %d, should be %d\n", i, A[i], (-4)*(i+SIZE1));
-                errs++;
+ 	   else if (rank == 2) {		
+            for (i=0; i<SIZE1; i++) {
+                MPI_Win_lock(MPI_LOCK_EXCLUSIVE, trank, 0, win);
+                MPI_Get(A+i, 1, MPI_INT, trank, SIZE1+i, 1, MPI_INT, win);
+                MPI_Win_unlock(trank, win);
             }
-    }
  
-    else if (rank == 1) { /*target*/
-        MPI_Win_free(&win); 
-        
-        for (i=0; i<SIZE1; i++) {
-            if (B[i] != i) {
-                printf("Put Error: B[%d] is %d, should be %d\n", i, B[i], i);
-                errs++;
+            MPI_Win_free(&win);
+ 
+            for (i=0; i<SIZE1; i++) 
+                if (A[i] != (-4)*(i+SIZE1)) {
+                    printf("Get Error: A[%d] is %d, should be %d\n", i, A[i], (-4)*(i+SIZE1));
+                    errs++;
+                }
+        }
+  
+        else if (rank == 1) { /*target*/
+            MPI_Win_free(&win); 
+            
+            for (i=0; i<SIZE1; i++) {
+                if (B[i] != i) {
+                    printf("Put Error: B[%d] is %d, should be %d\n", i, B[i], i);
+                    errs++;
+                }
             }
         }
     }
 
-/*    if (rank==0) printf("Done\n");*/
     MTest_Finalize(errs);
     MPI_Finalize(); 
     return 0;