[svn-r22105] Description:

	Bring r20557:22085 from trunk to this branch, also fixing some other
issues/failures in the branch simultaneously.  The h5repack tests are still
failing, but Neil will be checking into those, so the branch can be fully
functional again.

Tested on:
	Mac OSX/64 10.7.3 (amazon) w/debug

10 files changed, 3463 insertions, 2710 deletions

diff --git a/testpar/CMakeLists.txt b/testpar/CMakeLists.txt
index 40db59f..d60aea5 100644
--- a/testpar/CMakeLists.txt
+++ b/testpar/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 2.8)
+cmake_minimum_required (VERSION 2.8.6)
 PROJECT (HDF5_TEST_PAR)
 
 INCLUDE_DIRECTORIES (${HDF5_TEST_SRC_DIR})
@@ -22,21 +22,23 @@ SET (testphdf5_SRCS
 #-- Adding test for testhdf5
 ADD_EXECUTABLE (testphdf5 ${testphdf5_SRCS})
 TARGET_NAMING (testphdf5 ${LIB_TYPE})
-TARGET_LINK_LIBRARIES (testphdf5 ${HDF5_TEST_LIB_TARGET} ${HDF5_LIB_TARGET})
+TARGET_LINK_LIBRARIES (testphdf5 ${HDF5_TEST_LIB_TARGET} ${HDF5_LIB_TARGET} ${LINK_LIBS})
+SET_TARGET_PROPERTIES (testphdf5 PROPERTIES FOLDER test/par)
 
-ADD_TEST (NAME testphdf5 COMMAND ${MPIEXEC} ${MPIEXEC_PREFLAGS} ${MPIEXEC_NUMPROC_FLAG} ${MPIEXEC_MAX_NUMPROCS} ${MPIEXEC_POSTFLAGS} $<TARGET_FILE:testphdf5>)
+ADD_TEST (NAME TEST_PAR_testphdf5 COMMAND ${MPIEXEC} ${MPIEXEC_PREFLAGS} ${MPIEXEC_NUMPROC_FLAG} ${MPIEXEC_MAX_NUMPROCS} ${MPIEXEC_POSTFLAGS} $<TARGET_FILE:testphdf5>)
 
 MACRO (ADD_H5P_TEST file)
   ADD_EXECUTABLE (${file} ${HDF5_TEST_PAR_SOURCE_DIR}/${file}.c)
   TARGET_NAMING (${file} ${LIB_TYPE})
-  TARGET_LINK_LIBRARIES (${file} ${HDF5_TEST_LIB_TARGET} ${HDF5_LIB_TARGET})
+  TARGET_LINK_LIBRARIES (${file} ${HDF5_TEST_LIB_TARGET} ${HDF5_LIB_TARGET} ${LINK_LIBS})
+  SET_TARGET_PROPERTIES (${file} PROPERTIES FOLDER test/par)
 
-  ADD_TEST (NAME ${file} COMMAND ${MPIEXEC} ${MPIEXEC_PREFLAGS} ${MPIEXEC_NUMPROC_FLAG} ${MPIEXEC_MAX_NUMPROCS} ${MPIEXEC_POSTFLAGS} $<TARGET_FILE:${file}> -p)
+  ADD_TEST (NAME TEST_PAR_${file} COMMAND ${MPIEXEC} ${MPIEXEC_PREFLAGS} ${MPIEXEC_NUMPROC_FLAG} ${MPIEXEC_MAX_NUMPROCS} ${MPIEXEC_POSTFLAGS} $<TARGET_FILE:${file}>)
 ENDMACRO (ADD_H5P_TEST file)
 
 SET (H5P_TESTS
     t_mpi
-    t_posix_compliant
+#    t_posix_compliant
     t_cache
     t_pflush1
     t_pflush2
@@ -44,9 +46,15 @@ SET (H5P_TESTS
 )
 
 FOREACH (testp ${H5P_TESTS})
-    ADD_H5P_TEST(${testp})
+  ADD_H5P_TEST(${testp})
 ENDFOREACH (testp ${H5P_TESTS})
 
+SET_TESTS_PROPERTIES(TEST_PAR_t_pflush2 PROPERTIES DEPENDS TEST_PAR_t_pflush1)
+
+IF (NOT WIN32)
+  ADD_H5P_TEST(t_posix_compliant)
+ENDIF (NOT WIN32)
+  
 IF (HDF5_TEST_VFD)
 
   SET (VFD_LIST
@@ -91,4 +99,3 @@ IF (HDF5_TEST_VFD)
   ENDFOREACH (vfd ${VFD_LIST})
 
 ENDIF (HDF5_TEST_VFD)
-
diff --git a/testpar/Makefile.in b/testpar/Makefile.in
index b273ebb..ae0c7d0 100644
--- a/testpar/Makefile.in
+++ b/testpar/Makefile.in
@@ -202,6 +202,7 @@ F9XMODEXT = @F9XMODEXT@
 F9XMODFLAG = @F9XMODFLAG@
 F9XSUFFIXFLAG = @F9XSUFFIXFLAG@
 FC = @FC@
+FC2003 = @FC2003@
 FCFLAGS = @FCFLAGS@
 FCFLAGS_f90 = @FCFLAGS_f90@
 FCLIBS = @FCLIBS@
@@ -222,10 +223,12 @@ H5_LONE_COLON = @H5_LONE_COLON@
 H5_VERSION = @H5_VERSION@
 HADDR_T = @HADDR_T@
 HAVE_DMALLOC = @HAVE_DMALLOC@
+HAVE_FORTRAN_2003 = @HAVE_FORTRAN_2003@
 HDF5_HL = @HDF5_HL@
 HDF5_INTERFACES = @HDF5_INTERFACES@
 HDF_CXX = @HDF_CXX@
 HDF_FORTRAN = @HDF_FORTRAN@
+HDF_FORTRAN2003 = @HDF_FORTRAN2003@
 HID_T = @HID_T@
 HL = @HL@
 HL_FOR = @HL_FOR@
diff --git a/testpar/t_cache.c b/testpar/t_cache.c
index b0cad48..14e03c0 100644
--- a/testpar/t_cache.c
+++ b/testpar/t_cache.c
@@ -49,6 +49,9 @@ hid_t noblock_dxpl_id=(-1);
 #define NFILENAME 2
 #define PARATESTFILE filenames[0]
 const char *FILENAME[NFILENAME]={"CacheTestDummy", NULL};
+#ifndef PATH_MAX
+#define PATH_MAX    512
+#endif  /* !PATH_MAX */
 char    filenames[NFILENAME][PATH_MAX];
 hid_t   fapl;                           /* file access property list */
 
diff --git a/testpar/t_chunk_alloc.c b/testpar/t_chunk_alloc.c
index bb13d4e..e8a6ca4 100644
--- a/testpar/t_chunk_alloc.c
+++ b/testpar/t_chunk_alloc.c
@@ -37,7 +37,7 @@ get_filesize(const char *filename)
     MPI_File	fd;
     MPI_Offset	filesize;
 #ifndef H5_HAVE_MPI_GET_SIZE
-    struct stat stat_buf;
+    h5_stat_t stat_buf;
 #endif
 
 #ifdef H5_HAVE_MPI_GET_SIZE
@@ -54,7 +54,7 @@ get_filesize(const char *filename)
     /* Some systems (only SGI Altix Propack 4 so far) doesn't return correct
      * file size for MPI_File_get_size.  Use stat instead.
      */
-    if((mpierr=stat(filename, &stat_buf))<0)
+    if((mpierr=HDstat(filename, &stat_buf))<0)
     VRFY((mpierr == MPI_SUCCESS), "");
 
     /* Hopefully this casting is safe */
diff --git a/testpar/t_dset.c b/testpar/t_dset.c
index e4da0d3..699f86d 100644
--- a/testpar/t_dset.c
+++ b/testpar/t_dset.c
@@ -2516,3 +2516,552 @@ none_selection_chunk(void)
     if(data_origin) free(data_origin);
     if(data_array) free(data_array);
 }
+
+
+/* Function: test_actual_io_mode
+ *
+ * Purpose: tests one specific case of collective I/O and checks that the 
+ *          actual_chunk_opt_mode property and the actual_io_mode
+ *          properties in the DXPL have the correct values.
+ *
+ * Input:   selection_mode: changes the way processes select data from the space, as well
+ *          as some dxpl flags to get collective I/O to break in different ways.
+ *          
+ *          The relevant I/O function and expected response for each mode:
+ *              TEST_ACTUAL_IO_MULTI_CHUNK_IND:
+ *                  H5D_mpi_chunk_collective_io, each process reports independent I/O
+ *              
+ *              TEST_ACTUAL_IO_MULTI_CHUNK_COL:
+ *                  H5D_mpi_chunk_collective_io, each process reports collective I/O
+ *
+ *              TEST_ACTUAL_IO_MULTI_CHUNK_MIX:
+ *                  H5D_mpi_chunk_collective_io, each process reports mixed I/O
+ *
+ *              TEST_ACTUAL_IO_MULTI_CHUNK_MIX_DISAGREE:
+ *                  H5D_mpi_chunk_collective_io, processes disagree. The root reports
+ *                  collective, the rest report independent I/O
+ *
+ *              TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_COL:
+ *                  H5D_mpi_chunk_collective_io_no_opt, each process reports collective I/O
+ *
+ *              TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_MIX_DISAGREE:
+ *                  H5D_mpi_chunk_collective_io_no_opt, processes disagree
+ *                  (collective and mixed I/O)
+ *
+ *              TEST_ACTUAL_IO_LINK_CHUNK:
+ *                  H5D_link_chunk_collective_io, processes report linked chunk I/O
+ *
+ *              TEST_ACTUAL_IO_CONTIGUOUS:
+ *                  H5D_contig_collective_write or H5D_contig_collective_read
+ *                  each process reports contiguous collective I/O
+ *
+ *              TEST_ACTUAL_IO_NO_COLLECTIVE:
+ *                  Simple independent I/O. This tests that the defaults are properly set.
+ *
+ *              TEST_ACTUAL_IO_RESET:
+ *                  Perfroms collective and then independent I/O wit hthe same dxpl to
+ *                  make sure the peroperty is correctly reset to the default on each use.
+ *                  Specifically, this test runs TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_MIX_DISAGREE
+ *                  (The most complex case that works on all builds) and then performs
+ *                  an independent read and write with the same dxpls.
+ *
+ *          It may seem like TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_IND and 
+ *          TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_MIX have been accidentally
+ *          left out. This is intentional; the other test cases sufficiently
+ *          cover all cases for Multi Chunk No Opt I/O.
+ * 
+ * Programmer: Jacob Gruber
+ * Date: 2011-04-06
+ */
+static void 
+test_actual_io_mode(int selection_mode) {
+    H5D_mpio_actual_chunk_opt_mode_t   actual_chunk_opt_mode_write = -1;
+    H5D_mpio_actual_chunk_opt_mode_t   actual_chunk_opt_mode_read = -1;
+    H5D_mpio_actual_chunk_opt_mode_t   actual_chunk_opt_mode_expected = -1;
+    H5D_mpio_actual_io_mode_t   actual_io_mode_write = -1;
+    H5D_mpio_actual_io_mode_t   actual_io_mode_read = -1;
+    H5D_mpio_actual_io_mode_t   actual_io_mode_expected = -1;
+    const char  * filename;
+    const char  * test_name;
+    hbool_t     multi_chunk_no_opt;
+    hbool_t     multi_chunk_with_opt;
+    hbool_t     is_chunked;
+    hbool_t     is_collective;
+    int         mpi_size = -1; 
+    int         mpi_rank = -1;
+    int         length;
+    int         * buffer;
+    int         i;
+    MPI_Comm    mpi_comm = MPI_COMM_NULL;
+    MPI_Info    mpi_info = MPI_INFO_NULL;
+    hid_t       fid = -1;
+    hid_t       sid = -1;
+    hid_t       dataset = -1;
+    hid_t       data_type = H5T_NATIVE_INT;
+    hid_t       fapl = -1;
+    hid_t       mem_space = -1;
+    hid_t       file_space = -1;
+    hid_t       dcpl = -1;
+    hid_t       dxpl_write = -1;
+    hid_t       dxpl_read = -1;
+    hsize_t     dims[RANK];
+    hsize_t     chunk_dims[RANK];
+    hsize_t     start[RANK];
+    hsize_t     stride[RANK];
+    hsize_t     count[RANK];
+    hsize_t     block[RANK];
+    hbool_t     use_gpfs = FALSE;
+    herr_t      ret;
+   
+    /* Set up some flags to make some future if statements slightly more readable */
+    multi_chunk_no_opt = (
+        selection_mode == TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_IND ||
+        selection_mode == TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_COL ||
+        selection_mode == TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_MIX_DISAGREE );
+    
+    /* Note: RESET performs the same tests as MULTI_CHUNK_MIX_DISAGREE and then
+     * tests independent I/O
+     */
+    multi_chunk_with_opt = (
+        selection_mode == TEST_ACTUAL_IO_MULTI_CHUNK_IND ||
+        selection_mode == TEST_ACTUAL_IO_MULTI_CHUNK_COL ||
+        selection_mode == TEST_ACTUAL_IO_MULTI_CHUNK_MIX ||
+        selection_mode == TEST_ACTUAL_IO_MULTI_CHUNK_MIX_DISAGREE ||
+        selection_mode == TEST_ACTUAL_IO_RESET );
+ 
+    is_chunked = (
+        selection_mode != TEST_ACTUAL_IO_CONTIGUOUS &&
+        selection_mode != TEST_ACTUAL_IO_NO_COLLECTIVE);
+    
+    is_collective = selection_mode != TEST_ACTUAL_IO_NO_COLLECTIVE;
+
+    /* Set up MPI parameters */
+    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
+    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
+
+    MPI_Barrier(MPI_COMM_WORLD);
+    
+    HDassert(mpi_size >= 1);
+
+    mpi_comm = MPI_COMM_WORLD;
+    mpi_info = MPI_INFO_NULL;
+
+    filename = (const char *)GetTestParameters();
+    HDassert(filename != NULL);
+
+    /* Setup the file access template */
+    fapl = create_faccess_plist(mpi_comm, mpi_info, facc_type, use_gpfs);
+    VRFY((fapl >= 0), "create_faccess_plist() succeeded");
+
+    /* Create the file */
+    fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
+    VRFY((fid >= 0), "H5Fcreate succeeded");
+
+    /* Create the basic Space */    
+    dims[0] = dim0;
+    dims[1] = dim1;
+    sid = H5Screate_simple (RANK, dims, NULL);
+    VRFY((sid >= 0), "H5Screate_simple succeeded");
+
+    /* Create the dataset creation plist */
+    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    VRFY((dcpl >= 0), "dataset creation plist created successfully");
+
+    /* If we are not testing contiguous datasets */
+    if(is_chunked) {
+        /* Set up chunk information.  */
+        chunk_dims[0] = dims[0]/mpi_size;
+        chunk_dims[1] = dims[1];
+        ret = H5Pset_chunk(dcpl, 2, chunk_dims);
+        VRFY((ret >= 0),"chunk creation property list succeeded");
+    }
+
+    /* Create the dataset */
+    dataset = H5Dcreate2(fid, "actual_io", data_type, sid, H5P_DEFAULT,
+            dcpl, H5P_DEFAULT);
+    VRFY((dataset >= 0), "H5Dcreate2() dataset succeeded");
+
+    /* Create the file dataspace */
+    file_space = H5Dget_space(dataset);
+    VRFY((file_space >= 0), "H5Dget_space succeeded");
+
+    /* Choose a selection method based on the type of I/O we want to occur, 
+     * and also set up some selection-dependeent test info. */
+    switch(selection_mode) {
+        
+        /* Independent I/O with optimization */
+        case TEST_ACTUAL_IO_MULTI_CHUNK_IND:
+            /* Since the dataset is chunked by row and each process selects a row,
+             * each process  writes to a different chunk. This forces all I/O to be
+             * independent.
+             */
+            slab_set(mpi_rank, mpi_size, start, count, stride, block, BYROW);
+            
+            test_name = "Multi Chunk - Independent";
+            actual_chunk_opt_mode_expected = H5D_MPIO_MULTI_CHUNK;
+            actual_io_mode_expected = H5D_MPIO_CHUNK_INDEPENDENT;
+            break;
+
+        /* Collective I/O with optimization */
+        case TEST_ACTUAL_IO_MULTI_CHUNK_COL:
+            /* The dataset is chunked by rows, so each process takes a column which
+             * spans all chunks. Since the processes write non-overlapping regular
+             * selections to each chunk, the operation is purely collective.
+             */
+            slab_set(mpi_rank, mpi_size, start, count, stride, block, BYCOL);
+            
+            test_name = "Multi Chunk - Collective";
+            actual_chunk_opt_mode_expected = H5D_MPIO_MULTI_CHUNK;
+            actual_io_mode_expected = H5D_MPIO_CHUNK_COLLECTIVE;
+            break;
+        
+        /* Mixed I/O with optimization */
+        case TEST_ACTUAL_IO_MULTI_CHUNK_MIX:
+            /* A chunk will be assigned collective I/O only if it is selected by each
+             * process. To get mixed I/O, have the root select all chunks and each
+             * subsequent process select the first and nth chunk. The first chunk,
+             * accessed by all, will be assigned collective I/O while each other chunk
+             * will be accessed only by the root and the nth procecess and will be
+             * assigned independent I/O. Each process will access one chunk collectively
+             * and at least one chunk independently, reporting mixed I/O.
+             */
+           
+            if(mpi_rank == 0) {
+                 /* Select the first column */
+                 slab_set(mpi_rank, mpi_size, start, count, stride, block, BYCOL);
+            } else {
+                /* Select the first and the nth chunk in the nth column */
+                block[0] = dim0 / mpi_size;
+                block[1] = dim1 / mpi_size;
+                count[0] = 2;
+                count[1] = 1;
+                stride[0] = mpi_rank * block[0];
+                stride[1] = 1;
+                start[0] = 0;
+                start[1] = mpi_rank*block[1];
+            }
+                
+            test_name = "Multi Chunk - Mixed";
+            actual_chunk_opt_mode_expected = H5D_MPIO_MULTI_CHUNK;
+            actual_io_mode_expected = H5D_MPIO_CHUNK_MIXED;
+            break;
+
+        /* RESET tests that the properties are properly reset to defaults each time I/O is
+         * performed. To acheive this, we have RESET perform collective I/O (which would change
+         * the values from the defaults) followed by independent I/O (which should report the
+         * default values). RESET doesn't need to have a unique selection, so we reuse
+         * MULTI_CHUMK_MIX_DISAGREE, which was chosen because it is a complex case that works 
+         * on all builds. The independent section of RESET can be found at the end of this function.
+         */
+        case TEST_ACTUAL_IO_RESET:
+
+        /* Mixed I/O with optimization and internal disagreement */
+        case TEST_ACTUAL_IO_MULTI_CHUNK_MIX_DISAGREE:
+            /* A chunk will be assigned collective I/O only if it is selected by each
+             * process. To get mixed I/O with disagreement, assign process n to the
+             * first chunk and the nth chunk. The first chunk, selected by all, is 
+             * assgigned collective I/O, while each other process gets independent I/O.
+             * Since the root process with only access the first chunk, it will report
+             * collective I/O. The subsequent processes will access the first chunk
+             * collectively, and their other chunk indpendently, reporting mixed I/O.
+             */
+
+            if(mpi_rank == 0) {
+                 /* Select the first chunk in the first column */
+                 slab_set(mpi_rank, mpi_size, start, count, stride, block, BYCOL);
+                 block[0] = block[0] / mpi_size;
+            } else {
+                /* Select the first and the nth chunk in the nth column */
+                block[0] = dim0 / mpi_size;
+                block[1] = dim1 / mpi_size;
+                count[0] = 2;
+                count[1] = 1;
+                stride[0] = mpi_rank * block[0];
+                stride[1] = 1;
+                start[0] = 0;
+                start[1] = mpi_rank*block[1];
+            }
+            
+            /* If the testname was not already set by the RESET case */
+            if (selection_mode == TEST_ACTUAL_IO_RESET)
+                test_name = "RESET";
+            else
+                test_name = "Multi Chunk - Mixed (Disagreement)";
+            
+            actual_chunk_opt_mode_expected = H5D_MPIO_MULTI_CHUNK;
+               
+            if(mpi_rank == 0)
+                actual_io_mode_expected = H5D_MPIO_CHUNK_COLLECTIVE;
+            else
+                actual_io_mode_expected = H5D_MPIO_CHUNK_MIXED;
+            
+            break; 
+
+        /* Collective I/O without optimization */
+        case TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_COL:
+            /* The dataset is chunked by rows, so when each process takes a column, its
+             * selection spans all chunks. Since no process writes more chunks than any
+             * other, colective I/O is never broken. */ 
+            slab_set(mpi_rank, mpi_size, start, count, stride, block, BYCOL);
+                
+            test_name = "Multi Chunk No Opt - Collective";
+            actual_chunk_opt_mode_expected = H5D_MPIO_MULTI_CHUNK_NO_OPT;
+            actual_io_mode_expected = H5D_MPIO_CHUNK_COLLECTIVE;
+            break;
+       
+
+        /* Mixed I/O without optimization with disagreement */
+        case TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_MIX_DISAGREE:
+            /* Each process takes a column, but the root's column is shortened so that
+             * it only reads the first chunk. Since all the other processes are writing
+             * to more chunks, they will break collective after the first chunk.
+             */
+            slab_set(mpi_rank, mpi_size, start, count, stride, block, BYCOL);
+            if(mpi_rank == 0) 
+                  block[0] = block[0] / mpi_size;
+                
+            test_name = "Multi Chunk No Opt - Mixed (Disagreement)";
+            actual_chunk_opt_mode_expected = H5D_MPIO_MULTI_CHUNK_NO_OPT;
+
+            if(mpi_rank == 0)
+                actual_io_mode_expected = H5D_MPIO_CHUNK_COLLECTIVE;
+            else
+                actual_io_mode_expected = H5D_MPIO_CHUNK_MIXED;
+
+            break;
+        
+        /* Linked Chunk I/O */
+        case TEST_ACTUAL_IO_LINK_CHUNK:        
+            /* Nothing special; link chunk I/O is forced in the dxpl settings. */
+            slab_set(mpi_rank, mpi_size, start, count, stride, block, BYROW);
+              
+            test_name = "Link Chunk";
+            actual_chunk_opt_mode_expected = H5D_MPIO_LINK_CHUNK;
+            actual_io_mode_expected = H5D_MPIO_CHUNK_COLLECTIVE;
+            break;
+
+        /* Contiguous Dataset */
+        case TEST_ACTUAL_IO_CONTIGUOUS:
+            /* A non overlapping, regular selection in a contiguous dataset leads to
+             * collective I/O */
+            slab_set(mpi_rank, mpi_size, start, count, stride, block, BYROW);
+                
+            test_name = "Contiguous";
+            actual_chunk_opt_mode_expected = H5D_MPIO_NO_CHUNK_OPTIMIZATION;
+            actual_io_mode_expected = H5D_MPIO_CONTIGUOUS_COLLECTIVE;
+            break;
+
+        case TEST_ACTUAL_IO_NO_COLLECTIVE:
+            slab_set(mpi_rank, mpi_size, start, count, stride, block, BYROW);
+                
+            test_name = "Independent";
+            actual_chunk_opt_mode_expected = H5D_MPIO_NO_CHUNK_OPTIMIZATION;
+            actual_io_mode_expected = H5D_MPIO_NO_COLLECTIVE;
+            break;
+
+        default:
+            test_name = "Undefined Selection Mode";
+            actual_chunk_opt_mode_expected = -1;
+            actual_io_mode_expected = -1;
+            break;
+    }
+
+    /* Reset the expected values to defulats if the MPI_POSIX driver is in use. 
+     * This property is defined only for mpio, not MPI POSIX. */
+    if (facc_type == FACC_MPIPOSIX) {
+        actual_chunk_opt_mode_expected = H5D_MPIO_NO_CHUNK_OPTIMIZATION;
+        actual_io_mode_expected = H5D_MPIO_NO_COLLECTIVE;
+    }
+
+    ret = H5Sselect_hyperslab(file_space, H5S_SELECT_SET, start, stride, count, block);
+    VRFY((ret >= 0), "H5Sset_hyperslab succeeded");
+ 
+    /* Create a memory dataspace mirroring the dataset and select the same hyperslab
+     * as in the file space. 
+     */
+    mem_space = H5Screate_simple (RANK, dims, NULL);
+    VRFY((mem_space >= 0), "mem_space created");
+    
+    ret = H5Sselect_hyperslab(mem_space, H5S_SELECT_SET, start, stride, count, block);
+    VRFY((ret >= 0), "H5Sset_hyperslab succeeded");
+
+
+    /* Get the number of elements in the selection */
+    length = dim0 * dim1;
+
+    /* Allocate and initialize the buffer */
+    buffer = (int *)HDmalloc(sizeof(int) * length);
+    VRFY((buffer != NULL), "malloc of buffer succeeded"); 
+    for(i = 0; i < length; i++) 
+        buffer[i] = i;
+
+    /* Set up the dxpl for the write */
+    dxpl_write = H5Pcreate(H5P_DATASET_XFER);
+    VRFY((dxpl_write >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded");
+    
+    /* Set collective I/O properties in the dxpl. */
+    if(is_collective) {
+        /* Request collective I/O */
+        ret = H5Pset_dxpl_mpio(dxpl_write, H5FD_MPIO_COLLECTIVE);
+        VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
+        
+        /* Set the threshold number of processes per chunk for link chunk I/O
+         * to twice mpi_size. This will prevent the threshold from ever being
+         * met, thus forcing multi chunk io instead of link chunk io.
+         */
+        if(multi_chunk_with_opt) {
+            ret = H5Pset_dxpl_mpio_chunk_opt_num(dxpl_write, (unsigned) mpi_size*2);
+            VRFY((ret >= 0), "H5Pset_dxpl_mpio_chunk_opt_num succeeded");
+
+            ret = H5Pset_dxpl_mpio_chunk_opt_ratio(dxpl_write, (unsigned) 99);
+            VRFY((ret >= 0), "H5Pset_dxpl_mpio_chunk_opt_ratio succeeded");
+        }
+
+        /* Request multi chunk I/O without optimization */
+        if(multi_chunk_no_opt) {
+            ret = H5Pset_dxpl_mpio_chunk_opt(dxpl_write, H5FD_MPIO_CHUNK_MULTI_IO);
+            VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
+        }
+    }
+
+    /* Make a copy of the dxpl to test the read operation */
+    dxpl_read = H5Pcopy(dxpl_write);
+    VRFY((dxpl_read >= 0), "H5Pcopy succeeded");
+
+    /* Write */
+    ret = H5Dwrite(dataset, data_type, mem_space, file_space, dxpl_write, buffer);
+    if(ret < 0) H5Eprint2(H5E_DEFAULT, stdout);
+    VRFY((ret >= 0), "H5Dwrite() dataset multichunk write succeeded");
+
+    /* Retreive Actual io valuess */
+    ret = H5Pget_mpio_actual_io_mode(dxpl_write, &actual_io_mode_write);
+    VRFY((ret >= 0), "retriving actual io mode suceeded" );
+
+    ret = H5Pget_mpio_actual_chunk_opt_mode(dxpl_write, &actual_chunk_opt_mode_write);
+    VRFY((ret >= 0), "retriving actual chunk opt mode succeeded" );
+    
+    /* Read */
+    ret = H5Dread(dataset, data_type, mem_space, file_space, dxpl_read, buffer);
+    if(ret < 0) H5Eprint2(H5E_DEFAULT, stdout);
+    VRFY((ret >= 0), "H5Dread() dataset multichunk read succeeded");
+   
+    /* Retreive Actual io values */
+    ret = H5Pget_mpio_actual_io_mode(dxpl_read, &actual_io_mode_read);
+    VRFY((ret >= 0), "retriving actual io mode succeeded" );
+
+    ret = H5Pget_mpio_actual_chunk_opt_mode(dxpl_read, &actual_chunk_opt_mode_read);
+    VRFY((ret >= 0), "retriving actual chunk opt mode succeeded" );
+
+    /* Check write vs read */
+    VRFY((actual_io_mode_read == actual_io_mode_write),
+        "reading and writing are the same for actual_io_mode");
+    VRFY((actual_chunk_opt_mode_read == actual_chunk_opt_mode_write),
+        "reading and writing are the same for actual_chunk_opt_mode");
+
+    
+    /* Test values */
+    if(actual_chunk_opt_mode_expected != (unsigned) -1 && actual_io_mode_expected != (unsigned) -1) {
+        char message[100];
+        sprintf(message, "Actual Chunk Opt Mode has the correct value for %s.\n",test_name);
+        VRFY((actual_chunk_opt_mode_write == actual_chunk_opt_mode_expected), message);
+        sprintf(message, "Actual IO Mode has the correct value for %s.\n",test_name);
+        VRFY((actual_io_mode_write == actual_io_mode_expected), message);
+    } else {
+        HDfprintf(stderr, "%s %d -> (%d,%d)\n", test_name, mpi_rank,
+            actual_chunk_opt_mode_write, actual_io_mode_write);
+    }
+
+    /* To test that the property is succesfully reset to the default, we perform some
+     * independent I/O after the collective I/O
+     */
+    if (selection_mode == TEST_ACTUAL_IO_RESET) {
+        if (mpi_rank == 0) {
+            /* Switch to independent io */
+            ret = H5Pset_dxpl_mpio(dxpl_write, H5FD_MPIO_INDEPENDENT);
+            VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
+            ret = H5Pset_dxpl_mpio(dxpl_read, H5FD_MPIO_INDEPENDENT);
+            VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
+
+            /* Write */
+            ret = H5Dwrite(dataset, data_type, H5S_ALL, H5S_ALL, dxpl_write, buffer);
+            VRFY((ret >= 0), "H5Dwrite() dataset multichunk write succeeded");
+
+            /* Check Properties */
+            ret = H5Pget_mpio_actual_io_mode(dxpl_write, &actual_io_mode_write);
+            VRFY( (ret >= 0), "retriving actual io mode succeeded" );
+            ret = H5Pget_mpio_actual_chunk_opt_mode(dxpl_write, &actual_chunk_opt_mode_write);
+            VRFY( (ret >= 0), "retriving actual chunk opt mode succeeded" );
+
+            VRFY(actual_chunk_opt_mode_write == H5D_MPIO_NO_CHUNK_OPTIMIZATION,
+             "actual_chunk_opt_mode has correct value for reset write (independent)");
+            VRFY(actual_io_mode_write == H5D_MPIO_NO_COLLECTIVE,
+             "actual_io_mode has correct value for reset write (independent)");
+            
+            /* Read */
+            ret = H5Dread(dataset, data_type, H5S_ALL, H5S_ALL, dxpl_read, buffer);
+            VRFY((ret >= 0), "H5Dwrite() dataset multichunk write succeeded");
+
+            /* Check Properties */
+            ret = H5Pget_mpio_actual_io_mode(dxpl_read, &actual_io_mode_read);
+            VRFY( (ret >= 0), "retriving actual io mode succeeded" );
+            ret = H5Pget_mpio_actual_chunk_opt_mode(dxpl_read, &actual_chunk_opt_mode_read);
+            VRFY( (ret >= 0), "retriving actual chunk opt mode succeeded" );
+            
+            VRFY(actual_chunk_opt_mode_read == H5D_MPIO_NO_CHUNK_OPTIMIZATION,
+             "actual_chunk_opt_mode has correct value for reset read (independent)");
+            VRFY(actual_io_mode_read == H5D_MPIO_NO_COLLECTIVE,
+             "actual_io_mode has correct value for reset read (independent)");
+         }
+    }
+
+    /* Release some resources */
+    ret = H5Sclose(sid);
+    ret = H5Pclose(fapl);
+    ret = H5Pclose(dcpl);
+    ret = H5Pclose(dxpl_write);
+    ret = H5Pclose(dxpl_read);
+    ret = H5Dclose(dataset);
+    ret = H5Sclose(mem_space);
+    ret = H5Sclose(file_space);
+    ret = H5Fclose(fid);
+    HDfree(buffer);
+    return;
+}
+
+
+/* Function: actual_io_mode_tests
+ *
+ * Purpose: Tests all possible cases of the actual_io_mode property. 
+ *
+ * Programmer: Jacob Gruber
+ * Date: 2011-04-06
+ */
+void
+actual_io_mode_tests(void) {
+    int mpi_size = -1;
+    int mpi_rank = -1;
+    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
+    MPI_Comm_size(MPI_COMM_WORLD, &mpi_rank);
+    
+    test_actual_io_mode(TEST_ACTUAL_IO_NO_COLLECTIVE);
+    
+    test_actual_io_mode(TEST_ACTUAL_IO_MULTI_CHUNK_IND);
+    test_actual_io_mode(TEST_ACTUAL_IO_MULTI_CHUNK_COL);
+    
+    /* The Multi Chunk Mixed test requires atleast three processes. */
+    if (mpi_size > 2)
+        test_actual_io_mode(TEST_ACTUAL_IO_MULTI_CHUNK_MIX);
+    else
+        HDfprintf(stdout, "Multi Chunk Mixed test requires 3 proceses minimum\n");
+    
+    test_actual_io_mode(TEST_ACTUAL_IO_MULTI_CHUNK_MIX_DISAGREE);
+
+    test_actual_io_mode(TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_COL);
+    test_actual_io_mode(TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_MIX_DISAGREE);
+
+    test_actual_io_mode(TEST_ACTUAL_IO_LINK_CHUNK);
+    test_actual_io_mode(TEST_ACTUAL_IO_CONTIGUOUS);
+ 
+    test_actual_io_mode(TEST_ACTUAL_IO_RESET);
+    return;
+}
diff --git a/testpar/t_mpi.c b/testpar/t_mpi.c
index c3e04de..6cba5af 100644
--- a/testpar/t_mpi.c
+++ b/testpar/t_mpi.c
@@ -206,7 +206,7 @@ test_mpio_gb_file(char *filename)
     MPI_Offset  mpi_off;
     MPI_Offset  mpi_off_old;
     MPI_Status  mpi_stat;
-    struct stat stat_buf;
+    h5_stat_t stat_buf;
     int is_signed, sizeof_mpi_offset;
 
     nerrs = 0;
@@ -395,7 +395,7 @@ test_mpio_gb_file(char *filename)
             mrc = MPI_File_get_size(fh, &size);
 	    VRFY((mrc==MPI_SUCCESS), "");
 
-            mrc=stat(filename, &stat_buf);
+            mrc=HDstat(filename, &stat_buf);
 	    VRFY((mrc==0), "");
 
             /* Hopefully this casting is safe */
@@ -843,33 +843,13 @@ static int test_mpio_derived_dtype(char *filename) {
 
 
     mpi_err = MPI_Barrier(MPI_COMM_WORLD);
-#ifdef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS
     if(retcode == -1) {
 	if(mpi_rank == 0) {
 	    printf("Complicated derived datatype is NOT working at this platform\n");
-	    printf("Go back to hdf5/config and find the corresponding\n");
-	    printf("configure-specific file (for example, powerpc-ibm-aix5.x) and add\n");
-	    printf("hdf5_cv_mpi_complex_derived_datatype_works=${hdf5_cv_mpi_complex_derived_datatype-works='no'}\n");
-	    printf(" at the end of the file.\n");
-	    printf(" Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
+	    printf(" Please report to help@hdfgroup.org about this problem.\n");
 	}
 	retcode = 1;
     }
-#else
-    if(retcode == 0) {
-	if(mpi_rank == 0) {
-	    printf(" This is NOT an error, What it really says is\n");
-	    printf("Complicated derived datatype is WORKING at this platform\n");
-	    printf(" Go back to hdf5/config and find the corresponding \n");
-	    printf(" configure-specific file (for example, powerpc-ibm-aix5.x) and delete the line\n");
-	    printf("hdf5_cv_mpi_complex_derived_datatype_works=${hdf5_cv_mpi_complex_derived_datatype-works='no'}\n");
-	    printf(" at the end of the file.\n");
-	    printf("Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
-	}
-	retcode = 1;
-    }
-    if(retcode == -1) retcode = 0;
-#endif
     return retcode;
 }
 /*
@@ -907,30 +887,29 @@ test_mpio_special_collective(char *filename)
     char mpi_err_str[MPI_MAX_ERROR_STRING];
     int  mpi_err_strlen;
     int  mpi_err;
-    char writedata[2];
-    char *buf;
+    char writedata[2*DIMSIZE];
+    char filerep[7] = "native";
     int  i;
     int  count,bufcount;
     int blocklens[2];
     MPI_Aint offsets[2];
-    MPI_Offset  mpi_off;
+    MPI_Offset  mpi_off = 0;
     MPI_Status  mpi_stat;
-    int  retcode;
+    int  retcode = 0;
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
-    retcode = 0;
 
     /* create MPI data type */
     etype = MPI_BYTE;
     if(mpi_rank == 0 || mpi_rank == 1) {
         count = DIMSIZE;
         bufcount = 1;
-    }
+    } /* end if */
     else {
         count = 0;
         bufcount = 0;
-    }
+    } /* end else */
 
     blocklens[0] = count;
     offsets[0] = mpi_rank*count;
@@ -938,108 +917,103 @@ test_mpio_special_collective(char *filename)
     offsets[1] = (mpi_size+mpi_rank)*count;
 
     if(count !=0) {
-      if((mpi_err= MPI_Type_hindexed(2,blocklens,offsets,etype,&filetype))
-       != MPI_SUCCESS){
-      	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_Type_contiguous failed (%s)\n", mpi_err_str);
-	return 1;
-      }
-
-      if((mpi_err=MPI_Type_commit(&filetype))!=MPI_SUCCESS){
-        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
-	return 1;
-      }
-
-
-      if((mpi_err= MPI_Type_hindexed(2,blocklens,offsets,etype,&buftype))
-       != MPI_SUCCESS){
-      	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_Type_contiguous failed (%s)\n", mpi_err_str);
-	return 1;
-      }
-
-      if((mpi_err=MPI_Type_commit(&buftype))!=MPI_SUCCESS){
+        if((mpi_err = MPI_Type_hindexed(2,
+                                        blocklens,
+                                        offsets,
+                                        etype,
+                                        &filetype)) != MPI_SUCCESS) {
+            MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+            printf("MPI_Type_contiguous failed (%s)\n", mpi_err_str);
+            return 1;
+        } /* end if */
+
+        if((mpi_err = MPI_Type_commit(&filetype)) != MPI_SUCCESS) {
+            MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+            printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
+            return 1;
+        } /* end if */
+
+        if((mpi_err = MPI_Type_hindexed(2,
+                                        blocklens,
+                                        offsets,
+                                        etype,
+                                        &buftype)) != MPI_SUCCESS) {
+            MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+            printf("MPI_Type_contiguous failed (%s)\n", mpi_err_str);
+            return 1;
+        } /* end if */
+
+        if((mpi_err = MPI_Type_commit(&buftype)) != MPI_SUCCESS) {
+            MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+            printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
+            return 1;
+        } /* end if */
+    } /* end if */
+    else {
+        filetype = MPI_BYTE;
+        buftype  = MPI_BYTE;
+    } /* end else */
+
+    /* Open a file */
+    if ((mpi_err = MPI_File_open(MPI_COMM_WORLD,
+                                 filename,
+                                 MPI_MODE_RDWR | MPI_MODE_CREATE,
+                                 MPI_INFO_NULL,
+                                 &fh)) != MPI_SUCCESS) {
         MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_Type_commit failed (%s)\n", mpi_err_str);
-	return 1;
-      }
-     }
-     else {
-
-       filetype = MPI_BYTE;
-       buftype  = MPI_BYTE;
-     }
-
-   /* Open a file */
-    if ((mpi_err = MPI_File_open(MPI_COMM_WORLD, filename,
-	    MPI_MODE_RDWR | MPI_MODE_CREATE ,
-	    MPI_INFO_NULL, &fh))
-	    != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_open failed (%s)\n", mpi_err_str);
-	return 1;
-    }
+        printf("MPI_File_open failed (%s)\n", mpi_err_str);
+        return 1;
+    } /* end if */
 
     /* each process writes some data */
     for (i=0; i < 2*DIMSIZE; i++)
-	writedata[i] = mpi_rank*DIMSIZE + i;
-
-
-     mpi_off = 0;
-    if((mpi_err = MPI_File_set_view(fh, mpi_off, MPI_BYTE, filetype, "native", MPI_INFO_NULL))
-        != MPI_SUCCESS) {
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_set_view failed (%s)\n", mpi_err_str);
-	return 1;
-    }
-
-    buf   = writedata;
-    if ((mpi_err = MPI_File_write_at_all(fh, mpi_off, buf, bufcount, buftype,
-	    &mpi_stat))
-	    != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_write_at offset(%ld), bytes (%d), failed (%s)\n",
-		(long) mpi_off, bufcount, mpi_err_str);
-	return 1;
-    };
+        writedata[i] = (char)(mpi_rank*DIMSIZE + i);
+
+    /* Set the file view */
+    if((mpi_err = MPI_File_set_view(fh,
+                                    mpi_off,
+                                    MPI_BYTE,
+                                    filetype,
+                                    filerep,
+                                    MPI_INFO_NULL)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_File_set_view failed (%s)\n", mpi_err_str);
+        return 1;
+    } /* end if */
+
+    /* Collectively write into the file */
+    if ((mpi_err = MPI_File_write_at_all(fh,
+                                         mpi_off,
+                                         writedata,
+                                         bufcount,
+                                         buftype,
+                                         &mpi_stat)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_File_write_at offset(%ld), bytes (%d), failed (%s)\n",
+               (long) mpi_off, bufcount, mpi_err_str);
+        return 1;
+    } /* end if */
 
-     if ((mpi_err = MPI_File_close(&fh))
-	    != MPI_SUCCESS){
-	MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
-	printf("MPI_File_close failed. \n");
-	return 1;
-    };
+    /* Close the file */
+    if ((mpi_err = MPI_File_close(&fh)) != MPI_SUCCESS) {
+        MPI_Error_string(mpi_err, mpi_err_str, &mpi_err_strlen);
+        printf("MPI_File_close failed. \n");
+        return 1;
+    } /* end if */
 
+    /* Perform a barrier */
     mpi_err = MPI_Barrier(MPI_COMM_WORLD);
-#ifdef H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS
     if(retcode != 0) {
-	if(mpi_rank == 0) {
-	    printf("special collective IO is NOT working at this platform\n");
-	    printf("Go back to hdf5/config and find the corresponding\n");
-	    printf("configure-specific file (for example, powerpc-ibm-aix5.x) and add\n");
-	    printf("hdf5_cv_mpi_special_collective_io_works=${hdf5_cv_mpi_special_collective_io_works='no'}\n");
-	    printf(" at the end of the file.\n");
-	    printf(" Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
-	}
-	retcode = 1;
-    }
-#else
-    if(retcode == 0) {
-	if(mpi_rank == 0) {
-	    printf(" This is NOT an error, What it really says is\n");
-	    printf("special collective IO is WORKING at this platform\n");
-	    printf(" Go back to hdf5/config and find the corresponding \n");
-	    printf(" configure-specific file (for example, powerpc-ibm-aix5.x) and delete the line\n");
-	    printf("hdf5_cv_mpi_special_collective_io_works=${hdf5_cv_mpi_special_collective_io_works='no'}\n");
-	    printf(" at the end of the file.\n");
-	    printf("Please report to hdfhelp@ncsa.uiuc.edu about this problem.\n");
-	}
-	retcode = 1;
-    }
-#endif
+        if(mpi_rank == 0) {
+            printf("special collective IO is NOT working at this platform\n");
+            printf(" Please report to help@hdfgroup.org about this problem.\n");
+        } /* end if */
+        retcode = 1;
+    } /* end if */
+
     return retcode;
-}
+
+} /* test_mpio_special_collective */
 
 /*
  * parse the command line options
@@ -1226,22 +1200,8 @@ main(int argc, char **argv)
     /*=======================================
      * MPIO complicated derived datatype test
      *=======================================*/
-    /* test_mpio_derived_dtype often hangs when fails.
-     * Do not run it if it is known NOT working unless ask to
-     * run explicitly by high verbose mode.
-     */
-#ifdef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS
     MPI_BANNER("MPIO complicated derived datatype test...");
     ret_code = test_mpio_derived_dtype(filenames[0]);
-#else
-    if (VERBOSE_HI){
-	MPI_BANNER("MPIO complicated derived datatype test...");
-	ret_code = test_mpio_derived_dtype(filenames[0]);
-    }else{
-	MPI_BANNER("MPIO complicated derived datatype test SKIPPED.");
-	ret_code = 0;	/* fake ret_code */
-    }
-#endif
     ret_code = errors_sum(ret_code);
     if (mpi_rank==0 && ret_code > 0){
 	printf("***FAILED with %d total errors\n", ret_code);
@@ -1251,34 +1211,17 @@ main(int argc, char **argv)
     /*=======================================
      * MPIO special collective IO  test
      *=======================================*/
-    /* test_special_collective_io  often hangs when fails.
-     * Do not run it if it is known NOT working unless ask to
-     * run explicitly by high verbose mode.
-     */
-    if(mpi_size !=4){
-      MPI_BANNER("MPIO special collective io test SKIPPED.");
-      if(mpi_rank == 0){
-        printf("Use FOUR processes to run this test\n");
-        printf("If you still see the <test SKIPPED>, use <-vh> option to verify the test\n");
-  }
-      ret_code = 0;
-      goto sc_finish;
-    }
+    if (mpi_size < 4) {
+        MPI_BANNER("MPIO special collective io test SKIPPED.");
+        if (mpi_rank == 0)
+            printf("This test needs at least four processes to run.\n");
+        ret_code = 0;
+        goto sc_finish;
+    } /* end if */
 
-#ifdef H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS
     MPI_BANNER("MPIO special collective io test...");
     ret_code = test_mpio_special_collective(filenames[0]);
 
-#else
-    if (VERBOSE_HI){
-	MPI_BANNER("MPIO special collective io test...");
-	ret_code = test_mpio_special_collective(filenames[0]);
-    }else{
-	MPI_BANNER("MPIO special collective io test SKIPPED.");
-	ret_code = 0;	/* fake ret_code */
-    }
-#endif
-
 sc_finish:
     ret_code = errors_sum(ret_code);
     if (mpi_rank==0 && ret_code > 0){
diff --git a/testpar/t_posix_compliant.c b/testpar/t_posix_compliant.c
index 960f4c8..1bc0053 100644
--- a/testpar/t_posix_compliant.c
+++ b/testpar/t_posix_compliant.c
@@ -40,7 +40,9 @@
  *     mpiexec -np 3 ./t_posix_compliant
  */
 
+#ifdef H5_HAVE_UNISTD_H
 #include <unistd.h>
+#endif
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
diff --git a/testpar/t_shapesame.c b/testpar/t_shapesame.c
index a62e4f9..2d379d6 100644
--- a/testpar/t_shapesame.c
+++ b/testpar/t_shapesame.c
@@ -29,47 +29,6 @@
 #include "testphdf5.h"
 #include "H5Spkg.h"             /* Dataspaces                           */
 
-/* The following macros are used in the detection of tests that run overlong --
- * so that tests can be ommitted if necessary to get the overall set of tests
- * to complete.
- *
- * Observe that we can't do this if we don't have gettimeofday(), so in that
- * case, the macros resolve to the empty string.
- */
-
-#ifdef H5_HAVE_GETTIMEOFDAY
-
-#define	START_TIMER(time_tests, start_time, vrfy_msg)			\
-	{								\
-            int result;							\
-            if ( time_tests ) {						\
-                    result = HDgettimeofday(&(start_time), NULL);	\
-                    VRFY( (result == 0), (vrfy_msg));			\
-            }								\
-	}
-
-#define STOP_TIMER_AND_UPDATE(time_tests, end_time, vrfy_msg, times)	\
-        {								\
-            int result;							\
-            long long delta_usecs;					\
-            if ( time_tests ) {						\
-                result = HDgettimeofday(&(end_time), NULL);		\
-                VRFY( (result == 0), (vrfy_msg));			\
-                delta_usecs = 						\
-                   (1000000 * (timeval_b.tv_sec - timeval_a.tv_sec)) +	\
-                   (timeval_b.tv_usec - timeval_a.tv_usec);		\
-                HDassert( delta_usecs >= 0L );				\
-                (times) += delta_usecs;					\
-            }								\
-	}
-
-#else /* H5_HAVE_GETTIMEOFDAY */
-
-#define START_TIMER(time_tests, start_time, vrfy_msg)
-
-#define STOP_TIMER_AND_UPDATE(time_tests, end_time, vrfy_msg, times)
-
-#endif /* H5_HAVE_GETTIMEOFDAY */
 
 /* On Lustre (and perhaps other parallel file systems?), we have severe
  * slow downs if two or more processes attempt to access the same file system
@@ -81,101 +40,116 @@
 #define SHAPE_SAME_TEST_ALIGNMENT	((hsize_t)(4 * 1024 * 1024))
 
 
+#define PAR_SS_DR_MAX_RANK	5 	/* must update code if this changes */
+
+struct hs_dr_pio_test_vars_t
+{
+    int		mpi_size;
+    int         mpi_rank;
+    MPI_Comm    mpi_comm;
+    MPI_Info	mpi_info;
+    int         test_num;
+    int         edge_size;
+    int		checker_edge_size;
+    int         chunk_edge_size;
+    int         small_rank;
+    int         large_rank;
+    hid_t       dset_type;
+    uint32_t  * small_ds_buf_0;
+    uint32_t  * small_ds_buf_1;
+    uint32_t  * small_ds_buf_2;
+    uint32_t  * small_ds_slice_buf;
+    uint32_t  * large_ds_buf_0;
+    uint32_t  * large_ds_buf_1;
+    uint32_t  * large_ds_buf_2;
+    uint32_t  * large_ds_slice_buf;
+    int         small_ds_offset;
+    int         large_ds_offset;
+    hid_t       fid;               /* HDF5 file ID */
+    hid_t	xfer_plist;
+    hid_t       full_mem_small_ds_sid;
+    hid_t       full_file_small_ds_sid;
+    hid_t       mem_small_ds_sid;
+    hid_t       file_small_ds_sid_0;
+    hid_t       file_small_ds_sid_1;
+    hid_t	small_ds_slice_sid;
+    hid_t       full_mem_large_ds_sid;
+    hid_t       full_file_large_ds_sid;
+    hid_t       mem_large_ds_sid;
+    hid_t       file_large_ds_sid_0;
+    hid_t       file_large_ds_sid_1;
+    hid_t       file_large_ds_process_slice_sid;
+    hid_t       mem_large_ds_process_slice_sid;
+    hid_t	large_ds_slice_sid;
+    hid_t       small_dataset;     /* Dataset ID */
+    hid_t       large_dataset;     /* Dataset ID */
+    size_t      small_ds_size;
+    size_t      small_ds_slice_size;
+    size_t      large_ds_size;
+    size_t      large_ds_slice_size;
+    hsize_t     dims[PAR_SS_DR_MAX_RANK];
+    hsize_t     chunk_dims[PAR_SS_DR_MAX_RANK];
+    hsize_t     start[PAR_SS_DR_MAX_RANK];
+    hsize_t     stride[PAR_SS_DR_MAX_RANK];
+    hsize_t     count[PAR_SS_DR_MAX_RANK];
+    hsize_t     block[PAR_SS_DR_MAX_RANK];
+    hsize_t   * start_ptr;
+    hsize_t   * stride_ptr;
+    hsize_t   * count_ptr;
+    hsize_t   * block_ptr;
+    int         skips;
+    int	        max_skips;
+    int64_t	total_tests;
+    int64_t	tests_run;
+    int64_t	tests_skipped;
+};
+
 /*-------------------------------------------------------------------------
- * Function:	contig_hyperslab_dr_pio_test__run_test()
+ * Function:	hs_dr_pio_test__setup()
  *
- * Purpose:	Test I/O to/from hyperslab selections of different rank in
- *		the parallel.
+ * Purpose:	Do setup for tests of I/O to/from hyperslab selections of 
+ * 		different rank in the parallel case.
  *
  * Return:	void
  *
- * Programmer:	JRM -- 9/18/09
+ * Programmer:	JRM -- 8/9/11
  *
  * Modifications:
  *
- *		JRM -- 9/16/10
- *		Added express_test parameter.  Use it to control whether 
- *		we set up the chunks so that no chunk is shared between 
- *		processes, and also whether we set an alignment when we 
- *		create the test file.
+ *		None.
  *
  *-------------------------------------------------------------------------
  */
 
-#define PAR_SS_DR_MAX_RANK	5
-#define CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 0
+#define CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG 0
 
 static void
-contig_hyperslab_dr_pio_test__run_test(const int test_num,
-                                       const int edge_size,
-                                       const int chunk_edge_size,
-                                       const int small_rank,
-                                       const int large_rank,
-                                       const hbool_t use_collective_io,
-                                       const hid_t dset_type,
-                                       const int express_test)
+hs_dr_pio_test__setup(const int test_num,
+                      const int edge_size,
+                      const int checker_edge_size,
+                      const int chunk_edge_size,
+                      const int small_rank,
+                      const int large_rank,
+                      const hbool_t use_collective_io,
+                      const hid_t dset_type,
+                      const int express_test,
+                      struct hs_dr_pio_test_vars_t * tv_ptr)
 {
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-    const char *fcnName = "contig_hyperslab_dr_pio_test__run_test()";
-#endif /* CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */
+#if CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG 
+    const char *fcnName = "hs_dr_pio_test__setup()";
+#endif /* CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG */
     const char *filename;
     hbool_t	use_gpfs = FALSE;   /* Use GPFS hints */
     hbool_t	mis_match = FALSE;
-    int		i, j, k, l;
-    size_t	n;
+    int		i;
     int         mrc;
-    int		mpi_size = -1;
-    int         mpi_rank = -1;
-    size_t      start_index;
-    size_t      stop_index;
-    const int   test_max_rank = 5;  /* must update code if this changes */
+    int		mpi_rank; /* needed by the VRFY macro */
     uint32_t	expected_value;
-    uint32_t  * small_ds_buf_0 = NULL;
-    uint32_t  * small_ds_buf_1 = NULL;
-    uint32_t  * small_ds_buf_2 = NULL;
-    uint32_t  * small_ds_slice_buf = NULL;
-    uint32_t  * large_ds_buf_0 = NULL;
-    uint32_t  * large_ds_buf_1 = NULL;
-    uint32_t  * large_ds_buf_2 = NULL;
-    uint32_t  * large_ds_slice_buf = NULL;
     uint32_t  * ptr_0;
     uint32_t  * ptr_1;
-    MPI_Comm    mpi_comm = MPI_COMM_NULL;
-    MPI_Info	mpi_info = MPI_INFO_NULL;
-    hid_t       fid;			/* HDF5 file ID */
     hid_t	acc_tpl;		/* File access templates */
-    hid_t	xfer_plist = H5P_DEFAULT;
-    hid_t       full_mem_small_ds_sid;
-    hid_t       full_file_small_ds_sid;
-    hid_t       mem_small_ds_sid;
-    hid_t       file_small_ds_sid;
-    hid_t	small_ds_slice_sid;
-    hid_t       full_mem_large_ds_sid;
-    hid_t       full_file_large_ds_sid;
-    hid_t       mem_large_ds_sid;
-    hid_t       file_large_ds_sid;
-    hid_t       file_large_ds_process_slice_sid;
-    hid_t       mem_large_ds_process_slice_sid;
-    hid_t	large_ds_slice_sid;
     hid_t       small_ds_dcpl_id = H5P_DEFAULT;
     hid_t       large_ds_dcpl_id = H5P_DEFAULT;
-    hid_t       small_dataset;     /* Dataset ID                   */
-    hid_t       large_dataset;     /* Dataset ID                   */
-    size_t      small_ds_size = 1;
-    size_t      small_ds_slice_size = 1;
-    size_t      large_ds_size = 1;
-    size_t      large_ds_slice_size = 1;
-    hsize_t     dims[PAR_SS_DR_MAX_RANK];
-    hsize_t     chunk_dims[PAR_SS_DR_MAX_RANK];
-    hsize_t     start[PAR_SS_DR_MAX_RANK];
-    hsize_t     stride[PAR_SS_DR_MAX_RANK];
-    hsize_t     count[PAR_SS_DR_MAX_RANK];
-    hsize_t     block[PAR_SS_DR_MAX_RANK];
-    hsize_t   * start_ptr = NULL;
-    hsize_t   * stride_ptr = NULL;
-    hsize_t   * count_ptr = NULL;
-    hsize_t   * block_ptr = NULL;
-    htri_t      check;          /* Shape comparison return value */
     herr_t	ret;		/* Generic return value */
 
     HDassert( edge_size >= 6 );
@@ -183,107 +157,132 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     HDassert( ( chunk_edge_size == 0 ) || ( chunk_edge_size >= 3 ) );
     HDassert( 1 < small_rank );
     HDassert( small_rank < large_rank );
-    HDassert( large_rank <= test_max_rank );
-    HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK );
+    HDassert( large_rank <= PAR_SS_DR_MAX_RANK );
 
-    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
-    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
+    tv_ptr->test_num = test_num;
+    tv_ptr->edge_size = edge_size;
+    tv_ptr->checker_edge_size = checker_edge_size;
+    tv_ptr->chunk_edge_size = chunk_edge_size;
+    tv_ptr->small_rank = small_rank;
+    tv_ptr->large_rank = large_rank;
+    tv_ptr->dset_type = dset_type;
 
-    HDassert( mpi_size >= 1 );
+    MPI_Comm_size(MPI_COMM_WORLD, &(tv_ptr->mpi_size));
+    MPI_Comm_rank(MPI_COMM_WORLD, &(tv_ptr->mpi_rank));
+    /* the VRFY() macro needs the local variable mpi_rank -- set it up now */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    mpi_comm = MPI_COMM_WORLD;
-    mpi_info = MPI_INFO_NULL;
+    HDassert( tv_ptr->mpi_size >= 1 );
 
-    for ( i = 0; i < small_rank - 1; i++ )
+    tv_ptr->mpi_comm = MPI_COMM_WORLD;
+    tv_ptr->mpi_info = MPI_INFO_NULL;
+
+    for ( i = 0; i < tv_ptr->small_rank - 1; i++ )
     {
-        small_ds_size *= (size_t)edge_size;
-        small_ds_slice_size *= (size_t)edge_size;
+        tv_ptr->small_ds_size *= (size_t)(tv_ptr->edge_size);
+        tv_ptr->small_ds_slice_size *= (size_t)(tv_ptr->edge_size);
     }
-    small_ds_size *= (size_t)(mpi_size + 1);
+    tv_ptr->small_ds_size *= (size_t)(tv_ptr->mpi_size + 1);
+
+    /* used by checker board tests only */
+    tv_ptr->small_ds_offset = PAR_SS_DR_MAX_RANK - tv_ptr->small_rank;
 
+    HDassert( 0 < tv_ptr->small_ds_offset );
+    HDassert( tv_ptr->small_ds_offset < PAR_SS_DR_MAX_RANK );
 
-    for ( i = 0; i < large_rank - 1; i++ ) {
+    for ( i = 0; i < tv_ptr->large_rank - 1; i++ ) {
 
-        large_ds_size *= (size_t)edge_size;
-        large_ds_slice_size *= (size_t)edge_size;
+        tv_ptr->large_ds_size *= (size_t)(tv_ptr->edge_size);
+        tv_ptr->large_ds_slice_size *= (size_t)(tv_ptr->edge_size);
     }
-    large_ds_size *= (size_t)(mpi_size + 1);
+    tv_ptr->large_ds_size *= (size_t)(tv_ptr->mpi_size + 1);
+
+    /* used by checker board tests only */
+    tv_ptr->large_ds_offset = PAR_SS_DR_MAX_RANK - tv_ptr->large_rank;
+
+    HDassert( 0 <= tv_ptr->large_ds_offset );
+    HDassert( tv_ptr->large_ds_offset < PAR_SS_DR_MAX_RANK );
 
 
     /* set up the start, stride, count, and block pointers */
-    start_ptr  = &(start[PAR_SS_DR_MAX_RANK - large_rank]);
-    stride_ptr = &(stride[PAR_SS_DR_MAX_RANK - large_rank]);
-    count_ptr  = &(count[PAR_SS_DR_MAX_RANK - large_rank]);
-    block_ptr  = &(block[PAR_SS_DR_MAX_RANK - large_rank]);
+    /* used by contiguous tests only */
+    tv_ptr->start_ptr  = &(tv_ptr->start[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]);
+    tv_ptr->stride_ptr = &(tv_ptr->stride[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]);
+    tv_ptr->count_ptr  = &(tv_ptr->count[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]);
+    tv_ptr->block_ptr  = &(tv_ptr->block[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]);
 
 
     /* Allocate buffers */
-    small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded");
+    tv_ptr->small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
+    VRFY((tv_ptr->small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded");
 
-    small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded");
+    tv_ptr->small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
+    VRFY((tv_ptr->small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded");
 
-    small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded");
+    tv_ptr->small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size);
+    VRFY((tv_ptr->small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded");
 
-    small_ds_slice_buf = 
-	(uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_slice_size);
-    VRFY((small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded");
+    tv_ptr->small_ds_slice_buf = 
+        (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_slice_size);
+    VRFY((tv_ptr->small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded");
 
-    large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded");
+    tv_ptr->large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
+    VRFY((tv_ptr->large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded");
 
-    large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
+    tv_ptr->large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
+    VRFY((tv_ptr->large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
 
-    large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded");
+    tv_ptr->large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size);
+    VRFY((tv_ptr->large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded");
 
-    large_ds_slice_buf = 
-	(uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_slice_size);
-    VRFY((large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded");
+    tv_ptr->large_ds_slice_buf = 
+        (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_slice_size);
+    VRFY((tv_ptr->large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded");
 
     /* initialize the buffers */
 
-    ptr_0 = small_ds_buf_0;
-    for(i = 0; i < (int)small_ds_size; i++)
+    ptr_0 = tv_ptr->small_ds_buf_0;
+    for(i = 0; i < (int)(tv_ptr->small_ds_size); i++)
         *ptr_0++ = (uint32_t)i;
-    HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
-    HDmemset(small_ds_buf_2, 0, sizeof(uint32_t) * small_ds_size);
+    HDmemset(tv_ptr->small_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->small_ds_size);
+    HDmemset(tv_ptr->small_ds_buf_2, 0, sizeof(uint32_t) * tv_ptr->small_ds_size);
 
-    HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
+    HDmemset(tv_ptr->small_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->small_ds_slice_size);
 
-    ptr_0 = large_ds_buf_0;
-    for(i = 0; i < (int)large_ds_size; i++)
+    ptr_0 = tv_ptr->large_ds_buf_0;
+    for(i = 0; i < (int)(tv_ptr->large_ds_size); i++)
         *ptr_0++ = (uint32_t)i;
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
-    HDmemset(large_ds_buf_2, 0, sizeof(uint32_t) * large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_2, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
 
-    HDmemset(large_ds_slice_buf, 0, sizeof(uint32_t) * large_ds_slice_size);
+    HDmemset(tv_ptr->large_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->large_ds_slice_size);
 
     filename = (const char *)GetTestParameters();
     HDassert( filename != NULL );
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG 
     if ( MAINPROCESS ) {
 
-        HDfprintf(stdout, "%d: test num = %d.\n", mpi_rank, test_num);
-        HDfprintf(stdout, "%d: mpi_size = %d.\n", mpi_rank, mpi_size);
+        HDfprintf(stdout, "%d: test num = %d.\n", tv_ptr->mpi_rank, tv_ptr->test_num);
+        HDfprintf(stdout, "%d: mpi_size = %d.\n", tv_ptr->mpi_rank, tv_ptr->mpi_size);
         HDfprintf(stdout, 
                   "%d: small/large rank = %d/%d, use_collective_io = %d.\n",
-                  mpi_rank, small_rank, large_rank, (int)use_collective_io);
+                  tv_ptr->mpi_rank, tv_ptr->small_rank, tv_ptr->large_rank, 
+                  (int)use_collective_io);
         HDfprintf(stdout, "%d: edge_size = %d, chunk_edge_size = %d.\n",
-                  mpi_rank, edge_size, chunk_edge_size);
+                  tv_ptr->mpi_rank, tv_ptr->edge_size, tv_ptr->chunk_edge_size);
+        HDfprintf(stdout, "%d: checker_edge_size = %d.\n",
+                  tv_ptr->mpi_rank, tv_ptr->checker_edge_size);
         HDfprintf(stdout, "%d: small_ds_size = %d, large_ds_size = %d.\n",
-                  mpi_rank, (int)small_ds_size, (int)large_ds_size);
-        HDfprintf(stdout, "%d: filename = %s.\n", mpi_rank, filename);
+                  tv_ptr->mpi_rank, (int)(tv_ptr->small_ds_size), 
+                  (int)(tv_ptr->large_ds_size));
+        HDfprintf(stdout, "%d: filename = %s.\n", tv_ptr->mpi_rank, filename);
     }
-#endif
+#endif /* CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG */
     /* ----------------------------------------
      * CREATE AN HDF5 FILE WITH PARALLEL ACCESS
      * ---------------------------------------*/
     /* setup file access template */
-    acc_tpl = create_faccess_plist(mpi_comm, mpi_info, facc_type, use_gpfs);
+    acc_tpl = create_faccess_plist(tv_ptr->mpi_comm, tv_ptr->mpi_info, facc_type, use_gpfs);
     VRFY((acc_tpl >= 0), "create_faccess_plist() succeeded");
 
     /* set the alignment -- need it large so that we aren't always hitting the
@@ -297,8 +296,8 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     /* create the file collectively */
-    fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl);
-    VRFY((fid >= 0), "H5Fcreate succeeded");
+    tv_ptr->fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl);
+    VRFY((tv_ptr->fid >= 0), "H5Fcreate succeeded");
 
     MESG("File opened.");
 
@@ -308,60 +307,79 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
 
     /* setup dims: */
-    dims[0] = (hsize_t)(mpi_size + 1);
-    dims[1] = dims[2] = dims[3] = dims[4] = (hsize_t)edge_size;
+    tv_ptr->dims[0] = (hsize_t)(tv_ptr->mpi_size + 1);
+    tv_ptr->dims[1] = tv_ptr->dims[2] = 
+        tv_ptr->dims[3] = tv_ptr->dims[4] = (hsize_t)(tv_ptr->edge_size);
 
 
     /* Create small ds dataspaces */
-    full_mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((full_mem_small_ds_sid != 0), 
+    tv_ptr->full_mem_small_ds_sid = 
+        H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->full_mem_small_ds_sid != 0), 
          "H5Screate_simple() full_mem_small_ds_sid succeeded");
 
-    full_file_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((full_file_small_ds_sid != 0), 
+    tv_ptr->full_file_small_ds_sid = 
+        H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->full_file_small_ds_sid != 0), 
          "H5Screate_simple() full_file_small_ds_sid succeeded");
 
-    mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((mem_small_ds_sid != 0), 
-	 "H5Screate_simple() mem_small_ds_sid succeeded");
+    tv_ptr->mem_small_ds_sid = H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->mem_small_ds_sid != 0), 
+         "H5Screate_simple() mem_small_ds_sid succeeded");
 
-    file_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((file_small_ds_sid != 0), 
-         "H5Screate_simple() file_small_ds_sid succeeded");
+    tv_ptr->file_small_ds_sid_0 = H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->file_small_ds_sid_0 != 0), 
+         "H5Screate_simple() file_small_ds_sid_0 succeeded");
+
+    /* used by checker board tests only */
+    tv_ptr->file_small_ds_sid_1 = H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->file_small_ds_sid_1 != 0), 
+         "H5Screate_simple() file_small_ds_sid_1 succeeded");
 
-    small_ds_slice_sid = H5Screate_simple(small_rank - 1, &(dims[1]), NULL);
-    VRFY((small_ds_slice_sid != 0), 
+    tv_ptr->small_ds_slice_sid = 
+        H5Screate_simple(tv_ptr->small_rank - 1, &(tv_ptr->dims[1]), NULL);
+    VRFY((tv_ptr->small_ds_slice_sid != 0), 
          "H5Screate_simple() small_ds_slice_sid succeeded");
 
 
     /* Create large ds dataspaces */
-    full_mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((full_mem_large_ds_sid != 0), 
+    tv_ptr->full_mem_large_ds_sid = 
+        H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->full_mem_large_ds_sid != 0), 
          "H5Screate_simple() full_mem_large_ds_sid succeeded");
 
-    full_file_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((full_file_large_ds_sid != FAIL), 
+    tv_ptr->full_file_large_ds_sid = 
+        H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->full_file_large_ds_sid != FAIL), 
          "H5Screate_simple() full_file_large_ds_sid succeeded");
 
-    mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((mem_large_ds_sid != FAIL), 
+    tv_ptr->mem_large_ds_sid = H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->mem_large_ds_sid != FAIL), 
          "H5Screate_simple() mem_large_ds_sid succeeded");
 
-    file_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((file_large_ds_sid != FAIL), 
-         "H5Screate_simple() file_large_ds_sid succeeded");
+    tv_ptr->file_large_ds_sid_0 = H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->file_large_ds_sid_0 != FAIL), 
+         "H5Screate_simple() file_large_ds_sid_0 succeeded");
 
-    mem_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((mem_large_ds_process_slice_sid != FAIL), 
+    /* used by checker board tests only */
+    tv_ptr->file_large_ds_sid_1 = H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->file_large_ds_sid_1 != FAIL), 
+         "H5Screate_simple() file_large_ds_sid_1 succeeded");
+
+    tv_ptr->mem_large_ds_process_slice_sid = 
+        H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->mem_large_ds_process_slice_sid != FAIL), 
          "H5Screate_simple() mem_large_ds_process_slice_sid succeeded");
 
-    file_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((file_large_ds_process_slice_sid != FAIL), 
+    tv_ptr->file_large_ds_process_slice_sid = 
+        H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL);
+    VRFY((tv_ptr->file_large_ds_process_slice_sid != FAIL), 
          "H5Screate_simple() file_large_ds_process_slice_sid succeeded");
 
 
-    large_ds_slice_sid = H5Screate_simple(large_rank - 1, &(dims[1]), NULL);
-    VRFY((large_ds_slice_sid != 0), 
+    tv_ptr->large_ds_slice_sid = 
+        H5Screate_simple(tv_ptr->large_rank - 1, &(tv_ptr->dims[1]), NULL);
+    VRFY((tv_ptr->large_ds_slice_sid != 0), 
          "H5Screate_simple() large_ds_slice_sid succeeded");
 
 
@@ -369,10 +387,10 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * large data set creation property lists to specify chunked
      * datasets.
      */
-    if ( chunk_edge_size > 0 ) {
+    if ( tv_ptr->chunk_edge_size > 0 ) {
 
         /* Under Lustre (and perhaps other parallel file systems?) we get 
-	 * locking delays when two or more processes attempt to access the 
+         * locking delays when two or more processes attempt to access the 
          * same file system block.
          *
          * To minimize this problem, I have changed chunk_dims[0] 
@@ -390,14 +408,15 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
          */
         if ( express_test == 0 ) {
 
-            chunk_dims[0] = 1;
+            tv_ptr->chunk_dims[0] = 1;
 
         } else {
 
-            chunk_dims[0] = 1;
+            tv_ptr->chunk_dims[0] = 1;
         }
-        chunk_dims[1] = chunk_dims[2] = 
-                        chunk_dims[3] = chunk_dims[4] = (hsize_t)chunk_edge_size;
+        tv_ptr->chunk_dims[1] = tv_ptr->chunk_dims[2] = 
+                                tv_ptr->chunk_dims[3] = 
+                                tv_ptr->chunk_dims[4] = (hsize_t)(tv_ptr->chunk_edge_size);
 
         small_ds_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
         VRFY((ret != FAIL), "H5Pcreate() small_ds_dcpl_id succeeded");
@@ -405,7 +424,7 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
         ret = H5Pset_layout(small_ds_dcpl_id, H5D_CHUNKED);
         VRFY((ret != FAIL), "H5Pset_layout() small_ds_dcpl_id succeeded");
 
-        ret = H5Pset_chunk(small_ds_dcpl_id, small_rank, chunk_dims);
+        ret = H5Pset_chunk(small_ds_dcpl_id, tv_ptr->small_rank, tv_ptr->chunk_dims);
         VRFY((ret != FAIL), "H5Pset_chunk() small_ds_dcpl_id succeeded");
 
 
@@ -415,89 +434,88 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
         ret = H5Pset_layout(large_ds_dcpl_id, H5D_CHUNKED);
         VRFY((ret != FAIL), "H5Pset_layout() large_ds_dcpl_id succeeded");
 
-        ret = H5Pset_chunk(large_ds_dcpl_id, large_rank, chunk_dims);
+        ret = H5Pset_chunk(large_ds_dcpl_id, tv_ptr->large_rank, tv_ptr->chunk_dims);
         VRFY((ret != FAIL), "H5Pset_chunk() large_ds_dcpl_id succeeded");
     }
 
     /* create the small dataset */
-    small_dataset = H5Dcreate2(fid, "small_dataset", dset_type,
-                               file_small_ds_sid, H5P_DEFAULT,
-                               small_ds_dcpl_id, H5P_DEFAULT);
+    tv_ptr->small_dataset = H5Dcreate2(tv_ptr->fid, "small_dataset", tv_ptr->dset_type,
+                                       tv_ptr->file_small_ds_sid_0, H5P_DEFAULT,
+                                       small_ds_dcpl_id, H5P_DEFAULT);
     VRFY((ret != FAIL), "H5Dcreate2() small_dataset succeeded");
 
     /* create the large dataset */
-    large_dataset = H5Dcreate2(fid, "large_dataset", dset_type,
-                               file_large_ds_sid, H5P_DEFAULT,
-                               large_ds_dcpl_id, H5P_DEFAULT);
+    tv_ptr->large_dataset = H5Dcreate2(tv_ptr->fid, "large_dataset", tv_ptr->dset_type,
+                                       tv_ptr->file_large_ds_sid_0, H5P_DEFAULT,
+                                       large_ds_dcpl_id, H5P_DEFAULT);
     VRFY((ret != FAIL), "H5Dcreate2() large_dataset succeeded");
 
 
-
     /* setup xfer property list */
-    xfer_plist = H5Pcreate(H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded");
+    tv_ptr->xfer_plist = H5Pcreate(H5P_DATASET_XFER);
+    VRFY((tv_ptr->xfer_plist >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded");
 
     if(use_collective_io) {
-        ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
+        ret = H5Pset_dxpl_mpio(tv_ptr->xfer_plist, H5FD_MPIO_COLLECTIVE);
         VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
     }
 
     /* setup selection to write initial data to the small and large data sets */
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
     /* setup selections for writing initial data to the small data set */
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
 
-    ret = H5Sselect_hyperslab(file_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded");
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
+    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded");
 
     if ( MAINPROCESS ) { /* add an additional slice to the selections */
 
-        start[0] = (hsize_t)mpi_size;
+        tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_size);
 
-        ret = H5Sselect_hyperslab(mem_small_ds_sid,
+        ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid,
                                   H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
+                                  tv_ptr->start,
+                                  tv_ptr->stride,
+                                  tv_ptr->count,
+                                  tv_ptr->block);
         VRFY((ret>= 0), "H5Sselect_hyperslab(mem_small_ds_sid, or) suceeded");
 
-        ret = H5Sselect_hyperslab(file_small_ds_sid,
+        ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0,
                                   H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid, or) suceeded");
+                                  tv_ptr->start,
+                                  tv_ptr->stride,
+                                  tv_ptr->count,
+                                  tv_ptr->block);
+        VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, or) suceeded");
     }
 
 
     /* write the initial value of the small data set to file */
-    ret = H5Dwrite(small_dataset, dset_type, mem_small_ds_sid, file_small_ds_sid,
-                   xfer_plist, small_ds_buf_0);
+    ret = H5Dwrite(tv_ptr->small_dataset, tv_ptr->dset_type, tv_ptr->mem_small_ds_sid, 
+                   tv_ptr->file_small_ds_sid_0, tv_ptr->xfer_plist, tv_ptr->small_ds_buf_0);
 
     VRFY((ret >= 0), "H5Dwrite() small_dataset initial write succeeded");
 
@@ -511,24 +529,24 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
     /* read the small data set back to verify that it contains the 
      * expected data.  Note that each process reads in the entire 
-     * data set.
+     * data set and verifies it.
      */
-    ret = H5Dread(small_dataset,
+    ret = H5Dread(tv_ptr->small_dataset,
                   H5T_NATIVE_UINT32,
-                  full_mem_small_ds_sid,
-                  full_file_small_ds_sid,
-                  xfer_plist,
-                  small_ds_buf_1);
+                  tv_ptr->full_mem_small_ds_sid,
+                  tv_ptr->full_file_small_ds_sid,
+                  tv_ptr->xfer_plist,
+                  tv_ptr->small_ds_buf_1);
     VRFY((ret >= 0), "H5Dread() small_dataset initial read succeeded");
 
 
     /* verify that the correct data was written to the small data set */
     expected_value = 0;
     mis_match = FALSE;
-    ptr_1 = small_ds_buf_1;
+    ptr_1 = tv_ptr->small_ds_buf_1;
 
     i = 0;
-    for ( i = 0; i < (int)small_ds_size; i++ ) {
+    for ( i = 0; i < (int)(tv_ptr->small_ds_size); i++ ) {
 
         if ( *ptr_1 != expected_value ) {
 
@@ -540,72 +558,72 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     VRFY( (mis_match == FALSE), "small ds init data good.");
 
 
-
     /* setup selections for writing initial data to the large data set */
 
-    start[0] = (hsize_t)mpi_rank;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
 
-    ret = H5Sselect_hyperslab(mem_large_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_large_ds_sid, set) suceeded");
 
-    ret = H5Sselect_hyperslab(file_large_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid, set) suceeded");
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
+    VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, set) suceeded");
  
     /* In passing, setup the process slice data spaces as well */
 
-    ret = H5Sselect_hyperslab(mem_large_ds_process_slice_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_process_slice_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), 
          "H5Sselect_hyperslab(mem_large_ds_process_slice_sid, set) suceeded");
 
-    ret = H5Sselect_hyperslab(file_large_ds_process_slice_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_process_slice_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), 
          "H5Sselect_hyperslab(file_large_ds_process_slice_sid, set) suceeded");
 
     if ( MAINPROCESS ) { /* add an additional slice to the selections */
 
-        start[0] = (hsize_t)mpi_size;
+        tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_size);
 
-        ret = H5Sselect_hyperslab(mem_large_ds_sid,
+        ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid,
                                   H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
+                                  tv_ptr->start,
+                                  tv_ptr->stride,
+                                  tv_ptr->count,
+                                  tv_ptr->block);
         VRFY((ret>= 0), "H5Sselect_hyperslab(mem_large_ds_sid, or) suceeded");
 
-        ret = H5Sselect_hyperslab(file_large_ds_sid,
+        ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0,
                                   H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid, or) suceeded");
+                                  tv_ptr->start,
+                                  tv_ptr->stride,
+                                  tv_ptr->count,
+                                  tv_ptr->block);
+        VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, or) suceeded");
     }
 
 
     /* write the initial value of the large data set to file */
-    ret = H5Dwrite(large_dataset, dset_type, mem_large_ds_sid, file_large_ds_sid,
-                   xfer_plist, large_ds_buf_0);
+    ret = H5Dwrite(tv_ptr->large_dataset, tv_ptr->dset_type, 
+                   tv_ptr->mem_large_ds_sid, tv_ptr->file_large_ds_sid_0, 
+                   tv_ptr->xfer_plist, tv_ptr->large_ds_buf_0);
     if ( ret < 0 ) H5Eprint2(H5E_DEFAULT, stderr);
     VRFY((ret >= 0), "H5Dwrite() large_dataset initial write succeeded");
 
@@ -618,26 +636,26 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
 
-    /* read the small data set back to verify that it contains the 
+    /* read the large data set back to verify that it contains the 
      * expected data.  Note that each process reads in the entire 
      * data set.
      */
-    ret = H5Dread(large_dataset,
+    ret = H5Dread(tv_ptr->large_dataset,
                   H5T_NATIVE_UINT32,
-                  full_mem_large_ds_sid,
-                  full_file_large_ds_sid,
-                  xfer_plist,
-                  large_ds_buf_1);
+                  tv_ptr->full_mem_large_ds_sid,
+                  tv_ptr->full_file_large_ds_sid,
+                  tv_ptr->xfer_plist,
+                  tv_ptr->large_ds_buf_1);
     VRFY((ret >= 0), "H5Dread() large_dataset initial read succeeded");
 
 
     /* verify that the correct data was written to the large data set */
     expected_value = 0;
     mis_match = FALSE;
-    ptr_1 = large_ds_buf_1;
+    ptr_1 = tv_ptr->large_ds_buf_1;
 
     i = 0;
-    for ( i = 0; i < (int)large_ds_size; i++ ) {
+    for ( i = 0; i < (int)(tv_ptr->large_ds_size); i++ ) {
 
         if ( *ptr_1 != expected_value ) {
 
@@ -657,18 +675,170 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
         VRFY((mrc==MPI_SUCCESS), "Sync initial values check");
     }
 
+    return;
+
+} /* hs_dr_pio_test__setup() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	hs_dr_pio_test__takedown()
+ *
+ * Purpose:	Do takedown after tests of I/O to/from hyperslab selections 
+ *		of different rank in the parallel case.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 9/18/09
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define HS_DR_PIO_TEST__TAKEDOWN__DEBUG 0
+
+static void
+hs_dr_pio_test__takedown( struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if HS_DR_PIO_TEST__TAKEDOWN__DEBUG 
+    const char *fcnName = "hs_dr_pio_test__takedown()";
+#endif /* HS_DR_PIO_TEST__TAKEDOWN__DEBUG */
+    int		mpi_rank;       /* needed by the VRFY macro */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
+
+    /* Close property lists */
+    if ( tv_ptr->xfer_plist != H5P_DEFAULT ) {
+        ret = H5Pclose(tv_ptr->xfer_plist);
+        VRFY((ret != FAIL), "H5Pclose(xfer_plist) succeeded");
+    }
+
+    /* Close dataspaces */
+    ret = H5Sclose(tv_ptr->full_mem_small_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->full_file_small_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(full_file_small_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->mem_small_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(mem_small_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->file_small_ds_sid_0);
+    VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_0) succeeded");
+
+    ret = H5Sclose(tv_ptr->file_small_ds_sid_1);
+    VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_1) succeeded");
+
+    ret = H5Sclose(tv_ptr->small_ds_slice_sid);
+    VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->full_mem_large_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->full_file_large_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(full_file_large_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->mem_large_ds_sid);
+    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->file_large_ds_sid_0);
+    VRFY((ret != FAIL), "H5Sclose(file_large_ds_sid_0) succeeded");
+
+    ret = H5Sclose(tv_ptr->file_large_ds_sid_1);
+    VRFY((ret != FAIL), "H5Sclose(file_large_ds_sid_1) succeeded");
+
+    ret = H5Sclose(tv_ptr->mem_large_ds_process_slice_sid);
+    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_process_slice_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->file_large_ds_process_slice_sid);
+    VRFY((ret != FAIL), "H5Sclose(file_large_ds_process_slice_sid) succeeded");
+
+    ret = H5Sclose(tv_ptr->large_ds_slice_sid);
+    VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded");
+
+    /* Close Datasets */
+    ret = H5Dclose(tv_ptr->small_dataset);
+    VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
+
+    ret = H5Dclose(tv_ptr->large_dataset);
+    VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded");
+
+    /* close the file collectively */
+    MESG("about to close file.");
+    ret = H5Fclose(tv_ptr->fid);
+    VRFY((ret != FAIL), "file close succeeded");
+
+    /* Free memory buffers */
+
+    if ( tv_ptr->small_ds_buf_0 != NULL ) HDfree(tv_ptr->small_ds_buf_0);
+    if ( tv_ptr->small_ds_buf_1 != NULL ) HDfree(tv_ptr->small_ds_buf_1);
+    if ( tv_ptr->small_ds_buf_2 != NULL ) HDfree(tv_ptr->small_ds_buf_2);
+    if ( tv_ptr->small_ds_slice_buf != NULL ) HDfree(tv_ptr->small_ds_slice_buf);
+
+    if ( tv_ptr->large_ds_buf_0 != NULL ) HDfree(tv_ptr->large_ds_buf_0);
+    if ( tv_ptr->large_ds_buf_1 != NULL ) HDfree(tv_ptr->large_ds_buf_1);
+    if ( tv_ptr->large_ds_buf_2 != NULL ) HDfree(tv_ptr->large_ds_buf_2);
+    if ( tv_ptr->large_ds_slice_buf != NULL ) HDfree(tv_ptr->large_ds_slice_buf);
+
+    return;
+
+} /* hs_dr_pio_test__takedown() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	contig_hs_dr_pio_test__d2m_l2s()
+ *
+ * Purpose:	Part one of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can read from disk correctly using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *              In this function, we test this by reading small_rank - 1 
+ *		slices from the on disk large cube, and verifying that the 
+ *		data read is correct.  Verify that H5S_select_shape_same() 
+ *		returns true on the memory and file selections.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 9/10/11
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG 0
+
+static void
+contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+    const char *fcnName = "contig_hs_dr_pio_test__run_test()";
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t	n;
+    int		mpi_rank; /* needed by the VRFY macro */
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    /* first, verify that we can read from disk correctly using selections
-     * of different rank that H5S_select_shape_same() views as being of the
-     * same shape.
-     *
-     * Start by reading small_rank-D - 1 slice from the on disk large cube, 
-     * and verifying that the data read is correct.  Verify that 
-     * H5S_select_shape_same() returns true on the memory and file selections.
-     */
 
     /* We have already done a H5Sselect_all() on the data space 
-     * small_ds_slice_sid, so no need to call H5Sselect_all() again.
+     * small_ds_slice_sid in the initialization phase, so no need to 
+     * call H5Sselect_all() again.
      */
 
     /* set up start, stride, count, and block -- note that we will
@@ -676,27 +846,28 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
     /* zero out the buffer we will be reading into */
-    HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
+    HDmemset(tv_ptr->small_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->small_ds_slice_size);
 
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
     HDfprintf(stdout, 
               "%s reading slices from big cube on disk into small cube slice.\n",
               fcnName);
-#endif 
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
+
     /* in serial versions of this test, we loop through all the dimensions
      * of the large data set.  However, in the parallel version, each 
      * process only works with that slice of the large cube indicated
@@ -704,9 +875,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * mpi_rank, and don't itterate over it.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -719,9 +890,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -729,9 +900,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -751,145 +922,213 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank - 1 >= 1 and that 
-                 * large_rank > small_rank by the assertions at the head 
-                 * of this function.  Thus no need for another inner loop.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                ret = H5Sselect_hyperslab(file_large_ds_sid,
-                                          H5S_SELECT_SET,
-                                          start_ptr,
-                                          stride_ptr,
-                                          count_ptr,
-                                          block_ptr);
-                VRFY((ret != FAIL), 
-                     "H5Sselect_hyperslab(file_large_cube_sid) succeeded");
-
-
-                /* verify that H5S_select_shape_same() reports the two
-                 * selections as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(small_ds_slice_sid,
-                                                   file_large_ds_sid);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* Read selection from disk */
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, (int)mpi_rank, 
-                          (int)start[0], (int)start[1], (int)start[2], 
-                          (int)start[3], (int)start[4]);
-                HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n",
-                          fcnName,
-                          H5Sget_simple_extent_ndims(small_ds_slice_sid),
-                          H5Sget_simple_extent_ndims(file_large_ds_sid));
-#endif 
-                ret = H5Dread(large_dataset,
-                              H5T_NATIVE_UINT32,
-                              small_ds_slice_sid,
-                              file_large_ds_sid,
-                              xfer_plist,
-                              small_ds_slice_buf);
-                VRFY((ret >= 0), "H5Dread() slice from large ds succeeded.");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
 
