Add H5Sselect_shape_same and H5Sselect_intersect_block API routines, along

with tests and minor cleanups and refactorings.

2 files changed, 77 insertions, 201 deletions

diff --git a/testpar/t_shapesame.c b/testpar/t_shapesame.c
index f5282bd..b65e219 100644
--- a/testpar/t_shapesame.c
+++ b/testpar/t_shapesame.c
@@ -110,10 +110,6 @@ struct hs_dr_pio_test_vars_t
  *
  * Programmer:    JRM -- 8/9/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -573,7 +569,7 @@ hs_dr_pio_test__setup(const int test_num,
                               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 */
+    /* In passing, setup the process slice dataspaces as well */
 
     ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_process_slice_sid,
                               H5S_SELECT_SET,
@@ -685,10 +681,6 @@ hs_dr_pio_test__setup(const int test_num,
  *
  * Programmer:    JRM -- 9/18/09
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -791,22 +783,18 @@ hs_dr_pio_test__takedown( struct hs_dr_pio_test_vars_t * tv_ptr)
  *        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()
+ *        selections of different rank that H5Sselect_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()
+ *        data read is correct.  Verify that H5Sselect_shape_same()
  *        returns true on the memory and file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 9/10/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -831,7 +819,7 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
     mpi_rank = tv_ptr->mpi_rank;
 
 
-    /* We have already done a H5Sselect_all() on the data space
+    /* We have already done a H5Sselect_all() on the dataspace
      * small_ds_slice_sid in the initialization phase, so no need to
      * call H5Sselect_all() again.
      */
@@ -945,12 +933,11 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
                          "H5Sselect_hyperslab(file_large_cube_sid) succeeded");
 
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(tv_ptr->small_ds_slice_sid, tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* Read selection from disk */
@@ -1032,7 +1019,7 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        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()
+ *        selections of different rank that H5Sselect_shape_same()
  *        views as being of the same shape.
  *
  *        In this function, we test this by reading slices of the
@@ -1044,10 +1031,6 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  * Programmer:    JRM -- 8/10/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -1213,12 +1196,11 @@ contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
                          "H5Sselect_hyperslab(mem_large_ds_sid) succeeded");
 
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_0, tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* Read selection from disk */
@@ -1315,24 +1297,20 @@ contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        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()
+ *        selections of different rank that H5Sselect_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()
+ *        the expected data. Verify that H5Sselect_shape_same()
  *        returns true on the memory and file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 8/10/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -1361,12 +1339,12 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
 
     /* 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.
+     * H5Sselect_shape_same() views as being of the same shape.
      *
      * 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 expected data. Verify that H5Sselect_shape_same() returns true on
      * the memory and file selections.
      */
 
@@ -1527,13 +1505,12 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
                          "H5Sselect_hyperslab() mem_large_ds_sid succeeded.");
 
 
-                    /* verify that H5S_select_shape_same() reports the in
+                    /* verify that H5Sselect_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.");
+                    check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_0, tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed.");
 
 
                     /* write the slice from the in memory large data set to the
@@ -1643,7 +1620,7 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        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()
+ *        selections of different rank that H5Sselect_shape_same()
  *        views as being of the same shape.
  *
  *        Do this by writing the contents of the process's slice of
@@ -1652,17 +1629,13 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        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
+ *        Verify that H5Sselect_shape_same() returns true on the
  *        memory and file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 8/10/11
  *
- * Modifications:
- *
- *        None
- *
  *-------------------------------------------------------------------------
  */
 
@@ -1692,7 +1665,7 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
      * 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
+     * Verify that H5Sselect_shape_same() returns true on the memory
      * and file selections.
      */
 
@@ -1859,14 +1832,13 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
                          "H5Sselect_hyperslab() target large ds slice succeeded");
 
 
-                    /* verify that H5S_select_shape_same() reports the in
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(tv_ptr->mem_small_ds_sid, tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* write the small data set slice from memory to the
@@ -1986,21 +1958,6 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  * 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.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2108,12 +2065,12 @@ contig_hs_dr_pio_test__run_test(const int test_num,
 #endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */
 
     /* first, verify that we can read from disk correctly using selections
-     * of different rank that H5S_select_shape_same() views as being of the
+     * of different rank that H5Sselect_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.
+     * H5Sselect_shape_same() returns true on the memory and file selections.
      */
 
 #if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG
