summaryrefslogtreecommitdiffstats
path: root/testpar
diff options
context:
space:
mode:
Diffstat (limited to 'testpar')
-rw-r--r--testpar/t_rank_projection.c4433
1 files changed, 0 insertions, 4433 deletions
diff --git a/testpar/t_rank_projection.c b/testpar/t_rank_projection.c
deleted file mode 100644
index 7159ee0..0000000
--- a/testpar/t_rank_projection.c
+++ /dev/null
@@ -1,4433 +0,0 @@
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright by The HDF Group. *
- * Copyright by the Board of Trustees of the University of Illinois. *
- * All rights reserved. *
- * *
- * This file is part of HDF5. The full HDF5 copyright notice, including *
- * terms governing use, modification, and redistribution, is contained in *
- * the files COPYING and Copyright.html. COPYING can be found at the root *
- * of the source code distribution tree; Copyright.html can be found at the *
- * root level of an installed copy of the electronic HDF5 document set and *
- * is linked from the top-level documents page. It can also be found at *
- * http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
- * access to either file, you may request a copy from help@hdfgroup.org. *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-/*
- This program will test independant and collective reads and writes between
- selections of different rank that non-the-less are deemed as having the
- same shape by H5Sselect_shape_same().
- */
-
-#define H5S_PACKAGE /*suppress error about including H5Spkg */
-
-/* Define this macro to indicate that the testing APIs should be available */
-#define H5S_TESTING
-
-
-#include "hdf5.h"
-#include "H5private.h"
-#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
- * block. To minimize this problem, we set alignment in the shape same tests
- * to the default Lustre block size -- which greatly reduces contention in
- * the chunked dataset case.
- */
-
-#define SHAPE_SAME_TEST_ALIGNMENT ((hsize_t)(4 * 1024 * 1024))
-
-
-/*-------------------------------------------------------------------------
- * Function: contig_hyperslab_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.
- *
- *-------------------------------------------------------------------------
- */
-
-#define PAR_SS_DR_MAX_RANK 5
-#define CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__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)
-{
-#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 */
- const char *filename;
- hbool_t use_gpfs = FALSE; /* Use GPFS hints */
- hbool_t mis_match = FALSE;
- int i, j, k, l, n;
- int mrc;
- int mpi_size = -1;
- int mpi_rank = -1;
- int start_index;
- int 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;
- uint32_t * ptr_0;
- uint32_t * ptr_1;
- uint32_t * ptr_2;
- MPI_Comm mpi_comm = MPI_COMM_NULL;
- MPI_Info mpi_info = MPI_INFO_NULL;
- hid_t fid; /* HDF5 file ID */
- hid_t acc_tpl; /* File access templates */
- hid_t xfer_plist = H5P_DEFAULT;
- hid_t full_mem_small_ds_sid;
- hid_t full_file_small_ds_sid;
- hid_t mem_small_ds_sid;
- hid_t file_small_ds_sid;
- hid_t small_ds_slice_sid;
- hid_t full_mem_large_ds_sid;
- hid_t full_file_large_ds_sid;
- hid_t mem_large_ds_sid;
- hid_t file_large_ds_sid;
- hid_t file_large_ds_process_slice_sid;
- hid_t mem_large_ds_process_slice_sid;
- hid_t large_ds_slice_sid;
- hid_t small_ds_dcpl_id = H5P_DEFAULT;
- hid_t large_ds_dcpl_id = H5P_DEFAULT;
- hid_t small_dataset; /* Dataset ID */
- hid_t large_dataset; /* Dataset ID */
- size_t small_ds_size = 1;
- size_t small_ds_slice_size = 1;
- size_t large_ds_size = 1;
- size_t large_ds_slice_size = 1;
- hsize_t dims[PAR_SS_DR_MAX_RANK];
- hsize_t chunk_dims[PAR_SS_DR_MAX_RANK];
- hsize_t start[PAR_SS_DR_MAX_RANK];
- hsize_t stride[PAR_SS_DR_MAX_RANK];
- hsize_t count[PAR_SS_DR_MAX_RANK];
- hsize_t block[PAR_SS_DR_MAX_RANK];
- hsize_t * start_ptr = NULL;
- hsize_t * stride_ptr = NULL;
- hsize_t * count_ptr = NULL;
- hsize_t * block_ptr = NULL;
- htri_t check; /* Shape comparison return value */
- herr_t ret; /* Generic return value */
-
- HDassert( edge_size >= 6 );
- 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);
-
-
- 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);
-
-
- /* 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]);
-
-
- /* Allocate buffers */
- small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
- VRFY((small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded");
-
- small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
- VRFY((small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded");
-
- small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
- VRFY((small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded");
-
- small_ds_slice_buf =
- (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_slice_size);
- VRFY((small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded");
-
- large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
- VRFY((large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded");
-
- large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
- VRFY((large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
-
- large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
- VRFY((large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded");
-
- large_ds_slice_buf =
- (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_slice_size);
- VRFY((large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded");
-
- /* initialize the buffers */
-
- ptr_0 = small_ds_buf_0;
- for(i = 0; i < (int)small_ds_size; i++)
- *ptr_0++ = (uint32_t)i;
- HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
- HDmemset(small_ds_buf_2, 0, sizeof(uint32_t) * small_ds_size);
-
- HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
-
- ptr_0 = large_ds_buf_0;
- for(i = 0; i < (int)large_ds_size; i++)
- *ptr_0++ = (uint32_t)i;
- HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
- HDmemset(large_ds_buf_2, 0, sizeof(uint32_t) * large_ds_size);
-
- HDmemset(large_ds_slice_buf, 0, sizeof(uint32_t) * large_ds_slice_size);
-
- filename = (const char *)GetTestParameters();
- HDassert( filename != NULL );
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__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: small/large rank = %d/%d, use_collective_io = %d.\n",
- mpi_rank, small_rank, large_rank, (int)use_collective_io);
- HDfprintf(stdout, "%d: edge_size = %d, chunk_edge_size = %d.\n",
- mpi_rank, edge_size, chunk_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);
- }
-#endif
- /* ----------------------------------------
- * 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] = (int)(mpi_size + 1);
- dims[1] = dims[2] = dims[3] = dims[4] = 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 = H5Screate_simple(small_rank, dims, NULL);
- VRFY((file_small_ds_sid != 0),
- "H5Screate_simple() file_small_ds_sid 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 = H5Screate_simple(large_rank, dims, NULL);
- VRFY((file_large_ds_sid != FAIL),
- "H5Screate_simple() file_large_ds_sid 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] = 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, 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);
- 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] = mpi_rank;
- stride[0] = 2 * (mpi_size + 1);
- count[0] = 1;
- block[0] = 1;
-
- for ( i = 1; i < large_rank; i++ ) {
-
- start[i] = 0;
- stride[i] = 2 * edge_size;
- count[i] = 1;
- block[i] = 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,
- H5S_SELECT_SET,
- start,
- stride,
- count,
- block);
- VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded");
-
- if ( MAINPROCESS ) { /* add an additional slice to the selections */
-
- start[0] = 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,
- H5S_SELECT_OR,
- start,
- stride,
- count,
- block);
- VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid, 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);
-
- 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.
- */
- 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] = 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,
- H5S_SELECT_SET,
- start,
- stride,
- count,
- block);
- VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid, 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] = 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,
- H5S_SELECT_OR,
- start,
- stride,
- count,
- block);
- VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid, 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);
- 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 large 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 initial values check");
- }
-
-
- /* 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.
- */
-
- /* 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] = 2 * edge_size;
- count[i] = 1;
- if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
-
- block[i] = 1;
-
- } else {
-
- block[i] = edge_size;
- }
- }
-
- /* zero out the buffer we will be reading into */
- HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
-
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
- HDfprintf(stdout,
- "%s reading slices from big cube on disk into small cube slice.\n",
- fcnName);
-#endif
- /* 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
- * by its rank -- hence we set the most slowly changing index to
- * mpi_rank, and don't itterate over it.
- */
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
-
- i = mpi_rank;
-
- } else {
-
- i = 0;
- }
-
- /* since large_rank is at most PAR_SS_DR_MAX_RANK, no need to
- * loop over it -- either we are setting i to mpi_rank, or
- * we are setting it to zero. It will not change during the
- * test.
- */
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
-
- j = mpi_rank;
-
- } else {
-
- j = 0;
- }
-
- do {
- if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
-
- k = mpi_rank;
-
- } else {
-
- k = 0;
- }
-
- do {
- /* since small rank >= 2 and large_rank > small_rank, we
- * have large_rank >= 3. Since PAR_SS_DR_MAX_RANK == 5
- * (baring major re-orgaization), this gives us:
- *
- * (PAR_SS_DR_MAX_RANK - large_rank) <= 2
- *
- * so no need to repeat the test in the outer loops --
- * just set l = 0.
- */
-
- 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] = i;
- start[1] = j;
- start[2] = k;
- start[3] = 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), "H5Sread() slice from large ds succeeded.");
-
-
- /* verify that expected data is retrieved */
-
- mis_match = FALSE;
- ptr_1 = small_ds_slice_buf;
- expected_value =
- (i * edge_size * edge_size * edge_size * edge_size) +
- (j * edge_size * edge_size * edge_size) +
- (k * edge_size * edge_size) +
- (l * edge_size);
-
- for ( n = 0; n < (int)small_ds_slice_size; n++ ) {
-
- if ( *ptr_1 != expected_value ) {
-
- mis_match = TRUE;
- }
-
- *ptr_1 = 0; /* zero data for next use */
-
- ptr_1++;
- expected_value++;
- }
-
- VRFY((mis_match == FALSE),
- "small slice read from large ds data good.");
- l++;
-
- } 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 ) );
-
-
- /* 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.
- */
-
- start[0] = mpi_rank;
- stride[0] = 2 * (mpi_size + 1);
- count[0] = 1;
- block[0] = 1;
-
- for ( i = 1; i < large_rank; i++ ) {
-
- start[i] = 0;
- stride[i] = 2 * edge_size;
- count[i] = 1;
- block[i] = edge_size;
- }
-
- ret = H5Sselect_hyperslab(file_small_ds_sid,
- H5S_SELECT_SET,
- start,
- stride,
- count,
- block);
- VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded");
-
-
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
- HDfprintf(stdout,
- "%s reading slices of on disk small data set into slices of big data set.\n",
- fcnName);
-#endif
-
- /* zero out the in memory large ds */
- HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * 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] = 2 * edge_size;
- count[i] = 1;
- if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
-
- block[i] = 1;
-
- } else {
-
- block[i] = 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.
- *
- * However, in the parallel version, each process only works with that
- * slice of the large (and small) data set indicated by its rank -- hence
- * we set the most slowly changing index to mpi_rank, and don't itterate
- * over it.
- */
-
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
-
- i = mpi_rank;
-
- } else {
-
- i = 0;
- }
-
- /* since large_rank is at most PAR_SS_DR_MAX_RANK, no need to
- * loop over it -- either we are setting i to mpi_rank, or
- * we are setting it to zero. It will not change during the
- * test.
- */
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
-
- j = mpi_rank;
-
- } else {
-
- j = 0;
- }
-
- do {
- if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
-
- k = mpi_rank;
-
- } else {
-
- k = 0;
- }
-
- do {
- /* since small rank >= 2 and large_rank > small_rank, we
- * have large_rank >= 3. Since PAR_SS_DR_MAX_RANK == 5
- * (baring major re-orgaization), this gives us:
- *
- * (PAR_SS_DR_MAX_RANK - large_rank) <= 2
- *
- * so no need to repeat the test in the outer loops --
- * just set l = 0.
- */
-
- 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] = i;
- start[1] = j;
- start[2] = k;
- start[3] = 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), "H5Sread() 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 = mpi_rank * small_ds_slice_size;
- start_index =
- (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 + (int)small_ds_slice_size - 1;
-
- HDassert( 0 <= start_index );
- HDassert( start_index < stop_index );
- HDassert( stop_index <= (int)large_ds_size );
-
- for ( n = 0; n < (int)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++;
- }
-
- VRFY((mis_match == FALSE),
- "small slice read from large ds data good.");
-
- l++;
-
- } 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 ) );
-
-
- /* 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.
- */
-
- start[0] = mpi_rank;
- stride[0] = 2 * (mpi_size + 1);
- count[0] = 1;
- block[0] = 1;
-
- for ( i = 1; i < large_rank; i++ ) {
-
- start[i] = 0;
- stride[i] = 2 * edge_size;
- count[i] = 1;
- block[i] = edge_size;
- }
-
- ret = H5Sselect_hyperslab(file_small_ds_sid,
- H5S_SELECT_SET,
- start,
- stride,
- count,
- block);
- VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded");
-
- 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");
-
-
- /* 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] = 2 * edge_size;
- count[i] = 1;
- if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
-
- block[i] = 1;
-
- } else {
-
- block[i] = edge_size;
- }
- }
-
- /* zero out the in memory small ds */
- HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
-
-
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
- HDfprintf(stdout,
- "%s writing slices from big ds to slices of small ds on disk.\n",
- fcnName);
-#endif
-
- /* 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.
- *
- * However, in the parallel version, each process only works with that
- * slice of the large (and small) data set indicated by its rank -- hence
- * we set the most slowly changing index to mpi_rank, and don't itterate
- * over it.
- */
-
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
-
- i = mpi_rank;
-
- } else {
-
- i = 0;
- }
-
- /* since large_rank is at most PAR_SS_DR_MAX_RANK, no need to
- * loop over it -- either we are setting i to mpi_rank, or
- * we are setting it to zero. It will not change during the
- * test.
- */
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
-
- j = mpi_rank;
-
- } else {
-
- j = 0;
- }
-
- j = 0;
- do {
- if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
-
- k = mpi_rank;
-
- } else {
-
- k = 0;
- }
-
- do {
- /* since small rank >= 2 and large_rank > small_rank, we
- * have large_rank >= 3. Since PAR_SS_DR_MAX_RANK == 5
- * (baring major re-orgaization), this gives us:
- *
- * (PAR_SS_DR_MAX_RANK - large_rank) <= 2
- *
- * so no need to repeat the test in the outer loops --
- * just set l = 0.
- */
-
- 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] = i;
- start[1] = j;
- start[2] = k;
- start[3] = 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.");
-
-
- /* 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.");
-
-
- /* verify that expected data is retrieved */
-
- mis_match = FALSE;
- ptr_1 = small_ds_buf_1;
-
- expected_value =
- (i * edge_size * edge_size * edge_size * edge_size) +
- (j * edge_size * edge_size * edge_size) +
- (k * edge_size * edge_size) +
- (l * edge_size);
-
- start_index = mpi_rank * small_ds_slice_size;
- stop_index = start_index + small_ds_slice_size - 1;
-
- HDassert( 0 <= start_index );
- HDassert( start_index < stop_index );
- HDassert( stop_index <= (int)small_ds_size );
-
- for ( n = 0; n < (int)small_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++;
- }
-
- VRFY((mis_match == FALSE),
- "small slice write from large ds data good.");
-
- l++;
-
- } 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 ) );
-
-
- /* 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.
- */
-
- /* select the slice of the in memory small data set associated with
- * the process's mpi rank.
- */
- start[0] = mpi_rank;
- stride[0] = 2 * (mpi_size + 1);
- count[0] = 1;
- block[0] = 1;
-
- for ( i = 1; i < large_rank; i++ ) {
-
- start[i] = 0;
- stride[i] = 2 * edge_size;
- count[i] = 1;
- block[i] = edge_size;
- }
-
- 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");
-
-
- /* set up start, stride, count, and block -- note that we will
- * change start[] so as to write slices of the small data set to
- * slices of the large data set.
- */
- for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
-
- start[i] = 0;
- stride[i] = 2 * edge_size;
- count[i] = 1;
- if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
-
- block[i] = 1;
-
- } else {
-
- block[i] = edge_size;
- }
- }
-
- /* zero out the in memory large ds */
- HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
-
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
- HDfprintf(stdout,
- "%s writing process slices of small ds to slices of large ds on disk.\n",
- fcnName);
-#endif
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
-
- i = mpi_rank;
-
- } else {
-
- i = 0;
- }
-
- /* since large_rank is at most PAR_SS_DR_MAX_RANK, no need to
- * loop over it -- either we are setting i to mpi_rank, or
- * we are setting it to zero. It will not change during the
- * test.
- */
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
-
- j = mpi_rank;
-
- } else {
-
- j = 0;
- }
-
- do {
- if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
-
- k = mpi_rank;
-
- } else {
-
- k = 0;
- }
-
- do {
- /* since small rank >= 2 and large_rank > small_rank, we
- * have large_rank >= 3. Since PAR_SS_DR_MAX_RANK == 5
- * (baring major re-orgaization), this gives us:
- *
- * (PAR_SS_DR_MAX_RANK - large_rank) <= 2
- *
- * so no need to repeat the test in the outer loops --
- * just set l = 0.
- */
-
- 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] = i;
- start[1] = j;
- start[2] = k;
- start[3] = 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");
-
-
- /* 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");
-
-
- /* verify that the expected data and only the
- * expected data was read.
- */
- ptr_1 = large_ds_buf_1;
- expected_value = (uint32_t)(mpi_rank) * small_ds_slice_size;
-
-
- start_index = (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 + (int)small_ds_slice_size - 1;
-
- HDassert( 0 <= start_index );
- HDassert( start_index < stop_index );
- HDassert( stop_index < (int)large_ds_size );
-
- for ( n = 0; n < (int)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 buffer for next test */
- *ptr_1 = 0;
- ptr_1++;
- }
-
- VRFY((mis_match == FALSE),
- "small ds slice write to large ds slice data good.");
-
- l++;
-
- } 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 ) );
-
-
- /* Close dataspaces */
- ret = H5Sclose(full_mem_small_ds_sid);
- VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded");
-
- 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");
-
- ret = H5Sclose(file_small_ds_sid);
- VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid) succeeded");
-
- ret = H5Sclose(small_ds_slice_sid);
- VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded");
-
- ret = H5Sclose(full_mem_large_ds_sid);
- VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded");
-
- 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");
-
- ret = H5Sclose(file_large_ds_sid);
- VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded");
-
- 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");
-
- ret = H5Sclose(large_ds_slice_sid);
- VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded");
-
-
- /* Close Datasets */
- ret = H5Dclose(small_dataset);
- VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
-
- ret = H5Dclose(large_dataset);
- VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded");
-
-
- /* close the file collectively */
- MESG("about to close file.");
- ret = H5Fclose(fid);
- VRFY((ret != FAIL), "file close succeeded");
-
- /* 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);
-
- return;
-
-} /* contig_hyperslab_dr_pio_test__run_test() */
-
-
-/*-------------------------------------------------------------------------
- * Function: contig_hyperslab_dr_pio_test()
- *
- * Purpose: Test I/O to/from hyperslab selections of different rank in
- * the parallel case.
- *
- * Return: void
- *
- * Programmer: JRM -- 9/18/09
- *
- * Modifications:
- *
- * Modified function to take a sample of the run times
- * of the different tests, and skip some of them if
- * run times are too long.
- *
- * We need to do this because Lustre runns very slowly
- * if two or more processes are banging on the same
- * block of memory.
- * JRM -- 9/10/10
- *
- *-------------------------------------------------------------------------
- */
-
-void
-contig_hyperslab_dr_pio_test(void)
-{
- 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 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;
-
- MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
- MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
-#endif /* H5_HAVE_GETTIMEOFDAY */
-
- HDcompile_assert(sizeof(uint32_t) == sizeof(unsigned));
-
- local_express_test = GetTestExpress();
-
- mpi_result = MPI_Allreduce((void *)&local_express_test,
- (void *)&express_test,
- 1,
- MPI_INT,
- MPI_MAX,
- MPI_COMM_WORLD);
-
- VRFY((mpi_result == MPI_SUCCESS ), "MPI_Allreduce(0) succeeded");
-
- for ( large_rank = 3; large_rank <= PAR_SS_DR_MAX_RANK; large_rank++ ) {
-
- for ( small_rank = 2; small_rank < large_rank; small_rank++ ) {
-
- chunk_edge_size = 0;
-
- /* contiguous data set, independent I/O */
- if ( skip_counters[ind_contig_idx] < skips[ind_contig_idx] ) {
-
- skip_counters[ind_contig_idx]++;
- tests_skiped[ind_contig_idx]++;
-
- } 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,
- 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++;
-
- /* contiguous data set, collective I/O */
- if ( skip_counters[col_contig_idx] < skips[col_contig_idx] ) {
-
- skip_counters[col_contig_idx]++;
- tests_skiped[col_contig_idx]++;
-
- } 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,
- 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++;
-
- chunk_edge_size = 5;
-
- /* chunked data set, independent I/O */
- if ( skip_counters[ind_chunked_idx] < skips[ind_chunked_idx] ) {
-
- skip_counters[ind_chunked_idx]++;
- tests_skiped[ind_chunked_idx]++;
-
- } 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,
- 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++;
-
- /* chunked data set, collective I/O */
- if ( skip_counters[col_chunked_idx] < skips[col_chunked_idx] ) {
-
- skip_counters[col_chunked_idx]++;
- tests_skiped[col_chunked_idx]++;
-
- } 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,
- 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++;
-
-#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");
- }
- }
-#endif /* H5_HAVE_GETTIMEOFDAY */
-
- }
- }
-
-#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");
- }
-#endif /* H5_HAVE_GETTIMEOFDAY */
-
- return;
-
-} /* contig_hyperslab_dr_pio_test() */
-
-
-/****************************************************************
-**
-** checker_board_hyperslab_dr_pio_test__select_checker_board():
-** Given a data space of tgt_rank, and dimensions:
-**
-** (mpi_size + 1), edge_size, ... , edge_size
-**
-** edge_size, and a checker_edge_size, select a checker
-** board selection of a sel_rank (sel_rank < tgt_rank)
-** dimensional slice through the data space parallel to the
-** sel_rank fastest changing indicies, with origin (in the
-** higher indicies) as indicated by the start array.
-**
-** Note that this function, like all its relatives, is
-** hard coded to presume a maximum data space rank of 5.
-** 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
-**
-****************************************************************/
-
-#define CHECKER_BOARD_HYPERSLAB_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[])
-{
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG
- const char * fcnName =
- "checker_board_hyperslab_dr_pio_test__select_checker_board():";
-#endif
- 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 */
- /* this changes */
- 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 */
-
- HDassert( edge_size >= 6 );
- HDassert( 0 < checker_edge_size );
- HDassert( checker_edge_size <= edge_size );
- HDassert( 0 < sel_rank );
- HDassert( sel_rank <= tgt_rank );
- HDassert( tgt_rank <= test_max_rank );
- HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK );
-
- sel_offset = test_max_rank - sel_rank;
- HDassert( sel_offset >= 0 );
-
- n_cube_offset = test_max_rank - tgt_rank;
- HDassert( n_cube_offset >= 0 );
- HDassert( n_cube_offset <= sel_offset );
-
-#if CHECKER_BOARD_HYPERSLAB_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 */
-
- /* First, compute the base count (which assumes start == 0
- * for the associated offset) and offset_count (which
- * assumes start == checker_edge_size for the associated
- * offset).
- *
- * Note that the following computation depends on the C99
- * requirement that integer division discard any fraction
- * (truncation towards zero) to function correctly. As we
- * now require C99, this shouldn't be a problem, but noting
- * it may save us some pain if we are ever obliged to support
- * pre-C99 compilers again.
- */
-
- base_count = edge_size / (checker_edge_size * 2);
-
- if ( (edge_size % (checker_edge_size * 2)) > 0 ) {
-
- base_count++;
- }
-
- offset_count = (edge_size - checker_edge_size) / (checker_edge_size * 2);
-
- if ( ((edge_size - checker_edge_size) % (checker_edge_size * 2)) > 0 ) {
-
- offset_count++;
- }
-
- /* Now set up the stride and block arrays, and portions of the start
- * and count arrays that will not be altered during the selection of
- * the checker board.
- */
- i = 0;
- while ( i < n_cube_offset ) {
-
- /* these values should never be used */
- start[i] = 0;
- stride[i] = 0;
- count[i] = 0;
- block[i] = 0;
-
- i++;
- }
-
- while ( i < sel_offset ) {
-
- start[i] = sel_start[i];
- stride[i] = 2 * edge_size;
- count[i] = 1;
- block[i] = 1;
-
- i++;
- }
-
- while ( i < test_max_rank ) {
-
- stride[i] = 2 * checker_edge_size;
- block[i] = checker_edge_size;
-
- i++;
- }
-
- i = 0;
- do {
- if ( 0 >= sel_offset ) {
-
- if ( i == 0 ) {
-
- start[0] = 0;
- count[0] = base_count;
-
- } else {
-
- start[0] = checker_edge_size;
- count[0] = offset_count;
-
- }
- }
-
- j = 0;
- do {
- if ( 1 >= sel_offset ) {
-
- if ( j == 0 ) {
-
- start[1] = 0;
- count[1] = base_count;
-
- } else {
-
- start[1] = checker_edge_size;
- count[1] = offset_count;
-
- }
- }
-
- k = 0;
- do {
- if ( 2 >= sel_offset ) {
-
- if ( k == 0 ) {
-
- start[2] = 0;
- count[2] = base_count;
-
- } else {
-
- start[2] = checker_edge_size;
- count[2] = offset_count;
-
- }
- }
-
- l = 0;
- do {
- if ( 3 >= sel_offset ) {
-
- if ( l == 0 ) {
-
- start[3] = 0;
- count[3] = base_count;
-
- } else {
-
- start[3] = checker_edge_size;
- count[3] = offset_count;
-
- }
- }
-
- m = 0;
- do {
- if ( 4 >= sel_offset ) {
-
- if ( m == 0 ) {
-
- start[4] = 0;
- count[4] = base_count;
-
- } else {
-
- start[4] = checker_edge_size;
- count[4] = offset_count;
-
- }
- }
-
- if ( ((i + j + k + l + m) % 2) == 0 ) {
-
-#if CHECKER_BOARD_HYPERSLAB_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",
- fcnName, mpi_rank, i, j, k, l, m);
- HDfprintf(stdout,
- "%s:%d: start = %d %d %d %d %d.\n",
- fcnName, mpi_rank, (int)start[0], (int)start[1],
- (int)start[2], (int)start[3], (int)start[4]);
- HDfprintf(stdout,
- "%s:%d: stride = %d %d %d %d %d.\n",
- fcnName, mpi_rank, (int)stride[0], (int)stride[1],
- (int)stride[2], (int)stride[3], (int)stride[4]);
- HDfprintf(stdout,
- "%s:%d: count = %d %d %d %d %d.\n",
- fcnName, mpi_rank, (int)count[0], (int)count[1],
- (int)count[2], (int)count[3], (int)count[4]);
- HDfprintf(stdout,
- "%s:%d: block = %d %d %d %d %d.\n",
- fcnName, mpi_rank, (int)block[0], (int)block[1],
- (int)block[2], (int)block[3], (int)block[4]);
- HDfprintf(stdout, "%s:%d: n-cube extent dims = %d.\n",
- fcnName, mpi_rank,
- H5Sget_simple_extent_ndims(tgt_sid));
- HDfprintf(stdout, "%s:%d: selection rank = %d.\n",
- fcnName, mpi_rank, sel_rank);
-#endif
-
- if ( first_selection ) {
-
- first_selection = FALSE;
-
- ret = H5Sselect_hyperslab
- (
- tgt_sid,
- H5S_SELECT_SET,
- &(start[n_cube_offset]),
- &(stride[n_cube_offset]),
- &(count[n_cube_offset]),
- &(block[n_cube_offset])
- );
-
- VRFY((ret != FAIL), "H5Sselect_hyperslab(SET) succeeded");
-
- } else {
-
- ret = H5Sselect_hyperslab
- (
- tgt_sid,
- H5S_SELECT_OR,
- &(start[n_cube_offset]),
- &(stride[n_cube_offset]),
- &(count[n_cube_offset]),
- &(block[n_cube_offset])
- );
-
- VRFY((ret != FAIL), "H5Sselect_hyperslab(OR) succeeded");
-
- }
- }
-
- m++;
-
- } while ( ( m <= 1 ) &&
- ( 4 >= sel_offset ) );
-
- l++;
-
- } while ( ( l <= 1 ) &&
- ( 3 >= sel_offset ) );
-
- k++;
-
- } while ( ( k <= 1 ) &&
- ( 2 >= sel_offset ) );
-
- j++;
-
- } while ( ( j <= 1 ) &&
- ( 1 >= sel_offset ) );
-
-
- i++;
-
- } while ( ( i <= 1 ) &&
- ( 0 >= sel_offset ) );
-
-#if CHECKER_BOARD_HYPERSLAB_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 */
-
- /* Clip the selection back to the data space proper. */
-
- for ( i = 0; i < test_max_rank; i++ ) {
-
- start[i] = 0;
- stride[i] = edge_size;
- count[i] = 1;
- block[i] = edge_size;
- }
-
- ret = H5Sselect_hyperslab(tgt_sid, H5S_SELECT_AND,
- start, stride, count, block);
-
- VRFY((ret != FAIL), "H5Sselect_hyperslab(AND) succeeded");
-
-#if CHECKER_BOARD_HYPERSLAB_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 */
-
- return;
-
-} /* checker_board_hyperslab_dr_pio_test__select_checker_board() */
-
-
-/****************************************************************
-**
-** checker_board_hyperslab_dr_pio_test__verify_data():
-**
-** 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.
-**
-** 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.
-**
-** 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.
-**
-** 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:
-**
-** (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:
-**
-** 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.
-**
-** 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
-
-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)
-{
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG
- const char * fcnName =
- "checker_board_hyperslab_dr_pio_test__verify_data():";
-#endif
- hbool_t good_data = TRUE;
- hbool_t in_checker;
- hbool_t start_in_checker[5];
- uint32_t expected_value;
- uint32_t * val_ptr;
- int i, j, k, l, m; /* to track position in n-cube */
- int v, w, x, y, z; /* to track position in checker */
- const int test_max_rank = 5; /* code changes needed if this is increased */
-
- HDassert( buf_ptr != NULL );
- HDassert( 0 < rank );
- HDassert( rank <= test_max_rank );
- HDassert( edge_size >= 6 );
- HDassert( 0 < checker_edge_size );
- 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
-
- int mpi_rank;
-
- MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
- HDfprintf(stdout, "%s mpi_rank = %d.\n", fcnName, mpi_rank);
- HDfprintf(stdout, "%s rank = %d.\n", fcnName, rank);
- HDfprintf(stdout, "%s edge_size = %d.\n", fcnName, edge_size);
- HDfprintf(stdout, "%s checker_edge_size = %d.\n", fcnName, checker_edge_size);
- HDfprintf(stdout, "%s first_expected_val = %d.\n", fcnName, (int)first_expected_val);
- HDfprintf(stdout, "%s starts_in_checker = %d.\n", fcnName, (int)buf_starts_in_checker);
-}
-#endif
-
- val_ptr = buf_ptr;
- expected_value = first_expected_val;
-
- i = 0;
- v = 0;
- start_in_checker[0] = buf_starts_in_checker;
- do
- {
- if ( v >= checker_edge_size ) {
-
- start_in_checker[0] = ! start_in_checker[0];
- v = 0;
- }
-
- j = 0;
- w = 0;
- start_in_checker[1] = start_in_checker[0];
- do
- {
- if ( w >= checker_edge_size ) {
-
- start_in_checker[1] = ! start_in_checker[1];
- w = 0;
- }
-
- k = 0;
- x = 0;
- start_in_checker[2] = start_in_checker[1];
- do
- {
- if ( x >= checker_edge_size ) {
-
- start_in_checker[2] = ! start_in_checker[2];
- x = 0;
- }
-
- l = 0;
- y = 0;
- start_in_checker[3] = start_in_checker[2];
- do
- {
- if ( y >= checker_edge_size ) {
-
- start_in_checker[3] = ! start_in_checker[3];
- y = 0;
- }
-
- m = 0;
- z = 0;
-#if CHECKER_BOARD_HYPERSLAB_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
- HDfprintf(stdout, " %d", (int)(*val_ptr));
-#endif
- if ( z >= checker_edge_size ) {
-
- in_checker = ! in_checker;
- z = 0;
- }
-
- if ( in_checker ) {
-
- if ( *val_ptr != expected_value ) {
-
- good_data = FALSE;
- }
-
- /* zero out buffer for re-use */
- *val_ptr = 0;
-
- } else if ( *val_ptr != 0 ) {
-
- good_data = FALSE;
-
- /* zero out buffer for re-use */
- *val_ptr = 0;
-
- }
-
- val_ptr++;
- expected_value++;
- m++;
- z++;
-
- } while ( ( rank >= (test_max_rank - 4) ) &&
- ( m < edge_size ) );
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG
- HDfprintf(stdout, "\n");
-#endif
- l++;
- y++;
- } while ( ( rank >= (test_max_rank - 3) ) &&
- ( l < edge_size ) );
- k++;
- x++;
- } while ( ( rank >= (test_max_rank - 2) ) &&
- ( k < edge_size ) );
- j++;
- w++;
- } while ( ( rank >= (test_max_rank - 1) ) &&
- ( j < edge_size ) );
- i++;
- v++;
- } while ( ( rank >= test_max_rank ) &&
- ( i < edge_size ) );
-
- return(good_data);
-
-} /* checker_board_hyperslab_dr_pio_test__verify_data() */
-
-
-/*-------------------------------------------------------------------------
- * Function: checker_board_hyperslab_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.
- *
- *-------------------------------------------------------------------------
- */
-
-#define PAR_SS_DR_MAX_RANK 5
-#define CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__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)
-{
-#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, n;
- int mrc;
- int start_index;
- int stop_index;
- int small_ds_offset;
- int large_ds_offset;
- const int test_max_rank = 5; /* must update code if this changes */
- uint32_t expected_value;
- uint32_t * small_ds_buf_0 = NULL;
- uint32_t * small_ds_buf_1 = NULL;
- uint32_t * small_ds_buf_2 = NULL;
- uint32_t * small_ds_slice_buf = NULL;
- uint32_t * large_ds_buf_0 = NULL;
- uint32_t * large_ds_buf_1 = NULL;
- uint32_t * large_ds_buf_2 = NULL;
- uint32_t * large_ds_slice_buf = NULL;
- uint32_t * ptr_0;
- uint32_t * ptr_1;
- uint32_t * ptr_2;
- 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];
- hsize_t sel_start[PAR_SS_DR_MAX_RANK];
- htri_t check; /* Shape comparison return value */
- herr_t ret; /* Generic return value */
-
- HDassert( edge_size >= 6 );
- HDassert( edge_size >= chunk_edge_size );
- HDassert( ( chunk_edge_size == 0 ) || ( chunk_edge_size >= 3 ) );
- HDassert( 1 < small_rank );
- HDassert( small_rank < large_rank );
- HDassert( large_rank <= test_max_rank );
- HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK );
-
- MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
- MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
-
- HDassert( mpi_size >= 1 );
-
- mpi_comm = MPI_COMM_WORLD;
- mpi_info = MPI_INFO_NULL;
-
- for ( i = 0; i < small_rank - 1; i++ )
- {
- small_ds_size *= (size_t)edge_size;
- small_ds_slice_size *= (size_t)edge_size;
- }
- small_ds_size *= (size_t)(mpi_size + 1);
-
- small_ds_offset = PAR_SS_DR_MAX_RANK - small_rank;
-
- HDassert( 0 < small_ds_offset );
- HDassert( small_ds_offset < PAR_SS_DR_MAX_RANK );
-
-
- for ( i = 0; i < large_rank - 1; i++ ) {
-
- large_ds_size *= (size_t)edge_size;
- large_ds_slice_size *= (size_t)edge_size;
- }
- large_ds_size *= (size_t)(mpi_size + 1);
-
- large_ds_offset = PAR_SS_DR_MAX_RANK - large_rank;
-
- HDassert( 0 <= large_ds_offset );
- HDassert( large_ds_offset < PAR_SS_DR_MAX_RANK );
-
-
- /* Allocate buffers */
- small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
- VRFY((small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded");
-
- small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
- VRFY((small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded");
-
- small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size);
- VRFY((small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded");
-
- small_ds_slice_buf =
- (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_slice_size);
- VRFY((small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded");
-
- large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
- VRFY((large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded");
-
- large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
- VRFY((large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded");
-
- large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size);
- VRFY((large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded");
-
- large_ds_slice_buf =
- (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_slice_size);
- VRFY((large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded");
-
- /* initialize the buffers */
-
- ptr_0 = small_ds_buf_0;
- for(i = 0; i < (int)small_ds_size; i++)
- *ptr_0++ = (uint32_t)i;
- HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
- HDmemset(small_ds_buf_2, 0, sizeof(uint32_t) * small_ds_size);
-
- HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
-
- ptr_0 = large_ds_buf_0;
- for(i = 0; i < (int)large_ds_size; i++)
- *ptr_0++ = (uint32_t)i;
- HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
- HDmemset(large_ds_buf_2, 0, sizeof(uint32_t) * large_ds_size);
-
- HDmemset(large_ds_slice_buf, 0, sizeof(uint32_t) * large_ds_slice_size);
-
- filename = (const char *)GetTestParameters();
- HDassert( filename != NULL );
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
- if ( MAINPROCESS ) {
-
- HDfprintf(stdout, "%s:%d: test num = %d.\n", fcnName, mpi_rank, test_num);
- HDfprintf(stdout, "%s:%d: mpi_size = %d.\n", fcnName, mpi_rank, mpi_size);
- HDfprintf(stdout,
- "%s:%d: small/large rank = %d/%d, use_collective_io = %d.\n",
- fcnName, mpi_rank, small_rank, large_rank, (int)use_collective_io);
- HDfprintf(stdout, "%s:%d: edge_size = %d, chunk_edge_size = %d.\n",
- fcnName, mpi_rank, edge_size, chunk_edge_size);
- HDfprintf(stdout, "%s:%d: checker_edge_size = %d.\n",
- fcnName, mpi_rank, checker_edge_size);
- HDfprintf(stdout, "%s:%d: small_ds_size = %d, large_ds_size = %d.\n",
- fcnName, mpi_rank, (int)small_ds_size, (int)large_ds_size);
- HDfprintf(stdout, "%s:%d: filename = %s.\n", fcnName, mpi_rank, filename);
- }
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */
-
- /* ----------------------------------------
- * CREATE AN HDF5 FILE WITH PARALLEL ACCESS
- * ---------------------------------------*/
- /* setup file access template */
- acc_tpl = create_faccess_plist(mpi_comm, mpi_info, facc_type, use_gpfs);
- VRFY((acc_tpl >= 0), "create_faccess_plist() succeeded");
-
- /* set the alignment -- need it large so that we aren't always hitting the
- * the same file system block. Do this only if express_test is greater
- * than zero.
- */
- if ( express_test > 0 ) {
-
- ret = H5Pset_alignment(acc_tpl, (hsize_t)0, SHAPE_SAME_TEST_ALIGNMENT);
- VRFY((ret != FAIL), "H5Pset_alignment() succeeded");
- }
-
- /* create the file collectively */
- fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl);
- VRFY((fid >= 0), "H5Fcreate succeeded");
-
- MESG("File opened.");
-
- /* Release file-access template */
- ret = H5Pclose(acc_tpl);
- VRFY((ret >= 0), "H5Pclose(acc_tpl) succeeded");
-
-
- /* setup dims: */
- dims[0] = (int)(mpi_size + 1);
- dims[1] = dims[2] = dims[3] = dims[4] = 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] = 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] = mpi_rank;
- stride[0] = 2 * (mpi_size + 1);
- count[0] = 1;
- block[0] = 1;
-
- for ( i = 1; i < large_rank; i++ ) {
-
- start[i] = 0;
- stride[i] = 2 * edge_size;
- count[i] = 1;
- block[i] = 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] = 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] = 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] = 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.
- *
- * 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] = 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);
-
- /* zero out the buffer we will be reading into */
- HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size);
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__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));
- ptr_0++;
- }
- HDfprintf(stdout, "\n");
-#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__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] = 2 * edge_size;
- count[i] = 1;
- if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
-
- block[i] = 1;
-
- } else {
-
- block[i] = edge_size;
- }
- }
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__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 */
- /* 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
- * by its rank -- hence we set the most slowly changing index to
- * mpi_rank, and don't itterate over it.
- */
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
-
- i = mpi_rank;
-
- } else {
-
- i = 0;
- }
-
- /* since large_rank is at most PAR_SS_DR_MAX_RANK, no need to
- * loop over it -- either we are setting i to mpi_rank, or
- * we are setting it to zero. It will not change during the
- * test.
- */
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
-
- j = mpi_rank;
-
- } else {
-
- j = 0;
- }
-
- do {
- if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
-
- k = mpi_rank;
-
- } else {
-
- k = 0;
- }
-
- do {
- /* since small rank >= 2 and large_rank > small_rank, we
- * have large_rank >= 3. Since PAR_SS_DR_MAX_RANK == 5
- * (baring major re-orgaization), this gives us:
- *
- * (PAR_SS_DR_MAX_RANK - large_rank) <= 2
- *
- * so no need to repeat the test in the outer loops --
- * just set l = 0.
- */
-
- 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] = i;
- start[1] = j;
- start[2] = k;
- start[3] = 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), "H5Sread() 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
-
- /* 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 ) );
- k++;
- } while ( ( large_rank > 3 ) &&
- ( (small_rank - 1) <= 2 ) &&
- ( k < edge_size ) );
- j++;
- } while ( ( large_rank > 4 ) &&
- ( (small_rank - 1) <= 3 ) &&
- ( j < edge_size ) );
-
-
- /* 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.
- */
-
- sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
- sel_start[small_ds_offset] = 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);
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
- HDfprintf(stdout,
- "%s reading slices of on disk small data set into slices of big data set.\n",
- fcnName);
-#endif
-
- /* zero out the buffer we will be reading into */
- HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * 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
- * into different slices of the process slice of the large data
- * set.
- */
- for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
-
- start[i] = 0;
- stride[i] = 2 * edge_size;
- count[i] = 1;
- if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
-
- block[i] = 1;
-
- } else {
-
- block[i] = 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.
- *
- * However, in the parallel version, each process only works with that
- * slice of the large (and small) data set indicated by its rank -- hence
- * we set the most slowly changing index to mpi_rank, and don't itterate
- * over it.
- */
-
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
-
- i = mpi_rank;
-
- } else {
-
- i = 0;
- }
-
- /* since large_rank is at most PAR_SS_DR_MAX_RANK, no need to
- * loop over it -- either we are setting i to mpi_rank, or
- * we are setting it to zero. It will not change during the
- * test.
- */
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
-
- j = mpi_rank;
-
- } else {
-
- j = 0;
- }
-
- do {
- if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
-
- k = mpi_rank;
-
- } else {
-
- k = 0;
- }
-
- do {
- /* since small rank >= 2 and large_rank > small_rank, we
- * have large_rank >= 3. Since PAR_SS_DR_MAX_RANK == 5
- * (baring major re-orgaization), this gives us:
- *
- * (PAR_SS_DR_MAX_RANK - large_rank) <= 2
- *
- * so no need to repeat the test in the outer loops --
- * just set l = 0.
- */
-
- 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] = i;
- start[1] = j;
- start[2] = k;
- start[3] = 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), "H5Sread() 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 = mpi_rank * small_ds_slice_size;
- start_index =
- (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 + (int)small_ds_slice_size - 1;
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
-{
-int m;
- 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");
- n = 0;
- }
- }
- HDfprintf(stdout, "\n");
- fsync(stdout);
- ptr_1 = large_ds_buf_1;
-}
-#endif
-
- HDassert( 0 <= start_index );
- HDassert( start_index < stop_index );
- HDassert( stop_index <= (int)large_ds_size );
-
- for ( n = 0; n < (int)start_index; n++ ) {
-
- if ( *ptr_1 != 0 ) {
-
- data_ok = FALSE;
- }
-
- /* zero out the value for the next pass */
- *ptr_1 = 0;
-
- ptr_1++;
- }
-
- VRFY((data_ok == TRUE),
- "slice read from small to large ds data good(1).");
-
- data_ok = checker_board_hyperslab_dr_pio_test__verify_data
- (
- ptr_1,
- small_rank - 1,
- edge_size,
- checker_edge_size,
- expected_value,
- (hbool_t)TRUE
- );
-
- VRFY((data_ok == TRUE),
- "slice read from small to large ds data good(2).");
-
-
- ptr_1 = large_ds_buf_1 + stop_index + 1;
-
- for ( n = stop_index + 1; n < large_ds_size; n++ ) {
-
- if ( *ptr_1 != 0 ) {
-
- data_ok = FALSE;
- }
-
- /* zero out the value for the next pass */
- *ptr_1 = 0;
-
- *ptr_1++;
- }
-
- VRFY((data_ok == TRUE),
- "slice read from small to large ds data good(3).");
-
- l++;
-
- } 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 ) );
-
-
- /* 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.
- */
-
- start[0] = mpi_rank;
- stride[0] = 2 * (mpi_size + 1);
- count[0] = 1;
- block[0] = 1;
-
- for ( i = 1; i < large_rank; i++ ) {
-
- start[i] = 0;
- stride[i] = 2 * edge_size;
- count[i] = 1;
- block[i] = edge_size;
- }
-
- 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");
-
- 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");
-
-
- sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0;
- sel_start[small_ds_offset] = 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);
-
-
- /* 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] = 2 * edge_size;
- count[i] = 1;
- if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
-
- block[i] = 1;
-
- } else {
-
- block[i] = edge_size;
- }
- }
-
- /* zero out the in memory small ds */
- HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size);
-
-
-#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
- HDfprintf(stdout,
- "%s writing checker boards selections of slices from big ds to slices of small ds on disk.\n",
- fcnName);
-#endif
-
- /* 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.
- *
- * However, in the parallel version, each process only works with that
- * slice of the large (and small) data set indicated by its rank -- hence
- * we set the most slowly changing index to mpi_rank, and don't itterate
- * over it.
- */
-
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
-
- i = mpi_rank;
-
- } else {
-
- i = 0;
- }
-
- /* since large_rank is at most PAR_SS_DR_MAX_RANK, no need to
- * loop over it -- either we are setting i to mpi_rank, or
- * we are setting it to zero. It will not change during the
- * test.
- */
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
-
- j = mpi_rank;
-
- } else {
-
- j = 0;
- }
-
- j = 0;
- do {
- if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
-
- k = mpi_rank;
-
- } else {
-
- k = 0;
- }
-
- do {
- /* since small rank >= 2 and large_rank > small_rank, we
- * have large_rank >= 3. Since PAR_SS_DR_MAX_RANK == 5
- * (baring major re-orgaization), this gives us:
- *
- * (PAR_SS_DR_MAX_RANK - large_rank) <= 2
- *
- * so no need to repeat the test in the outer loops --
- * just set l = 0.
- */
-
- 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] = i;
- start[1] = j;
- start[2] = k;
- start[3] = 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.");
-
-
- /* 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.");
-
-
- /* verify that expected data is retrieved */
-
- mis_match = FALSE;
- ptr_1 = small_ds_buf_1;
-
- expected_value =
- (i * edge_size * edge_size * edge_size * edge_size) +
- (j * edge_size * edge_size * edge_size) +
- (k * edge_size * edge_size) +
- (l * edge_size);
-
- start_index = mpi_rank * small_ds_slice_size;
- stop_index = start_index + small_ds_slice_size - 1;
-
- HDassert( 0 <= start_index );
- HDassert( start_index < stop_index );
- HDassert( stop_index <= (int)small_ds_size );
-
- data_ok = TRUE;
-
- for ( n = 0; n < start_index; n++ ) {
-
- if ( *(ptr_1 + n) != 0 ) {
-
- data_ok = FALSE;
- *(ptr_1 + n) = 0;
- }
- }
-
- data_ok &= checker_board_hyperslab_dr_pio_test__verify_data
- (
- ptr_1 + start_index,
- small_rank - 1,
- edge_size,
- checker_edge_size,
- expected_value,
- (hbool_t)TRUE
- );
-
-
- for ( n = stop_index; n < small_ds_size; n++ ) {
-
- if ( *(ptr_1 + n) != 0 ) {
-
- data_ok = FALSE;
- *(ptr_1 + n) = 0;
- }
- }
-
- VRFY((data_ok == TRUE),
- "large slice write slice to small slice data good.");
-
- l++;
-
- } 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 ) );
-
-
- /* 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.
- */
-
- start[0] = mpi_rank;
- stride[0] = 2 * (mpi_size + 1);
- count[0] = 1;
- block[0] = 1;
-
- for ( i = 1; i < large_rank; i++ ) {
-
- start[i] = 0;
- stride[i] = 2 * edge_size;
- count[i] = 1;
- block[i] = edge_size;
- }
-
- 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");
-
- ret = H5Sselect_hyperslab(mem_large_ds_sid,
- H5S_SELECT_SET,
- start,
- stride,
- count,
- block);
- VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_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] = 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);
-
- /* set up start, stride, count, and block -- note that we will
- * change start[] so as to write checkerboard selections of slices
- * of the small data set to slices of the large data set.
- */
- for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) {
-
- start[i] = 0;
- stride[i] = 2 * edge_size;
- count[i] = 1;
- if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) {
-
- block[i] = 1;
-
- } else {
-
- block[i] = edge_size;
- }
- }
-
- /* zero out the in memory large ds */
- HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size);
-
-#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG
- HDfprintf(stdout,
- "%s writing process checkerboard selections of slices of small ds to process slices of large ds on disk.\n",
- fcnName);
-#endif
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) {
-
- i = mpi_rank;
-
- } else {
-
- i = 0;
- }
-
- /* since large_rank is at most PAR_SS_DR_MAX_RANK, no need to
- * loop over it -- either we are setting i to mpi_rank, or
- * we are setting it to zero. It will not change during the
- * test.
- */
-
- if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) {
-
- j = mpi_rank;
-
- } else {
-
- j = 0;
- }
-
- do {
- if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) {
-
- k = mpi_rank;
-
- } else {
-
- k = 0;
- }
-
- do {
- /* since small rank >= 2 and large_rank > small_rank, we
- * have large_rank >= 3. Since PAR_SS_DR_MAX_RANK == 5
- * (baring major re-orgaization), this gives us:
- *
- * (PAR_SS_DR_MAX_RANK - large_rank) <= 2
- *
- * so no need to repeat the test in the outer loops --
- * just set l = 0.
- */
-
- 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] = i;
- start[1] = j;
- start[2] = k;
- start[3] = 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");
-
-
- /* read this processes slice on the on disk large
- * data set into memory.
- */
-
- 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");
-
-
- /* verify that the expected data and only the
- * expected data was read.
- */
- ptr_1 = large_ds_buf_1;
- expected_value = (uint32_t)(mpi_rank) * small_ds_slice_size;
-
-
- start_index = (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 + (int)small_ds_slice_size - 1;
-
- HDassert( 0 <= start_index );
- HDassert( start_index < stop_index );
- HDassert( stop_index < (int)large_ds_size );
-
-
- mis_match = FALSE;
-
- data_ok = TRUE;
-
- for ( n = 0; n < start_index; n++ ) {
-
- if ( *(ptr_1 + n) != 0 ) {
-
- data_ok = FALSE;
- *(ptr_1 + n) = 0;
- }
- }
-
- data_ok &= checker_board_hyperslab_dr_pio_test__verify_data
- (
- ptr_1 + start_index,
- small_rank - 1,
- edge_size,
- checker_edge_size,
- expected_value,
- (hbool_t)TRUE
- );
-
-
- for ( n = stop_index; n < small_ds_size; n++ ) {
-
- if ( *(ptr_1 + n) != 0 ) {
-
- data_ok = FALSE;
- *(ptr_1 + n) = 0;
- }
- }
-
- VRFY((data_ok == TRUE),
- "small ds cb slice write to large ds slice data good.");
-
- l++;
-
- } 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 ) );
-
-
- /* Close dataspaces */
- ret = H5Sclose(full_mem_small_ds_sid);
- VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded");
-
- 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");
-
- ret = H5Sclose(file_small_ds_sid_0);
- VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_0) succeeded");
-
- ret = H5Sclose(file_small_ds_sid_1);
- VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_1) succeeded");
-
- ret = H5Sclose(small_ds_slice_sid);
- VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded");
-
- ret = H5Sclose(full_mem_large_ds_sid);
- VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded");
-
- 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");
-
- 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");
-
- 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");
-
- ret = H5Sclose(large_ds_slice_sid);
- VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded");
-
-
- /* Close Datasets */
- ret = H5Dclose(small_dataset);
- VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded");
-
- ret = H5Dclose(large_dataset);
- VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded");
-
-
- /* close the file collectively */
- MESG("about to close file.");
- ret = H5Fclose(fid);
- VRFY((ret != FAIL), "file close succeeded");
-
- /* 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);
-
- return;
-
-} /* checker_board_hyperslab_dr_pio_test__run_test() */
-
-
-/*-------------------------------------------------------------------------
- * Function: checker_board_hyperslab_dr_pio_test()
- *
- * Purpose: Test I/O to/from hyperslab selections of different rank in
- * the parallel case.
- *
- * Return: void
- *
- * Programmer: JRM -- 9/18/09
- *
- * Modifications:
- *
- * Modified function to take a sample of the run times
- * of the different tests, and skip some of them if
- * run times are too long.
- *
- * We need to do this because Lustre runns very slowly
- * if two or more processes are banging on the same
- * block of memory.
- * JRM -- 9/10/10
- *
- *-------------------------------------------------------------------------
- */
-
-void
-checker_board_hyperslab_dr_pio_test(void)
-{
- int test_num = 0;
- int edge_size = 10;
- int checker_edge_size = 3;
- int chunk_edge_size = 0;
- int small_rank = 3;
- int large_rank = 4;
- int skips[4] = {0, 0, 0, 0};
- int skip_counters[4] = {0, 0, 0, 0};
- int tests_skiped[4] = {0, 0, 0, 0};
- int mpi_result;
- hid_t dset_type = H5T_NATIVE_UINT;
-#ifdef H5_HAVE_GETTIMEOFDAY
- hbool_t time_tests = TRUE;
- hbool_t display_skips = FALSE;
- int local_express_test;
- int express_test;
- int i;
- int samples = 0;
- int sample_size = 1;
- int mpi_size = -1;
- int mpi_rank = -1;
- int local_skips[4];
- const int ind_contig_idx = 0;
- const int col_contig_idx = 1;
- const int ind_chunked_idx = 2;
- const int col_chunked_idx = 3;
- const int test_types = 4;
- long long max_test_time = 3000000; /* for one test */
- long long sample_times[4] = {0, 0, 0, 0};
- struct timeval timeval_a;
- struct timeval timeval_b;
-
- MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
- MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
-#endif /* H5_HAVE_GETTIMEOFDAY */
-
- local_express_test = GetTestExpress();
-
- HDcompile_assert(sizeof(uint32_t) == sizeof(unsigned));
-
- mpi_result = MPI_Allreduce((void *)&local_express_test,
- (void *)&express_test,
- 1,
- MPI_INT,
- MPI_MAX,
- MPI_COMM_WORLD);
-
- VRFY((mpi_result == MPI_SUCCESS ), "MPI_Allreduce(0) succeeded");
-
-#if 0
- {
- int DebugWait = 1;
-
- while (DebugWait) ;
- }
-#endif
-
- for ( large_rank = 3; large_rank <= PAR_SS_DR_MAX_RANK; large_rank++ ) {
-
- for ( small_rank = 2; small_rank < large_rank; small_rank++ ) {
-
- chunk_edge_size = 0;
-
- /* contiguous data set, independent I/O */
- if ( skip_counters[ind_contig_idx] < skips[ind_contig_idx] ) {
-
- skip_counters[ind_contig_idx]++;
- tests_skiped[ind_contig_idx]++;
-
- } 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++;
-
- /* contiguous data set, collective I/O */
- if ( skip_counters[col_contig_idx] < skips[col_contig_idx] ) {
-
- skip_counters[col_contig_idx]++;
- tests_skiped[col_contig_idx]++;
-
- } else {
- skip_counters[col_contig_idx] = 0;
- START_TIMER(time_tests, timeval_a, "HDgettimeofday(2) succeeds.");
-
- checker_board_hyperslab_dr_pio_test__run_test(test_num,
- edge_size,
- checker_edge_size,
- chunk_edge_size,
- small_rank,
- large_rank,
- TRUE,
- dset_type,
- express_test);
- STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \
- "HDgettimeofday(3) succeeds.", \
- sample_times[col_contig_idx]);
-
- }
- test_num++;
-
- chunk_edge_size = 5;
-
- /* chunked data set, independent I/O */
- if ( skip_counters[ind_chunked_idx] < skips[ind_chunked_idx] ) {
-
- skip_counters[ind_chunked_idx]++;
- tests_skiped[ind_chunked_idx]++;
-
- } 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++;
-
-
- /* chunked data set, collective I/O */
- if ( skip_counters[col_chunked_idx] < skips[col_chunked_idx] ) {
-
- skip_counters[col_chunked_idx]++;
- tests_skiped[col_chunked_idx]++;
-
- } 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++;
-
-#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 */
-
- }
- }
-
-#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");
- }
-#endif /* H5_HAVE_GETTIMEOFDAY */
-
- return;
-
-} /* checker_board_hyperslab_dr_pio_test() */
-