+ 		    (tv_ptr->tests_skipped)++;
 
-                /* verify that expected data is retrieved */
+                } else { /* run the test */
 
-                mis_match = FALSE;
-                ptr_1 = small_ds_slice_buf;
-                expected_value = (uint32_t)(
-			(i * edge_size * edge_size * edge_size * edge_size) +
-                        (j * edge_size * edge_size * edge_size) +
-                        (k * edge_size * edge_size) +
-                        (l * edge_size));
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
-                for ( n = 0; n < small_ds_slice_size; n++ ) {
+                    /* we know that small_rank - 1 >= 1 and that 
+                     * large_rank > small_rank by the assertions at the head 
+                     * of this function.  Thus no need for another inner loop.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0,
+                                              H5S_SELECT_SET,
+                                              tv_ptr->start_ptr,
+                                              tv_ptr->stride_ptr,
+                                              tv_ptr->count_ptr,
+                                              tv_ptr->block_ptr);
+                    VRFY((ret != FAIL), 
+                         "H5Sselect_hyperslab(file_large_cube_sid) succeeded");
+
+
+                    /* verify that H5S_select_shape_same() reports the two
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->small_ds_slice_sid,
+                                                       tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
+
+
+                    /* Read selection from disk */
+#if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, (int)(tv_ptr->mpi_rank), 
+                              (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), 
+                              (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), 
+                              (int)(tv_ptr->start[4]));
+                    HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n",
+                              fcnName,
+                              H5Sget_simple_extent_ndims(tv_ptr->small_ds_slice_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0));
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
+                    ret = H5Dread(tv_ptr->large_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->small_ds_slice_sid,
+                                  tv_ptr->file_large_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->small_ds_slice_buf);
+                    VRFY((ret >= 0), "H5Dread() slice from large ds succeeded.");
+
+
+                    /* verify that expected data is retrieved */
+
+                    mis_match = FALSE;
+                    ptr_1 = tv_ptr->small_ds_slice_buf;
+                    expected_value = (uint32_t)(
+                        (i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                             tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (l * tv_ptr->edge_size));
+
+                    for ( n = 0; n < tv_ptr->small_ds_slice_size; n++ ) {
+
+                        if ( *ptr_1 != expected_value ) {
+
+                            mis_match = TRUE;
+                        }
 
-                    if ( *ptr_1 != expected_value ) {
+                        *ptr_1 = 0; /* zero data for next use */
 
-                        mis_match = TRUE;
+                        ptr_1++;
+                        expected_value++;
                     }
 
-                    *ptr_1 = 0; /* zero data for next use */
+                    VRFY((mis_match == FALSE), 
+                         "small slice read from large ds data good.");
 
-                    ptr_1++;
-                    expected_value++;
+ 		    (tv_ptr->tests_run)++;
                 }
 
-                VRFY((mis_match == FALSE), 
-                     "small slice read from large ds data good.");
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
+
+    return;
 
+} /* contig_hs_dr_pio_test__d2m_l2s() */
 