@@ -2139,12 +2096,12 @@ contig_hs_dr_pio_test__run_test(const int test_num,
 
     /* 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.
+     * H5Sselect_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 expected data. Verify that H5Sselect_shape_same() returns true on
      * the memory and file selections.
      */
 
@@ -2160,7 +2117,7 @@ contig_hs_dr_pio_test__run_test(const int test_num,
      * 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
+     * Verify that H5Sselect_shape_same() returns true on the memory
      * and file selections.
      */
 
@@ -2208,20 +2165,6 @@ contig_hs_dr_pio_test__run_test(const int test_num,
  *
  * Programmer:    JRM -- 9/18/09
  *
- * Modifications:
- *
- *          Modified function to take a sample of the run times
- *        of the different tests, and skip some of them if
- *        run times are too long.
- *
- *        We need to do this because Lustre runns very slowly
- *        if two or more processes are banging on the same
- *        block of memory.
- *                        JRM -- 9/10/10
- *              Break this one big test into 4 smaller tests according
- *              to {independent,collective}x{contigous,chunked} datasets.
- *        AKC -- 2010/01/14
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2395,18 +2338,18 @@ contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
 /****************************************************************
 **
 **  ckrbrd_hs_dr_pio_test__slct_ckrbrd():
-**    Given a data space of tgt_rank, and dimensions:
+**    Given a dataspace of tgt_rank, and dimensions:
 **
 **        (mpi_size + 1), edge_size, ... , edge_size
 **
 **    edge_size, and a checker_edge_size, select a checker
 **    board selection of a sel_rank (sel_rank < tgt_rank)
-**    dimensional slice through the data space parallel to the
+**    dimensional slice through the dataspace parallel to the
 **      sel_rank fastest changing indicies, with origin (in the
 **    higher indicies) as indicated by the start array.
 **
 **    Note that this function, like all its relatives, is
-**    hard coded to presume a maximum data space rank of 5.
+**    hard coded to presume a maximum dataspace rank of 5.
 **    While this maximum is declared as a constant, increasing
 **    it will require extensive coding in addition to changing
 **      the value of the constant.
@@ -2707,7 +2650,7 @@ ckrbrd_hs_dr_pio_test__slct_ckrbrd(const int mpi_rank,
               fcnName, mpi_rank, (int)H5Sget_select_npoints(tgt_sid));
 #endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
-    /* Clip the selection back to the data space proper. */
+    /* Clip the selection back to the dataspace proper. */
 
     for ( i = 0; i < test_max_rank; i++ ) {
 
@@ -2956,22 +2899,18 @@ ckrbrd_hs_dr_pio_test__verify_data(uint32_t * buf_ptr,
  *
  *        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.
+ *        H5Sselect_shape_same() views as being of the same shape.
  *
- *              In this function, we test this by reading small_rank - 1
+ *        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
+ *        H5Sselect_shape_same() returns true on the memory and
  *        file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 9/15/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2997,12 +2936,12 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
 
 
     /* first, verify that we can read from disk correctly using selections
-     * of different rank that H5S_select_shape_same() views as being of the
+     * of different rank that H5Sselect_shape_same() views as being of the
      * same shape.
      *
      * 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
+     * data read is correct.  Verify that H5Sselect_shape_same() returns
      * true on the memory and file selections.
      *
      * The first step is to set up the needed checker board selection in the
@@ -3146,12 +3085,11 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
                       tv_ptr->start
                     );
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(tv_ptr->small_ds_slice_sid, tv_ptr->file_large_ds_sid_0);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* Read selection from disk */
@@ -3231,7 +3169,7 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        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()
+ *        selections of different rank that H5Sselect_shape_same()
  *        views as being of the same shape.
  *
  *        In this function, we test this by reading checker board
@@ -3243,10 +3181,6 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  * Programmer:    JRM -- 8/15/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -3412,12 +3346,11 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
                     );
 
 
-                    /* verify that H5S_select_shape_same() reports the two
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_0, tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* Read selection from disk */
@@ -3561,24 +3494,20 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  *        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.
+ *        H5Sselect_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
+ *        H5Sselect_shape_same() returns true on the memory and
  *        file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 8/15/11
  *
- * Modifications:
- *
- *        None.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -3609,12 +3538,12 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
 
     /* 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.
+     * H5Sselect_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
+     * expected data. Verify that H5Sselect_shape_same() returns true on
      * the memory and file selections.
      */
 
@@ -3795,14 +3724,13 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
                     );
 
 
-                    /* verify that H5S_select_shape_same() reports the in
+                    /* verify that H5Sselect_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.");
+                    check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_1, tv_ptr->mem_large_ds_sid);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed.");
 
 
                     /* write the checker board selection of the slice from the in
@@ -3922,7 +3850,7 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        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()
+ *        selections of different rank that H5Sselect_shape_same()
  *        views as being of the same shape.
  *
  *        Do this by writing checker board selections of the contents
@@ -3931,17 +3859,13 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr)
  *        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
+ *        Verify that H5Sselect_shape_same() returns true on the
  *        memory and file selections.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 8/15/11
  *
- * Modifications:
- *
- *        None
- *
  *-------------------------------------------------------------------------
  */
 
@@ -3974,7 +3898,7 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
      * 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
+     * Verify that H5Sselect_shape_same() returns true on the memory
      * and file selections.
      */
 
@@ -4150,14 +4074,13 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
                     );
 
 
-                    /* verify that H5S_select_shape_same() reports the in
+                    /* verify that H5Sselect_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");
+                    check = H5Sselect_shape_same(tv_ptr->mem_small_ds_sid, tv_ptr->file_large_ds_sid_1);
+                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
 
 
                     /* write the small data set slice from memory to the
@@ -4287,14 +4210,6 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr)
  *
  * 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.
- *
  *-------------------------------------------------------------------------
  */
 
@@ -4409,12 +4324,12 @@ ckrbrd_hs_dr_pio_test__run_test(const int test_num,
 
 
     /* first, verify that we can read from disk correctly using selections
-     * of different rank that H5S_select_shape_same() views as being of the
+     * of different rank that H5Sselect_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
+     * correct.  Verify that H5Sselect_shape_same() returns true on the
      * memory and file selections.
      *
      * The first step is to set up the needed checker board selection in the
@@ -4434,12 +4349,12 @@ ckrbrd_hs_dr_pio_test__run_test(const int test_num,
 
     /* 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.
+     * H5Sselect_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
+     * expected data. Verify that H5Sselect_shape_same() returns true on
      * the memory and file selections.
      */
 
@@ -4450,7 +4365,7 @@ ckrbrd_hs_dr_pio_test__run_test(const int test_num,
      * 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
+     * Verify that H5Sselect_shape_same() returns true on the memory
      * and file selections.
      */
 
@@ -4494,20 +4409,6 @@ ckrbrd_hs_dr_pio_test__run_test(const int test_num,
  *
  * Programmer:    JRM -- 9/18/09
  *
- * Modifications:
- *
- *          Modified function to take a sample of the run times
- *        of the different tests, and skip some of them if
- *        run times are too long.
- *
- *        We need to do this because Lustre runns very slowly
- *        if two or more processes are banging on the same
- *        block of memory.
- *                        JRM -- 9/10/10
- *          Break this one big test into 4 smaller tests according
- *          to {independent,collective}x{contigous,chunked} datasets.
- *        AKC -- 2010/01/17
- *
  *-------------------------------------------------------------------------
  */
 
diff --git a/testpar/t_span_tree.c b/testpar/t_span_tree.c
index cc79af2..352a089 100644
--- a/testpar/t_span_tree.c
+++ b/testpar/t_span_tree.c
@@ -60,8 +60,6 @@ static void coll_read_test(int chunk_factor);
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -87,8 +85,6 @@ coll_irregular_cont_write(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -113,8 +109,6 @@ coll_irregular_cont_read(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -140,8 +134,6 @@ coll_irregular_simple_chunk_write(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -165,8 +157,6 @@ coll_irregular_simple_chunk_read(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -192,8 +182,6 @@ coll_irregular_complex_chunk_write(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void
@@ -219,8 +207,6 @@ coll_irregular_complex_chunk_read(void)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications: Oct 18th, 2005
- *
  *-------------------------------------------------------------------------
  */
 void coll_write_test(int chunk_factor)
@@ -694,9 +680,6 @@ void coll_write_test(int chunk_factor)
  * Programmer:    Unknown
  *        Dec 2nd, 2004
  *
- * Modifications: Oct 18th, 2005
- * Note:        This test must be used with the correpsonding
-                coll_write_test.
  *-------------------------------------------------------------------------
  */
 static void
@@ -948,18 +931,18 @@ coll_read_test(int chunk_factor)
 **
 **  lower_dim_size_comp_test__select_checker_board():
 **
-**    Given a data space of tgt_rank, and dimensions:
+**    Given a dataspace of tgt_rank, and dimensions:
 **
 **        (mpi_size + 1), edge_size, ... , edge_size
 **
 **    edge_size, and a checker_edge_size, select a checker
 **    board selection of a sel_rank (sel_rank < tgt_rank)
-**    dimensional slice through the data space parallel to the
+**    dimensional slice through the dataspace parallel to the
 **      sel_rank fastest changing indicies, with origin (in the
 **    higher indicies) as indicated by the start array.
 **
 **    Note that this function, is hard coded to presume a
-**    maximum data space rank of 5.
+**    maximum dataspace rank of 5.
 **
 **    While this maximum is declared as a constant, increasing
 **    it will require extensive coding in addition to changing
@@ -1304,7 +1287,7 @@ lower_dim_size_comp_test__select_checker_board(
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
-    /* Clip the selection back to the data space proper. */
+    /* Clip the selection back to the dataspace proper. */
 
     for ( i = 0; i < test_max_rank; i++ ) {
 
@@ -1564,15 +1547,13 @@ lower_dim_size_comp_test__verify_data(uint32_t * buf_ptr,
  * Function:    lower_dim_size_comp_test__run_test()
  *
  * Purpose:    Verify that a bug in the computation of the size of the
- *        lower dimensions of a data space in H5S_obtain_datatype()
+ *        lower dimensions of a dataspace in H5S_obtain_datatype()
  *        has been corrected.
  *
  * Return:    void
  *
  * Programmer:    JRM -- 11/11/09
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 
@@ -1763,7 +1744,7 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
     }
 #endif
 
-    /* create data spaces */
+    /* create dataspaces */
 
     full_mem_small_ds_sid = H5Screate_simple(5, small_dims, NULL);
     VRFY((full_mem_small_ds_sid != 0),
@@ -2177,7 +2158,7 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
 #endif /* LOWER_DIM_SIZE_COMP_TEST__RUN_TEST__DEBUG */
     }
 
-    /* try clipping the selection back to the large data space proper */
+    /* try clipping the selection back to the large dataspace proper */
     start[0] = start[1] = start[2] = start[3] = start[4] = (hsize_t)0;
 
     stride[0] = (hsize_t)(2 * (mpi_size + 1));
@@ -2331,12 +2312,11 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
                                                    large_sel_start);
 
 
-    /* verify that H5S_select_shape_same() reports the two
+    /* verify that H5Sselect_shape_same() reports the two
      * selections as having the same shape.
      */
-    check = H5S__select_shape_same_test(mem_large_ds_sid,
-                                       file_small_ds_sid);
-    VRFY((check == TRUE), "H5S__select_shape_same_test passed (1)");
+    check = H5Sselect_shape_same(mem_large_ds_sid, file_small_ds_sid);
+    VRFY((check == TRUE), "H5Sselect_shape_same passed (1)");
 
 
     ret = H5Dread(small_dataset,
@@ -2452,12 +2432,11 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
                                                    large_sel_start);
 
 
-    /* verify that H5S_select_shape_same() reports the two
+    /* verify that H5Sselect_shape_same() reports the two
      * selections 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 (2)");
+    check = H5Sselect_shape_same(mem_small_ds_sid, file_large_ds_sid);
+    VRFY((check == TRUE), "H5Sselect_shape_same passed (2)");
 
 
     ret = H5Dread(large_dataset,
@@ -2613,8 +2592,6 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size,
  *
  * Programmer:    JRM -- 11/11/09
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2672,8 +2649,6 @@ lower_dim_size_comp_test(void)
  *
  * Programmer:    JRM -- 12/16/09
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 
@@ -2737,7 +2712,7 @@ link_chunk_collective_io_test(void)
     /* setup dims */
     dims[0] = ((hsize_t)mpi_size) * ((hsize_t)(LINK_CHUNK_COLLECTIVE_IO_TEST_CHUNK_SIZE));
 
-    /* setup mem and file data spaces */
+    /* setup mem and file dataspaces */
     write_mem_ds_sid = H5Screate_simple(1, chunk_dims, NULL);
     VRFY((write_mem_ds_sid != 0),
          "H5Screate_simple() write_mem_ds_sid succeeded");