summaryrefslogtreecommitdiffstats
path: root/testpar
diff options
context:
space:
mode:
authorJohn Mainzer <mainzer@hdfgroup.org>2011-09-13 18:29:58 (GMT)
committerJohn Mainzer <mainzer@hdfgroup.org>2011-09-13 18:29:58 (GMT)
commit98e7f67b0038d54c5909f19ae8be4f509076fcfc (patch)
treedeb2368550fc0889b6c17254c46a133eb3743dca /testpar
parent9e56bed5e0921e0d1399325eaf5f092d1f19590a (diff)
downloadhdf5-98e7f67b0038d54c5909f19ae8be4f509076fcfc.zip
hdf5-98e7f67b0038d54c5909f19ae8be4f509076fcfc.tar.gz
hdf5-98e7f67b0038d54c5909f19ae8be4f509076fcfc.tar.bz2
[svn-r21380]
Ported shape same test express test mods from trunk to 1.8 branch. This was mostly a matter of copying testpar/t_shapesame.c from trunk to the 1.8 branch, as the root versions of the files were almost identical. Tested parallel on Jam only, as changes have been well tested on the trunk.
Diffstat (limited to 'testpar')
-rw-r--r--testpar/t_shapesame.c5837
1 files changed, 3033 insertions, 2804 deletions
diff --git a/testpar/t_shapesame.c b/testpar/t_shapesame.c
index 459fcf8..b76b481 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
@@ -78,212 +37,252 @@
* the chunked dataset case.
*/
-#define SHAPE_SAME_TEST_ALIGNMENT ((hsize_t)(4 * 1024 * 1024))
+#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
+ * 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;
+ hbool_t use_gpfs = FALSE; /* Use GPFS hints */
+ hbool_t mis_match = FALSE;
+ 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 */
- 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;
+ int mpi_rank; /* needed by the VRFY macro */
+ uint32_t expected_value;
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 acc_tpl; /* File access templates */
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 */
+ 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 );
+ 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");
- small_ds_slice_sid = H5Screate_simple(small_rank - 1, &(dims[1]), NULL);
- VRFY((small_ds_slice_sid != 0),
+ /* 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");
+
+ 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");
+
+ /* 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");
- mem_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL);
- VRFY((mem_large_ds_process_slice_sid != FAIL),
+ 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)++;
+ } else { /* run the test */
- /* verify that expected data is retrieved */
+ tv_ptr->skips = 0; /* reset the skips counter */
- 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));
+ /* 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++ ) {
- for ( n = 0; n < small_ds_slice_size; n++ ) {
+ if ( *ptr_1 != expected_value ) {
- if ( *ptr_1 != expected_value ) {
+ mis_match = TRUE;
+ }
- mis_match = TRUE;
+ *ptr_1 = 0; /* zero data for next use */
+
+ 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)++;
- /* 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.");
+ } 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.
+ */
- mis_match = FALSE;
- ptr_1 = small_ds_buf_1;
+ /* 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++;
- 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));
+ } else {
- start_index = (size_t)mpi_rank * small_ds_slice_size;
- stop_index = start_index + small_ds_slice_size - 1;
+ if ( *ptr_1 != 0 ) {
- HDassert( start_index < stop_index );
- HDassert( stop_index <= small_ds_size );
+ mis_match = TRUE;
+ }
+ }
+ /* zero out the value for the next pass */
+ *ptr_1 = 0;
- for ( n = 0; n < small_ds_size; n++ ) {
+ ptr_1++;
+ }
- if ( ( n >= start_index ) && ( n <= stop_index ) ) {
+ VRFY((mis_match == FALSE),
+ "small slice write from large ds data good.");
- if ( *ptr_1 != expected_value ) {
+ (tv_ptr->tests_run)++;
+ }
- mis_match = TRUE;
- }
- expected_value++;
+ l++;
- } else {
+ (tv_ptr->total_tests)++;
- if ( *ptr_1 != 0 ) {
+ } 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 ) );
- mis_match = TRUE;
- }
- }
- /* zero out the value for the next pass */
- *ptr_1 = 0;
+ return;
- ptr_1++;
- }
+} /* contig_hs_dr_pio_test__m2d_l2s() */
- VRFY((mis_match == FALSE),
- "small slice write from large ds data good.");
- l++;
+/*-------------------------------------------------------------------------
+ * 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
+ *
+ *-------------------------------------------------------------------------
+ */
- } 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 CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 0
+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,278 +1801,466 @@ 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.
+ */
+
+#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);
- /* Close Datasets */
- ret = H5Dclose(small_dataset);
- VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
- 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.
+ */
+
+#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);
- /* close the file collectively */
- MESG("about to close file.");
- ret = H5Fclose(fid);
- VRFY((ret != FAIL), "file close succeeded");
+ /* 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.
+ */
- /* Free memory buffers */
+#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 ( 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 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 */
- 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);
+ 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 */
+
+ *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.
+ * Purpose: Test I/O to/from hyperslab selections of different rank in
+ * the parallel case.
*
- * Return: void
+ * Return: void
*
- * Programmer: JRM -- 9/18/09
+ * 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.
+ * 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
+ * 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
+ * AKC -- 2010/01/14
*
*-------------------------------------------------------------------------
*/
+#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 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;
- 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 express_test;
+ int local_express_test;
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 */
+ int test_num = 0;
+ int edge_size = 10;
+ int chunk_edge_size = 0;
+ int small_rank;
+ int large_rank;
+ 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, 32, 256};
+ hid_t dset_type = H5T_NATIVE_UINT;
+ 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,247 +2272,177 @@ 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():
-** Given a data space of tgt_rank, and dimensions:
+** ckrbrd_hs_dr_pio_test__slct_ckrbrd():
+** Given a data space of tgt_rank, and dimensions:
**
-** (mpi_size + 1), edge_size, ... , edge_size
+** (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
+** 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
** sel_rank fastest changing indicies, with origin (in the
-** higher indicies) as indicated by the start array.
+** 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.
-** While this maximum is declared as a constant, increasing
-** it will require extensive coding in addition to changing
+** Note that this function, like all its relatives, is
+** hard coded to presume a maximum data space 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.
**
-** JRM -- 10/8/09
+** JRM -- 10/8/09
**
****************************************************************/
-#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;
+ hbool_t first_selection = TRUE;
int i, j, k, l, m;
- int n_cube_offset;
- int sel_offset;
- const int test_max_rank = PAR_SS_DR_MAX_RANK; /* must update code if */
+ int n_cube_offset;
+ int sel_offset;
+ const int test_max_rank = PAR_SS_DR_MAX_RANK; /* must update code if */
/* this changes */
- hsize_t base_count;
+ hsize_t base_count;
hsize_t offset_count;
- 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];
- herr_t ret; /* Generic return value */
+ 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];
+ herr_t ret; /* Generic return value */
HDassert( edge_size >= 6 );
HDassert( 0 < checker_edge_size );
@@ -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,86 +2723,85 @@ 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
+** Examine the supplied buffer to see if it contains the
+** expected data. Return TRUE if it does, and FALSE
** otherwise.
**
-** The supplied buffer is presumed to this process's slice
-** of the target data set. Each such slice will be an
-** n-cube of rank (rank -1) and the supplied edge_size with
-** origin (mpi_rank, 0, ... , 0) in the target data set.
+** The supplied buffer is presumed to this process's slice
+** of the target data set. Each such slice will be an
+** n-cube of rank (rank -1) and the supplied edge_size with
+** origin (mpi_rank, 0, ... , 0) in the target data set.
**
-** Further, the buffer is presumed to be the result of reading
-** or writing a checker board selection of an m (1 <= m <
+** Further, the buffer is presumed to be the result of reading
+** or writing a checker board selection of an m (1 <= m <
** rank) dimensional slice through this processes slice
-** of the target data set. Also, this slice must be parallel
-** to the fastest changing indicies.
+** of the target data set. Also, this slice must be parallel
+** to the fastest changing indicies.
**
-** It is further presumed that the buffer was zeroed before
-** the read/write, and that the full target data set (i.e.
-** the buffer/data set for all processes) was initialized
+** It is further presumed that the buffer was zeroed before
+** the read/write, and that the full target data set (i.e.
+** the buffer/data set for all processes) was initialized
** with the natural numbers listed in order from the origin
-** along the fastest changing axis.
+** along the fastest changing axis.
**
** Thus for a 20x10x10 dataset, the value stored in location
-** (x, y, z) (assuming that z is the fastest changing index
-** and x the slowest) is assumed to be:
+** (x, y, z) (assuming that z is the fastest changing index
+** and x the slowest) is assumed to be:
**
-** (10 * 10 * x) + (10 * y) + z
+** (10 * 10 * x) + (10 * y) + z
**
-** Further, supposing that this is process 10, this process's
-** slice of the dataset would be a 10 x 10 2-cube with origin
-** (10, 0, 0) in the data set, and would be initialize (prior
-** to the checkerboard selection) as follows:
+** Further, supposing that this is process 10, this process's
+** slice of the dataset would be a 10 x 10 2-cube with origin
+** (10, 0, 0) in the data set, and would be initialize (prior
+** to the checkerboard selection) as follows:
**
-** 1000, 1001, 1002, ... 1008, 1009
-** 1010, 1011, 1012, ... 1018, 1019
-** . . . . .
-** . . . . .
-** . . . . .
-** 1090, 1091, 1092, ... 1098, 1099
+** 1000, 1001, 1002, ... 1008, 1009
+** 1010, 1011, 1012, ... 1018, 1019
+** . . . . .
+** . . . . .
+** . . . . .
+** 1090, 1091, 1092, ... 1098, 1099
**
-** In the case of a read from the processors slice of another
-** data set of different rank, the values expected will have
-** to be adjusted accordingly. This is done via the
-** first_expected_val parameter.
+** In the case of a read from the processors slice of another
+** data set of different rank, the values expected will have
+** to be adjusted accordingly. This is done via the
+** first_expected_val parameter.
**
-** Finally, the function presumes that the first element
-** of the buffer resides either at the origin of either
-** a selected or an unselected checker. (Translation:
-** if partial checkers appear in the buffer, they will
-** intersect the edges of the n-cube oposite the origin.)
+** Finally, the function presumes that the first element
+** of the buffer resides either at the origin of either
+** a selected or an unselected checker. (Translation:
+** if partial checkers appear in the buffer, they will
+** intersect the edges of the n-cube oposite the origin.)
**
****************************************************************/
-#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,9 +2820,9 @@ 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;
+ int mpi_rank;
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
HDfprintf(stdout, "%s mpi_rank = %d.\n", fcnName, 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: Part one of a series of tests of I/O to/from hyperslab
+ * selections of different rank in the parallel.
*
- * Purpose: Test I/O to/from checkerboard selections of hyperslabs 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.
*
- * Return: void
+ * 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.
*
- * Programmer: JRM -- 10/10/09
+ * Return: void
+ *
+ * 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 */
- 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;
+#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG
+ const char *fcnName = "ckrbrd_hs_dr_pio_test__d2m_l2s()";
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];
+#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
+ hbool_t data_ok = FALSE;
+ int i, j, k, l;
+ uint32_t expected_value;
+ 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 */
+ 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);
+ /* initialize the local copy of mpi_rank */
+ mpi_rank = tv_ptr->mpi_rank;
- 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");
-
-
- /* 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 = 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
+ );
- 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
- );
+ 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 = tv_ptr->large_ds_buf_1 + stop_index + 1;
- ptr_1 = large_ds_buf_1 + stop_index + 1;
+ for ( u = stop_index + 1; u < tv_ptr->large_ds_size; u++ ) {
- for ( u = stop_index + 1; u < 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,303 +4098,449 @@ 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.
+ */
+
+ 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");
- data_ok = TRUE;
- ptr_1 = large_ds_buf_1;
- for ( u = 0; u < start_index; u++, ptr_1++ ) {
+ /* 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);
- if ( *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;
- data_ok = FALSE;
- *ptr_1 = 0;
+ 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.
+ * Purpose: Test I/O to/from hyperslab selections of different rank in
+ * the parallel case.
*
- * Return: void
+ * Return: void
*
- * Programmer: JRM -- 9/18/09
+ * 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.
+ * 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
+ * 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
*
*-------------------------------------------------------------------------
*/
-void
-checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type)
+static void
+ckrbrd_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
{
- 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 local_express_test;
+ 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 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 mpi_result;
+ hid_t dset_type = H5T_NATIVE_UINT;
+ 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, 32, 256};
+ 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]);
-
- }
- 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]);
-
+ 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 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. */
@@ -4469,15 +4699,15 @@ int dim0;
int dim1;
int chunkdim0;
int chunkdim1;
-int nerrors = 0; /* errors count */
-int ndatasets = 300; /* number of datasets to create*/
+int nerrors = 0; /* errors count */
+int ndatasets = 300; /* number of datasets to create*/
int ngroups = 512; /* number of groups to create in root
* group. */
-int facc_type = FACC_MPIO; /*Test file access type */
+int facc_type = FACC_MPIO; /*Test file access type */
int dxfer_coll_type = DXFER_COLLECTIVE_IO;
-H5E_auto2_t old_func; /* previous error handler */
-void *old_client_data; /* previous error handler arg.*/
+H5E_auto2_t old_func; /* previous error handler */
+void *old_client_data; /* previous error handler arg.*/
/* other option flags */
@@ -4489,10 +4719,10 @@ void *old_client_data; /* previous error handler arg.*/
#define NFILENAME 2
#define PARATESTFILE filenames[0]
const char *FILENAME[NFILENAME]={
- "ShapeSameTest",
- NULL};
-char filenames[NFILENAME][PATH_MAX];
-hid_t fapl; /* file access property list */
+ "ShapeSameTest",
+ NULL};
+char filenames[NFILENAME][PATH_MAX];
+hid_t fapl; /* file access property list */
#ifdef USE_PAUSE
/* pause the process for a moment to allow debugger to attach if desired. */
@@ -4505,7 +4735,7 @@ void pause_proc(void)
{
int pid;
- h5_stat_t statbuf;
+ h5_stat_t statbuf;
char greenlight[] = "go";
int maxloop = 10;
int loops = 0;
@@ -4522,15 +4752,15 @@ void pause_proc(void)
MPI_Get_processor_name(mpi_name, &mpi_namelen);
if (MAINPROCESS)
- 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);
- }
- printf("waiting(%ds) for file %s ...\n", time_int, greenlight);
- fflush(stdout);
- sleep(time_int);
- }
+ 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);
+ }
+ printf("waiting(%ds) for file %s ...\n", time_int, greenlight);
+ fflush(stdout);
+ sleep(time_int);
+ }
MPI_Barrier(MPI_COMM_WORLD);
}
@@ -4542,7 +4772,7 @@ int MPI_Init(int *argc, char ***argv)
pause_proc();
return (ret_code);
}
-#endif /* USE_PAUSE */
+#endif /* USE_PAUSE */
/*
@@ -4552,16 +4782,16 @@ static void
usage(void)
{
printf(" [-r] [-w] [-m<n_datasets>] [-n<n_groups>] "
- "[-o] [-f <prefix>] [-d <dim0> <dim1>]\n");
+ "[-o] [-f <prefix>] [-d <dim0> <dim1>]\n");
printf("\t-m<n_datasets>"
- "\tset number of datasets for the multiple dataset test\n");
+ "\tset number of datasets for the multiple dataset test\n");
printf("\t-n<n_groups>"
"\tset number of groups for the multiple group test\n");
printf("\t-f <prefix>\tfilename prefix\n");
printf("\t-2\t\tuse Split-file together with MPIO\n");
printf("\t-p\t\tuse combo MPI-POSIX driver\n");
printf("\t-d <factor0> <factor1>\tdataset dimensions factors. Defaults (%d,%d)\n",
- ROW_FACTOR, COL_FACTOR);
+ ROW_FACTOR, COL_FACTOR);
printf("\t-c <dim0> <dim1>\tdataset chunk dimensions. Defaults (dim0/10,dim1/10)\n");
printf("\n");
}
@@ -4573,7 +4803,7 @@ usage(void)
static int
parse_options(int argc, char **argv)
{
- int mpi_size, mpi_rank; /* mpi variables */
+ int mpi_size, mpi_rank; /* mpi variables */
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@@ -4584,110 +4814,110 @@ parse_options(int argc, char **argv)
chunkdim1 = (dim1+9)/10;
while (--argc){
- if (**(++argv) != '-'){
- break;
- }else{
- switch(*(*argv+1)){
- case 'm': ndatasets = atoi((*argv+1)+1);
- if (ndatasets < 0){
- nerrors++;
- return(1);
- }
- break;
- case 'n': ngroups = atoi((*argv+1)+1);
- if (ngroups < 0){
+ if (**(++argv) != '-'){
+ break;
+ }else{
+ switch(*(*argv+1)){
+ case 'm': ndatasets = atoi((*argv+1)+1);
+ if (ndatasets < 0){
+ nerrors++;
+ return(1);
+ }
+ break;
+ case 'n': ngroups = atoi((*argv+1)+1);
+ if (ngroups < 0){
nerrors++;
return(1);
- }
+ }
break;
- case 'f': if (--argc < 1) {
- nerrors++;
- return(1);
- }
- if (**(++argv) == '-') {
- nerrors++;
- return(1);
- }
- paraprefix = *argv;
- break;
- case 'p': /* Use the MPI-POSIX driver access */
- facc_type = FACC_MPIPOSIX;
- break;
- case 'i': /* Collective MPI-IO access with independent IO */
- dxfer_coll_type = DXFER_INDEPENDENT_IO;
- break;
- case '2': /* Use the split-file driver with MPIO access */
- /* Can use $HDF5_METAPREFIX to define the */
- /* meta-file-prefix. */
- facc_type = FACC_MPIO | FACC_SPLIT;
- break;
- case 'd': /* dimensizes */
- if (--argc < 2){
- nerrors++;
- return(1);
- }
- dim0 = atoi(*(++argv))*mpi_size;
- argc--;
- dim1 = atoi(*(++argv))*mpi_size;
- /* set default chunkdim sizes too */
- chunkdim0 = (dim0+9)/10;
- chunkdim1 = (dim1+9)/10;
- break;
- case 'c': /* chunk dimensions */
- if (--argc < 2){
- nerrors++;
- return(1);
- }
- chunkdim0 = atoi(*(++argv));
- argc--;
- chunkdim1 = atoi(*(++argv));
- break;
- case 'h': /* print help message--return with nerrors set */
- return(1);
- default: printf("Illegal option(%s)\n", *argv);
- nerrors++;
- return(1);
- }
- }
+ case 'f': if (--argc < 1) {
+ nerrors++;
+ return(1);
+ }
+ if (**(++argv) == '-') {
+ nerrors++;
+ return(1);
+ }
+ paraprefix = *argv;
+ break;
+ case 'p': /* Use the MPI-POSIX driver access */
+ facc_type = FACC_MPIPOSIX;
+ break;
+ case 'i': /* Collective MPI-IO access with independent IO */
+ dxfer_coll_type = DXFER_INDEPENDENT_IO;
+ break;
+ case '2': /* Use the split-file driver with MPIO access */
+ /* Can use $HDF5_METAPREFIX to define the */
+ /* meta-file-prefix. */
+ facc_type = FACC_MPIO | FACC_SPLIT;
+ break;
+ case 'd': /* dimensizes */
+ if (--argc < 2){
+ nerrors++;
+ return(1);
+ }
+ dim0 = atoi(*(++argv))*mpi_size;
+ argc--;
+ dim1 = atoi(*(++argv))*mpi_size;
+ /* set default chunkdim sizes too */
+ chunkdim0 = (dim0+9)/10;
+ chunkdim1 = (dim1+9)/10;
+ break;
+ case 'c': /* chunk dimensions */
+ if (--argc < 2){
+ nerrors++;
+ return(1);
+ }
+ chunkdim0 = atoi(*(++argv));
+ argc--;
+ chunkdim1 = atoi(*(++argv));
+ break;
+ case 'h': /* print help message--return with nerrors set */
+ return(1);
+ default: printf("Illegal option(%s)\n", *argv);
+ nerrors++;
+ return(1);
+ }
+ }
} /*while*/
/* check validity of dimension and chunk sizes */
if (dim0 <= 0 || dim1 <= 0){
- printf("Illegal dim sizes (%d, %d)\n", dim0, dim1);
- nerrors++;
- return(1);
+ printf("Illegal dim sizes (%d, %d)\n", dim0, dim1);
+ nerrors++;
+ return(1);
}
if (chunkdim0 <= 0 || chunkdim1 <= 0){
- printf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1);
- nerrors++;
- return(1);
+ printf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1);
+ nerrors++;
+ return(1);
}
/* Make sure datasets can be divided into equal portions by the processes */
if ((dim0 % mpi_size) || (dim1 % mpi_size)){
- if (MAINPROCESS)
- printf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n",
- dim0, dim1, mpi_size);
- nerrors++;
- return(1);
+ if (MAINPROCESS)
+ printf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n",
+ dim0, dim1, mpi_size);
+ nerrors++;
+ return(1);
}
/* compose the test filenames */
{
- int i, n;
-
- n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1; /* exclude the NULL */
-
- for (i=0; i < n; i++)
- if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i]))
- == NULL){
- printf("h5_fixname failed\n");
- nerrors++;
- return(1);
- }
- printf("Test filenames are:\n");
- for (i=0; i < n; i++)
- printf(" %s\n", filenames[i]);
+ int i, n;
+
+ n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1; /* exclude the NULL */
+
+ for (i=0; i < n; i++)
+ if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i]))
+ == NULL){
+ printf("h5_fixname failed\n");
+ nerrors++;
+ return(1);
+ }
+ printf("Test filenames are:\n");
+ for (i=0; i < n; i++)
+ printf(" %s\n", filenames[i]);
}
return(0);
@@ -4703,7 +4933,7 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type,
{
hid_t ret_pl = -1;
herr_t ret; /* generic return value */
- int mpi_rank; /* mpi variables */
+ int mpi_rank; /* mpi variables */
/* need the rank for error checking macros */
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@@ -4712,39 +4942,39 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type,
VRFY((ret_pl >= 0), "H5P_FILE_ACCESS");
if (l_facc_type == FACC_DEFAULT)
- return (ret_pl);
+ return (ret_pl);
if (l_facc_type == FACC_MPIO){
- /* set Parallel access with communicator */
- ret = H5Pset_fapl_mpio(ret_pl, comm, info);
- VRFY((ret >= 0), "");
- return(ret_pl);
+ /* set Parallel access with communicator */
+ ret = H5Pset_fapl_mpio(ret_pl, comm, info);
+ VRFY((ret >= 0), "");
+ return(ret_pl);
}
if (l_facc_type == (FACC_MPIO | FACC_SPLIT)){
- hid_t mpio_pl;
-
- mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
- VRFY((mpio_pl >= 0), "");
- /* set Parallel access with communicator */
- ret = H5Pset_fapl_mpio(mpio_pl, comm, info);
- VRFY((ret >= 0), "");
-
- /* setup file access template */
- ret_pl = H5Pcreate (H5P_FILE_ACCESS);
- VRFY((ret_pl >= 0), "");
- /* set Parallel access with communicator */
- ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl);
- VRFY((ret >= 0), "H5Pset_fapl_split succeeded");
- H5Pclose(mpio_pl);
- return(ret_pl);
+ hid_t mpio_pl;
+
+ mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
+ VRFY((mpio_pl >= 0), "");
+ /* set Parallel access with communicator */
+ ret = H5Pset_fapl_mpio(mpio_pl, comm, info);
+ VRFY((ret >= 0), "");
+
+ /* setup file access template */
+ ret_pl = H5Pcreate (H5P_FILE_ACCESS);
+ VRFY((ret_pl >= 0), "");
+ /* set Parallel access with communicator */
+ ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl);
+ VRFY((ret >= 0), "H5Pset_fapl_split succeeded");
+ H5Pclose(mpio_pl);
+ return(ret_pl);
}
if (l_facc_type == FACC_MPIPOSIX) {
- /* set Parallel access with communicator */
- ret = H5Pset_fapl_mpiposix(ret_pl, comm, use_gpfs);
- VRFY((ret >= 0), "H5Pset_fapl_mpiposix succeeded");
- return(ret_pl);
+ /* set Parallel access with communicator */
+ ret = H5Pset_fapl_mpiposix(ret_pl, comm, use_gpfs);
+ VRFY((ret >= 0), "H5Pset_fapl_mpiposix succeeded");
+ return(ret_pl);
}
/* unknown file access types */
@@ -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;
+ int mpi_size, mpi_rank; /* mpi variables */
/* Un-buffer the stdout and stderr */
setbuf(stderr, NULL);
@@ -4830,9 +5056,10 @@ int main(int argc, char **argv)
dim1 = COL_FACTOR*mpi_size;
if (MAINPROCESS){
- printf("===================================\n");
- printf("Shape Same Tests Start\n");
- printf("===================================\n");
+ printf("===================================\n");
+ printf("Shape Same Tests Start\n");
+ printf(" express_test = %d.\n", GetTestExpress());
+ printf("===================================\n");
}
/* Attempt to turn off atexit post processing so that in case errors
@@ -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,24 +5077,26 @@ 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);
+ "Shape Same, contigous hyperslab, ind IO, contig datasets", PARATESTFILE);
AddTest("sscontig2", sscontig2, NULL,
- "Shape Same, contigous hyperslab, col IO, contig datasets", PARATESTFILE);
+ "Shape Same, contigous hyperslab, col IO, contig datasets", PARATESTFILE);
AddTest("sscontig3", sscontig3, NULL,
- "Shape Same, contigous hyperslab, ind IO, chunked datasets", PARATESTFILE);
+ "Shape Same, contigous hyperslab, ind IO, chunked datasets", PARATESTFILE);
AddTest("sscontig4", sscontig4, NULL,
- "Shape Same, contigous hyperslab, col IO, chunked datasets", PARATESTFILE);
+ "Shape Same, contigous hyperslab, col IO, chunked datasets", PARATESTFILE);
+#endif
/* Shape Same tests using checker board hyperslab */
AddTest("sschecker1", sschecker1, NULL,
- "Shape Same, checker hyperslab, ind IO, contig datasets", PARATESTFILE);
+ "Shape Same, checker hyperslab, ind IO, contig datasets", PARATESTFILE);
AddTest("sschecker2", sschecker2, NULL,
- "Shape Same, checker hyperslab, col IO, contig datasets", PARATESTFILE);
+ "Shape Same, checker hyperslab, col IO, contig datasets", PARATESTFILE);
AddTest("sschecker3", sschecker3, NULL,
- "Shape Same, checker hyperslab, ind IO, chunked datasets", PARATESTFILE);
+ "Shape Same, checker hyperslab, ind IO, chunked datasets", PARATESTFILE);
AddTest("sschecker4", sschecker4, NULL,
- "Shape Same, checker hyperslab, col IO, chunked datasets", PARATESTFILE);
+ "Shape Same, checker hyperslab, col IO, chunked datasets", PARATESTFILE);
/* Display testing information */
TestInfo(argv[0]);
@@ -4880,15 +5109,15 @@ int main(int argc, char **argv)
TestParseCmdLine(argc, argv);
if (facc_type == FACC_MPIPOSIX && MAINPROCESS){
- printf("===================================\n"
- " Using MPIPOSIX driver\n"
- "===================================\n");
+ printf("===================================\n"
+ " Using MPIPOSIX driver\n"
+ "===================================\n");
}
if (dxfer_coll_type == DXFER_INDEPENDENT_IO && MAINPROCESS){
- printf("===================================\n"
- " Using Independent I/O with file set view to replace collective I/O \n"
- "===================================\n");
+ printf("===================================\n"
+ " Using Independent I/O with file set view to replace collective I/O \n"
+ "===================================\n");
}
@@ -4913,16 +5142,16 @@ int main(int argc, char **argv)
{
int temp;
MPI_Allreduce(&nerrors, &temp, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
- nerrors=temp;
+ nerrors=temp;
}
- if (MAINPROCESS){ /* only process 0 reports */
- printf("===================================\n");
- if (nerrors)
- printf("***PHDF5 tests detected %d errors***\n", nerrors);
- else
- printf("PHDF5 tests finished with no errors\n");
- printf("===================================\n");
+ if (MAINPROCESS){ /* only process 0 reports */
+ printf("===================================\n");
+ if (nerrors)
+ printf("***Shape Same tests detected %d errors***\n", nerrors);
+ else
+ printf("Shape Same tests finished with no errors\n");
+ printf("===================================\n");
}
/* close HDF5 library */
H5close();
generated by cgit v0.12 at 2024-11-25 23:51:55 (GMT)