-    /* similarly, read slices of the on disk small data set into slices 
+
+/*-------------------------------------------------------------------------
+ * Function:	contig_hs_dr_pio_test__d2m_s2l()
+ *
+ * Purpose:	Part two of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can read from disk correctly using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *		In this function, we test this by reading slices of the 
+ *		on disk small data set into slices through the in memory 
+ *		large data set, and verify that the correct data (and 
+ *		only the correct data) is read.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/10/11
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG 0
+
+static void
+contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
+    const char *fcnName = "contig_hs_dr_pio_test__d2m_s2l()";
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t	n;
+    int		mpi_rank; /* needed by the VRFY macro */
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
+
+    /* Read slices of the on disk small data set into slices 
      * through the in memory large data set, and verify that the correct 
      * data (and only the correct data) is read.
      */
 
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
-    ret = H5Sselect_hyperslab(file_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded");
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
+    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded");
 
 
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
     HDfprintf(stdout, 
       "%s reading slices of on disk small data set into slices of big data set.\n",
               fcnName);
-#endif 
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
 
     /* zero out the in memory large ds */
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
 
     /* set up start, stride, count, and block -- note that we will
      * change start[] so as to read slices of the large cube.
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
@@ -904,9 +1143,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      */
 
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -919,9 +1158,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -929,9 +1168,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -951,147 +1190,218 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                ret = H5Sselect_hyperslab(mem_large_ds_sid,
-                                          H5S_SELECT_SET,
-                                          start_ptr,
-                                          stride_ptr,
-                                          count_ptr,
-                                          block_ptr);
-                VRFY((ret != FAIL), 
-                     "H5Sselect_hyperslab(mem_large_ds_sid) succeeded");
-
-
-                /* verify that H5S_select_shape_same() reports the two
-                 * selections as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(file_small_ds_sid,
-                                                   mem_large_ds_sid);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* Read selection from disk */
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, (int)mpi_rank, 
-                          (int)start[0], (int)start[1], (int)start[2], 
-                          (int)start[3], (int)start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(mem_large_ds_sid),
-                          H5Sget_simple_extent_ndims(file_small_ds_sid));
-#endif 
-                ret = H5Dread(small_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_large_ds_sid,
-                              file_small_ds_sid,
-                              xfer_plist,
-                              large_ds_buf_1);
-                VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
-
-                /* verify that the expected data and only the
-                 * expected data was read.
-                 */
-                ptr_1 = large_ds_buf_1;
-                expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size);
-                start_index = (size_t)(
-                        (i * edge_size * edge_size * edge_size * edge_size) +
-                        (j * edge_size * edge_size * edge_size) +
-                        (k * edge_size * edge_size) +
-                        (l * edge_size));
-                stop_index = start_index + small_ds_slice_size - 1;
-
-                HDassert( start_index < stop_index );
-                HDassert( stop_index <= large_ds_size );
-
-                for ( n = 0; n < large_ds_size; n++ ) {
-
-                    if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
 
-                        if ( *ptr_1 != expected_value ) {
+                    (tv_ptr->tests_skipped)++;
 
-                            mis_match = TRUE;
-                        }
-                        expected_value++;
+                } else { /* run the test */
 
-                    } else {
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
-                        if ( *ptr_1 != 0 ) {
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid,
+                                              H5S_SELECT_SET,
+                                              tv_ptr->start_ptr,
+                                              tv_ptr->stride_ptr,
+                                              tv_ptr->count_ptr,
+                                              tv_ptr->block_ptr);
+                    VRFY((ret != FAIL), 
+                         "H5Sselect_hyperslab(mem_large_ds_sid) succeeded");
+
+
+                    /* verify that H5S_select_shape_same() reports the two
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_0,
+                                                       tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
+
+
+                    /* Read selection from disk */
+#if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, (int)(tv_ptr->mpi_rank), 
+                              (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), 
+                              (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), 
+                              (int)(tv_ptr->start[4]));
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_large_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_0));
+#endif /* CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
+                    ret = H5Dread(tv_ptr->small_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_large_ds_sid,
+                                  tv_ptr->file_small_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->large_ds_buf_1);
+                    VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+
+                    /* verify that the expected data and only the
+                     * expected data was read.
+                     */
+                    ptr_1 = tv_ptr->large_ds_buf_1;
+                    expected_value = (uint32_t)
+                        ((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size);
+                    start_index = (size_t)(
+                        (i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                             tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (l * tv_ptr->edge_size));
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
 
-                            mis_match = TRUE;
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index <= tv_ptr->large_ds_size );
+
+                    for ( n = 0; n < tv_ptr->large_ds_size; n++ ) {
+
+                        if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+
+                            if ( *ptr_1 != expected_value ) {
+
+                                mis_match = TRUE;
+                            }
+                            expected_value++;
+
+                        } else {
+
+                            if ( *ptr_1 != 0 ) {
+
+                                mis_match = TRUE;
+                            }
                         }
+                        /* zero out the value for the next pass */
+                        *ptr_1 = 0;
+
+                        ptr_1++;
                     }
-                    /* zero out the value for the next pass */
-                    *ptr_1 = 0;
 
-                    ptr_1++;
-                }
+                    VRFY((mis_match == FALSE), 
+                         "small slice read from large ds data good.");
 
-                VRFY((mis_match == FALSE), 
-                     "small slice read from large ds data good.");
+                    (tv_ptr->tests_run)++;
+                }
 
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
+
+    return;
+
+} /* contig_hs_dr_pio_test__d2m_s2l() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	contig_hs_dr_pio_test__m2d_l2s()
+ *
+ * Purpose:	Part three of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can write from memory to file using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *		Do this by writing small_rank - 1 dimensional slices from 
+ *		the in memory large data set to the on disk small cube 
+ *		dataset.  After each write, read the slice of the small 
+ *		dataset back from disk, and verify that it contains 
+ *              the expected data. Verify that H5S_select_shape_same() 
+ *		returns true on the memory and file selections.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/10/11
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG 0
+
+static void
+contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
+    const char *fcnName = "contig_hs_dr_pio_test__m2d_l2s()";
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t	n;
+    int		mpi_rank; /* needed by the VRFY macro */
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
 
     /* now we go in the opposite direction, verifying that we can write
      * from memory to file using selections of different rank that
      * H5S_select_shape_same() views as being of the same shape.
      *
-     * Start by writing small_rank - 1 D slices from the in memory large data
-     * set to the on disk small cube dataset.  After each write, read the 
+     * Start by writing small_rank - 1 dimensional slices from the in memory large 
+     * data set to the on disk small cube dataset.  After each write, read the 
      * slice of the small dataset back from disk, and verify that it contains 
      * the expected data. Verify that H5S_select_shape_same() returns true on 
      * the memory and file selections.
      */
 
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
-    ret = H5Sselect_hyperslab(file_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded");
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
+    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded");
 
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
 
 
@@ -1100,28 +1410,28 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
     /* zero out the in memory small ds */
-    HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
+    HDmemset(tv_ptr->small_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->small_ds_size);
 
 
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
     HDfprintf(stdout, 
               "%s writing slices from big ds to slices of small ds on disk.\n",
               fcnName);
-#endif 
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
 
     /* in serial versions of this test, we loop through all the dimensions
      * of the large data set that don't appear in the small data set.  
@@ -1133,9 +1443,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      */
 
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -1148,9 +1458,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -1159,9 +1469,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
     j = 0;
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -1181,136 +1491,207 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-
-                /* zero out this rank's slice of the on disk small data set */
-                ret = H5Dwrite(small_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_small_ds_sid,
-                               file_small_ds_sid,
-                               xfer_plist,
-                               small_ds_buf_2);
-                VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded.");
-
-                /* select the portion of the in memory large cube from which we
-                 * are going to write data.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                ret = H5Sselect_hyperslab(mem_large_ds_sid,
-                                          H5S_SELECT_SET,
-                                          start_ptr,
-                                          stride_ptr,
-                                          count_ptr,
-                                          block_ptr);
-                VRFY((ret >= 0), 
-                     "H5Sselect_hyperslab() mem_large_ds_sid succeeded.");
-
-
-                /* verify that H5S_select_shape_same() reports the in
-                 * memory slice through the cube selection and the
-                 * on disk full square selections as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(file_small_ds_sid,
-                                                   mem_large_ds_sid);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed.");
-
-
-                /* write the slice from the in memory large data set to the 
-                 * slice of the on disk small dataset. */
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, (int)mpi_rank,
-                          (int)start[0], (int)start[1], (int)start[2], 
-                          (int)start[3], (int)start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(mem_large_ds_sid),
-                          H5Sget_simple_extent_ndims(file_small_ds_sid));
-#endif 
-                ret = H5Dwrite(small_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_large_ds_sid,
-                               file_small_ds_sid,
-                               xfer_plist,
-                               large_ds_buf_0);
-                VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded.");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
+
+                    (tv_ptr->tests_skipped)++;
 
+                } else { /* run the test */
 
-                /* read the on disk square into memory */
-                ret = H5Dread(small_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_small_ds_sid,
-                              file_small_ds_sid,
-                              xfer_plist,
-                              small_ds_buf_1);
-                VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
 
-                /* verify that expected data is retrieved */
+                    /* zero out this rank's slice of the on disk small data set */
+                    ret = H5Dwrite(tv_ptr->small_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_small_ds_sid,
+                                   tv_ptr->file_small_ds_sid_0,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->small_ds_buf_2);
+                    VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded.");
+
+                    /* select the portion of the in memory large cube from which we
+                     * are going to write data.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid,
+                                              H5S_SELECT_SET,
+                                              tv_ptr->start_ptr,
+                                              tv_ptr->stride_ptr,
+                                              tv_ptr->count_ptr,
+                                              tv_ptr->block_ptr);
+                    VRFY((ret >= 0), 
+                         "H5Sselect_hyperslab() mem_large_ds_sid succeeded.");
+
+
+                    /* verify that H5S_select_shape_same() reports the in
+                     * memory slice through the cube selection and the
+                     * on disk full square selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_0,
+                                                       tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed.");
+
+
+                    /* write the slice from the in memory large data set to the 
+                     * slice of the on disk small dataset. */
+#if CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, (int)(tv_ptr->mpi_rank),
+                              (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), 
+                              (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), 
+                              (int)(tv_ptr->start[4]));
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_large_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_0));
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
+                    ret = H5Dwrite(tv_ptr->small_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_large_ds_sid,
+                                   tv_ptr->file_small_ds_sid_0,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->large_ds_buf_0);
+                    VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded.");
+
+
+                    /* read the on disk square into memory */
+                    ret = H5Dread(tv_ptr->small_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_small_ds_sid,
+                                  tv_ptr->file_small_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->small_ds_buf_1);
+                    VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+
+
+                    /* verify that expected data is retrieved */
+
+                    mis_match = FALSE;
+                    ptr_1 = tv_ptr->small_ds_buf_1;
+
+                    expected_value = (uint32_t)(
+                        (i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                             tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (l * tv_ptr->edge_size));
+
+                    start_index = (size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size;
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
+
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index <= tv_ptr->small_ds_size );
+
+                    for ( n = 0; n < tv_ptr->small_ds_size; n++ ) {
+
+                        if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+
+                            if ( *ptr_1 != expected_value ) {
+
+                                mis_match = TRUE;
+                            }
+                            expected_value++;
 
-                mis_match = FALSE;
-                ptr_1 = small_ds_buf_1;
+                        } else {
 
-                expected_value = (uint32_t)(
-			(i * edge_size * edge_size * edge_size * edge_size) +
-                        (j * edge_size * edge_size * edge_size) +
-                        (k * edge_size * edge_size) +
-                        (l * edge_size));
+                            if ( *ptr_1 != 0 ) {
 
-                start_index = (size_t)mpi_rank * small_ds_slice_size;
-                stop_index = start_index + small_ds_slice_size - 1;
+                                mis_match = TRUE;
+                            }
+                        }
+                        /* zero out the value for the next pass */
+                        *ptr_1 = 0;
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index <= small_ds_size );
+                        ptr_1++;
+                    }
 
-                for ( n = 0; n < small_ds_size; n++ ) {
+                    VRFY((mis_match == FALSE), 
+                         "small slice write from large ds data good.");
 
-                    if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+                    (tv_ptr->tests_run)++;
+                }
 
-                        if ( *ptr_1 != expected_value ) {
+                l++;
 
-                            mis_match = TRUE;
-                        }
-                        expected_value++;
+               (tv_ptr->total_tests)++;
 
-                    } else {
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
+            k++;
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
+        j++;
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
 
-                        if ( *ptr_1 != 0 ) {
+    return;
 
-                            mis_match = TRUE;
-                        }
-                    }
-                    /* zero out the value for the next pass */
-                    *ptr_1 = 0;
+} /* contig_hs_dr_pio_test__m2d_l2s() */
 
-                    ptr_1++;
-                }
 
-                VRFY((mis_match == FALSE), 
-                     "small slice write from large ds data good.");
+/*-------------------------------------------------------------------------
+ * Function:	contig_hs_dr_pio_test__m2d_s2l()
+ *
+ * Purpose:	Part four of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can write from memory to file using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *		Do this by writing the contents of the process's slice of 
+ *		the in memory small data set to slices of the on disk 
+ *		large data set.  After each write, read the process's 
+ *		slice of the large data set back into memory, and verify 
+ *		that it contains the expected data. 
+ *
+ *		Verify that H5S_select_shape_same() returns true on the 
+ *		memory and file selections.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/10/11
+ *
+ * Modifications:
+ *
+ *		None
+ *
+ *-------------------------------------------------------------------------
+ */
 
-                l++;
+#define CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 0
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
-            k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
-        j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+static void
+contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
+    const char *fcnName = "contig_hs_dr_pio_test__m2d_s2l()";
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t	n;
+    int		mpi_rank; /* needed by the VRFY macro */
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
 
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
     /* Now write the contents of the process's slice of the in memory 
      * small data set to slices of the on disk large data set.  After 
@@ -1323,25 +1704,25 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     /* select the slice of the in memory small data set associated with 
      * the process's mpi rank.
      */
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
 
 
@@ -1351,31 +1732,31 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
     /* zero out the in memory large ds */
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
 
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
     HDfprintf(stdout, 
          "%s writing process slices of small ds to slices of large ds on disk.\n",
          fcnName);
-#endif 
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -1388,9 +1769,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -1398,9 +1779,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -1420,216 +1801,410 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-
-                /* Zero out this processes slice of the on disk large data set.
-                 * Note that this will leave one slice with its original data
-                 * as there is one more slice than processes.
-                  */
-                ret = H5Dwrite(large_dataset,
-                               H5T_NATIVE_UINT32,
-                               large_ds_slice_sid,
-                               file_large_ds_process_slice_sid,
-                               xfer_plist,
-                               large_ds_buf_2);
-		VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded");
-
-
-                /* select the portion of the in memory large cube to which we
-                 * are going to write data.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                ret = H5Sselect_hyperslab(file_large_ds_sid,
-                                          H5S_SELECT_SET,
-                                          start_ptr,
-                                          stride_ptr,
-                                          count_ptr,
-                                          block_ptr);
-		VRFY((ret != FAIL), 
-                     "H5Sselect_hyperslab() target large ds slice succeeded");
-
-
-                /* verify that H5S_select_shape_same() reports the in
-                 * memory small data set slice selection and the
-                 * on disk slice through the large data set selection
-                 * as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(mem_small_ds_sid,
-                                                   file_large_ds_sid);
-		VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* write the small data set slice from memory to the 
-                 * target slice of the disk data set 
-                 */
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, (int)mpi_rank,
-                          (int)start[0], (int)start[1], (int)start[2], 
-                          (int)start[3], (int)start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(mem_small_ds_sid),
-                          H5Sget_simple_extent_ndims(file_large_ds_sid));
-#endif 
-                ret = H5Dwrite(large_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_small_ds_sid,
-                               file_large_ds_sid,
-                               xfer_plist,
-                               small_ds_buf_0);
-		VRFY((ret != FAIL), 
-                      "H5Dwrite of small ds slice to large ds succeeded");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
+
+                    (tv_ptr->tests_skipped)++;
+
+#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    HDfprintf(stdout, 
+                              "%s:%d: skipping test with start = %d %d %d %d %d.\n", 
+                              fcnName, (int)(tv_ptr->mpi_rank),
+                              (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), 
+                              (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), 
+                              (int)(tv_ptr->start[4]));
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_small_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0));
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
+                } else { /* run the test */
+
+                    tv_ptr->skips = 0; /* reset the skips counter */
+
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
 
+                    /* Zero out this processes slice of the on disk large data set.
+                     * Note that this will leave one slice with its original data
+                     * as there is one more slice than processes.
+                     */
+                    ret = H5Dwrite(tv_ptr->large_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->large_ds_slice_sid,
+                                   tv_ptr->file_large_ds_process_slice_sid,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->large_ds_buf_2);
+                    VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded");
 
-                /* read this processes slice on the on disk large 
-                 * data set into memory.
-                 */
 
-                ret = H5Dread(large_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_large_ds_process_slice_sid,
-                              file_large_ds_process_slice_sid,
-                              xfer_plist,
-                              large_ds_buf_1);
-                VRFY((ret != FAIL), 
-                     "H5Dread() of process slice of large ds succeeded");
+                    /* select the portion of the in memory large cube to which we
+                     * are going to write data.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0,
+                                              H5S_SELECT_SET,
+                                              tv_ptr->start_ptr,
+                                              tv_ptr->stride_ptr,
+                                              tv_ptr->count_ptr,
+                                              tv_ptr->block_ptr);
+                    VRFY((ret != FAIL), 
+                         "H5Sselect_hyperslab() target large ds slice succeeded");
+
+
+                    /* verify that H5S_select_shape_same() reports the in
+                     * memory small data set slice selection and the
+                     * on disk slice through the large data set selection
+                     * as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->mem_small_ds_sid,
+                                                       tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
 
 
-                /* verify that the expected data and only the
-                 * expected data was read.
-                 */
-                ptr_1 = large_ds_buf_1;
-                expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size);
+                    /* write the small data set slice from memory to the 
+                     * target slice of the disk data set 
+                     */
+#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, (int)(tv_ptr->mpi_rank),
+                              (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), 
+                              (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), 
+                              (int)(tv_ptr->start[4]));
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_small_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0));
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
+                    ret = H5Dwrite(tv_ptr->large_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_small_ds_sid,
+                                   tv_ptr->file_large_ds_sid_0,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->small_ds_buf_0);
+                    VRFY((ret != FAIL), 
+                          "H5Dwrite of small ds slice to large ds succeeded");
+
+
+                    /* read this processes slice on the on disk large 
+                     * data set into memory.
+                     */
 
-                start_index = (size_t)((i * edge_size * edge_size * edge_size * edge_size) +
-                              (j * edge_size * edge_size * edge_size) +
-                              (k * edge_size * edge_size) +
-                              (l * edge_size));
-                stop_index = start_index + small_ds_slice_size - 1;
+                    ret = H5Dread(tv_ptr->large_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_large_ds_process_slice_sid,
+                                  tv_ptr->file_large_ds_process_slice_sid,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->large_ds_buf_1);
+                    VRFY((ret != FAIL), 
+                         "H5Dread() of process slice of large ds succeeded");
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index < large_ds_size );
 
-                for ( n = 0; n < large_ds_size; n++ ) {
+                    /* verify that the expected data and only the
+                     * expected data was read.
+                     */
+                    ptr_1 = tv_ptr->large_ds_buf_1;
+                    expected_value = (uint32_t)
+                	    ((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size);
 
-                    if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+                    start_index = (size_t)
+                                  ((i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                                        tv_ptr->edge_size * tv_ptr->edge_size) +
+                                   (j * tv_ptr->edge_size * tv_ptr->edge_size * 
+                                        tv_ptr->edge_size) +
+                                   (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                                   (l * tv_ptr->edge_size));
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
 
-                        if ( *ptr_1 != expected_value ) {
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index < tv_ptr->large_ds_size );
 
-                            mis_match = TRUE;
-                        }
+                    for ( n = 0; n < tv_ptr->large_ds_size; n++ ) {
 
-                        expected_value++;
+                        if ( ( n >= start_index ) && ( n <= stop_index ) ) {
 
-                    } else {
+                            if ( *ptr_1 != expected_value ) {
 
-                        if ( *ptr_1 != 0 ) {
+                                mis_match = TRUE;
+                            }
 
-                            mis_match = TRUE;
+                            expected_value++;
+
+                        } else {
+
+                            if ( *ptr_1 != 0 ) {
+
+                                mis_match = TRUE;
+                            }
                         }
+                        /* zero out buffer for next test */
+                        *ptr_1 = 0;
+                        ptr_1++;
                     }
-                    /* zero out buffer for next test */
-                    *ptr_1 = 0;
-                    ptr_1++;
-                }
 
-                VRFY((mis_match == FALSE), 
-                     "small ds slice write to large ds slice data good.");
+                    VRFY((mis_match == FALSE), 
+                         "small ds slice write to large ds slice data good.");
+
+                    (tv_ptr->tests_run)++;
+                }
 
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
 
+    return;
 
-    /* Close dataspaces */
-    ret = H5Sclose(full_mem_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded");
+} /* contig_hs_dr_pio_test__m2d_s2l() */
 
-    ret = H5Sclose(full_file_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_file_small_ds_sid) succeeded");
 
-    ret = H5Sclose(mem_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_small_ds_sid) succeeded");
+/*-------------------------------------------------------------------------
+ * Function:	contig_hs_dr_pio_test__run_test()
+ *
+ * Purpose:	Test I/O to/from hyperslab selections of different rank in
+ *		the parallel.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 9/18/09
+ *
+ * Modifications:
+ *
+ *		JRM -- 9/16/10
+ *		Added express_test parameter.  Use it to control whether 
+ *		we set up the chunks so that no chunk is shared between 
+ *		processes, and also whether we set an alignment when we 
+ *		create the test file.
+ *
+ *		JRM -- 8/11/11
+ *		Refactored function heavily & broke it into six functions.
+ *		Added the skips_ptr, max_skips, total_tests_ptr, 
+ *		tests_run_ptr, and tests_skiped_ptr parameters to support 
+ *		skipping portions of the test according to the express 
+ *		test value.
+ *
+ *-------------------------------------------------------------------------
+ */
 
-    ret = H5Sclose(file_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid) succeeded");
+#define CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 0
 
-    ret = H5Sclose(small_ds_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded");
+static void
+contig_hs_dr_pio_test__run_test(const int test_num,
+                                const int edge_size,
+                                const int chunk_edge_size,
+                                const int small_rank,
+                                const int large_rank,
+                                const hbool_t use_collective_io,
+                                const hid_t dset_type,
+                                int express_test,
+                                int * skips_ptr,
+                                int max_skips,
+                                int64_t * total_tests_ptr,
+                                int64_t * tests_run_ptr,
+                                int64_t * tests_skipped_ptr)
+{
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    const char *fcnName = "contig_hs_dr_pio_test__run_test()";
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    int		mpi_rank;
+    struct hs_dr_pio_test_vars_t test_vars = 
+    {
+        /* int	       mpi_size                        = */ -1,
+        /* int         mpi_rank                        = */ -1,
+        /* MPI_Comm    mpi_comm                        = */ MPI_COMM_NULL,
+        /* MPI_Inf     mpi_info                        = */ MPI_INFO_NULL,
+        /* int         test_num                        = */ -1,
+        /* int         edge_size                       = */ -1,
+        /* int         checker_edge_size               = */ -1,
+        /* int         chunk_edge_size                 = */ -1,
+        /* int         small_rank                      = */ -1,
+        /* int         large_rank                      = */ -1,
+        /* hid_t       dset_type                       = */ -1,
+        /* uint32_t  * small_ds_buf_0                  = */ NULL,
+        /* uint32_t  * small_ds_buf_1                  = */ NULL,
+        /* uint32_t  * small_ds_buf_2                  = */ NULL,
+        /* uint32_t  * small_ds_slice_buf              = */ NULL,
+        /* uint32_t  * large_ds_buf_0                  = */ NULL,
+        /* uint32_t  * large_ds_buf_1                  = */ NULL, 
+        /* uint32_t  * large_ds_buf_2                  = */ NULL,
+        /* uint32_t  * large_ds_slice_buf              = */ NULL,
+        /* int         small_ds_offset                 = */ -1,
+        /* int         large_ds_offset                 = */ -1,
+        /* hid_t       fid                             = */ -1,  /* HDF5 file ID */
+        /* hid_t       xfer_plist                      = */ H5P_DEFAULT,
+        /* hid_t       full_mem_small_ds_sid           = */ -1,
+        /* hid_t       full_file_small_ds_sid          = */ -1,
+        /* hid_t       mem_small_ds_sid                = */ -1,
+        /* hid_t       file_small_ds_sid_0             = */ -1,
+        /* hid_t       file_small_ds_sid_1             = */ -1,
+        /* hid_t       small_ds_slice_sid              = */ -1,
+        /* hid_t       full_mem_large_ds_sid           = */ -1,
+        /* hid_t       full_file_large_ds_sid          = */ -1,
+        /* hid_t       mem_large_ds_sid                = */ -1,
+        /* hid_t       file_large_ds_sid_0             = */ -1,
+        /* hid_t       file_large_ds_sid_1             = */ -1,
+        /* hid_t       file_large_ds_process_slice_sid = */ -1,
+        /* hid_t       mem_large_ds_process_slice_sid  = */ -1,
+        /* hid_t       large_ds_slice_sid              = */ -1,
+        /* hid_t       small_dataset                   = */ -1,     /* Dataset ID */
+        /* hid_t       large_dataset                   = */ -1,     /* Dataset ID */
+        /* size_t      small_ds_size                   = */ 1,
+        /* size_t      small_ds_slice_size             = */ 1,
+        /* size_t      large_ds_size                   = */ 1,
+        /* size_t      large_ds_slice_size             = */ 1,
+        /* hsize_t     dims[PAR_SS_DR_MAX_RANK]        = */ {0,0,0,0,0},
+        /* hsize_t     chunk_dims[PAR_SS_DR_MAX_RANK]  = */ {0,0,0,0,0},
+        /* hsize_t     start[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t     stride[PAR_SS_DR_MAX_RANK]      = */ {0,0,0,0,0},
+        /* hsize_t     count[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t     block[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t   * start_ptr                       = */ NULL,
+        /* hsize_t   * stride_ptr                      = */ NULL,
+        /* hsize_t   * count_ptr                       = */ NULL,
+        /* hsize_t   * block_ptr                       = */ NULL,
+        /* int 	       skips                           = */ 0,
+        /* int 	       max_skips                       = */ 0,
+        /* int64_t     total_tests                     = */ 0,
+        /* int64_t     tests_run                       = */ 0,
+        /* int64_t     tests_skipped                   = */ 0
+    };
+    struct hs_dr_pio_test_vars_t * tv_ptr = &test_vars;
 
-    ret = H5Sclose(full_mem_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded");
+    hs_dr_pio_test__setup(test_num, edge_size, -1, chunk_edge_size,
+                          small_rank, large_rank, use_collective_io,
+                          dset_type, express_test, tv_ptr);
 
-    ret = H5Sclose(full_file_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_file_large_ds_sid) succeeded");
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    ret = H5Sclose(mem_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
+    /* initialize skips & max_skips */
+    tv_ptr->skips = *skips_ptr;
+    tv_ptr->max_skips = max_skips;
 
-    ret = H5Sclose(file_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: small rank = %d, large rank = %d.\n",
+                  test_num, small_rank, large_rank);
+        HDfprintf(stdout, "test %d: Initialization complete.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
 
-    ret = H5Sclose(mem_large_ds_process_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_process_slice_sid) succeeded");
+    /* first, verify that we can read from disk correctly using selections
+     * of different rank that H5S_select_shape_same() views as being of the
+     * same shape.
+     *
+     * Start by reading small_rank - 1 dimensional slice from the on disk 
+     * large cube, and verifying that the data read is correct.  Verify that 
+     * H5S_select_shape_same() returns true on the memory and file selections.
+     */
 
-    ret = H5Sclose(file_large_ds_process_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(file_large_ds_process_slice_sid) succeeded");
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__d2m_l2s.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    contig_hs_dr_pio_test__d2m_l2s(tv_ptr);
 
-    ret = H5Sclose(large_ds_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded");
 
+    /* Second, read slices of the on disk small data set into slices 
+     * through the in memory large data set, and verify that the correct 
+     * data (and only the correct data) is read.
+     */
 
-    /* Close Datasets */
-    ret = H5Dclose(small_dataset);
-    VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__d2m_s2l.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    contig_hs_dr_pio_test__d2m_s2l(tv_ptr);
 
-    ret = H5Dclose(large_dataset);
-    VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded");
 
+    /* now we go in the opposite direction, verifying that we can write
+     * from memory to file using selections of different rank that
+     * H5S_select_shape_same() views as being of the same shape.
+     *
+     * Start by writing small_rank - 1 D slices from the in memory large data
+     * set to the on disk small cube dataset.  After each write, read the 
+     * slice of the small dataset back from disk, and verify that it contains 
+     * the expected data. Verify that H5S_select_shape_same() returns true on 
+     * the memory and file selections.
+     */
 
-    /* close the file collectively */
-    MESG("about to close file.");
-    ret = H5Fclose(fid);
-    VRFY((ret != FAIL), "file close succeeded");
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__m2d_l2s.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    contig_hs_dr_pio_test__m2d_l2s(tv_ptr);
 
-    /* Free memory buffers */
 
-    if ( small_ds_buf_0 != NULL ) HDfree(small_ds_buf_0);
-    if ( small_ds_buf_1 != NULL ) HDfree(small_ds_buf_1);
-    if ( small_ds_buf_2 != NULL ) HDfree(small_ds_buf_2);
-    if ( small_ds_slice_buf != NULL ) HDfree(small_ds_slice_buf);
+    /* Now write the contents of the process's slice of the in memory 
+     * small data set to slices of the on disk large data set.  After 
+     * each write, read the process's slice of the large data set back
+     * into memory, and verify that it contains the expected data. 
+     * Verify that H5S_select_shape_same() returns true on the memory 
+     * and file selections.
+     */
+
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__m2d_s2l.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    contig_hs_dr_pio_test__m2d_s2l(tv_ptr);
+
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, 
+            "test %d: Subtests complete -- tests run/skipped/total = %lld/%lld/%lld.\n", 
+             test_num, (long long)(tv_ptr->tests_run), (long long)(tv_ptr->tests_skipped),
+             (long long)(tv_ptr->total_tests));
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+
+    hs_dr_pio_test__takedown(tv_ptr);
+
+#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: Takedown complete.\n", test_num);
+    }
+#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
 
-    if ( large_ds_buf_0 != NULL ) HDfree(large_ds_buf_0);
-    if ( large_ds_buf_1 != NULL ) HDfree(large_ds_buf_1);
-    if ( large_ds_buf_2 != NULL ) HDfree(large_ds_buf_2);
-    if ( large_ds_slice_buf != NULL ) HDfree(large_ds_slice_buf);
+    *skips_ptr = tv_ptr->skips;
+    *total_tests_ptr += tv_ptr->total_tests;
+    *tests_run_ptr += tv_ptr->tests_run;
+    *tests_skipped_ptr += tv_ptr->tests_skipped;
 
     return;
 
-} /* contig_hyperslab_dr_pio_test__run_test() */
+} /* contig_hs_dr_pio_test__run_test() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
+ * Function:	contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
  *
  * Purpose:	Test I/O to/from hyperslab selections of different rank in
  *		the parallel case.
@@ -1655,43 +2230,37 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num,
  *-------------------------------------------------------------------------
  */
 
+#define CONTIG_HS_DR_PIO_TEST__DEBUG 0
+
 void
-contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
+contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
 {
+    int         express_test;
+    int         local_express_test;
+    int         mpi_rank = -1;
     int	        test_num = 0;
     int		edge_size = 10;
     int		chunk_edge_size = 0;
     int	        small_rank;
     int	        large_rank;
-    int		skips[4] = {0, 0, 0, 0};
-    int		skip_counters[4] = {0, 0, 0, 0};
-    int		tests_skiped[4] = {0, 0, 0, 0};
     int		mpi_result;
+    int		skips = 0;
+    int		max_skips = 0;
+    /* The following table list the number of sub-tests skipped between 
+     * each test that is actually executed as a function of the express 
+     * test level.  Note that any value in excess of 4880 will cause all
+     * sub tests to be skipped.
+     */
+    int         max_skips_tbl[4] = {0, 4, 64, 1024};
     hid_t	dset_type = H5T_NATIVE_UINT;
-#ifdef H5_HAVE_GETTIMEOFDAY
-    hbool_t	time_tests = TRUE;
-    hbool_t	display_skips = FALSE;
-    int		local_express_test;
-    int		express_test;
-    int		i;
-    int		samples = 0;
-    int		sample_size = 1;
-    int		mpi_size = -1;
-    int         mpi_rank = -1;
-    int		local_skips[4];
-    const int	ind_contig_idx = 0;
-    const int	col_contig_idx = 1;
-    const int	ind_chunked_idx = 2;
-    const int	col_chunked_idx = 3;
-    const int	test_types = 4;
-    long long   max_test_time = 3000000; /* for one test */
-    long long	sample_times[4] = {0, 0, 0, 0};
-    struct timeval timeval_a;
-    struct timeval timeval_b;
-#endif /* H5_HAVE_GETTIMEOFDAY */
+    int64_t	total_tests = 0;
+    int64_t	tests_run = 0;
+    int64_t     tests_skipped = 0;
 
     HDcompile_assert(sizeof(uint32_t) == sizeof(unsigned));
 
+    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
+
     local_express_test = GetTestExpress();
 
     mpi_result = MPI_Allreduce((void *)&local_express_test,
@@ -1703,198 +2272,130 @@ contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
 
     VRFY((mpi_result == MPI_SUCCESS ), "MPI_Allreduce(0) succeeded");
 
+    if ( local_express_test < 0 ) {
+        max_skips = max_skips_tbl[0];
+    } else if ( local_express_test > 3 ) {
+        max_skips = max_skips_tbl[3];
+    } else {
+        max_skips = max_skips_tbl[local_express_test];
+    }
+
     for ( large_rank = 3; large_rank <= PAR_SS_DR_MAX_RANK; large_rank++ ) {
 
         for ( small_rank = 2; small_rank < large_rank; small_rank++ ) {
-	  switch(sstest_type){
-	  case IND_CONTIG:
-	    /* contiguous data set, independent I/O */
-            chunk_edge_size = 0;
-            if ( skip_counters[ind_contig_idx] < skips[ind_contig_idx] ) {
-
-                skip_counters[ind_contig_idx]++;
-                tests_skiped[ind_contig_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[ind_contig_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(0) succeeds.");
-                contig_hyperslab_dr_pio_test__run_test(test_num,
+
+            switch(sstest_type){
+                case IND_CONTIG:
+                    /* contiguous data set, independent I/O */
+                    chunk_edge_size = 0;
+
+                    contig_hs_dr_pio_test__run_test(test_num,
                                                    edge_size,
                                                    chunk_edge_size,
                                                    small_rank,
                                                    large_rank,
                                                    FALSE,  
                                                    dset_type,
-                                                   express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(1) succeeds.", \
-                                      sample_times[col_contig_idx]);
-            }
-            test_num++;
-	    break;
-	    /* end of case IND_CONTIG */
-
-	  case COL_CONTIG:
-	    /* contiguous data set, collective I/O */
-            chunk_edge_size = 0;
-            if ( skip_counters[col_contig_idx] < skips[col_contig_idx] ) {
-
-                skip_counters[col_contig_idx]++;
-                tests_skiped[col_contig_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[col_contig_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(2) succeeds.");
-                contig_hyperslab_dr_pio_test__run_test(test_num,
+                                                   express_test,
+                                                   &skips,
+                                                   max_skips,
+                                                   &total_tests,
+                                                   &tests_run,
+                                                   &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case IND_CONTIG */
+
+                case COL_CONTIG:
+                    /* contiguous data set, collective I/O */
+                    chunk_edge_size = 0;
+
+                    contig_hs_dr_pio_test__run_test(test_num,
                                                    edge_size,
                                                    chunk_edge_size,
                                                    small_rank,
                                                    large_rank,
                                                    TRUE,  
                                                    dset_type,
-                                                   express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(3) succeeds.", \
-                                      sample_times[ind_contig_idx]);
-            }
-            test_num++;
-	    break;
-	    /* end of case COL_CONTIG */
-
-	  case IND_CHUNKED:
-	    /* chunked data set, independent I/O */
-            chunk_edge_size = 5;
-            if ( skip_counters[ind_chunked_idx] < skips[ind_chunked_idx] ) {
-
-                skip_counters[ind_chunked_idx]++;
-                tests_skiped[ind_chunked_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[ind_chunked_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(4) succeeds.");
-                contig_hyperslab_dr_pio_test__run_test(test_num,
+                                                   express_test,
+                                                   &skips,
+                                                   max_skips,
+                                                   &total_tests,
+                                                   &tests_run,
+                                                   &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case COL_CONTIG */
+
+                case IND_CHUNKED:
+                    /* chunked data set, independent I/O */
+                    chunk_edge_size = 5;
+
+                    contig_hs_dr_pio_test__run_test(test_num,
                                                    edge_size,
                                                    chunk_edge_size,
                                                    small_rank,
                                                    large_rank,
                                                    FALSE,  
                                                    dset_type,
-                                                   express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(5) succeeds.", \
-                                      sample_times[col_chunked_idx]);
-            }
-            test_num++;
-	    break;
-	    /* end of case IND_CHUNKED */
-
-	  case COL_CHUNKED:
-	    /* chunked data set, collective I/O */
-            chunk_edge_size = 5;
-            if ( skip_counters[col_chunked_idx] < skips[col_chunked_idx] ) {
-
-                skip_counters[col_chunked_idx]++;
-                tests_skiped[col_chunked_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[col_chunked_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(6) succeeds.");
-                contig_hyperslab_dr_pio_test__run_test(test_num,
+                                                   express_test,
+                                                   &skips,
+                                                   max_skips,
+                                                   &total_tests,
+                                                   &tests_run,
+                                                   &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case IND_CHUNKED */
+
+                case COL_CHUNKED:
+                    /* chunked data set, collective I/O */
+                    chunk_edge_size = 5;
+
+                    contig_hs_dr_pio_test__run_test(test_num,
                                                    edge_size,
                                                    chunk_edge_size,
                                                    small_rank,
                                                    large_rank,
                                                    TRUE,  
                                                    dset_type,
-                                                   express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(7) succeeds.", \
-                                      sample_times[ind_chunked_idx]);
-            }
-            test_num++;
-	    break;
-	    /* end of case COL_CHUNKED */
-	  } /* end of switch(sstest_type) */
-
-#ifdef H5_HAVE_GETTIMEOFDAY
-            if ( time_tests ) {
-            
-                samples++;
-
-                if ( samples >= sample_size ) {
-
-                    int result;
-
-                    time_tests = FALSE;
-
-                    max_test_time = ((long long)sample_size) * max_test_time;
-
-                    for ( i = 0; i < test_types; i++ ) {
-
-                        if ( ( express_test == 0 ) ||
-                             ( sample_times[i] <= max_test_time ) ) {
-
-                            local_skips[i] = 0;
-
-                        } else {
-
-                            local_skips[i] = (int)(sample_times[i] / max_test_time);
-                        }
-                    }
-
-                    /* do an MPI_Allreduce() with the skips vector to ensure that 
-                     * all processes agree on its contents.
-                     */
-                    result = MPI_Allreduce((void *)local_skips,
-                                           (void *)skips,
-                                           test_types,
-                                           MPI_INT,
-                                           MPI_MAX,
-                                           MPI_COMM_WORLD);
-                    VRFY((result == MPI_SUCCESS ), \
-                         "MPI_Allreduce(1) succeeded");
-                }
+                                                   express_test,
+                                                   &skips,
+                                                   max_skips,
+                                                   &total_tests,
+                                                   &tests_run,
+                                                   &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case COL_CHUNKED */
+
+                default:
+                    VRFY((FALSE), "unknown test type");
+                    break;
+
+            } /* end of switch(sstest_type) */
+#if CONTIG_HS_DR_PIO_TEST__DEBUG
+            if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) {
+                HDfprintf(stdout, "	run/skipped/total = %lld/%lld/%lld.\n",
+                          tests_run, tests_skipped, total_tests);
             }
-#endif /* H5_HAVE_GETTIMEOFDAY */
-
+#endif /* CONTIG_HS_DR_PIO_TEST__DEBUG */
         }
     }
 
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if ( ( MAINPROCESS ) && ( display_skips ) ) {
-
-        HDfprintf(stdout, "***********************************\n");
-        HDfprintf(stdout, "express_test = %d.\n", express_test);
-        HDfprintf(stdout, "sample_size = %d, max_test_time = %lld.\n",
-                  sample_size, max_test_time);
-        HDfprintf(stdout, "sample_times[]  = %lld, %lld, %lld, %lld.\n", 
-                  sample_times[ind_contig_idx],
-                  sample_times[col_contig_idx],
-                  sample_times[ind_chunked_idx],
-                  sample_times[col_chunked_idx]);
-        HDfprintf(stdout, "skips[]  = %d, %d, %d, %d.\n", 
-                  skips[ind_contig_idx],
-                  skips[col_contig_idx],
-                  skips[ind_chunked_idx],
-                  skips[col_chunked_idx]);
-        HDfprintf(stdout, "tests_skiped[]  = %d, %d, %d, %d.\n", 
-                  tests_skiped[ind_contig_idx],
-                  tests_skiped[col_contig_idx],
-                  tests_skiped[ind_chunked_idx],
-                  tests_skiped[col_chunked_idx]);
-        HDfprintf(stdout, "test_num          = %d.\n", test_num);
-        HDfprintf(stdout, "***********************************\n");
+    if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) {
+        HDfprintf(stdout, "	%lld of %lld subtests skipped to expedite testing.\n",
+                  tests_skipped, total_tests);
     }
-#endif /* H5_HAVE_GETTIMEOFDAY */
 
     return;
 
-} /* contig_hyperslab_dr_pio_test() */
+} /* contig_hs_dr_pio_test() */
 
 
 /****************************************************************
 **
-**  checker_board_hyperslab_dr_pio_test__select_checker_board():  
+**  ckrbrd_hs_dr_pio_test__slct_ckrbrd():  
 **	Given a data space of tgt_rank, and dimensions:
 **
 **		(mpi_size + 1), edge_size, ... , edge_size
@@ -1915,21 +2416,19 @@ contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
 **
 ****************************************************************/
 
-#define CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 0
+#define CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 0
 
 static void
-checker_board_hyperslab_dr_pio_test__select_checker_board(
-                                 const int mpi_rank,
-                                 const hid_t tgt_sid,
-                                 const int tgt_rank,
-                                 const int edge_size,
-                                 const int checker_edge_size,
-                                 const int sel_rank,
-                                 hsize_t sel_start[])
+ckrbrd_hs_dr_pio_test__slct_ckrbrd(const int mpi_rank,
+                                   const hid_t tgt_sid,
+                                   const int tgt_rank,
+                                   const int edge_size,
+                                   const int checker_edge_size,
+                                   const int sel_rank,
+                                   hsize_t sel_start[])
 {
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
-    const char *	fcnName = 
-			"checker_board_hyperslab_dr_pio_test__select_checker_board():";
+#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
+    const char *	fcnName = "ckrbrd_hs_dr_pio_test__slct_ckrbrd():";
 #endif 
     hbool_t		first_selection = TRUE;
     int                 i, j, k, l, m;
@@ -1960,14 +2459,14 @@ checker_board_hyperslab_dr_pio_test__select_checker_board(
     HDassert( n_cube_offset >= 0 );
     HDassert( n_cube_offset <= sel_offset );
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
     HDfprintf(stdout, "%s:%d: edge_size/checker_edge_size = %d/%d\n",
               fcnName, mpi_rank, edge_size, checker_edge_size);
     HDfprintf(stdout, "%s:%d: sel_rank/sel_offset = %d/%d.\n", 
               fcnName, mpi_rank, sel_rank, sel_offset);
     HDfprintf(stdout, "%s:%d: tgt_rank/n_cube_offset = %d/%d.\n", 
               fcnName, mpi_rank, tgt_rank, n_cube_offset);
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */ 
+#endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */ 
 
     /* First, compute the base count (which assumes start == 0
      * for the associated offset) and offset_count (which
@@ -2117,7 +2616,7 @@ checker_board_hyperslab_dr_pio_test__select_checker_board(
 
                         if ( ((i + j + k + l + m) % 2) == 0 ) {
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
                             HDfprintf(stdout, "%s%d: *** first_selection = %d ***\n", 
                                       fcnName, mpi_rank, (int)first_selection);
                             HDfprintf(stdout, "%s:%d: i/j/k/l/m = %d/%d/%d/%d/%d\n",
@@ -2204,10 +2703,10 @@ checker_board_hyperslab_dr_pio_test__select_checker_board(
     } while ( ( i <= 1 ) &&
               ( 0 >= sel_offset ) );
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
     HDfprintf(stdout, "%s%d: H5Sget_select_npoints(tgt_sid) = %d.\n",
               fcnName, mpi_rank, (int)H5Sget_select_npoints(tgt_sid));
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */
+#endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
     /* Clip the selection back to the data space proper. */
 
@@ -2224,20 +2723,20 @@ checker_board_hyperslab_dr_pio_test__select_checker_board(
 
     VRFY((ret != FAIL), "H5Sselect_hyperslab(AND) succeeded");
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 
     HDfprintf(stdout, "%s%d: H5Sget_select_npoints(tgt_sid) = %d.\n",
               fcnName, mpi_rank, (int)H5Sget_select_npoints(tgt_sid));
     HDfprintf(stdout, "%s%d: done.\n", fcnName, mpi_rank);
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */
+#endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
     return;
 
-} /* checker_board_hyperslab_dr_pio_test__select_checker_board() */
+} /* ckrbrd_hs_dr_pio_test__slct_ckrbrd() */
 
 
 /****************************************************************
 **
-**  checker_board_hyperslab_dr_pio_test__verify_data(): 
+**  ckrbrd_hs_dr_pio_test__verify_data(): 
 **
 **	Examine the supplied buffer to see if it contains the 
 **	expected data.  Return TRUE if it does, and FALSE 
@@ -2291,19 +2790,18 @@ checker_board_hyperslab_dr_pio_test__select_checker_board(
 **
 ****************************************************************/
 
-#define CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 0
+#define CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 0
 
 static hbool_t
-checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr,
-                                                 const int rank,
-                                                 const int edge_size,
-                                                 const int checker_edge_size,
-                                                 uint32_t first_expected_val,
-                                                 hbool_t buf_starts_in_checker)
+ckrbrd_hs_dr_pio_test__verify_data(uint32_t * buf_ptr,
+                                   const int rank,
+                                   const int edge_size,
+                                   const int checker_edge_size,
+                                   uint32_t first_expected_val,
+                                   hbool_t buf_starts_in_checker)
 {
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG
-    const char *	fcnName = 
-			"checker_board_hyperslab_dr_pio_test__verify_data():";
+#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG
+    const char *	fcnName = "ckrbrd_hs_dr_pio_test__verify_data():";
 #endif
     hbool_t good_data = TRUE;
     hbool_t in_checker;
@@ -2322,7 +2820,7 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr,
     HDassert( checker_edge_size <= edge_size );
     HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK );
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 
 
     int		mpi_rank;
 
@@ -2385,13 +2883,13 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr,
 
                     m = 0;
                     z = 0;
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 
                     HDfprintf(stdout, "%d, %d, %d, %d, %d:", i, j, k, l, m);
 #endif
                     in_checker = start_in_checker[3];
                     do
                     {
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 
                         HDfprintf(stdout, " %d", (int)(*val_ptr));
 #endif
                         if ( z >= checker_edge_size ) {
@@ -2426,7 +2924,7 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr,
  
                     } while ( ( rank >= (test_max_rank - 4) ) &&
                               ( m < edge_size ) );
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 
+#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 
                     HDfprintf(stdout, "\n");
 #endif
                     l++;
@@ -2448,668 +2946,118 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr,
 
     return(good_data);
 
-} /* checker_board_hyperslab_dr_pio_test__verify_data() */
+} /* ckrbrd_hs_dr_pio_test__verify_data() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	checker_board_hyperslab_dr_pio_test__run_test()
+ * Function:	ckrbrd_hs_dr_pio_test__d2m_l2s()
  *
- * Purpose:	Test I/O to/from checkerboard selections of hyperslabs of 
- *		different rank in the parallel.
+ * Purpose:	Part one of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can read from disk correctly using checker
+ *		board selections of different rank that 
+ *              H5S_select_shape_same() views as being of the same shape.
+ *
+ *              In this function, we test this by reading small_rank - 1 
+ *		checker board slices from the on disk large cube, and 
+ *		verifying that the data read is correct.  Verify that 
+ *		H5S_select_shape_same() returns true on the memory and 
+ *		file selections.
  *
  * Return:	void
  *
- * Programmer:	JRM -- 10/10/09
+ * Programmer:	JRM -- 9/15/11
  *
  * Modifications:
  *
- *		JRM -- 9/16/10
- *		Added the express_test parameter.  Use it to control 
- *		whether we set an alignment, and whether we allocate
- *		chunks such that no two processes will normally touch
- *		the same chunk.
+ *		None.
  *
  *-------------------------------------------------------------------------
  */
 
-#define PAR_SS_DR_MAX_RANK	5
-#define CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 0
+#define CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 0
 
 static void
-checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
-                                              const int edge_size,
-                                              const int checker_edge_size,
-                                              const int chunk_edge_size,
-                                              const int small_rank,
-                                              const int large_rank,
-                                              const hbool_t use_collective_io,
-                                              const hid_t dset_type,
-                                              const int express_test)
+ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
 {
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
-    const char *fcnName = "checker_board_hyperslab_dr_pio_test__run_test()";
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */
-    const char *filename;
-    hbool_t	use_gpfs = FALSE;   /* Use GPFS hints */
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__d2m_l2s()";
+    uint32_t  * ptr_0;
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
     hbool_t	data_ok = FALSE;
-    hbool_t	mis_match = FALSE;
     int		i, j, k, l;
-    size_t      u;
-    int         mrc;
-    size_t      start_index;
-    size_t      stop_index;
-    int		small_ds_offset;
-    int         large_ds_offset;
-    const int   test_max_rank = 5;  /* must update code if this changes */
     uint32_t	expected_value;
-    uint32_t  * small_ds_buf_0 = NULL;
-    uint32_t  * small_ds_buf_1 = NULL;
-    uint32_t  * small_ds_buf_2 = NULL;
-    uint32_t  * small_ds_slice_buf = NULL;
-    uint32_t  * large_ds_buf_0 = NULL;
-    uint32_t  * large_ds_buf_1 = NULL;
-    uint32_t  * large_ds_buf_2 = NULL;
-    uint32_t  * large_ds_slice_buf = NULL;
-    uint32_t  * ptr_0;
-    uint32_t  * ptr_1;
-    int		mpi_rank;
-    int		mpi_size;
-    MPI_Comm    mpi_comm = MPI_COMM_NULL;
-    MPI_Info	mpi_info = MPI_INFO_NULL;
-    hid_t       fid;			/* HDF5 file ID */
-    hid_t	acc_tpl;		/* File access templates */
-    hid_t	xfer_plist = H5P_DEFAULT;
-    hid_t       full_mem_small_ds_sid;
-    hid_t       full_file_small_ds_sid;
-    hid_t       mem_small_ds_sid;
-    hid_t       file_small_ds_sid_0;
-    hid_t       file_small_ds_sid_1;
-    hid_t	small_ds_slice_sid;
-    hid_t       full_mem_large_ds_sid;
-    hid_t       full_file_large_ds_sid;
-    hid_t       mem_large_ds_sid;
-    hid_t       file_large_ds_sid_0;
-    hid_t       file_large_ds_sid_1;
-    hid_t       file_large_ds_process_slice_sid;
-    hid_t       mem_large_ds_process_slice_sid;
-    hid_t	large_ds_slice_sid;
-    hid_t       small_ds_dcpl_id = H5P_DEFAULT;
-    hid_t       large_ds_dcpl_id = H5P_DEFAULT;
-    hid_t       small_dataset;     /* Dataset ID                   */
-    hid_t       large_dataset;     /* Dataset ID                   */
-    size_t      small_ds_size = 1;
-    size_t      small_ds_slice_size = 1;
-    size_t      large_ds_size = 1;
-    size_t      large_ds_slice_size = 1;
-    hsize_t     dims[PAR_SS_DR_MAX_RANK];
-    hsize_t     chunk_dims[PAR_SS_DR_MAX_RANK];
-    hsize_t     start[PAR_SS_DR_MAX_RANK];
-    hsize_t     stride[PAR_SS_DR_MAX_RANK];
-    hsize_t     count[PAR_SS_DR_MAX_RANK];
-    hsize_t     block[PAR_SS_DR_MAX_RANK];
+    int		mpi_rank; /* needed by VRFY */
     hsize_t     sel_start[PAR_SS_DR_MAX_RANK];
     htri_t      check;          /* Shape comparison return value */
     herr_t	ret;		/* Generic return value */
 
-    HDassert( edge_size >= 6 );
-    HDassert( edge_size >= chunk_edge_size );
-    HDassert( ( chunk_edge_size == 0 ) || ( chunk_edge_size >= 3 ) );
-    HDassert( 1 < small_rank );
-    HDassert( small_rank < large_rank );
-    HDassert( large_rank <= test_max_rank );
-    HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK );
-
-    MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
-    MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
-
-    HDassert( mpi_size >= 1 );
-
-    mpi_comm = MPI_COMM_WORLD;
-    mpi_info = MPI_INFO_NULL;
-
-    for ( i = 0; i < small_rank - 1; i++ )
-    {
-        small_ds_size *= (size_t)edge_size;
-        small_ds_slice_size *= (size_t)edge_size;
-    }
-    small_ds_size *= (size_t)(mpi_size + 1);
-
-    small_ds_offset = PAR_SS_DR_MAX_RANK - small_rank;
-
-    HDassert( 0 < small_ds_offset );
-    HDassert( small_ds_offset < PAR_SS_DR_MAX_RANK );
-
-
-    for ( i = 0; i < large_rank - 1; i++ ) {
-
-        large_ds_size *= (size_t)edge_size;
-        large_ds_slice_size *= (size_t)edge_size;
-    }
-    large_ds_size *= (size_t)(mpi_size + 1);
-
-    large_ds_offset = PAR_SS_DR_MAX_RANK - large_rank;
-
-    HDassert( 0 <= large_ds_offset );
-    HDassert( large_ds_offset < PAR_SS_DR_MAX_RANK );
-
-
-    /* Allocate buffers */
-    small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded");
-
-    small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded");
-
-    small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
-    VRFY((small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded");
-
-    small_ds_slice_buf = 
-	(uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_slice_size);
-    VRFY((small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded");
-
-    large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded");
-
-    large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
-
-    large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
-    VRFY((large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded");
-
-    large_ds_slice_buf = 
-	(uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_slice_size);
-    VRFY((large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded");
-
-    /* initialize the buffers */
-
-    ptr_0 = small_ds_buf_0;
-    for(i = 0; i < (int)small_ds_size; i++)
-        *ptr_0++ = (uint32_t)i;
-    HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
-    HDmemset(small_ds_buf_2, 0, sizeof(uint32_t) * small_ds_size);
-
-    HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
-
-    ptr_0 = large_ds_buf_0;
-    for(i = 0; i < (int)large_ds_size; i++)
-        *ptr_0++ = (uint32_t)i;
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
-    HDmemset(large_ds_buf_2, 0, sizeof(uint32_t) * large_ds_size);
-
-    HDmemset(large_ds_slice_buf, 0, sizeof(uint32_t) * large_ds_slice_size);
-
-    filename = (const char *)GetTestParameters();
-    HDassert( filename != NULL );
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
-    if ( MAINPROCESS ) {
-
-        HDfprintf(stdout, "%s:%d: test num = %d.\n", fcnName, mpi_rank, test_num);
-        HDfprintf(stdout, "%s:%d: mpi_size = %d.\n", fcnName, mpi_rank, mpi_size);
-        HDfprintf(stdout, 
-                  "%s:%d: small/large rank = %d/%d, use_collective_io = %d.\n",
-                  fcnName, mpi_rank, small_rank, large_rank, (int)use_collective_io);
-        HDfprintf(stdout, "%s:%d: edge_size = %d, chunk_edge_size = %d.\n",
-                  fcnName, mpi_rank, edge_size, chunk_edge_size);
-        HDfprintf(stdout, "%s:%d: checker_edge_size = %d.\n", 
-                  fcnName, mpi_rank, checker_edge_size);
-        HDfprintf(stdout, "%s:%d: small_ds_size = %d, large_ds_size = %d.\n",
-                  fcnName, mpi_rank, (int)small_ds_size, (int)large_ds_size);
-        HDfprintf(stdout, "%s:%d: filename = %s.\n", fcnName, mpi_rank, filename);
-    }
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */
-
-    /* ----------------------------------------
-     * CREATE AN HDF5 FILE WITH PARALLEL ACCESS
-     * ---------------------------------------*/
-    /* setup file access template */
-    acc_tpl = create_faccess_plist(mpi_comm, mpi_info, facc_type, use_gpfs);
-    VRFY((acc_tpl >= 0), "create_faccess_plist() succeeded");
-
-    /* set the alignment -- need it large so that we aren't always hitting the
-     * the same file system block.  Do this only if express_test is greater
-     * than zero.
-     */
-    if ( express_test > 0 ) {
-
-        ret = H5Pset_alignment(acc_tpl, (hsize_t)0, SHAPE_SAME_TEST_ALIGNMENT);
-        VRFY((ret != FAIL), "H5Pset_alignment() succeeded");
-    }
-
-    /* create the file collectively */
-    fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl);
-    VRFY((fid >= 0), "H5Fcreate succeeded");
-
-    MESG("File opened.");
-
-    /* Release file-access template */
-    ret = H5Pclose(acc_tpl);
-    VRFY((ret >= 0), "H5Pclose(acc_tpl) succeeded");
-
-
-    /* setup dims: */
-    dims[0] = (hsize_t)(mpi_size + 1);
-    dims[1] = dims[2] = dims[3] = dims[4] = (hsize_t)edge_size;
-
-
-    /* Create small ds dataspaces */
-    full_mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((full_mem_small_ds_sid != 0), 
-         "H5Screate_simple() full_mem_small_ds_sid succeeded");
-
-    full_file_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((full_file_small_ds_sid != 0), 
-         "H5Screate_simple() full_file_small_ds_sid succeeded");
-
-    mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((mem_small_ds_sid != 0), 
-	 "H5Screate_simple() mem_small_ds_sid succeeded");
-
-    file_small_ds_sid_0 = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((file_small_ds_sid_0 != 0), 
-         "H5Screate_simple() file_small_ds_sid_0 succeeded");
-
-    file_small_ds_sid_1 = H5Screate_simple(small_rank, dims, NULL);
-    VRFY((file_small_ds_sid_1 != 0), 
-         "H5Screate_simple() file_small_ds_sid_1 succeeded");
-
-    small_ds_slice_sid = H5Screate_simple(small_rank - 1, &(dims[1]), NULL);
-    VRFY((small_ds_slice_sid != 0), 
-         "H5Screate_simple() small_ds_slice_sid succeeded");
-
-
-    /* Create large ds dataspaces */
-    full_mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((full_mem_large_ds_sid != 0), 
-         "H5Screate_simple() full_mem_large_ds_sid succeeded");
-
-    full_file_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((full_file_large_ds_sid != FAIL), 
-         "H5Screate_simple() full_file_large_ds_sid succeeded");
-
-    mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((mem_large_ds_sid != FAIL), 
-         "H5Screate_simple() mem_large_ds_sid succeeded");
-
-    file_large_ds_sid_0 = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((file_large_ds_sid_0 != FAIL), 
-         "H5Screate_simple() file_large_ds_sid_0 succeeded");
-
-    file_large_ds_sid_1 = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((file_large_ds_sid_1 != FAIL), 
-         "H5Screate_simple() file_large_ds_sid_1 succeeded");
-
-    mem_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((mem_large_ds_process_slice_sid != FAIL), 
-         "H5Screate_simple() mem_large_ds_process_slice_sid succeeded");
-
-    file_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL);
-    VRFY((file_large_ds_process_slice_sid != FAIL), 
-         "H5Screate_simple() file_large_ds_process_slice_sid succeeded");
-
-
-    large_ds_slice_sid = H5Screate_simple(large_rank - 1, &(dims[1]), NULL);
-    VRFY((large_ds_slice_sid != 0), 
-         "H5Screate_simple() large_ds_slice_sid succeeded");
-
-
-    /* if chunk edge size is greater than zero, set up the small and
-     * large data set creation property lists to specify chunked
-     * datasets.
-     */
-    if ( chunk_edge_size > 0 ) {
-
-        /* Under Lustre (and perhaps other parallel file systems?) we get 
-	 * locking delays when two or more processes attempt to access the 
-         * same file system block.
-         *
-         * To minimize this problem, I have changed chunk_dims[0] 
-         * from (mpi_size + 1) to just when any sort of express test is
-         * selected.  Given the structure of the test, and assuming we 
-         * set the alignment large enough, this avoids the contention 
-         * issue by seeing to it that each chunk is only accessed by one 
-         * process.
-         *
-         * One can argue as to whether this is a good thing to do in our 
-         * tests, but for now it is necessary if we want the test to complete
-         * in a reasonable amount of time.
-         *
-         *                                         JRM -- 9/16/10
-         */
-        if ( express_test == 0 ) {
-
-            chunk_dims[0] = 1;
-
-        } else {
-
-            chunk_dims[0] = 1;
-        }
-
-        chunk_dims[1] = chunk_dims[2] = 
-                        chunk_dims[3] = chunk_dims[4] = (hsize_t)chunk_edge_size;
-
-        small_ds_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
-        VRFY((ret != FAIL), "H5Pcreate() small_ds_dcpl_id succeeded");
-
-        ret = H5Pset_layout(small_ds_dcpl_id, H5D_CHUNKED);
-        VRFY((ret != FAIL), "H5Pset_layout() small_ds_dcpl_id succeeded");
-
-        ret = H5Pset_chunk(small_ds_dcpl_id, small_rank, chunk_dims);
-        VRFY((ret != FAIL), "H5Pset_chunk() small_ds_dcpl_id succeeded");
-
-
-        large_ds_dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
-        VRFY((ret != FAIL), "H5Pcreate() large_ds_dcpl_id succeeded");
-
-        ret = H5Pset_layout(large_ds_dcpl_id, H5D_CHUNKED);
-        VRFY((ret != FAIL), "H5Pset_layout() large_ds_dcpl_id succeeded");
-
-        ret = H5Pset_chunk(large_ds_dcpl_id, large_rank, chunk_dims);
-        VRFY((ret != FAIL), "H5Pset_chunk() large_ds_dcpl_id succeeded");
-    }
-
-    /* create the small dataset */
-    small_dataset = H5Dcreate2(fid, "small_dataset", dset_type,
-                               file_small_ds_sid_0, H5P_DEFAULT,
-                               small_ds_dcpl_id, H5P_DEFAULT);
-    VRFY((ret != FAIL), "H5Dcreate2() small_dataset succeeded");
-
-    /* create the large dataset */
-    large_dataset = H5Dcreate2(fid, "large_dataset", dset_type,
-                               file_large_ds_sid_0, H5P_DEFAULT,
-                               large_ds_dcpl_id, H5P_DEFAULT);
-    VRFY((ret != FAIL), "H5Dcreate2() large_dataset succeeded");
-
-
-    /* setup xfer property list */
-    xfer_plist = H5Pcreate(H5P_DATASET_XFER);
-    VRFY((xfer_plist >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded");
-
-    if(use_collective_io) {
-        ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE);
-        VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded");
-    }
-
-
-    /* setup selection to write initial data to the small and large data sets */
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
-
-    for ( i = 1; i < large_rank; i++ ) {
-
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
-    }
-
-    /* setup selections for writing initial data to the small data set */
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
-
-    ret = H5Sselect_hyperslab(file_small_ds_sid_0,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded");
-
-    if ( MAINPROCESS ) { /* add an additional slice to the selections */
-
-        start[0] = (hsize_t)mpi_size;
-
-        ret = H5Sselect_hyperslab(mem_small_ds_sid,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(mem_small_ds_sid, or) suceeded");
-
-        ret = H5Sselect_hyperslab(file_small_ds_sid_0,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, or) suceeded");
-    }
-
-
-    /* write the initial value of the small data set to file */
-    ret = H5Dwrite(small_dataset, dset_type, mem_small_ds_sid, file_small_ds_sid_0,
-                   xfer_plist, small_ds_buf_0);
-    VRFY((ret >= 0), "H5Dwrite() small_dataset initial write succeeded");
-
-
-    /* sync with the other processes before checking data */
-    if ( ! use_collective_io ) {
-
-        mrc = MPI_Barrier(MPI_COMM_WORLD);
-        VRFY((mrc==MPI_SUCCESS), "Sync after small dataset writes");
-    }
-
-    /* read the small data set back to verify that it contains the 
-     * expected data.  Note that each process reads in the entire 
-     * data set and verifies it.
-     */
-    ret = H5Dread(small_dataset,
-                  H5T_NATIVE_UINT32,
-                  full_mem_small_ds_sid,
-                  full_file_small_ds_sid,
-                  xfer_plist,
-                  small_ds_buf_1);
-    VRFY((ret >= 0), "H5Dread() small_dataset initial read succeeded");
-
-
-    /* verify that the correct data was written to the small data set */
-    expected_value = 0;
-    mis_match = FALSE;
-    ptr_1 = small_ds_buf_1;
-
-    i = 0;
-    for ( i = 0; i < (int)small_ds_size; i++ ) {
-
-        if ( *ptr_1 != expected_value ) {
-
-            mis_match = TRUE;
-        }
-        ptr_1++;
-        expected_value++;
-    }
-    VRFY( (mis_match == FALSE), "small ds init data good.");
-
-
-
-    /* setup selections for writing initial data to the large data set */
-
-    start[0] = (hsize_t)mpi_rank;
-
-    ret = H5Sselect_hyperslab(mem_large_ds_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(mem_large_ds_sid, set) suceeded");
-
-    ret = H5Sselect_hyperslab(file_large_ds_sid_0,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, set) suceeded");
- 
-    /* In passing, setup the process slice data spaces as well */
-
-    ret = H5Sselect_hyperslab(mem_large_ds_process_slice_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), 
-         "H5Sselect_hyperslab(mem_large_ds_process_slice_sid, set) suceeded");
-
-    ret = H5Sselect_hyperslab(file_large_ds_process_slice_sid,
-                              H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), 
-         "H5Sselect_hyperslab(file_large_ds_process_slice_sid, set) suceeded");
-
-    if ( MAINPROCESS ) { /* add an additional slice to the selections */
-
-        start[0] = (hsize_t)mpi_size;
-
-        ret = H5Sselect_hyperslab(mem_large_ds_sid,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(mem_large_ds_sid, or) suceeded");
-
-        ret = H5Sselect_hyperslab(file_large_ds_sid_0,
-                                  H5S_SELECT_OR,
-                                  start,
-                                  stride,
-                                  count,
-                                  block);
-        VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, or) suceeded");
-    }
-
-
-    /* write the initial value of the large data set to file */
-    ret = H5Dwrite(large_dataset, dset_type, mem_large_ds_sid, file_large_ds_sid_0,
-                   xfer_plist, large_ds_buf_0);
-    if ( ret < 0 ) H5Eprint2(H5E_DEFAULT, stderr);
-    VRFY((ret >= 0), "H5Dwrite() large_dataset initial write succeeded");
-
-
-    /* sync with the other processes before checking data */
-    if ( ! use_collective_io ) {
-
-        mrc = MPI_Barrier(MPI_COMM_WORLD);
-        VRFY((mrc==MPI_SUCCESS), "Sync after large dataset writes");
-    }
-
-
-    /* read the small data set back to verify that it contains the 
-     * expected data.  Note that each process reads in the entire 
-     * data set.
-     */
-    ret = H5Dread(large_dataset,
-                  H5T_NATIVE_UINT32,
-                  full_mem_large_ds_sid,
-                  full_file_large_ds_sid,
-                  xfer_plist,
-                  large_ds_buf_1);
-    VRFY((ret >= 0), "H5Dread() large_dataset initial read succeeded");
-
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    /* verify that the correct data was written to the small data set */
-    expected_value = 0;
-    mis_match = FALSE;
-    ptr_1 = large_ds_buf_1;
-
-    i = 0;
-    for ( i = 0; i < (int)large_ds_size; i++ ) {
-
-        if ( *ptr_1 != expected_value ) {
-
-            mis_match = TRUE;
-        }
-        ptr_1++;
-        expected_value++;
-    }
-    VRFY( (mis_match == FALSE), "large ds init data good.");
- 
-    /* sync with the other processes before changing data */
-
-    if ( ! use_collective_io ) {
-
-        mrc = MPI_Barrier(MPI_COMM_WORLD);
-        VRFY((mrc==MPI_SUCCESS), "Sync after initial values check");
-    }
-
-
-    /***********************************/
-    /***** INITIALIZATION COMPLETE *****/
-    /***********************************/
 
     /* first, verify that we can read from disk correctly using selections
      * of different rank that H5S_select_shape_same() views as being of the
      * same shape.
      *
-     * Start by reading a (small_rank - 1)-D slice from this processes slice 
-     * of the on disk large data set, and verifying that the data read is 
-     * correct.  Verify that H5S_select_shape_same() returns true on the 
-     * memory and file selections.
+     * Start by reading a (small_rank - 1)-D checker board slice from this 
+     * processes slice of the on disk large data set, and verifying that the 
+     * data read is correct.  Verify that H5S_select_shape_same() returns 
+     * true on the memory and file selections.
      *
      * The first step is to set up the needed checker board selection in the
      * in memory small small cube
      */
 
     sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
-    sel_start[small_ds_offset] = (hsize_t)mpi_rank;
+    sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank);
 
-    checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank,
-                                                              small_ds_slice_sid,
-                                                              small_rank - 1,
-                                                              edge_size,
-                                                              checker_edge_size,
-                                                              small_rank - 1,
-                                                              sel_start);
+    ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank,
+                                       tv_ptr->small_ds_slice_sid,
+                                       tv_ptr->small_rank - 1,
+                                       tv_ptr->edge_size,
+                                       tv_ptr->checker_edge_size,
+                                       tv_ptr->small_rank - 1,
+                                       sel_start);
 
     /* zero out the buffer we will be reading into */
-    HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
+    HDmemset(tv_ptr->small_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->small_ds_slice_size);
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
     HDfprintf(stdout, "%s:%d: initial small_ds_slice_buf = ",
-              fcnName, mpi_rank);
-    ptr_0 = small_ds_slice_buf;
-    for ( i = 0; i < (int)small_ds_slice_size; i++ ) {
-	HDfprintf(stdout, "%d ", (int)(*ptr_0));
+              fcnName, tv_ptr->mpi_rank);
+    ptr_0 = tv_ptr->small_ds_slice_buf;
+    for ( i = 0; i < (int)(tv_ptr->small_ds_slice_size); i++ ) {
+        HDfprintf(stdout, "%d ", (int)(*ptr_0));
         ptr_0++;
     }
     HDfprintf(stdout, "\n");
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ 
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ 
 
     /* set up start, stride, count, and block -- note that we will
      * change start[] so as to read slices of the large cube.
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
     HDfprintf(stdout, 
               "%s:%d: reading slice from big ds on disk into small ds slice.\n",
-              fcnName, mpi_rank);
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ 
+              fcnName, tv_ptr->mpi_rank);
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ 
     /* in serial versions of this test, we loop through all the dimensions
      * of the large data set.  However, in the parallel version, each 
      * process only works with that slice of the large cube indicated
@@ -3117,9 +3065,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      * mpi_rank, and don't itterate over it.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3132,9 +3080,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3142,9 +3090,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -3164,98 +3112,167 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank - 1 >= 1 and that 
-                 * large_rank > small_rank by the assertions at the head 
-                 * of this function.  Thus no need for another inner loop.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) );
-                HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) );
-                HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) );
-                HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) );
-                HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) );
-
-                checker_board_hyperslab_dr_pio_test__select_checker_board
-                (
-                  mpi_rank,
-                  file_large_ds_sid_0,
-                  large_rank,
-                  edge_size,
-                  checker_edge_size,
-                  small_rank - 1,
-                  start
-                );
-
-                /* verify that H5S_select_shape_same() reports the two
-                 * selections as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(small_ds_slice_sid,
-                                                   file_large_ds_sid_0);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* Read selection from disk */
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", fcnName,
-                          mpi_rank, start[0], start[1], start[2], start[3], 
-                          start[4]);
-                HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n",
-                          fcnName,
-                          H5Sget_simple_extent_ndims(small_ds_slice_sid),
-                          H5Sget_simple_extent_ndims(file_large_ds_sid_0));
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ 
-
-                ret = H5Dread(large_dataset,
-                              H5T_NATIVE_UINT32,
-                              small_ds_slice_sid,
-                              file_large_ds_sid_0,
-                              xfer_plist,
-                              small_ds_slice_buf);
-                VRFY((ret >= 0), "H5Dread() slice from large ds succeeded.");
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-		HDfprintf(stdout, "%s:%d: H5Dread() returns.\n", 
-                          fcnName, mpi_rank);
-#endif 
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
+
+                    (tv_ptr->tests_skipped)++;
+
+                } else { /* run the test */
+
+                    tv_ptr->skips = 0; /* reset the skips counter */
+
+                    /* we know that small_rank - 1 >= 1 and that 
+                     * large_rank > small_rank by the assertions at the head 
+                     * of this function.  Thus no need for another inner loop.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1));
+
+                    ckrbrd_hs_dr_pio_test__slct_ckrbrd
+                    (
+                      tv_ptr->mpi_rank,
+                      tv_ptr->file_large_ds_sid_0,
+                      tv_ptr->large_rank,
+                      tv_ptr->edge_size,
+                      tv_ptr->checker_edge_size,
+                      tv_ptr->small_rank - 1,
+                      tv_ptr->start
+                    );
+
+                    /* verify that H5S_select_shape_same() reports the two
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->small_ds_slice_sid,
+                                                       tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
+
+
+                    /* Read selection from disk */
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", fcnName,
+                              tv_ptr->mpi_rank, tv_ptr->start[0], tv_ptr->start[1], 
+                              tv_ptr->start[2], tv_ptr->start[3], tv_ptr->start[4]);
+                    HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n",
+                              fcnName,
+                              H5Sget_simple_extent_ndims(tv_ptr->small_ds_slice_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0));
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ 
+
+                    ret = H5Dread(tv_ptr->large_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->small_ds_slice_sid,
+                                  tv_ptr->file_large_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->small_ds_slice_buf);
+                    VRFY((ret >= 0), "H5Dread() slice from large ds succeeded.");
+
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 
+                    HDfprintf(stdout, "%s:%d: H5Dread() returns.\n", 
+                              fcnName, tv_ptr->mpi_rank);
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
+
+                    /* verify that expected data is retrieved */
+
+                    expected_value = (uint32_t)
+                        ((i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                              tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (l * tv_ptr->edge_size));
+
+                    data_ok = ckrbrd_hs_dr_pio_test__verify_data
+                              (
+                                tv_ptr->small_ds_slice_buf,
+                                tv_ptr->small_rank - 1,
+                                tv_ptr->edge_size,
+                                tv_ptr->checker_edge_size,
+                                expected_value,
+                                (hbool_t)TRUE
+                              );
+
+                    VRFY((data_ok == TRUE), 
+                         "small slice read from large ds data good.");
+
+                    (tv_ptr->tests_run)++;
+                }
 
-                /* verify that expected data is retrieved */
-
-                expected_value = (uint32_t)
-			((i * edge_size * edge_size * edge_size * edge_size) +
-                         (j * edge_size * edge_size * edge_size) +
-                         (k * edge_size * edge_size) +
-                         (l * edge_size));
-
-                data_ok = checker_board_hyperslab_dr_pio_test__verify_data
-                          (
-                            small_ds_slice_buf,
-                            small_rank - 1,
-                            edge_size,
-                            checker_edge_size,
-                            expected_value,
-                            (hbool_t)TRUE
-                          );
-
-                VRFY((data_ok == TRUE), 
-                     "small slice read from large ds data good.");
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
+
+    return;
+
+} /* ckrbrd_hs_dr_pio_test__d2m_l2s() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	ckrbrd_hs_dr_pio_test__d2m_s2l()
+ *
+ * Purpose:	Part two of a series of tests of I/O to/from hyperslab 
+ *		selections of different rank in the parallel.
+ *
+ *		Verify that we can read from disk correctly using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *		In this function, we test this by reading checker board
+ *		slices of the on disk small data set into slices through 
+ *		the in memory large data set, and verify that the correct 
+ *		data (and only the correct data) is read.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/15/11
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 0
+
+static void
+ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__d2m_s2l()";
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
+    hbool_t	data_ok = FALSE;
+    int		i, j, k, l;
+    size_t      u;
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    int		mpi_rank; /* needed by VRFY */
+    hsize_t     sel_start[PAR_SS_DR_MAX_RANK];
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
 
     /* similarly, read slices of the on disk small data set into slices 
@@ -3264,24 +3281,24 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      */
 
     sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
-    sel_start[small_ds_offset] = (hsize_t)mpi_rank;
+    sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank);
 
-    checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank,
-                                                              file_small_ds_sid_0,
-                                                              small_rank,
-                                                              edge_size,
-                                                              checker_edge_size,
-                                                              small_rank - 1,
-                                                              sel_start);
+    ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank,
+                                       tv_ptr->file_small_ds_sid_0,
+                                       tv_ptr->small_rank,
+                                       tv_ptr->edge_size,
+                                       tv_ptr->checker_edge_size,
+                                       tv_ptr->small_rank - 1,
+                                       sel_start);
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
     HDfprintf(stdout, 
       "%s reading slices of on disk small data set into slices of big data set.\n",
               fcnName);
-#endif 
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
 
     /* zero out the buffer we will be reading into */
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
 
     /* set up start, stride, count, and block -- note that we will
      * change start[] so as to read the slice of the small data set
@@ -3290,20 +3307,19 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
-
     /* in serial versions of this test, we loop through all the dimensions
      * of the large data set that don't appear in the small data set.  
      *
@@ -3314,9 +3330,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      */
 
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3329,9 +3345,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3339,9 +3355,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -3361,161 +3377,235 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num,
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) );
-                HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) );
-                HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) );
-                HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) );
-                HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) );
-
-                checker_board_hyperslab_dr_pio_test__select_checker_board
-                (
-                  mpi_rank,
-                  mem_large_ds_sid,
-                  large_rank,
-                  edge_size,
-                  checker_edge_size,
-                  small_rank - 1,
-                  start
-                );
-
-
-                /* verify that H5S_select_shape_same() reports the two
-                 * selections as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(file_small_ds_sid_0,
-                                                   mem_large_ds_sid);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* Read selection from disk */
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, mpi_rank, 
-                          start[0], start[1], start[2], start[3], start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(large_ds_slice_sid),
-                          H5Sget_simple_extent_ndims(file_small_ds_sid_0));
-#endif 
-                ret = H5Dread(small_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_large_ds_sid,
-                              file_small_ds_sid_0,
-                              xfer_plist,
-                              large_ds_buf_1);
-                VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
-
-                /* verify that the expected data and only the
-                 * expected data was read.
-                 */
-                data_ok = TRUE;
-                ptr_1 = large_ds_buf_1;
-                expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size);
-                start_index = (size_t)(
-                        (i * edge_size * edge_size * edge_size * edge_size) +
-                        (j * edge_size * edge_size * edge_size) +
-                        (k * edge_size * edge_size) +
-                        (l * edge_size));
-                stop_index = start_index + small_ds_slice_size - 1;
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-{
-int		m, n;
-
-		HDfprintf(stdout, "%s:%d: expected_value = %d.\n", 
-                          fcnName, mpi_rank, expected_value);
-		HDfprintf(stdout, "%s:%d: start/stop index = %d/%d.\n",
-                          fcnName, mpi_rank, start_index, stop_index);
-                n = 0;
-                for ( m = 0; m < large_ds_size; m ++ ) {
-                    HDfprintf(stdout, "%d ", (int)(*ptr_1));
-                    ptr_1++;
-                    n++;
-                    if ( n >= edge_size ) {
-                        HDfprintf(stdout, "\n");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
+
+                    (tv_ptr->tests_skipped)++;
+
+                } else { /* run the test */
+
+                    tv_ptr->skips = 0; /* reset the skips counter */
+
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1));
+
+                    ckrbrd_hs_dr_pio_test__slct_ckrbrd
+                    (
+                      tv_ptr->mpi_rank,
+                      tv_ptr->mem_large_ds_sid,
+                      tv_ptr->large_rank,
+                      tv_ptr->edge_size,
+                      tv_ptr->checker_edge_size,
+                      tv_ptr->small_rank - 1,
+                      tv_ptr->start
+                    );
+
+
+                    /* verify that H5S_select_shape_same() reports the two
+                     * selections as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_0,
+                                                       tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
+
+
+                    /* Read selection from disk */
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, tv_ptr->mpi_rank, 
+                              tv_ptr->start[0], tv_ptr->start[1], tv_ptr->start[2], 
+                              tv_ptr->start[3], tv_ptr->start[4]); 
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->large_ds_slice_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_0));
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
+                    ret = H5Dread(tv_ptr->small_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_large_ds_sid,
+                                  tv_ptr->file_small_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->large_ds_buf_1);
+                    VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+
+                    /* verify that the expected data and only the
+                     * expected data was read.
+                     */
+                    data_ok = TRUE;
+                    ptr_1 = tv_ptr->large_ds_buf_1;
+                    expected_value = 
+                       (uint32_t)((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size);
+                    start_index = (size_t)(
+                        (i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                             tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (l * tv_ptr->edge_size));
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
+
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 
+                    {
+                        int m, n;
+
+                        HDfprintf(stdout, "%s:%d: expected_value = %d.\n", 
+                                  fcnName, tv_ptr->mpi_rank, expected_value);
+                        HDfprintf(stdout, "%s:%d: start/stop index = %d/%d.\n",
+                                  fcnName, tv_ptr->mpi_rank, start_index, stop_index);
                         n = 0;
+                        for ( m = 0; (unsigned)m < tv_ptr->large_ds_size; m ++ ) {
+                            HDfprintf(stdout, "%d ", (int)(*ptr_1));
+                            ptr_1++;
+                            n++;
+                            if ( n >= tv_ptr->edge_size ) {
+                                HDfprintf(stdout, "\n");
+                                n = 0;
+                            }
+                        }
+                        HDfprintf(stdout, "\n");
+                        ptr_1 = tv_ptr->large_ds_buf_1;
                     }
-                }
-                HDfprintf(stdout, "\n");
-                fsync(stdout);
-                ptr_1 = large_ds_buf_1;
-}
-#endif 
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index <= large_ds_size );
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index <= tv_ptr->large_ds_size );
 
-                for ( u = 0; u < start_index; u++ ) {
+                    for ( u = 0; u < start_index; u++ ) {
 
-                    if ( *ptr_1 != 0 ) {
+                        if ( *ptr_1 != 0 ) {
 
-			data_ok = FALSE;
-		    }
+                            data_ok = FALSE;
+                        }
 
-                    /* zero out the value for the next pass */
-                    *ptr_1 = 0;
+                        /* zero out the value for the next pass */
+                        *ptr_1 = 0;
 
-                    ptr_1++;
-                }
+                        ptr_1++;
+                    }
 
-                VRFY((data_ok == TRUE), 
-                     "slice read from small to large ds data good(1).");
+                    VRFY((data_ok == TRUE), 
+                         "slice read from small to large ds data good(1).");
 
-                data_ok = checker_board_hyperslab_dr_pio_test__verify_data
-                          (
-                            ptr_1,
-                            small_rank - 1,
-                            edge_size,
-                            checker_edge_size,
-                            expected_value,
-                            (hbool_t)TRUE
-                          );
+                    data_ok = ckrbrd_hs_dr_pio_test__verify_data
+                              (
+                                ptr_1,
+                                tv_ptr->small_rank - 1,
+                                tv_ptr->edge_size,
+                                tv_ptr->checker_edge_size,
+                                expected_value,
+                                (hbool_t)TRUE
+                              );
 
-                VRFY((data_ok == TRUE), 
-                     "slice read from small to large ds data good(2).");
+                    VRFY((data_ok == TRUE), 
+                         "slice read from small to large ds data good(2).");
 
 
-                ptr_1 = large_ds_buf_1 + stop_index + 1;
+                    ptr_1 = tv_ptr->large_ds_buf_1 + stop_index + 1;
 
-                for ( u = stop_index + 1; u < large_ds_size; u++ ) {
+                    for ( u = stop_index + 1; u < tv_ptr->large_ds_size; u++ ) {
 
-                    if ( *ptr_1 != 0 ) {
+                        if ( *ptr_1 != 0 ) {
 
-			data_ok = FALSE;
-		    }
+                            data_ok = FALSE;
+                        }
 
-                    /* zero out the value for the next pass */
-                    *ptr_1 = 0;
+                        /* zero out the value for the next pass */
+                        *ptr_1 = 0;
 
-                    *ptr_1++;
-                }
+                        ptr_1++;
+                    }
+
+                    VRFY((data_ok == TRUE), 
+                         "slice read from small to large ds data good(3).");
 
-                VRFY((data_ok == TRUE), 
-                     "slice read from small to large ds data good(3).");
+                    (tv_ptr->tests_run)++;
+                }
 
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
+
+    return;
+
+} /* ckrbrd_hs_dr_pio_test__d2m_s2l() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	ckrbrd_hs_dr_pio_test__m2d_l2s()
+ *
+ * Purpose:	Part three of a series of tests of I/O to/from checker
+ *		board hyperslab selections of different rank in the 
+ *		parallel.
+ *
+ *		Verify that we can write from memory to file using checker
+ *		board selections of different rank that 
+ *		H5S_select_shape_same() views as being of the same shape.
+ *
+ *		Do this by writing small_rank - 1 dimensional checker 
+ *		board slices from the in memory large data set to the on 
+ *		disk small cube dataset.  After each write, read the 
+ *		slice of the small dataset back from disk, and verify 
+ *		that it contains the expected data. Verify that 
+ *		H5S_select_shape_same() returns true on the memory and 
+ *		file selections.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/15/11
+ *
+ * Modifications:
+ *
+ *		None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#define CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG 0
+
+static void
+ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__m2d_l2s()";
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
+    hbool_t	data_ok = FALSE;
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t      u;
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    int		mpi_rank; /* needed by VRFY */
+    hsize_t     sel_start[PAR_SS_DR_MAX_RANK];
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
 
     /* now we go in the opposite direction, verifying that we can write
@@ -3529,46 +3619,46 @@ int		m, n;
      * the memory and file selections.
      */
 
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
-    ret = H5Sselect_hyperslab(file_small_ds_sid_0,
+    ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded");
 
-    ret = H5Sselect_hyperslab(mem_small_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
 
 
     sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
-    sel_start[small_ds_offset] = (hsize_t)mpi_rank;
+    sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank);
 
-    checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank,
-                                                              file_small_ds_sid_1,
-                                                              small_rank,
-                                                              edge_size,
-                                                              checker_edge_size,
-                                                              small_rank - 1,
-                                                              sel_start);
+    ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank,
+                                       tv_ptr->file_small_ds_sid_1,
+                                       tv_ptr->small_rank,
+                                       tv_ptr->edge_size,
+                                       tv_ptr->checker_edge_size,
+                                       tv_ptr->small_rank - 1,
+                                       sel_start);
 
 
     /* set up start, stride, count, and block -- note that we will
@@ -3576,28 +3666,28 @@ int		m, n;
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
     /* zero out the in memory small ds */
-    HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
+    HDmemset(tv_ptr->small_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->small_ds_size);
 
 
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
     HDfprintf(stdout, 
     "%s writing checker boards selections of slices from big ds to slices of small ds on disk.\n",
     fcnName);
-#endif 
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
 
     /* in serial versions of this test, we loop through all the dimensions
      * of the large data set that don't appear in the small data set.  
@@ -3609,9 +3699,9 @@ int		m, n;
      */
 
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3624,9 +3714,9 @@ int		m, n;
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3635,9 +3725,9 @@ int		m, n;
 
     j = 0;
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -3657,154 +3747,228 @@ int		m, n;
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-
-                /* zero out this rank's slice of the on disk small data set */
-                ret = H5Dwrite(small_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_small_ds_sid,
-                               file_small_ds_sid_0,
-                               xfer_plist,
-                               small_ds_buf_2);
-                VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded.");
-
-                /* select the portion of the in memory large cube from which we
-                 * are going to write data.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) );
-                HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) );
-                HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) );
-                HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) );
-                HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) );
-
-                checker_board_hyperslab_dr_pio_test__select_checker_board
-                (
-                  mpi_rank,
-                  mem_large_ds_sid,
-                  large_rank,
-                  edge_size,
-                  checker_edge_size,
-                  small_rank - 1,
-                  start
-                );
-
-
-                /* verify that H5S_select_shape_same() reports the in
-                 * memory checkerboard selection of the slice through the 
-                 * large dataset and the checkerboard selection of the process
-                 * slice of the small data set as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(file_small_ds_sid_1,
-                                                   mem_large_ds_sid);
-                VRFY((check == TRUE), "H5S_select_shape_same_test passed.");
-
-
-                /* write the checker board selection of the slice from the in 
-                 * memory large data set to the slice of the on disk small 
-                 * dataset. 
-                 */
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, mpi_rank,
-                          start[0], start[1], start[2], start[3], start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(mem_large_ds_sid),
-                          H5Sget_simple_extent_ndims(file_small_ds_sid_1));
-#endif 
-                ret = H5Dwrite(small_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_large_ds_sid,
-                               file_small_ds_sid_1,
-                               xfer_plist,
-                               large_ds_buf_0);
-                VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded.");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
 
+                    (tv_ptr->tests_skipped)++;
 
-                /* read the on disk process slice of the small dataset into memory */
-                ret = H5Dread(small_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_small_ds_sid,
-                              file_small_ds_sid_0,
-                              xfer_plist,
-                              small_ds_buf_1);
-                VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+                } else { /* run the test */
 
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
-                /* verify that expected data is retrieved */
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
+    
+                    /* zero out this rank's slice of the on disk small data set */
+                    ret = H5Dwrite(tv_ptr->small_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_small_ds_sid,
+                                   tv_ptr->file_small_ds_sid_0,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->small_ds_buf_2);
+                    VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded.");
+    
+                    /* select the portion of the in memory large cube from which we
+                     * are going to write data.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+    
+                    HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1));
+    
+                    ckrbrd_hs_dr_pio_test__slct_ckrbrd
+                    (
+                      tv_ptr->mpi_rank,
+                      tv_ptr->mem_large_ds_sid,
+                      tv_ptr->large_rank,
+                      tv_ptr->edge_size,
+                      tv_ptr->checker_edge_size,
+                      tv_ptr->small_rank - 1,
+                      tv_ptr->start
+                    );
+    
+    
+                    /* verify that H5S_select_shape_same() reports the in
+                     * memory checkerboard selection of the slice through the 
+                     * large dataset and the checkerboard selection of the process
+                     * slice of the small data set as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_1,
+                                                       tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed.");
+    
+    
+                    /* write the checker board selection of the slice from the in 
+                     * memory large data set to the slice of the on disk small 
+                     * dataset. 
+                     */
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, tv_ptr->mpi_rank,
+                              tv_ptr->start[0], tv_ptr->start[1], tv_ptr->start[2], 
+                              tv_ptr->start[3], tv_ptr->start[4]);
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_large_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_1));
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
+                    ret = H5Dwrite(tv_ptr->small_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_large_ds_sid,
+                                   tv_ptr->file_small_ds_sid_1,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->large_ds_buf_0);
+                    VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded.");
+    
+    
+                    /* read the on disk process slice of the small dataset into memory */
+                    ret = H5Dread(tv_ptr->small_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_small_ds_sid,
+                                  tv_ptr->file_small_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->small_ds_buf_1);
+                    VRFY((ret >= 0), "H5Dread() slice from small ds succeeded.");
+    
+    
+                    /* verify that expected data is retrieved */
+    
+                    mis_match = FALSE;
+    
+                    expected_value = (uint32_t)(
+    			(i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                                 tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                        (l * tv_ptr->edge_size));
+    
+                    start_index = (size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size;
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
+    
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index <= tv_ptr->small_ds_size );
+    
+                    data_ok = TRUE;
+    
+                    ptr_1 = tv_ptr->small_ds_buf_1;
+                    for ( u = 0; u < start_index; u++, ptr_1++ ) {
+    
+                        if ( *ptr_1 != 0 ) {
 
-                mis_match = FALSE;
+                            data_ok = FALSE;
+                            *ptr_1 = 0;
+                        }
+                    }
 
-                expected_value = (uint32_t)(
-			(i * edge_size * edge_size * edge_size * edge_size) +
-                        (j * edge_size * edge_size * edge_size) +
-                        (k * edge_size * edge_size) +
-                        (l * edge_size));
+                    data_ok &= ckrbrd_hs_dr_pio_test__verify_data
+                               (
+                                 tv_ptr->small_ds_buf_1 + start_index,
+                                 tv_ptr->small_rank - 1,
+                                 tv_ptr->edge_size,
+                                 tv_ptr->checker_edge_size,
+                                 expected_value,
+                                 (hbool_t)TRUE
+                               );
 
-                start_index = (size_t)mpi_rank * small_ds_slice_size;
-                stop_index = start_index + small_ds_slice_size - 1;
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index <= small_ds_size );
+                    ptr_1 = tv_ptr->small_ds_buf_1;
+                    for ( u = stop_index; u < tv_ptr->small_ds_size; u++, ptr_1++ ) {
 
-                data_ok = TRUE;
+                        if ( *ptr_1 != 0 ) {
 
-                ptr_1 = small_ds_buf_1;
-                for ( u = 0; u < start_index; u++, ptr_1++ ) {
+                            data_ok = FALSE;
+                            *ptr_1 = 0;
+                        }
+                    }
 
-                    if ( *ptr_1 != 0 ) {
+                    VRFY((data_ok == TRUE), 
+                         "large slice write slice to small slice data good.");
 
-                        data_ok = FALSE;
-                        *ptr_1 = 0;
-                    }
+                    (tv_ptr->tests_run)++;
                 }
 
-                data_ok &= checker_board_hyperslab_dr_pio_test__verify_data
-                           (
-                             small_ds_buf_1 + start_index,
-                             small_rank - 1,
-                             edge_size,
-                             checker_edge_size,
-                             expected_value,
-                             (hbool_t)TRUE
-                           );
+                l++;
 
+                (tv_ptr->total_tests)++;
 
-                ptr_1 = small_ds_buf_1;
-                for ( u = stop_index; u < small_ds_size; u++, ptr_1++ ) {
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
+            k++;
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
+        j++;
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
 
-                    if ( *ptr_1 != 0 ) {
+    return;
 
-                        data_ok = FALSE;
-                        *ptr_1 = 0;
-                    }
-                }
+} /* ckrbrd_hs_dr_pio_test__m2d_l2s() */
 
-                VRFY((data_ok == TRUE), 
-                     "large slice write slice to small slice data good.");
 
-                l++;
+/*-------------------------------------------------------------------------
+ * Function:	ckrbrd_hs_dr_pio_test__m2d_s2l()
+ *
+ * Purpose:	Part four of a series of tests of I/O to/from checker
+ *		board hyperslab selections of different rank in the parallel.
+ *
+ *		Verify that we can write from memory to file using 
+ *		selections of different rank that H5S_select_shape_same() 
+ *		views as being of the same shape.
+ *
+ *		Do this by writing checker board selections of the contents 
+ *		of the process's slice of the in memory small data set to 
+ *		slices of the on disk large data set.  After each write, 
+ *		read the process's slice of the large data set back into 
+ *		memory, and verify that it contains the expected data. 
+ *
+ *		Verify that H5S_select_shape_same() returns true on the 
+ *		memory and file selections.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 8/15/11
+ *
+ * Modifications:
+ *
+ *		None
+ *
+ *-------------------------------------------------------------------------
+ */
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
-            k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
-        j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+#define CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG 0
+
+static void
+ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
+{
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__m2d_s2l()";
+#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
+    hbool_t	data_ok = FALSE;
+    hbool_t	mis_match = FALSE;
+    int		i, j, k, l;
+    size_t      u;
+    size_t      start_index;
+    size_t      stop_index;
+    uint32_t	expected_value;
+    uint32_t  * ptr_1;
+    int		mpi_rank; /* needed by VRFY */
+    hsize_t     sel_start[PAR_SS_DR_MAX_RANK];
+    htri_t      check;          /* Shape comparison return value */
+    herr_t	ret;		/* Generic return value */
+
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
 
     /* Now write the contents of the process's slice of the in memory 
@@ -3815,49 +3979,49 @@ int		m, n;
      * and file selections.
      */
 
-    start[0] = (hsize_t)mpi_rank;
-    stride[0] = (hsize_t)(2 * (mpi_size + 1));
-    count[0] = 1;
-    block[0] = 1;
+    tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank);
+    tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1));
+    tv_ptr->count[0] = 1;
+    tv_ptr->block[0] = 1;
 
-    for ( i = 1; i < large_rank; i++ ) {
+    for ( i = 1; i < tv_ptr->large_rank; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        block[i] = (hsize_t)edge_size;
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
     }
 
-    ret = H5Sselect_hyperslab(file_large_ds_sid_0,
+    ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
     VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, set) suceeded");
 
-    ret = H5Sselect_hyperslab(mem_large_ds_sid,
+    ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid,
                               H5S_SELECT_SET,
-                              start,
-                              stride,
-                              count,
-                              block);
-    VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded");
+                              tv_ptr->start,
+                              tv_ptr->stride,
+                              tv_ptr->count,
+                              tv_ptr->block);
+    VRFY((ret >= 0), "H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid, set) suceeded");
 
     /* setup a checkerboard selection of the slice of the in memory small 
      * data set associated with the process's mpi rank.
      */
 
     sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
-    sel_start[small_ds_offset] = (hsize_t)mpi_rank;
+    sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank);
 
-    checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank,
-                                                              mem_small_ds_sid,
-                                                              small_rank,
-                                                              edge_size,
-                                                              checker_edge_size,
-                                                              small_rank - 1,
-                                                              sel_start);
+    ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank,
+                                       tv_ptr->mem_small_ds_sid,
+                                       tv_ptr->small_rank,
+                                       tv_ptr->edge_size,
+                                       tv_ptr->checker_edge_size,
+                                       tv_ptr->small_rank - 1,
+                                       sel_start);
 
     /* set up start, stride, count, and block -- note that we will
      * change start[] so as to write checkerboard selections of slices 
@@ -3865,31 +4029,31 @@ int		m, n;
      */
     for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
 
-        start[i] = 0;
-        stride[i] = (hsize_t)(2 * edge_size);
-        count[i] = 1;
-        if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
+        tv_ptr->start[i] = 0;
+        tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size);
+        tv_ptr->count[i] = 1;
+        if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) {
 
-            block[i] = 1;
+            tv_ptr->block[i] = 1;
 
         } else {
 
-            block[i] = (hsize_t)edge_size;
+            tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size);
         }
     }
 
     /* zero out the in memory large ds */
-    HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
+    HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size);
 
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG
     HDfprintf(stdout, 
          "%s writing process checkerboard selections of slices of small ds to process slices of large ds on disk.\n",
          fcnName);
-#endif 
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) {
 
-        i = mpi_rank;
+        i = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3902,9 +4066,9 @@ int		m, n;
      * test.
      */
 
-    if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
+    if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) {
 
-        j = mpi_rank;
+        j = tv_ptr->mpi_rank;
 
     } else {
 
@@ -3912,9 +4076,9 @@ int		m, n;
     }
 
     do {
-        if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
+        if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) {
 
-            k = mpi_rank;
+            k = tv_ptr->mpi_rank;
 
         } else {
 
@@ -3934,240 +4098,395 @@ int		m, n;
 
             l = 0;
             do {
-                /* we know that small_rank >= 1 and that large_rank > small_rank
-                 * by the assertions at the head of this function.  Thus no
-                 * need for another inner loop.
-                 */
-
-                /* Zero out this processes slice of the on disk large data set.
-                 * Note that this will leave one slice with its original data
-                 * as there is one more slice than processes.
-                  */
-                ret = H5Dwrite(large_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_large_ds_sid,
-                               file_large_ds_sid_0,
-                               xfer_plist,
-                               large_ds_buf_2);
-		VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded");
-
-
-                /* select the portion of the in memory large cube to which we
-                 * are going to write data.
-                 */
-                start[0] = (hsize_t)i;
-                start[1] = (hsize_t)j;
-                start[2] = (hsize_t)k;
-                start[3] = (hsize_t)l;
-                start[4] = 0;
-
-                HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) );
-                HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) );
-                HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) );
-                HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) );
-                HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) );
-
-                checker_board_hyperslab_dr_pio_test__select_checker_board
-                (
-                  mpi_rank,
-                  file_large_ds_sid_1,
-                  large_rank,
-                  edge_size,
-                  checker_edge_size,
-                  small_rank - 1,
-                  start
-                );
-
-
-                /* verify that H5S_select_shape_same() reports the in
-                 * memory small data set slice selection and the
-                 * on disk slice through the large data set selection
-                 * as having the same shape.
-                 */
-                check = H5S_select_shape_same_test(mem_small_ds_sid,
-                                                   file_large_ds_sid_1);
-		VRFY((check == TRUE), "H5S_select_shape_same_test passed");
-
-
-                /* write the small data set slice from memory to the 
-                 * target slice of the disk data set 
-                 */
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 
-                HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
-                          fcnName, mpi_rank,
-                          start[0], start[1], start[2], start[3], start[4]);
-                HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
-                          fcnName, mpi_rank,
-                          H5Sget_simple_extent_ndims(mem_small_ds_sid),
-                          H5Sget_simple_extent_ndims(file_large_ds_sid_1));
-#endif 
-                ret = H5Dwrite(large_dataset,
-                               H5T_NATIVE_UINT32,
-                               mem_small_ds_sid,
-                               file_large_ds_sid_1,
-                               xfer_plist,
-                               small_ds_buf_0);
-		VRFY((ret != FAIL), 
-                      "H5Dwrite of small ds slice to large ds succeeded");
+                if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */
 
+                    (tv_ptr->tests_skipped)++;
 
-                /* read this processes slice on the on disk large 
-                 * data set into memory.
-                 */
+                } else { /* run the test */
 
-                ret = H5Dread(large_dataset,
-                              H5T_NATIVE_UINT32,
-                              mem_large_ds_sid,
-                              file_large_ds_sid_0,
-                              xfer_plist,
-                              large_ds_buf_1);
-                VRFY((ret != FAIL), 
-                     "H5Dread() of process slice of large ds succeeded");
+                    tv_ptr->skips = 0; /* reset the skips counter */
 
+                    /* we know that small_rank >= 1 and that large_rank > small_rank
+                     * by the assertions at the head of this function.  Thus no
+                     * need for another inner loop.
+                     */
 
-                /* verify that the expected data and only the
-                 * expected data was read.
-                 */
-                expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size);
+                    /* Zero out this processes slice of the on disk large data set.
+                     * Note that this will leave one slice with its original data
+                     * as there is one more slice than processes.
+                     */
+                    ret = H5Dwrite(tv_ptr->large_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_large_ds_sid,
+                                   tv_ptr->file_large_ds_sid_0,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->large_ds_buf_2);
+                    VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded");
 
-                start_index = (size_t)((i * edge_size * edge_size * edge_size * edge_size) +
-                              (j * edge_size * edge_size * edge_size) +
-                              (k * edge_size * edge_size) +
-                              (l * edge_size));
-                stop_index = start_index + small_ds_slice_size - 1;
 
-                HDassert( start_index < stop_index );
-                HDassert( stop_index < large_ds_size );
+                    /* select the portion of the in memory large cube to which we
+                     * are going to write data.
+                     */
+                    tv_ptr->start[0] = (hsize_t)i;
+                    tv_ptr->start[1] = (hsize_t)j;
+                    tv_ptr->start[2] = (hsize_t)k;
+                    tv_ptr->start[3] = (hsize_t)l;
+                    tv_ptr->start[4] = 0;
+
+                    HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1));
+                    HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1));
+
+                    ckrbrd_hs_dr_pio_test__slct_ckrbrd
+                    (
+                      tv_ptr->mpi_rank,
+                      tv_ptr->file_large_ds_sid_1,
+                      tv_ptr->large_rank,
+                      tv_ptr->edge_size,
+                      tv_ptr->checker_edge_size,
+                      tv_ptr->small_rank - 1,
+                      tv_ptr->start
+                    );
+
+
+                    /* verify that H5S_select_shape_same() reports the in
+                     * memory small data set slice selection and the
+                     * on disk slice through the large data set selection
+                     * as having the same shape.
+                     */
+                    check = H5S_select_shape_same_test(tv_ptr->mem_small_ds_sid,
+                                                       tv_ptr->file_large_ds_sid_1);
+                    VRFY((check == TRUE), "H5S_select_shape_same_test passed");
 
 
-                mis_match = FALSE;
+                    /* write the small data set slice from memory to the 
+                     * target slice of the disk data set 
+                     */
+#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG 
+                    HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", 
+                              fcnName, tv_ptr->mpi_rank,
+                              tv_ptr->start[0], tv_ptr->start[1], tv_ptr->start[2], 
+                              tv_ptr->start[3], tv_ptr->start[4]);
+                    HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n",
+                              fcnName, tv_ptr->mpi_rank,
+                              H5Sget_simple_extent_ndims(tv_ptr->mem_small_ds_sid),
+                              H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_1));
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
+                    ret = H5Dwrite(tv_ptr->large_dataset,
+                                   H5T_NATIVE_UINT32,
+                                   tv_ptr->mem_small_ds_sid,
+                                   tv_ptr->file_large_ds_sid_1,
+                                   tv_ptr->xfer_plist,
+                                   tv_ptr->small_ds_buf_0);
+                    VRFY((ret != FAIL), 
+                         "H5Dwrite of small ds slice to large ds succeeded");
+
+
+                    /* read this processes slice on the on disk large 
+                     * data set into memory.
+                     */
 
-                data_ok = TRUE;
+                    ret = H5Dread(tv_ptr->large_dataset,
+                                  H5T_NATIVE_UINT32,
+                                  tv_ptr->mem_large_ds_sid,
+                                  tv_ptr->file_large_ds_sid_0,
+                                  tv_ptr->xfer_plist,
+                                  tv_ptr->large_ds_buf_1);
+                    VRFY((ret != FAIL), 
+                         "H5Dread() of process slice of large ds succeeded");
 
-                ptr_1 = large_ds_buf_1;
-                for ( u = 0; u < start_index; u++, ptr_1++ ) {
 
-                    if ( *ptr_1 != 0 ) {
+                    /* verify that the expected data and only the
+                     * expected data was read.
+                     */
+                    expected_value = 
+                       (uint32_t)((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size);
 
-                        data_ok = FALSE;
-                        *ptr_1 = 0;
+                    start_index = (size_t)
+                        ((i * tv_ptr->edge_size * tv_ptr->edge_size * 
+                              tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (k * tv_ptr->edge_size * tv_ptr->edge_size) +
+                         (l * tv_ptr->edge_size));
+                    stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
+
+                    HDassert( start_index < stop_index );
+                    HDassert( stop_index < tv_ptr->large_ds_size );
+
+
+                    mis_match = FALSE;
+
+                    data_ok = TRUE;
+
+                    ptr_1 = tv_ptr->large_ds_buf_1;
+                    for ( u = 0; u < start_index; u++, ptr_1++ ) {
+
+                        if ( *ptr_1 != 0 ) {
+
+                            data_ok = FALSE;
+                            *ptr_1 = 0;
+                        }
                     }
-                }
 
-                data_ok &= checker_board_hyperslab_dr_pio_test__verify_data
-                           (
-                             large_ds_buf_1 + start_index,
-                             small_rank - 1,
-                             edge_size,
-                             checker_edge_size,
-                             expected_value,
-                             (hbool_t)TRUE
-                           );
+                    data_ok &= ckrbrd_hs_dr_pio_test__verify_data
+                               (
+                                 tv_ptr->large_ds_buf_1 + start_index,
+                                 tv_ptr->small_rank - 1,
+                                 tv_ptr->edge_size,
+                                 tv_ptr->checker_edge_size,
+                                 expected_value,
+                                 (hbool_t)TRUE
+                               );
 
 
-                ptr_1 = large_ds_buf_1;
-                for ( u = stop_index; u < small_ds_size; u++, ptr_1++ ) {
+                    ptr_1 = tv_ptr->large_ds_buf_1;
+                    for ( u = stop_index; u < tv_ptr->small_ds_size; u++, ptr_1++ ) {
 
-                    if ( *ptr_1 != 0 ) {
+                        if ( *ptr_1 != 0 ) {
 
-                        data_ok = FALSE;
-                        *ptr_1 = 0;
+                            data_ok = FALSE;
+                            *ptr_1 = 0;
+                        }
                     }
-                }
 
-                VRFY((data_ok == TRUE), 
-                     "small ds cb slice write to large ds slice data good.");
+                    VRFY((data_ok == TRUE), 
+                         "small ds cb slice write to large ds slice data good.");
+
+                    (tv_ptr->tests_run)++;
+                }
 
                 l++;
 
-            } while ( ( large_rank > 2 ) &&
-                      ( (small_rank - 1) <= 1 ) &&
-                      ( l < edge_size ) );
+                (tv_ptr->total_tests)++;
+
+            } while ( ( tv_ptr->large_rank > 2 ) &&
+                      ( (tv_ptr->small_rank - 1) <= 1 ) &&
+                      ( l < tv_ptr->edge_size ) );
             k++;
-        } while ( ( large_rank > 3 ) &&
-                  ( (small_rank - 1) <= 2 ) &&
-                  ( k < edge_size ) );
+        } while ( ( tv_ptr->large_rank > 3 ) &&
+                  ( (tv_ptr->small_rank - 1) <= 2 ) &&
+                  ( k < tv_ptr->edge_size ) );
         j++;
-    } while ( ( large_rank > 4 ) &&
-              ( (small_rank - 1) <= 3 ) &&
-              ( j < edge_size ) );
+    } while ( ( tv_ptr->large_rank > 4 ) &&
+              ( (tv_ptr->small_rank - 1) <= 3 ) &&
+              ( j < tv_ptr->edge_size ) );
 
+    return;
 
-    /* Close dataspaces */
-    ret = H5Sclose(full_mem_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded");
+} /* ckrbrd_hs_dr_pio_test__m2d_s2l() */
 
-    ret = H5Sclose(full_file_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_file_small_ds_sid) succeeded");
 
-    ret = H5Sclose(mem_small_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_small_ds_sid) succeeded");
+/*-------------------------------------------------------------------------
+ * Function:	ckrbrd_hs_dr_pio_test__run_test()
+ *
+ * Purpose:	Test I/O to/from checkerboard selections of hyperslabs of 
+ *		different rank in the parallel.
+ *
+ * Return:	void
+ *
+ * Programmer:	JRM -- 10/10/09
+ *
+ * Modifications:
+ *
+ *		JRM -- 9/16/10
+ *		Added the express_test parameter.  Use it to control 
+ *		whether we set an alignment, and whether we allocate
+ *		chunks such that no two processes will normally touch
+ *		the same chunk.
+ *
+ *-------------------------------------------------------------------------
+ */
 
-    ret = H5Sclose(file_small_ds_sid_0);
-    VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_0) succeeded");
+#define CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG 0
 
-    ret = H5Sclose(file_small_ds_sid_1);
-    VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_1) succeeded");
+static void
+ckrbrd_hs_dr_pio_test__run_test(const int test_num,
+                                const int edge_size,
+                                const int checker_edge_size,
+                                const int chunk_edge_size,
+                                const int small_rank,
+                                const int large_rank,
+                                const hbool_t use_collective_io,
+                                const hid_t dset_type,
+                                const int express_test,
+                                int * skips_ptr,
+                                int max_skips,
+                                int64_t * total_tests_ptr,
+                                int64_t * tests_run_ptr,
+                                int64_t * tests_skipped_ptr)
 
-    ret = H5Sclose(small_ds_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded");
+{
+#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG
+    const char *fcnName = "ckrbrd_hs_dr_pio_test__run_test()";
+#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+    int		mpi_rank; /* needed by VRFY */
+    struct hs_dr_pio_test_vars_t test_vars = 
+    {
+        /* int	       mpi_size                        = */ -1,
+        /* int         mpi_rank                        = */ -1,
+        /* MPI_Comm    mpi_comm                        = */ MPI_COMM_NULL,
+        /* MPI_Inf     mpi_info                        = */ MPI_INFO_NULL,
+        /* int         test_num                        = */ -1,
+        /* int         edge_size                       = */ -1,
+        /* int         checker_edge_size               = */ -1,
+        /* int         chunk_edge_size                 = */ -1,
+        /* int         small_rank                      = */ -1,
+        /* int         large_rank                      = */ -1,
+        /* hid_t       dset_type                       = */ -1,
+        /* uint32_t  * small_ds_buf_0                  = */ NULL,
+        /* uint32_t  * small_ds_buf_1                  = */ NULL,
+        /* uint32_t  * small_ds_buf_2                  = */ NULL,
+        /* uint32_t  * small_ds_slice_buf              = */ NULL,
+        /* uint32_t  * large_ds_buf_0                  = */ NULL,
+        /* uint32_t  * large_ds_buf_1                  = */ NULL, 
+        /* uint32_t  * large_ds_buf_2                  = */ NULL,
+        /* uint32_t  * large_ds_slice_buf              = */ NULL,
+        /* int         small_ds_offset                 = */ -1,
+        /* int         large_ds_offset                 = */ -1,
+        /* hid_t       fid                             = */ -1,  /* HDF5 file ID */
+        /* hid_t       xfer_plist                      = */ H5P_DEFAULT,
+        /* hid_t       full_mem_small_ds_sid           = */ -1,
+        /* hid_t       full_file_small_ds_sid          = */ -1,
+        /* hid_t       mem_small_ds_sid                = */ -1,
+        /* hid_t       file_small_ds_sid_0             = */ -1,
+        /* hid_t       file_small_ds_sid_1             = */ -1,
+        /* hid_t       small_ds_slice_sid              = */ -1,
+        /* hid_t       full_mem_large_ds_sid           = */ -1,
+        /* hid_t       full_file_large_ds_sid          = */ -1,
+        /* hid_t       mem_large_ds_sid                = */ -1,
+        /* hid_t       file_large_ds_sid_0             = */ -1,
+        /* hid_t       file_large_ds_sid_1             = */ -1,
+        /* hid_t       file_large_ds_process_slice_sid = */ -1,
+        /* hid_t       mem_large_ds_process_slice_sid  = */ -1,
+        /* hid_t       large_ds_slice_sid              = */ -1,
+        /* hid_t       small_dataset                   = */ -1,     /* Dataset ID */
+        /* hid_t       large_dataset                   = */ -1,     /* Dataset ID */
+        /* size_t      small_ds_size                   = */ 1,
+        /* size_t      small_ds_slice_size             = */ 1,
+        /* size_t      large_ds_size                   = */ 1,
+        /* size_t      large_ds_slice_size             = */ 1,
+        /* hsize_t     dims[PAR_SS_DR_MAX_RANK]        = */ {0,0,0,0,0},
+        /* hsize_t     chunk_dims[PAR_SS_DR_MAX_RANK]  = */ {0,0,0,0,0},
+        /* hsize_t     start[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t     stride[PAR_SS_DR_MAX_RANK]      = */ {0,0,0,0,0},
+        /* hsize_t     count[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t     block[PAR_SS_DR_MAX_RANK]       = */ {0,0,0,0,0},
+        /* hsize_t   * start_ptr                       = */ NULL,
+        /* hsize_t   * stride_ptr                      = */ NULL,
+        /* hsize_t   * count_ptr                       = */ NULL,
+        /* hsize_t   * block_ptr                       = */ NULL,
+        /* int 	       skips                           = */ 0,
+        /* int 	       max_skips                       = */ 0,
+        /* int64_t     total_tests                     = */ 0,
+        /* int64_t     tests_run                       = */ 0,
+        /* int64_t     tests_skipped                   = */ 0
+    };
+    struct hs_dr_pio_test_vars_t * tv_ptr = &test_vars;
 
-    ret = H5Sclose(full_mem_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded");
+    hs_dr_pio_test__setup(test_num, edge_size, checker_edge_size, 
+                          chunk_edge_size, small_rank, large_rank, 
+                          use_collective_io, dset_type, express_test, 
+                          tv_ptr);
 
-    ret = H5Sclose(full_file_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(full_file_large_ds_sid) succeeded");
 
-    ret = H5Sclose(mem_large_ds_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
+    /* initialize the local copy of mpi_rank */
+    mpi_rank = tv_ptr->mpi_rank;
 
-    ret = H5Sclose(file_large_ds_sid_0);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
 
-    ret = H5Sclose(file_large_ds_sid_1);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
+    /* initialize skips & max_skips */
+    tv_ptr->skips = *skips_ptr;
+    tv_ptr->max_skips = max_skips;
 
-    ret = H5Sclose(mem_large_ds_process_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(mem_large_ds_process_slice_sid) succeeded");
 
-    ret = H5Sclose(file_large_ds_process_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(file_large_ds_process_slice_sid) succeeded");
+#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: small rank = %d, large rank = %d.\n",
+                  test_num, small_rank, large_rank);
+        HDfprintf(stdout, "test %d: Initialization complete.\n", test_num);
+    }
+#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
 
-    ret = H5Sclose(large_ds_slice_sid);
-    VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded");
 
+    /* first, verify that we can read from disk correctly using selections
+     * of different rank that H5S_select_shape_same() views as being of the
+     * same shape.
+     *
+     * Start by reading a (small_rank - 1)-D slice from this processes slice 
+     * of the on disk large data set, and verifying that the data read is 
+     * correct.  Verify that H5S_select_shape_same() returns true on the 
+     * memory and file selections.
+     *
+     * The first step is to set up the needed checker board selection in the
+     * in memory small small cube
+     */
 
-    /* Close Datasets */
-    ret = H5Dclose(small_dataset);
-    VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
+    ckrbrd_hs_dr_pio_test__d2m_l2s(tv_ptr);
 
-    ret = H5Dclose(large_dataset);
-    VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded");
 
+    /* similarly, read slices of the on disk small data set into slices 
+     * through the in memory large data set, and verify that the correct 
+     * data (and only the correct data) is read.
+     */
 
-    /* close the file collectively */
-    MESG("about to close file.");
-    ret = H5Fclose(fid);
-    VRFY((ret != FAIL), "file close succeeded");
+    ckrbrd_hs_dr_pio_test__d2m_s2l(tv_ptr);
 
-    /* Free memory buffers */
-    if ( small_ds_buf_0 != NULL ) HDfree(small_ds_buf_0);
-    if ( small_ds_buf_1 != NULL ) HDfree(small_ds_buf_1);
-    if ( small_ds_buf_2 != NULL ) HDfree(small_ds_buf_2);
-    if ( small_ds_slice_buf != NULL ) HDfree(small_ds_slice_buf);
 
-    if ( large_ds_buf_0 != NULL ) HDfree(large_ds_buf_0);
-    if ( large_ds_buf_1 != NULL ) HDfree(large_ds_buf_1);
-    if ( large_ds_buf_2 != NULL ) HDfree(large_ds_buf_2);
-    if ( large_ds_slice_buf != NULL ) HDfree(large_ds_slice_buf);
+    /* now we go in the opposite direction, verifying that we can write
+     * from memory to file using selections of different rank that
+     * H5S_select_shape_same() views as being of the same shape.
+     *
+     * Start by writing small_rank - 1 D slices from the in memory large data
+     * set to the on disk small dataset.  After each write, read the slice of 
+     * the small dataset back from disk, and verify that it contains the 
+     * expected data. Verify that H5S_select_shape_same() returns true on 
+     * the memory and file selections.
+     */
+
+    ckrbrd_hs_dr_pio_test__m2d_l2s(tv_ptr);
+
+
+    /* Now write the contents of the process's slice of the in memory 
+     * small data set to slices of the on disk large data set.  After 
+     * each write, read the process's slice of the large data set back
+     * into memory, and verify that it contains the expected data. 
+     * Verify that H5S_select_shape_same() returns true on the memory 
+     * and file selections.
+     */
+
+    ckrbrd_hs_dr_pio_test__m2d_s2l(tv_ptr);
+
+
+#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, 
+            "test %d: Subtests complete -- tests run/skipped/total = %lld/%lld/%lld.\n", 
+             test_num, (long long)(tv_ptr->tests_run), (long long)(tv_ptr->tests_skipped),
+             (long long)(tv_ptr->total_tests));
+    }
+#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+
+    hs_dr_pio_test__takedown(tv_ptr);
+
+#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG
+    if ( MAINPROCESS ) {
+        HDfprintf(stdout, "test %d: Takedown complete.\n", test_num);
+    }
+#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
+
+    *skips_ptr = tv_ptr->skips;
+    *total_tests_ptr += tv_ptr->total_tests;
+    *tests_run_ptr += tv_ptr->tests_run;
+    *tests_skipped_ptr += tv_ptr->tests_skipped;
 
     return;
 
-} /* checker_board_hyperslab_dr_pio_test__run_test() */
+} /* ckrbrd_hs_dr_pio_test__run_test() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	checker_board_hyperslab_dr_pio_test()
+ * Function:	ckrbrd_hs_dr_pio_test()
  *
  * Purpose:	Test I/O to/from hyperslab selections of different rank in
  *		the parallel case.
@@ -4193,44 +4512,35 @@ int		m, n;
  *-------------------------------------------------------------------------
  */
 
-void
-checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
+static void
+ckrbrd_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
 {
+    int         express_test;
+    int         local_express_test;
+    int	        mpi_size = -1;
+    int         mpi_rank = -1;
     int	        test_num = 0;
     int		edge_size = 10;
     int         checker_edge_size = 3;
     int		chunk_edge_size = 0;
     int	        small_rank = 3;
     int	        large_rank = 4;
-    int         skips[4] = {0, 0, 0, 0};
-    int         skip_counters[4] = {0, 0, 0, 0};
-    int         tests_skiped[4] = {0, 0, 0, 0};
     int		mpi_result;
     hid_t	dset_type = H5T_NATIVE_UINT;
-#ifdef H5_HAVE_GETTIMEOFDAY
-    hbool_t     time_tests = TRUE;
-    hbool_t	display_skips = FALSE;
-    int         local_express_test;
-    int         express_test;
-    int         i;
-    int         samples = 0;
-    int         sample_size = 1;
-    int         mpi_size = -1;
-    int         mpi_rank = -1;
-    int         local_skips[4];
-    const int   ind_contig_idx = 0;
-    const int   col_contig_idx = 1;
-    const int   ind_chunked_idx = 2;
-    const int   col_chunked_idx = 3;
-    const int   test_types = 4;
-    long long   max_test_time = 3000000; /* for one test */
-    long long   sample_times[4] = {0, 0, 0, 0};
-    struct timeval timeval_a;
-    struct timeval timeval_b;
+    int         skips = 0;
+    int         max_skips = 0;
+    /* The following table list the number of sub-tests skipped between
+     * each test that is actually executed as a function of the express
+     * test level.  Note that any value in excess of 4880 will cause all
+     * sub tests to be skipped.
+     */
+    int         max_skips_tbl[4] = {0, 4, 64, 1024};
+    int64_t     total_tests = 0;
+    int64_t     tests_run = 0;
+    int64_t     tests_skipped = 0;
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
-#endif /* H5_HAVE_GETTIMEOFDAY */
 
     local_express_test = GetTestExpress();
 
@@ -4245,6 +4555,14 @@ checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
 
     VRFY((mpi_result == MPI_SUCCESS ), "MPI_Allreduce(0) succeeded");
 
+    if ( local_express_test < 0 ) {
+        max_skips = max_skips_tbl[0];
+    } else if ( local_express_test > 3 ) {
+        max_skips = max_skips_tbl[3];
+    } else {
+        max_skips = max_skips_tbl[local_express_test];
+    }
+
 #if 0 
     {
         int DebugWait = 1;
@@ -4256,201 +4574,113 @@ checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
     for ( large_rank = 3; large_rank <= PAR_SS_DR_MAX_RANK; large_rank++ ) {
 
         for ( small_rank = 2; small_rank < large_rank; small_rank++ ) {
-	  switch(sstest_type){
-	  case IND_CONTIG:
-            /* contiguous data set, independent I/O */
-            chunk_edge_size = 0;
-            if ( skip_counters[ind_contig_idx] < skips[ind_contig_idx] ) {
-
-                skip_counters[ind_contig_idx]++;
-                tests_skiped[ind_contig_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[ind_contig_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(0) succeeds.");
-
-                checker_board_hyperslab_dr_pio_test__run_test(test_num,
-                                                  edge_size,
-                                                  checker_edge_size,
-                                                  chunk_edge_size,
-                                                  small_rank,
-                                                  large_rank,
-                                                  FALSE,
-                                                  dset_type,
-                                                  express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(1) succeeds.", \
-                                      sample_times[ind_contig_idx]);
-
+            switch(sstest_type){
+                case IND_CONTIG:
+                    /* contiguous data set, independent I/O */
+                    chunk_edge_size = 0;
+                    ckrbrd_hs_dr_pio_test__run_test(test_num,
+                                                    edge_size,
+                                                    checker_edge_size,
+                                                    chunk_edge_size,
+                                                    small_rank,
+                                                    large_rank,
+                                                    FALSE,
+                                                    dset_type,
+                                                    express_test,
+                                                    &skips,
+                                                    max_skips,
+                                                    &total_tests,
+                                                    &tests_run,
+                                                    &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case IND_CONTIG */
+
+                 case COL_CONTIG:
+                    /* contiguous data set, collective I/O */
+                    chunk_edge_size = 0;
+                    ckrbrd_hs_dr_pio_test__run_test(test_num,
+                                                    edge_size,
+                                                    checker_edge_size,
+                                                    chunk_edge_size,
+                                                    small_rank,
+                                                    large_rank,
+                                                    TRUE,
+                                                    dset_type,
+                                                    express_test,
+                                                    &skips,
+                                                    max_skips,
+                                                    &total_tests,
+                                                    &tests_run,
+                                                    &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case COL_CONTIG */
+
+                case IND_CHUNKED:
+                    /* chunked data set, independent I/O */
+                    chunk_edge_size = 5;
+                    ckrbrd_hs_dr_pio_test__run_test(test_num,
+                                                    edge_size,
+                                                    checker_edge_size,
+                                                    chunk_edge_size,
+                                                    small_rank,
+                                                    large_rank,
+                                                    FALSE,
+                                                    dset_type,
+                                                    express_test,
+                                                    &skips,
+                                                    max_skips,
+                                                    &total_tests,
+                                                    &tests_run,
+                                                    &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case IND_CHUNKED */
+
+                case COL_CHUNKED:
+                    /* chunked data set, collective I/O */
+                    chunk_edge_size = 5;
+                    ckrbrd_hs_dr_pio_test__run_test(test_num,
+                                                    edge_size,
+                                                    checker_edge_size,
+                                                    chunk_edge_size,
+                                                    small_rank,
+                                                    large_rank,
+                                                    TRUE,
+                                                    dset_type,
+                                                    express_test,
+                                                    &skips,
+                                                    max_skips,
+                                                    &total_tests,
+                                                    &tests_run,
+                                                    &tests_skipped);
+                    test_num++;
+                    break;
+                    /* end of case COL_CHUNKED */
+
+                default:
+                    VRFY((FALSE), "unknown test type");
+                    break;
+
+            } /* end of switch(sstest_type) */
+#if CONTIG_HS_DR_PIO_TEST__DEBUG
+            if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) {
+                HDfprintf(stdout, "     run/skipped/total = %lld/%lld/%lld.\n",
+                          tests_run, tests_skipped, total_tests);
             }
-            test_num++;
-	    break;
-	    /* end of case IND_CONTIG */
-
-	  case COL_CONTIG:
-            /* contiguous data set, collective I/O */
-            chunk_edge_size = 0;
-            if ( skip_counters[col_contig_idx] < skips[col_contig_idx] ) {
-
-                skip_counters[col_contig_idx]++;
-                tests_skiped[col_contig_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[col_contig_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(2) succeeds.");
-
-                checker_board_hyperslab_dr_pio_test__run_test(test_num,
-                                                  edge_size,
-                                                  checker_edge_size,
-                                                  chunk_edge_size,
-                                                  small_rank,
-                                                  large_rank,
-                                                  TRUE,
-                                                  dset_type,
-                                                  express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(3) succeeds.", \
-                                      sample_times[col_contig_idx]);
-
-            }
-            test_num++;
-	    break;
-	    /* end of case COL_CONTIG */
-
-	  case IND_CHUNKED:
-            /* chunked data set, independent I/O */
-            chunk_edge_size = 5;
-            if ( skip_counters[ind_chunked_idx] < skips[ind_chunked_idx] ) {
-
-                skip_counters[ind_chunked_idx]++;
-                tests_skiped[ind_chunked_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[ind_chunked_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(4) succeeds.");
-
-                checker_board_hyperslab_dr_pio_test__run_test(test_num,
-                                                  edge_size,
-                                                  checker_edge_size,
-                                                  chunk_edge_size,
-                                                  small_rank,
-                                                  large_rank,
-                                                  FALSE,
-                                                  dset_type,
-                                                  express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(5) succeeds.", \
-                                      sample_times[ind_chunked_idx]);
-
-            }
-            test_num++;
-	    break;
-	    /* end of case IND_CHUNKED */
-
-	  case COL_CHUNKED:
-            /* chunked data set, collective I/O */
-            chunk_edge_size = 5;
-            if ( skip_counters[col_chunked_idx] < skips[col_chunked_idx] ) {
-
-                skip_counters[col_chunked_idx]++;
-                tests_skiped[col_chunked_idx]++;
-		printf("Test skipped\n");
-            } else {
-                skip_counters[col_chunked_idx] = 0;
-                START_TIMER(time_tests, timeval_a, "HDgettimeofday(6) succeeds.");
-
-                checker_board_hyperslab_dr_pio_test__run_test(test_num,
-                                                  edge_size,
-                                                  checker_edge_size,
-                                                  chunk_edge_size,
-                                                  small_rank,
-                                                  large_rank,
-                                                  TRUE,
-                                                  dset_type,
-                                                  express_test);
-                STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
-                                      "HDgettimeofday(7) succeeds.", \
-                                      sample_times[col_chunked_idx]);
-
-            }
-            test_num++;
-	    break;
-	    /* end of case COL_CHUNKED */
-	  } /* end of switch(sstest_type) */
-
-#ifdef H5_HAVE_GETTIMEOFDAY
-            if ( time_tests ) {
-
-                samples++;
-
-                if ( samples >= sample_size ) {
-
-                    int result;
-
-                    time_tests = FALSE;
-
-                    max_test_time = ((long long)sample_size) * max_test_time;
-
-                    for ( i = 0; i < test_types; i++ ) {
-
-                        if ( ( express_test == 0 ) ||
-                             ( sample_times[i] <= max_test_time ) ) {
-
-                            local_skips[i] = 0;
-
-                        } else {
-
-                            local_skips[i] = (int)(sample_times[i] / max_test_time);
-                        }
-                    }
-
-                    /* do an MPI_Allreduce() with the skips vector to ensure that
-                     * all processes agree on its contents.
-                     */
-                    result = MPI_Allreduce((void *)local_skips,
-                                           (void *)skips,
-                                           test_types,
-                                           MPI_INT,
-                                           MPI_MAX,
-                                           MPI_COMM_WORLD);
-                    VRFY((result == MPI_SUCCESS ), "MPI_Allreduce() succeeded");
-                }
-            }
-#endif /* H5_HAVE_GETTIMEOFDAY */
-
+#endif /* CONTIG_HS_DR_PIO_TEST__DEBUG */
         }
     }
 
-#ifdef H5_HAVE_GETTIMEOFDAY
-    if ( ( MAINPROCESS ) && ( display_skips ) ) {
-
-        HDfprintf(stdout, "***********************************\n");
-        HDfprintf(stdout, "express test = %d.\n", express_test);
-        HDfprintf(stdout, "sample_size = %d, max_test_time = %lld.\n",
-                  sample_size, max_test_time);
-        HDfprintf(stdout, "sample_times[]  = %lld, %lld, %lld, %lld.\n",
-                  sample_times[ind_contig_idx],
-                  sample_times[col_contig_idx],
-                  sample_times[ind_chunked_idx],
-                  sample_times[col_chunked_idx]);
-        HDfprintf(stdout, "skips[]  = %d, %d, %d, %d.\n",
-                  skips[ind_contig_idx],
-                  skips[col_contig_idx],
-                  skips[ind_chunked_idx],
-                  skips[col_chunked_idx]);
-        HDfprintf(stdout, "tests_skiped[]  = %d, %d, %d, %d.\n",
-                  tests_skiped[ind_contig_idx],
-                  tests_skiped[col_contig_idx],
-                  tests_skiped[ind_chunked_idx],
-                  tests_skiped[col_chunked_idx]);
-        HDfprintf(stdout, "test_num          = %d.\n", test_num);
-        HDfprintf(stdout, "***********************************\n");
+    if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) {
+        HDfprintf(stdout, "     %lld of %lld subtests skipped to expedite testing.\n",
+                  tests_skipped, total_tests);
     }
-#endif /* H5_HAVE_GETTIMEOFDAY */
 
     return;
 
-} /* checker_board_hyperslab_dr_pio_test() */
+} /* ckrbrd_hs_dr_pio_test() */
 
 /* Main Body. Here for now, may have to move them to a separated file later. */
 
@@ -4522,7 +4752,7 @@ void pause_proc(void)
     MPI_Get_processor_name(mpi_name, &mpi_namelen);
 
     if (MAINPROCESS)
-	while ((stat(greenlight, &statbuf) == -1) && loops < maxloop){
+	while ((HDstat(greenlight, &statbuf) == -1) && loops < maxloop){
 	    if (!loops++){
 		printf("Proc %d (%*s, %d): to debug, attach %d\n",
 		    mpi_rank, mpi_namelen, mpi_name, pid, pid);
@@ -4756,28 +4986,28 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type,
 static void
 sscontig1(void)
 {
-    contig_hyperslab_dr_pio_test(IND_CONTIG);
+    contig_hs_dr_pio_test(IND_CONTIG);
 }
 
 /* Shape Same test using contigous hyperslab using collective IO on contigous datasets */
 static void
 sscontig2(void)
 {
-    contig_hyperslab_dr_pio_test(COL_CONTIG);
+    contig_hs_dr_pio_test(COL_CONTIG);
 }
 
 /* Shape Same test using contigous hyperslab using independent IO on chunked datasets */
 static void
 sscontig3(void)
 {
-    contig_hyperslab_dr_pio_test(IND_CHUNKED);
+    contig_hs_dr_pio_test(IND_CHUNKED);
 }
 
 /* Shape Same test using contigous hyperslab using collective IO on chunked datasets */
 static void
 sscontig4(void)
 {
-    contig_hyperslab_dr_pio_test(COL_CHUNKED);
+    contig_hs_dr_pio_test(COL_CHUNKED);
 }
 
 
@@ -4785,38 +5015,34 @@ sscontig4(void)
 static void
 sschecker1(void)
 {
-    checker_board_hyperslab_dr_pio_test(IND_CONTIG);
+    ckrbrd_hs_dr_pio_test(IND_CONTIG);
 }
 
 /* Shape Same test using checker hyperslab using collective IO on contigous datasets */
 static void
 sschecker2(void)
 {
-    checker_board_hyperslab_dr_pio_test(COL_CONTIG);
+    ckrbrd_hs_dr_pio_test(COL_CONTIG);
 }
 
 /* Shape Same test using checker hyperslab using independent IO on chunked datasets */
 static void
 sschecker3(void)
 {
-    checker_board_hyperslab_dr_pio_test(IND_CHUNKED);
+    ckrbrd_hs_dr_pio_test(IND_CHUNKED);
 }
 
 /* Shape Same test using checker hyperslab using collective IO on chunked datasets */
 static void
 sschecker4(void)
 {
-    checker_board_hyperslab_dr_pio_test(COL_CHUNKED);
+    ckrbrd_hs_dr_pio_test(COL_CHUNKED);
 }
 
 
 int main(int argc, char **argv)
 {
     int mpi_size, mpi_rank;				/* mpi variables */
-    H5Ptest_param_t ndsets_params, ngroups_params;
-    H5Ptest_param_t collngroups_params;
-    H5Ptest_param_t io_mode_confusion_params;
-    H5Ptest_param_t rr_obj_flush_confusion_params;
 
     /* Un-buffer the stdout and stderr */
     setbuf(stderr, NULL);
@@ -4832,6 +5058,7 @@ int main(int argc, char **argv)
     if (MAINPROCESS){
 	printf("===================================\n");
 	printf("Shape Same Tests Start\n");
+        printf("	express_test = %d.\n", GetTestExpress());
 	printf("===================================\n");
     }
 
@@ -4841,7 +5068,7 @@ int main(int argc, char **argv)
      * calls.  By then, MPI calls may not work.
      */
     if (H5dont_atexit() < 0){
-	printf("Failed to turn off atexit processing. Continue.\n", mpi_rank);
+	printf("%d: Failed to turn off atexit processing. Continue.\n", mpi_rank);
     };
     H5open();
     h5_show_hostname();
@@ -4850,6 +5077,7 @@ int main(int argc, char **argv)
     TestInit(argv[0], usage, parse_options);
 
     /* Shape Same tests using contigous hyperslab */
+#if 1
     AddTest("sscontig1", sscontig1, NULL,
 	"Shape Same, contigous hyperslab, ind IO, contig datasets", PARATESTFILE);
     AddTest("sscontig2", sscontig2, NULL,
@@ -4858,6 +5086,7 @@ int main(int argc, char **argv)
 	"Shape Same, contigous hyperslab, ind IO, chunked datasets", PARATESTFILE);
     AddTest("sscontig4", sscontig4, NULL,
 	"Shape Same, contigous hyperslab, col IO, chunked datasets", PARATESTFILE);
+#endif
 
     /* Shape Same tests using checker board hyperslab */
     AddTest("sschecker1", sschecker1, NULL,
@@ -4919,9 +5148,9 @@ int main(int argc, char **argv)
     if (MAINPROCESS){		/* only process 0 reports */
 	printf("===================================\n");
 	if (nerrors)
-	    printf("***PHDF5 tests detected %d errors***\n", nerrors);
+	    printf("***Shape Same tests detected %d errors***\n", nerrors);
 	else
-	    printf("PHDF5 tests finished with no errors\n");
+	    printf("Shape Same tests finished with no errors\n");
 	printf("===================================\n");
     }
     /* close HDF5 library */
diff --git a/testpar/testphdf5.c b/testpar/testphdf5.c
index 8b24f87..e3c72ef 100644
--- a/testpar/testphdf5.c
+++ b/testpar/testphdf5.c
@@ -81,7 +81,7 @@ void pause_proc(void)
     MPI_Get_processor_name(mpi_name, &mpi_namelen);
 
     if (MAINPROCESS)
-	while ((stat(greenlight, &statbuf) == -1) && loops < maxloop){
+  while ((HDstat(greenlight, &statbuf) == -1) && loops < maxloop){
 	    if (!loops++){
 		printf("Proc %d (%*s, %d): to debug, attach %d\n",
 		    mpi_rank, mpi_namelen, mpi_name, pid, pid);
@@ -498,6 +498,9 @@ int main(int argc, char **argv)
             "test mpi derived type management", 
             PARATESTFILE);
 
+    AddTest("actualio", actual_io_mode_tests, NULL,
+            "test actual io mode proprerty",
+            PARATESTFILE);
 
     /* Display testing information */
     TestInfo(argv[0]);
diff --git a/testpar/testphdf5.h b/testpar/testphdf5.h
index 2b83047..11656f9 100644
--- a/testpar/testphdf5.h
+++ b/testpar/testphdf5.h
@@ -160,6 +160,19 @@ enum H5TEST_COLL_CHUNK_API {API_NONE=0,API_LINK_HARD,
 #define NPOINTS          4          /* Number of points that will be selected
                                                                 and overwritten */
 
+/* Definitions of the selection mode for the test_actual_io_function. */
+#define TEST_ACTUAL_IO_NO_COLLECTIVE                    0
+#define TEST_ACTUAL_IO_RESET                            1
+#define TEST_ACTUAL_IO_MULTI_CHUNK_IND                  2
+#define TEST_ACTUAL_IO_MULTI_CHUNK_COL                  3
+#define TEST_ACTUAL_IO_MULTI_CHUNK_MIX                  4
+#define TEST_ACTUAL_IO_MULTI_CHUNK_MIX_DISAGREE         5
+#define TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_IND           6
+#define TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_COL           7
+#define TEST_ACTUAL_IO_MULTI_CHUNK_NO_OPT_MIX_DISAGREE  8 
+#define TEST_ACTUAL_IO_LINK_CHUNK                       9
+#define TEST_ACTUAL_IO_CONTIGUOUS                       10
+
 /* Don't erase these lines, they are put here for debugging purposes */
 /*
 #define MSPACE1_RANK     1
@@ -173,9 +186,9 @@ enum H5TEST_COLL_CHUNK_API {API_NONE=0,API_LINK_HARD,
 #define MSPACE_DIM1      8
 #define MSPACE_DIM2      9
 #define NPOINTS          4
+*/ /* end of debugging macro */
 
 
-*/ /* end of debugging macro */
 /* type definitions */
 typedef struct H5Ptest_param_t  /* holds extra test parameters */
 {
@@ -222,6 +235,7 @@ void dataset_readAll(void);
 void extend_readInd(void);
 void extend_readAll(void);
 void none_selection_chunk(void);
+void actual_io_mode_tests(void);
 void test_chunk_alloc(void);
 void test_filter_read(void);
 void compact_dataset(void);