diff options
| -rw-r--r-- | testpar/t_shapesame.c | 5301 |
1 files changed, 2765 insertions, 2536 deletions
diff --git a/testpar/t_shapesame.c b/testpar/t_shapesame.c index a62e4f9..7601587 100644 --- a/testpar/t_shapesame.c +++ b/testpar/t_shapesame.c @@ -29,47 +29,6 @@ #include "testphdf5.h" #include "H5Spkg.h" /* Dataspaces */ -/* The following macros are used in the detection of tests that run overlong -- - * so that tests can be ommitted if necessary to get the overall set of tests - * to complete. - * - * Observe that we can't do this if we don't have gettimeofday(), so in that - * case, the macros resolve to the empty string. - */ - -#ifdef H5_HAVE_GETTIMEOFDAY - -#define START_TIMER(time_tests, start_time, vrfy_msg) \ - { \ - int result; \ - if ( time_tests ) { \ - result = HDgettimeofday(&(start_time), NULL); \ - VRFY( (result == 0), (vrfy_msg)); \ - } \ - } - -#define STOP_TIMER_AND_UPDATE(time_tests, end_time, vrfy_msg, times) \ - { \ - int result; \ - long long delta_usecs; \ - if ( time_tests ) { \ - result = HDgettimeofday(&(end_time), NULL); \ - VRFY( (result == 0), (vrfy_msg)); \ - delta_usecs = \ - (1000000 * (timeval_b.tv_sec - timeval_a.tv_sec)) + \ - (timeval_b.tv_usec - timeval_a.tv_usec); \ - HDassert( delta_usecs >= 0L ); \ - (times) += delta_usecs; \ - } \ - } - -#else /* H5_HAVE_GETTIMEOFDAY */ - -#define START_TIMER(time_tests, start_time, vrfy_msg) - -#define STOP_TIMER_AND_UPDATE(time_tests, end_time, vrfy_msg, times) - -#endif /* H5_HAVE_GETTIMEOFDAY */ /* On Lustre (and perhaps other parallel file systems?), we have severe * slow downs if two or more processes attempt to access the same file system @@ -81,101 +40,116 @@ #define SHAPE_SAME_TEST_ALIGNMENT ((hsize_t)(4 * 1024 * 1024)) +#define PAR_SS_DR_MAX_RANK 5 /* must update code if this changes */ + +struct hs_dr_pio_test_vars_t +{ + int mpi_size; + int mpi_rank; + MPI_Comm mpi_comm; + MPI_Info mpi_info; + int test_num; + int edge_size; + int checker_edge_size; + int chunk_edge_size; + int small_rank; + int large_rank; + hid_t dset_type; + uint32_t * small_ds_buf_0; + uint32_t * small_ds_buf_1; + uint32_t * small_ds_buf_2; + uint32_t * small_ds_slice_buf; + uint32_t * large_ds_buf_0; + uint32_t * large_ds_buf_1; + uint32_t * large_ds_buf_2; + uint32_t * large_ds_slice_buf; + int small_ds_offset; + int large_ds_offset; + hid_t fid; /* HDF5 file ID */ + hid_t xfer_plist; + hid_t full_mem_small_ds_sid; + hid_t full_file_small_ds_sid; + hid_t mem_small_ds_sid; + hid_t file_small_ds_sid_0; + hid_t file_small_ds_sid_1; + hid_t small_ds_slice_sid; + hid_t full_mem_large_ds_sid; + hid_t full_file_large_ds_sid; + hid_t mem_large_ds_sid; + hid_t file_large_ds_sid_0; + hid_t file_large_ds_sid_1; + hid_t file_large_ds_process_slice_sid; + hid_t mem_large_ds_process_slice_sid; + hid_t large_ds_slice_sid; + hid_t small_dataset; /* Dataset ID */ + hid_t large_dataset; /* Dataset ID */ + size_t small_ds_size; + size_t small_ds_slice_size; + size_t large_ds_size; + size_t large_ds_slice_size; + hsize_t dims[PAR_SS_DR_MAX_RANK]; + hsize_t chunk_dims[PAR_SS_DR_MAX_RANK]; + hsize_t start[PAR_SS_DR_MAX_RANK]; + hsize_t stride[PAR_SS_DR_MAX_RANK]; + hsize_t count[PAR_SS_DR_MAX_RANK]; + hsize_t block[PAR_SS_DR_MAX_RANK]; + hsize_t * start_ptr; + hsize_t * stride_ptr; + hsize_t * count_ptr; + hsize_t * block_ptr; + int skips; + int max_skips; + int64_t total_tests; + int64_t tests_run; + int64_t tests_skipped; +}; + /*------------------------------------------------------------------------- - * Function: contig_hyperslab_dr_pio_test__run_test() + * Function: hs_dr_pio_test__setup() * - * Purpose: Test I/O to/from hyperslab selections of different rank in - * the parallel. + * Purpose: Do setup for tests of I/O to/from hyperslab selections of + * different rank in the parallel case. * * Return: void * - * Programmer: JRM -- 9/18/09 + * Programmer: JRM -- 8/9/11 * * Modifications: * - * JRM -- 9/16/10 - * Added express_test parameter. Use it to control whether - * we set up the chunks so that no chunk is shared between - * processes, and also whether we set an alignment when we - * create the test file. + * None. * *------------------------------------------------------------------------- */ -#define PAR_SS_DR_MAX_RANK 5 -#define CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 0 +#define CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG 0 static void -contig_hyperslab_dr_pio_test__run_test(const int test_num, - const int edge_size, - const int chunk_edge_size, - const int small_rank, - const int large_rank, - const hbool_t use_collective_io, - const hid_t dset_type, - const int express_test) +hs_dr_pio_test__setup(const int test_num, + const int edge_size, + const int checker_edge_size, + const int chunk_edge_size, + const int small_rank, + const int large_rank, + const hbool_t use_collective_io, + const hid_t dset_type, + const int express_test, + struct hs_dr_pio_test_vars_t * tv_ptr) { -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - const char *fcnName = "contig_hyperslab_dr_pio_test__run_test()"; -#endif /* CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ +#if CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG + const char *fcnName = "hs_dr_pio_test__setup()"; +#endif /* CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG */ const char *filename; hbool_t use_gpfs = FALSE; /* Use GPFS hints */ hbool_t mis_match = FALSE; - int i, j, k, l; - size_t n; + int i; int mrc; - int mpi_size = -1; - int mpi_rank = -1; - size_t start_index; - size_t stop_index; - const int test_max_rank = 5; /* must update code if this changes */ + int mpi_rank; /* needed by the VRFY macro */ uint32_t expected_value; - uint32_t * small_ds_buf_0 = NULL; - uint32_t * small_ds_buf_1 = NULL; - uint32_t * small_ds_buf_2 = NULL; - uint32_t * small_ds_slice_buf = NULL; - uint32_t * large_ds_buf_0 = NULL; - uint32_t * large_ds_buf_1 = NULL; - uint32_t * large_ds_buf_2 = NULL; - uint32_t * large_ds_slice_buf = NULL; uint32_t * ptr_0; uint32_t * ptr_1; - MPI_Comm mpi_comm = MPI_COMM_NULL; - MPI_Info mpi_info = MPI_INFO_NULL; - hid_t fid; /* HDF5 file ID */ hid_t acc_tpl; /* File access templates */ - hid_t xfer_plist = H5P_DEFAULT; - hid_t full_mem_small_ds_sid; - hid_t full_file_small_ds_sid; - hid_t mem_small_ds_sid; - hid_t file_small_ds_sid; - hid_t small_ds_slice_sid; - hid_t full_mem_large_ds_sid; - hid_t full_file_large_ds_sid; - hid_t mem_large_ds_sid; - hid_t file_large_ds_sid; - hid_t file_large_ds_process_slice_sid; - hid_t mem_large_ds_process_slice_sid; - hid_t large_ds_slice_sid; hid_t small_ds_dcpl_id = H5P_DEFAULT; hid_t large_ds_dcpl_id = H5P_DEFAULT; - hid_t small_dataset; /* Dataset ID */ - hid_t large_dataset; /* Dataset ID */ - size_t small_ds_size = 1; - size_t small_ds_slice_size = 1; - size_t large_ds_size = 1; - size_t large_ds_slice_size = 1; - hsize_t dims[PAR_SS_DR_MAX_RANK]; - hsize_t chunk_dims[PAR_SS_DR_MAX_RANK]; - hsize_t start[PAR_SS_DR_MAX_RANK]; - hsize_t stride[PAR_SS_DR_MAX_RANK]; - hsize_t count[PAR_SS_DR_MAX_RANK]; - hsize_t block[PAR_SS_DR_MAX_RANK]; - hsize_t * start_ptr = NULL; - hsize_t * stride_ptr = NULL; - hsize_t * count_ptr = NULL; - hsize_t * block_ptr = NULL; - htri_t check; /* Shape comparison return value */ herr_t ret; /* Generic return value */ HDassert( edge_size >= 6 ); @@ -183,107 +157,132 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, HDassert( ( chunk_edge_size == 0 ) || ( chunk_edge_size >= 3 ) ); HDassert( 1 < small_rank ); HDassert( small_rank < large_rank ); - HDassert( large_rank <= test_max_rank ); - HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK ); + HDassert( large_rank <= PAR_SS_DR_MAX_RANK ); - MPI_Comm_size(MPI_COMM_WORLD, &mpi_size); - MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); + tv_ptr->test_num = test_num; + tv_ptr->edge_size = edge_size; + tv_ptr->checker_edge_size = checker_edge_size; + tv_ptr->chunk_edge_size = chunk_edge_size; + tv_ptr->small_rank = small_rank; + tv_ptr->large_rank = large_rank; + tv_ptr->dset_type = dset_type; - HDassert( mpi_size >= 1 ); + MPI_Comm_size(MPI_COMM_WORLD, &(tv_ptr->mpi_size)); + MPI_Comm_rank(MPI_COMM_WORLD, &(tv_ptr->mpi_rank)); + /* the VRFY() macro needs the local variable mpi_rank -- set it up now */ + mpi_rank = tv_ptr->mpi_rank; - mpi_comm = MPI_COMM_WORLD; - mpi_info = MPI_INFO_NULL; + HDassert( tv_ptr->mpi_size >= 1 ); - for ( i = 0; i < small_rank - 1; i++ ) + tv_ptr->mpi_comm = MPI_COMM_WORLD; + tv_ptr->mpi_info = MPI_INFO_NULL; + + for ( i = 0; i < tv_ptr->small_rank - 1; i++ ) { - small_ds_size *= (size_t)edge_size; - small_ds_slice_size *= (size_t)edge_size; + tv_ptr->small_ds_size *= (size_t)(tv_ptr->edge_size); + tv_ptr->small_ds_slice_size *= (size_t)(tv_ptr->edge_size); } - small_ds_size *= (size_t)(mpi_size + 1); + tv_ptr->small_ds_size *= (size_t)(tv_ptr->mpi_size + 1); + + /* used by checker board tests only */ + tv_ptr->small_ds_offset = PAR_SS_DR_MAX_RANK - tv_ptr->small_rank; + HDassert( 0 < tv_ptr->small_ds_offset ); + HDassert( tv_ptr->small_ds_offset < PAR_SS_DR_MAX_RANK ); - for ( i = 0; i < large_rank - 1; i++ ) { + for ( i = 0; i < tv_ptr->large_rank - 1; i++ ) { - large_ds_size *= (size_t)edge_size; - large_ds_slice_size *= (size_t)edge_size; + tv_ptr->large_ds_size *= (size_t)(tv_ptr->edge_size); + tv_ptr->large_ds_slice_size *= (size_t)(tv_ptr->edge_size); } - large_ds_size *= (size_t)(mpi_size + 1); + tv_ptr->large_ds_size *= (size_t)(tv_ptr->mpi_size + 1); + + /* used by checker board tests only */ + tv_ptr->large_ds_offset = PAR_SS_DR_MAX_RANK - tv_ptr->large_rank; + + HDassert( 0 <= tv_ptr->large_ds_offset ); + HDassert( tv_ptr->large_ds_offset < PAR_SS_DR_MAX_RANK ); /* set up the start, stride, count, and block pointers */ - start_ptr = &(start[PAR_SS_DR_MAX_RANK - large_rank]); - stride_ptr = &(stride[PAR_SS_DR_MAX_RANK - large_rank]); - count_ptr = &(count[PAR_SS_DR_MAX_RANK - large_rank]); - block_ptr = &(block[PAR_SS_DR_MAX_RANK - large_rank]); + /* used by contiguous tests only */ + tv_ptr->start_ptr = &(tv_ptr->start[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]); + tv_ptr->stride_ptr = &(tv_ptr->stride[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]); + tv_ptr->count_ptr = &(tv_ptr->count[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]); + tv_ptr->block_ptr = &(tv_ptr->block[PAR_SS_DR_MAX_RANK - tv_ptr->large_rank]); /* Allocate buffers */ - small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size); - VRFY((small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded"); + tv_ptr->small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size); + VRFY((tv_ptr->small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded"); - small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size); - VRFY((small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded"); + tv_ptr->small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size); + VRFY((tv_ptr->small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded"); - small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size); - VRFY((small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded"); + tv_ptr->small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_size); + VRFY((tv_ptr->small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded"); - small_ds_slice_buf = - (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_slice_size); - VRFY((small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded"); + tv_ptr->small_ds_slice_buf = + (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->small_ds_slice_size); + VRFY((tv_ptr->small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded"); - large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size); - VRFY((large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded"); + tv_ptr->large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size); + VRFY((tv_ptr->large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded"); - large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size); - VRFY((large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded"); + tv_ptr->large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size); + VRFY((tv_ptr->large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded"); - large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size); - VRFY((large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded"); + tv_ptr->large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_size); + VRFY((tv_ptr->large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded"); - large_ds_slice_buf = - (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_slice_size); - VRFY((large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded"); + tv_ptr->large_ds_slice_buf = + (uint32_t *)HDmalloc(sizeof(uint32_t) * tv_ptr->large_ds_slice_size); + VRFY((tv_ptr->large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded"); /* initialize the buffers */ - ptr_0 = small_ds_buf_0; - for(i = 0; i < (int)small_ds_size; i++) + ptr_0 = tv_ptr->small_ds_buf_0; + for(i = 0; i < (int)(tv_ptr->small_ds_size); i++) *ptr_0++ = (uint32_t)i; - HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size); - HDmemset(small_ds_buf_2, 0, sizeof(uint32_t) * small_ds_size); + HDmemset(tv_ptr->small_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->small_ds_size); + HDmemset(tv_ptr->small_ds_buf_2, 0, sizeof(uint32_t) * tv_ptr->small_ds_size); - HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size); + HDmemset(tv_ptr->small_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->small_ds_slice_size); - ptr_0 = large_ds_buf_0; - for(i = 0; i < (int)large_ds_size; i++) + ptr_0 = tv_ptr->large_ds_buf_0; + for(i = 0; i < (int)(tv_ptr->large_ds_size); i++) *ptr_0++ = (uint32_t)i; - HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size); - HDmemset(large_ds_buf_2, 0, sizeof(uint32_t) * large_ds_size); + HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size); + HDmemset(tv_ptr->large_ds_buf_2, 0, sizeof(uint32_t) * tv_ptr->large_ds_size); - HDmemset(large_ds_slice_buf, 0, sizeof(uint32_t) * large_ds_slice_size); + HDmemset(tv_ptr->large_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->large_ds_slice_size); filename = (const char *)GetTestParameters(); HDassert( filename != NULL ); -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG +#if CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG if ( MAINPROCESS ) { - HDfprintf(stdout, "%d: test num = %d.\n", mpi_rank, test_num); - HDfprintf(stdout, "%d: mpi_size = %d.\n", mpi_rank, mpi_size); + HDfprintf(stdout, "%d: test num = %d.\n", tv_ptr->mpi_rank, tv_ptr->test_num); + HDfprintf(stdout, "%d: mpi_size = %d.\n", tv_ptr->mpi_rank, tv_ptr->mpi_size); HDfprintf(stdout, "%d: small/large rank = %d/%d, use_collective_io = %d.\n", - mpi_rank, small_rank, large_rank, (int)use_collective_io); + tv_ptr->mpi_rank, tv_ptr->small_rank, tv_ptr->large_rank, + (int)use_collective_io); HDfprintf(stdout, "%d: edge_size = %d, chunk_edge_size = %d.\n", - mpi_rank, edge_size, chunk_edge_size); + tv_ptr->mpi_rank, tv_ptr->edge_size, tv_ptr->chunk_edge_size); + HDfprintf(stdout, "%d: checker_edge_size = %d.\n", + tv_ptr->mpi_rank, tv_ptr->checker_edge_size); HDfprintf(stdout, "%d: small_ds_size = %d, large_ds_size = %d.\n", - mpi_rank, (int)small_ds_size, (int)large_ds_size); - HDfprintf(stdout, "%d: filename = %s.\n", mpi_rank, filename); + tv_ptr->mpi_rank, (int)(tv_ptr->small_ds_size), + (int)(tv_ptr->large_ds_size)); + HDfprintf(stdout, "%d: filename = %s.\n", tv_ptr->mpi_rank, filename); } -#endif +#endif /* CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG */ /* ---------------------------------------- * CREATE AN HDF5 FILE WITH PARALLEL ACCESS * ---------------------------------------*/ /* setup file access template */ - acc_tpl = create_faccess_plist(mpi_comm, mpi_info, facc_type, use_gpfs); + acc_tpl = create_faccess_plist(tv_ptr->mpi_comm, tv_ptr->mpi_info, facc_type, use_gpfs); VRFY((acc_tpl >= 0), "create_faccess_plist() succeeded"); /* set the alignment -- need it large so that we aren't always hitting the @@ -297,8 +296,8 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, } /* create the file collectively */ - fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl); - VRFY((fid >= 0), "H5Fcreate succeeded"); + tv_ptr->fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl); + VRFY((tv_ptr->fid >= 0), "H5Fcreate succeeded"); MESG("File opened."); @@ -308,60 +307,79 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, /* setup dims: */ - dims[0] = (hsize_t)(mpi_size + 1); - dims[1] = dims[2] = dims[3] = dims[4] = (hsize_t)edge_size; + tv_ptr->dims[0] = (hsize_t)(tv_ptr->mpi_size + 1); + tv_ptr->dims[1] = tv_ptr->dims[2] = + tv_ptr->dims[3] = tv_ptr->dims[4] = (hsize_t)(tv_ptr->edge_size); /* Create small ds dataspaces */ - full_mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL); - VRFY((full_mem_small_ds_sid != 0), + tv_ptr->full_mem_small_ds_sid = + H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->full_mem_small_ds_sid != 0), "H5Screate_simple() full_mem_small_ds_sid succeeded"); - full_file_small_ds_sid = H5Screate_simple(small_rank, dims, NULL); - VRFY((full_file_small_ds_sid != 0), + tv_ptr->full_file_small_ds_sid = + H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->full_file_small_ds_sid != 0), "H5Screate_simple() full_file_small_ds_sid succeeded"); - mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL); - VRFY((mem_small_ds_sid != 0), - "H5Screate_simple() mem_small_ds_sid succeeded"); + tv_ptr->mem_small_ds_sid = H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->mem_small_ds_sid != 0), + "H5Screate_simple() mem_small_ds_sid succeeded"); - file_small_ds_sid = H5Screate_simple(small_rank, dims, NULL); - VRFY((file_small_ds_sid != 0), - "H5Screate_simple() file_small_ds_sid succeeded"); + tv_ptr->file_small_ds_sid_0 = H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->file_small_ds_sid_0 != 0), + "H5Screate_simple() file_small_ds_sid_0 succeeded"); + + /* used by checker board tests only */ + tv_ptr->file_small_ds_sid_1 = H5Screate_simple(tv_ptr->small_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->file_small_ds_sid_1 != 0), + "H5Screate_simple() file_small_ds_sid_1 succeeded"); - small_ds_slice_sid = H5Screate_simple(small_rank - 1, &(dims[1]), NULL); - VRFY((small_ds_slice_sid != 0), + tv_ptr->small_ds_slice_sid = + H5Screate_simple(tv_ptr->small_rank - 1, &(tv_ptr->dims[1]), NULL); + VRFY((tv_ptr->small_ds_slice_sid != 0), "H5Screate_simple() small_ds_slice_sid succeeded"); /* Create large ds dataspaces */ - full_mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((full_mem_large_ds_sid != 0), + tv_ptr->full_mem_large_ds_sid = + H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->full_mem_large_ds_sid != 0), "H5Screate_simple() full_mem_large_ds_sid succeeded"); - full_file_large_ds_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((full_file_large_ds_sid != FAIL), + tv_ptr->full_file_large_ds_sid = + H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->full_file_large_ds_sid != FAIL), "H5Screate_simple() full_file_large_ds_sid succeeded"); - mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((mem_large_ds_sid != FAIL), + tv_ptr->mem_large_ds_sid = H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->mem_large_ds_sid != FAIL), "H5Screate_simple() mem_large_ds_sid succeeded"); - file_large_ds_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((file_large_ds_sid != FAIL), - "H5Screate_simple() file_large_ds_sid succeeded"); + tv_ptr->file_large_ds_sid_0 = H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->file_large_ds_sid_0 != FAIL), + "H5Screate_simple() file_large_ds_sid_0 succeeded"); - mem_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((mem_large_ds_process_slice_sid != FAIL), + /* used by checker board tests only */ + tv_ptr->file_large_ds_sid_1 = H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->file_large_ds_sid_1 != FAIL), + "H5Screate_simple() file_large_ds_sid_1 succeeded"); + + tv_ptr->mem_large_ds_process_slice_sid = + H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->mem_large_ds_process_slice_sid != FAIL), "H5Screate_simple() mem_large_ds_process_slice_sid succeeded"); - file_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((file_large_ds_process_slice_sid != FAIL), + tv_ptr->file_large_ds_process_slice_sid = + H5Screate_simple(tv_ptr->large_rank, tv_ptr->dims, NULL); + VRFY((tv_ptr->file_large_ds_process_slice_sid != FAIL), "H5Screate_simple() file_large_ds_process_slice_sid succeeded"); - large_ds_slice_sid = H5Screate_simple(large_rank - 1, &(dims[1]), NULL); - VRFY((large_ds_slice_sid != 0), + tv_ptr->large_ds_slice_sid = + H5Screate_simple(tv_ptr->large_rank - 1, &(tv_ptr->dims[1]), NULL); + VRFY((tv_ptr->large_ds_slice_sid != 0), "H5Screate_simple() large_ds_slice_sid succeeded"); @@ -369,10 +387,10 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, * large data set creation property lists to specify chunked * datasets. */ - if ( chunk_edge_size > 0 ) { + if ( tv_ptr->chunk_edge_size > 0 ) { /* Under Lustre (and perhaps other parallel file systems?) we get - * locking delays when two or more processes attempt to access the + * locking delays when two or more processes attempt to access the * same file system block. * * To minimize this problem, I have changed chunk_dims[0] @@ -390,14 +408,15 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, */ if ( express_test == 0 ) { - chunk_dims[0] = 1; + tv_ptr->chunk_dims[0] = 1; } else { - chunk_dims[0] = 1; + tv_ptr->chunk_dims[0] = 1; } - chunk_dims[1] = chunk_dims[2] = - chunk_dims[3] = chunk_dims[4] = (hsize_t)chunk_edge_size; + tv_ptr->chunk_dims[1] = tv_ptr->chunk_dims[2] = + tv_ptr->chunk_dims[3] = + tv_ptr->chunk_dims[4] = (hsize_t)(tv_ptr->chunk_edge_size); small_ds_dcpl_id = H5Pcreate(H5P_DATASET_CREATE); VRFY((ret != FAIL), "H5Pcreate() small_ds_dcpl_id succeeded"); @@ -405,7 +424,7 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, ret = H5Pset_layout(small_ds_dcpl_id, H5D_CHUNKED); VRFY((ret != FAIL), "H5Pset_layout() small_ds_dcpl_id succeeded"); - ret = H5Pset_chunk(small_ds_dcpl_id, small_rank, chunk_dims); + ret = H5Pset_chunk(small_ds_dcpl_id, tv_ptr->small_rank, tv_ptr->chunk_dims); VRFY((ret != FAIL), "H5Pset_chunk() small_ds_dcpl_id succeeded"); @@ -415,89 +434,88 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, ret = H5Pset_layout(large_ds_dcpl_id, H5D_CHUNKED); VRFY((ret != FAIL), "H5Pset_layout() large_ds_dcpl_id succeeded"); - ret = H5Pset_chunk(large_ds_dcpl_id, large_rank, chunk_dims); + ret = H5Pset_chunk(large_ds_dcpl_id, tv_ptr->large_rank, tv_ptr->chunk_dims); VRFY((ret != FAIL), "H5Pset_chunk() large_ds_dcpl_id succeeded"); } /* create the small dataset */ - small_dataset = H5Dcreate2(fid, "small_dataset", dset_type, - file_small_ds_sid, H5P_DEFAULT, - small_ds_dcpl_id, H5P_DEFAULT); + tv_ptr->small_dataset = H5Dcreate2(tv_ptr->fid, "small_dataset", tv_ptr->dset_type, + tv_ptr->file_small_ds_sid_0, H5P_DEFAULT, + small_ds_dcpl_id, H5P_DEFAULT); VRFY((ret != FAIL), "H5Dcreate2() small_dataset succeeded"); /* create the large dataset */ - large_dataset = H5Dcreate2(fid, "large_dataset", dset_type, - file_large_ds_sid, H5P_DEFAULT, - large_ds_dcpl_id, H5P_DEFAULT); + tv_ptr->large_dataset = H5Dcreate2(tv_ptr->fid, "large_dataset", tv_ptr->dset_type, + tv_ptr->file_large_ds_sid_0, H5P_DEFAULT, + large_ds_dcpl_id, H5P_DEFAULT); VRFY((ret != FAIL), "H5Dcreate2() large_dataset succeeded"); - /* setup xfer property list */ - xfer_plist = H5Pcreate(H5P_DATASET_XFER); - VRFY((xfer_plist >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded"); + tv_ptr->xfer_plist = H5Pcreate(H5P_DATASET_XFER); + VRFY((tv_ptr->xfer_plist >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded"); if(use_collective_io) { - ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE); + ret = H5Pset_dxpl_mpio(tv_ptr->xfer_plist, H5FD_MPIO_COLLECTIVE); VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded"); } /* setup selection to write initial data to the small and large data sets */ - start[0] = (hsize_t)mpi_rank; - stride[0] = (hsize_t)(2 * (mpi_size + 1)); - count[0] = 1; - block[0] = 1; + tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank); + tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1)); + tv_ptr->count[0] = 1; + tv_ptr->block[0] = 1; - for ( i = 1; i < large_rank; i++ ) { + for ( i = 1; i < tv_ptr->large_rank; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - block[i] = (hsize_t)edge_size; + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } /* setup selections for writing initial data to the small data set */ - ret = H5Sselect_hyperslab(mem_small_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid, H5S_SELECT_SET, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded"); - ret = H5Sselect_hyperslab(file_small_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0, H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded"); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); + VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded"); if ( MAINPROCESS ) { /* add an additional slice to the selections */ - start[0] = (hsize_t)mpi_size; + tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_size); - ret = H5Sselect_hyperslab(mem_small_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid, H5S_SELECT_OR, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret>= 0), "H5Sselect_hyperslab(mem_small_ds_sid, or) suceeded"); - ret = H5Sselect_hyperslab(file_small_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0, H5S_SELECT_OR, - start, - stride, - count, - block); - VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid, or) suceeded"); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); + VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, or) suceeded"); } /* write the initial value of the small data set to file */ - ret = H5Dwrite(small_dataset, dset_type, mem_small_ds_sid, file_small_ds_sid, - xfer_plist, small_ds_buf_0); + ret = H5Dwrite(tv_ptr->small_dataset, tv_ptr->dset_type, tv_ptr->mem_small_ds_sid, + tv_ptr->file_small_ds_sid_0, tv_ptr->xfer_plist, tv_ptr->small_ds_buf_0); VRFY((ret >= 0), "H5Dwrite() small_dataset initial write succeeded"); @@ -511,24 +529,24 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, /* read the small data set back to verify that it contains the * expected data. Note that each process reads in the entire - * data set. + * data set and verifies it. */ - ret = H5Dread(small_dataset, + ret = H5Dread(tv_ptr->small_dataset, H5T_NATIVE_UINT32, - full_mem_small_ds_sid, - full_file_small_ds_sid, - xfer_plist, - small_ds_buf_1); + tv_ptr->full_mem_small_ds_sid, + tv_ptr->full_file_small_ds_sid, + tv_ptr->xfer_plist, + tv_ptr->small_ds_buf_1); VRFY((ret >= 0), "H5Dread() small_dataset initial read succeeded"); /* verify that the correct data was written to the small data set */ expected_value = 0; mis_match = FALSE; - ptr_1 = small_ds_buf_1; + ptr_1 = tv_ptr->small_ds_buf_1; i = 0; - for ( i = 0; i < (int)small_ds_size; i++ ) { + for ( i = 0; i < (int)(tv_ptr->small_ds_size); i++ ) { if ( *ptr_1 != expected_value ) { @@ -540,72 +558,72 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, VRFY( (mis_match == FALSE), "small ds init data good."); - /* setup selections for writing initial data to the large data set */ - start[0] = (hsize_t)mpi_rank; + tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank); - ret = H5Sselect_hyperslab(mem_large_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid, H5S_SELECT_SET, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret >= 0), "H5Sselect_hyperslab(mem_large_ds_sid, set) suceeded"); - ret = H5Sselect_hyperslab(file_large_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0, H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid, set) suceeded"); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); + VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, set) suceeded"); /* In passing, setup the process slice data spaces as well */ - ret = H5Sselect_hyperslab(mem_large_ds_process_slice_sid, + ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_process_slice_sid, H5S_SELECT_SET, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret >= 0), "H5Sselect_hyperslab(mem_large_ds_process_slice_sid, set) suceeded"); - ret = H5Sselect_hyperslab(file_large_ds_process_slice_sid, + ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_process_slice_sid, H5S_SELECT_SET, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_process_slice_sid, set) suceeded"); if ( MAINPROCESS ) { /* add an additional slice to the selections */ - start[0] = (hsize_t)mpi_size; + tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_size); - ret = H5Sselect_hyperslab(mem_large_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid, H5S_SELECT_OR, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret>= 0), "H5Sselect_hyperslab(mem_large_ds_sid, or) suceeded"); - ret = H5Sselect_hyperslab(file_large_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0, H5S_SELECT_OR, - start, - stride, - count, - block); - VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid, or) suceeded"); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); + VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, or) suceeded"); } /* write the initial value of the large data set to file */ - ret = H5Dwrite(large_dataset, dset_type, mem_large_ds_sid, file_large_ds_sid, - xfer_plist, large_ds_buf_0); + ret = H5Dwrite(tv_ptr->large_dataset, tv_ptr->dset_type, + tv_ptr->mem_large_ds_sid, tv_ptr->file_large_ds_sid_0, + tv_ptr->xfer_plist, tv_ptr->large_ds_buf_0); if ( ret < 0 ) H5Eprint2(H5E_DEFAULT, stderr); VRFY((ret >= 0), "H5Dwrite() large_dataset initial write succeeded"); @@ -618,26 +636,26 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, } - /* read the small data set back to verify that it contains the + /* read the large data set back to verify that it contains the * expected data. Note that each process reads in the entire * data set. */ - ret = H5Dread(large_dataset, + ret = H5Dread(tv_ptr->large_dataset, H5T_NATIVE_UINT32, - full_mem_large_ds_sid, - full_file_large_ds_sid, - xfer_plist, - large_ds_buf_1); + tv_ptr->full_mem_large_ds_sid, + tv_ptr->full_file_large_ds_sid, + tv_ptr->xfer_plist, + tv_ptr->large_ds_buf_1); VRFY((ret >= 0), "H5Dread() large_dataset initial read succeeded"); /* verify that the correct data was written to the large data set */ expected_value = 0; mis_match = FALSE; - ptr_1 = large_ds_buf_1; + ptr_1 = tv_ptr->large_ds_buf_1; i = 0; - for ( i = 0; i < (int)large_ds_size; i++ ) { + for ( i = 0; i < (int)(tv_ptr->large_ds_size); i++ ) { if ( *ptr_1 != expected_value ) { @@ -657,18 +675,170 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, VRFY((mrc==MPI_SUCCESS), "Sync initial values check"); } + return; + +} /* hs_dr_pio_test__setup() */ + + +/*------------------------------------------------------------------------- + * Function: hs_dr_pio_test__takedown() + * + * Purpose: Do takedown after tests of I/O to/from hyperslab selections + * of different rank in the parallel case. + * + * Return: void + * + * Programmer: JRM -- 9/18/09 + * + * Modifications: + * + * None. + * + *------------------------------------------------------------------------- + */ + +#define HS_DR_PIO_TEST__TAKEDOWN__DEBUG 0 + +static void +hs_dr_pio_test__takedown( struct hs_dr_pio_test_vars_t * tv_ptr) +{ +#if HS_DR_PIO_TEST__TAKEDOWN__DEBUG + const char *fcnName = "hs_dr_pio_test__takedown()"; +#endif /* HS_DR_PIO_TEST__TAKEDOWN__DEBUG */ + int mpi_rank; /* needed by the VRFY macro */ + herr_t ret; /* Generic return value */ + + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; + + /* Close property lists */ + if ( tv_ptr->xfer_plist != H5P_DEFAULT ) { + ret = H5Pclose(tv_ptr->xfer_plist); + VRFY((ret != FAIL), "H5Pclose(xfer_plist) succeeded"); + } + + /* Close dataspaces */ + ret = H5Sclose(tv_ptr->full_mem_small_ds_sid); + VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded"); + + ret = H5Sclose(tv_ptr->full_file_small_ds_sid); + VRFY((ret != FAIL), "H5Sclose(full_file_small_ds_sid) succeeded"); + + ret = H5Sclose(tv_ptr->mem_small_ds_sid); + VRFY((ret != FAIL), "H5Sclose(mem_small_ds_sid) succeeded"); + + ret = H5Sclose(tv_ptr->file_small_ds_sid_0); + VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_0) succeeded"); + + ret = H5Sclose(tv_ptr->file_small_ds_sid_1); + VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_1) succeeded"); + + ret = H5Sclose(tv_ptr->small_ds_slice_sid); + VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded"); + + ret = H5Sclose(tv_ptr->full_mem_large_ds_sid); + VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded"); + + ret = H5Sclose(tv_ptr->full_file_large_ds_sid); + VRFY((ret != FAIL), "H5Sclose(full_file_large_ds_sid) succeeded"); + + ret = H5Sclose(tv_ptr->mem_large_ds_sid); + VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded"); + + ret = H5Sclose(tv_ptr->file_large_ds_sid_0); + VRFY((ret != FAIL), "H5Sclose(file_large_ds_sid_0) succeeded"); + + ret = H5Sclose(tv_ptr->file_large_ds_sid_1); + VRFY((ret != FAIL), "H5Sclose(file_large_ds_sid_1) succeeded"); + + ret = H5Sclose(tv_ptr->mem_large_ds_process_slice_sid); + VRFY((ret != FAIL), "H5Sclose(mem_large_ds_process_slice_sid) succeeded"); + + ret = H5Sclose(tv_ptr->file_large_ds_process_slice_sid); + VRFY((ret != FAIL), "H5Sclose(file_large_ds_process_slice_sid) succeeded"); + + ret = H5Sclose(tv_ptr->large_ds_slice_sid); + VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded"); + + /* Close Datasets */ + ret = H5Dclose(tv_ptr->small_dataset); + VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded"); + + ret = H5Dclose(tv_ptr->large_dataset); + VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded"); + + /* close the file collectively */ + MESG("about to close file."); + ret = H5Fclose(tv_ptr->fid); + VRFY((ret != FAIL), "file close succeeded"); + + /* Free memory buffers */ + + if ( tv_ptr->small_ds_buf_0 != NULL ) HDfree(tv_ptr->small_ds_buf_0); + if ( tv_ptr->small_ds_buf_1 != NULL ) HDfree(tv_ptr->small_ds_buf_1); + if ( tv_ptr->small_ds_buf_2 != NULL ) HDfree(tv_ptr->small_ds_buf_2); + if ( tv_ptr->small_ds_slice_buf != NULL ) HDfree(tv_ptr->small_ds_slice_buf); + + if ( tv_ptr->large_ds_buf_0 != NULL ) HDfree(tv_ptr->large_ds_buf_0); + if ( tv_ptr->large_ds_buf_1 != NULL ) HDfree(tv_ptr->large_ds_buf_1); + if ( tv_ptr->large_ds_buf_2 != NULL ) HDfree(tv_ptr->large_ds_buf_2); + if ( tv_ptr->large_ds_slice_buf != NULL ) HDfree(tv_ptr->large_ds_slice_buf); + + return; + +} /* hs_dr_pio_test__takedown() */ + + +/*------------------------------------------------------------------------- + * Function: contig_hs_dr_pio_test__d2m_l2s() + * + * Purpose: Part one of a series of tests of I/O to/from hyperslab + * selections of different rank in the parallel. + * + * Verify that we can read from disk correctly using + * selections of different rank that H5S_select_shape_same() + * views as being of the same shape. + * + * In this function, we test this by reading small_rank - 1 + * slices from the on disk large cube, and verifying that the + * data read is correct. Verify that H5S_select_shape_same() + * returns true on the memory and file selections. + * + * Return: void + * + * Programmer: JRM -- 9/10/11 + * + * Modifications: + * + * None. + * + *------------------------------------------------------------------------- + */ + +#define CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG 0 + +static void +contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr) +{ +#if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG + const char *fcnName = "contig_hs_dr_pio_test__run_test()"; +#endif /* CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ + hbool_t mis_match = FALSE; + int i, j, k, l; + size_t n; + int mpi_rank; /* needed by the VRFY macro */ + uint32_t expected_value; + uint32_t * ptr_1; + htri_t check; /* Shape comparison return value */ + herr_t ret; /* Generic return value */ + + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; - /* first, verify that we can read from disk correctly using selections - * of different rank that H5S_select_shape_same() views as being of the - * same shape. - * - * Start by reading small_rank-D - 1 slice from the on disk large cube, - * and verifying that the data read is correct. Verify that - * H5S_select_shape_same() returns true on the memory and file selections. - */ /* We have already done a H5Sselect_all() on the data space - * small_ds_slice_sid, so no need to call H5Sselect_all() again. + * small_ds_slice_sid in the initialization phase, so no need to + * call H5Sselect_all() again. */ /* set up start, stride, count, and block -- note that we will @@ -676,27 +846,28 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, */ for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) { + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) { - block[i] = 1; + tv_ptr->block[i] = 1; } else { - block[i] = (hsize_t)edge_size; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } } /* zero out the buffer we will be reading into */ - HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size); + HDmemset(tv_ptr->small_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->small_ds_slice_size); -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG +#if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG HDfprintf(stdout, "%s reading slices from big cube on disk into small cube slice.\n", fcnName); -#endif +#endif /* CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ + /* in serial versions of this test, we loop through all the dimensions * of the large data set. However, in the parallel version, each * process only works with that slice of the large cube indicated @@ -704,9 +875,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, * mpi_rank, and don't itterate over it. */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) { - i = mpi_rank; + i = tv_ptr->mpi_rank; } else { @@ -719,9 +890,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, * test. */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) { - j = mpi_rank; + j = tv_ptr->mpi_rank; } else { @@ -729,9 +900,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, } do { - if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) { - k = mpi_rank; + k = tv_ptr->mpi_rank; } else { @@ -751,145 +922,213 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, l = 0; do { - /* we know that small_rank - 1 >= 1 and that - * large_rank > small_rank by the assertions at the head - * of this function. Thus no need for another inner loop. - */ - start[0] = (hsize_t)i; - start[1] = (hsize_t)j; - start[2] = (hsize_t)k; - start[3] = (hsize_t)l; - start[4] = 0; - - ret = H5Sselect_hyperslab(file_large_ds_sid, - H5S_SELECT_SET, - start_ptr, - stride_ptr, - count_ptr, - block_ptr); - VRFY((ret != FAIL), - "H5Sselect_hyperslab(file_large_cube_sid) succeeded"); - - - /* verify that H5S_select_shape_same() reports the two - * selections as having the same shape. - */ - check = H5S_select_shape_same_test(small_ds_slice_sid, - file_large_ds_sid); - VRFY((check == TRUE), "H5S_select_shape_same_test passed"); - - - /* Read selection from disk */ -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", - fcnName, (int)mpi_rank, - (int)start[0], (int)start[1], (int)start[2], - (int)start[3], (int)start[4]); - HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n", - fcnName, - H5Sget_simple_extent_ndims(small_ds_slice_sid), - H5Sget_simple_extent_ndims(file_large_ds_sid)); -#endif - ret = H5Dread(large_dataset, - H5T_NATIVE_UINT32, - small_ds_slice_sid, - file_large_ds_sid, - xfer_plist, - small_ds_slice_buf); - VRFY((ret >= 0), "H5Dread() slice from large ds succeeded."); + if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */ + (tv_ptr->tests_skipped)++; - /* verify that expected data is retrieved */ + } else { /* run the test */ - mis_match = FALSE; - ptr_1 = small_ds_slice_buf; - expected_value = (uint32_t)( - (i * edge_size * edge_size * edge_size * edge_size) + - (j * edge_size * edge_size * edge_size) + - (k * edge_size * edge_size) + - (l * edge_size)); + tv_ptr->skips = 0; /* reset the skips counter */ - for ( n = 0; n < small_ds_slice_size; n++ ) { + /* we know that small_rank - 1 >= 1 and that + * large_rank > small_rank by the assertions at the head + * of this function. Thus no need for another inner loop. + */ + tv_ptr->start[0] = (hsize_t)i; + tv_ptr->start[1] = (hsize_t)j; + tv_ptr->start[2] = (hsize_t)k; + tv_ptr->start[3] = (hsize_t)l; + tv_ptr->start[4] = 0; + + ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0, + H5S_SELECT_SET, + tv_ptr->start_ptr, + tv_ptr->stride_ptr, + tv_ptr->count_ptr, + tv_ptr->block_ptr); + VRFY((ret != FAIL), + "H5Sselect_hyperslab(file_large_cube_sid) succeeded"); + + + /* verify that H5S_select_shape_same() reports the two + * selections as having the same shape. + */ + check = H5S_select_shape_same_test(tv_ptr->small_ds_slice_sid, + tv_ptr->file_large_ds_sid_0); + VRFY((check == TRUE), "H5S_select_shape_same_test passed"); + + + /* Read selection from disk */ +#if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG + HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", + fcnName, (int)(tv_ptr->mpi_rank), + (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), + (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), + (int)(tv_ptr->start[4])); + HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n", + fcnName, + H5Sget_simple_extent_ndims(tv_ptr->small_ds_slice_sid), + H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0)); +#endif /* CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ + ret = H5Dread(tv_ptr->large_dataset, + H5T_NATIVE_UINT32, + tv_ptr->small_ds_slice_sid, + tv_ptr->file_large_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->small_ds_slice_buf); + VRFY((ret >= 0), "H5Dread() slice from large ds succeeded."); + + + /* verify that expected data is retrieved */ + + mis_match = FALSE; + ptr_1 = tv_ptr->small_ds_slice_buf; + expected_value = (uint32_t)( + (i * tv_ptr->edge_size * tv_ptr->edge_size * + tv_ptr->edge_size * tv_ptr->edge_size) + + (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) + + (k * tv_ptr->edge_size * tv_ptr->edge_size) + + (l * tv_ptr->edge_size)); + + for ( n = 0; n < tv_ptr->small_ds_slice_size; n++ ) { + + if ( *ptr_1 != expected_value ) { + + mis_match = TRUE; + } - if ( *ptr_1 != expected_value ) { + *ptr_1 = 0; /* zero data for next use */ - mis_match = TRUE; + ptr_1++; + expected_value++; } - *ptr_1 = 0; /* zero data for next use */ + VRFY((mis_match == FALSE), + "small slice read from large ds data good."); - ptr_1++; - expected_value++; + (tv_ptr->tests_run)++; } - VRFY((mis_match == FALSE), - "small slice read from large ds data good."); l++; - } while ( ( large_rank > 2 ) && - ( (small_rank - 1) <= 1 ) && - ( l < edge_size ) ); + (tv_ptr->total_tests)++; + + } while ( ( tv_ptr->large_rank > 2 ) && + ( (tv_ptr->small_rank - 1) <= 1 ) && + ( l < tv_ptr->edge_size ) ); k++; - } while ( ( large_rank > 3 ) && - ( (small_rank - 1) <= 2 ) && - ( k < edge_size ) ); + } while ( ( tv_ptr->large_rank > 3 ) && + ( (tv_ptr->small_rank - 1) <= 2 ) && + ( k < tv_ptr->edge_size ) ); j++; - } while ( ( large_rank > 4 ) && - ( (small_rank - 1) <= 3 ) && - ( j < edge_size ) ); + } while ( ( tv_ptr->large_rank > 4 ) && + ( (tv_ptr->small_rank - 1) <= 3 ) && + ( j < tv_ptr->edge_size ) ); + + return; +} /* contig_hs_dr_pio_test__d2m_l2s() */ - /* similarly, read slices of the on disk small data set into slices + +/*------------------------------------------------------------------------- + * Function: contig_hs_dr_pio_test__d2m_s2l() + * + * Purpose: Part two of a series of tests of I/O to/from hyperslab + * selections of different rank in the parallel. + * + * Verify that we can read from disk correctly using + * selections of different rank that H5S_select_shape_same() + * views as being of the same shape. + * + * In this function, we test this by reading slices of the + * on disk small data set into slices through the in memory + * large data set, and verify that the correct data (and + * only the correct data) is read. + * + * Return: void + * + * Programmer: JRM -- 8/10/11 + * + * Modifications: + * + * None. + * + *------------------------------------------------------------------------- + */ + +#define CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG 0 + +static void +contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr) +{ +#if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG + const char *fcnName = "contig_hs_dr_pio_test__d2m_s2l()"; +#endif /* CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG */ + hbool_t mis_match = FALSE; + int i, j, k, l; + size_t n; + int mpi_rank; /* needed by the VRFY macro */ + size_t start_index; + size_t stop_index; + uint32_t expected_value; + uint32_t * ptr_1; + htri_t check; /* Shape comparison return value */ + herr_t ret; /* Generic return value */ + + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; + + /* Read slices of the on disk small data set into slices * through the in memory large data set, and verify that the correct * data (and only the correct data) is read. */ - start[0] = (hsize_t)mpi_rank; - stride[0] = (hsize_t)(2 * (mpi_size + 1)); - count[0] = 1; - block[0] = 1; + tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank); + tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1)); + tv_ptr->count[0] = 1; + tv_ptr->block[0] = 1; - for ( i = 1; i < large_rank; i++ ) { + for ( i = 1; i < tv_ptr->large_rank; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - block[i] = (hsize_t)edge_size; + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } - ret = H5Sselect_hyperslab(file_small_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0, H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded"); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); + VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded"); -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG +#if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG HDfprintf(stdout, "%s reading slices of on disk small data set into slices of big data set.\n", fcnName); -#endif +#endif /* CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG */ /* zero out the in memory large ds */ - HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size); + HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size); /* set up start, stride, count, and block -- note that we will * change start[] so as to read slices of the large cube. */ for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) { + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) { - block[i] = 1; + tv_ptr->block[i] = 1; } else { - block[i] = (hsize_t)edge_size; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } } @@ -904,9 +1143,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) { - i = mpi_rank; + i = tv_ptr->mpi_rank; } else { @@ -919,9 +1158,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, * test. */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) { - j = mpi_rank; + j = tv_ptr->mpi_rank; } else { @@ -929,9 +1168,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, } do { - if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) { - k = mpi_rank; + k = tv_ptr->mpi_rank; } else { @@ -951,147 +1190,218 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, l = 0; do { - /* we know that small_rank >= 1 and that large_rank > small_rank - * by the assertions at the head of this function. Thus no - * need for another inner loop. - */ - start[0] = (hsize_t)i; - start[1] = (hsize_t)j; - start[2] = (hsize_t)k; - start[3] = (hsize_t)l; - start[4] = 0; - - ret = H5Sselect_hyperslab(mem_large_ds_sid, - H5S_SELECT_SET, - start_ptr, - stride_ptr, - count_ptr, - block_ptr); - VRFY((ret != FAIL), - "H5Sselect_hyperslab(mem_large_ds_sid) succeeded"); - - - /* verify that H5S_select_shape_same() reports the two - * selections as having the same shape. - */ - check = H5S_select_shape_same_test(file_small_ds_sid, - mem_large_ds_sid); - VRFY((check == TRUE), "H5S_select_shape_same_test passed"); - - - /* Read selection from disk */ -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", - fcnName, (int)mpi_rank, - (int)start[0], (int)start[1], (int)start[2], - (int)start[3], (int)start[4]); - HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", - fcnName, mpi_rank, - H5Sget_simple_extent_ndims(mem_large_ds_sid), - H5Sget_simple_extent_ndims(file_small_ds_sid)); -#endif - ret = H5Dread(small_dataset, - H5T_NATIVE_UINT32, - mem_large_ds_sid, - file_small_ds_sid, - xfer_plist, - large_ds_buf_1); - VRFY((ret >= 0), "H5Dread() slice from small ds succeeded."); - - /* verify that the expected data and only the - * expected data was read. - */ - ptr_1 = large_ds_buf_1; - expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size); - start_index = (size_t)( - (i * edge_size * edge_size * edge_size * edge_size) + - (j * edge_size * edge_size * edge_size) + - (k * edge_size * edge_size) + - (l * edge_size)); - stop_index = start_index + small_ds_slice_size - 1; - - HDassert( start_index < stop_index ); - HDassert( stop_index <= large_ds_size ); - - for ( n = 0; n < large_ds_size; n++ ) { - - if ( ( n >= start_index ) && ( n <= stop_index ) ) { + if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */ - if ( *ptr_1 != expected_value ) { + (tv_ptr->tests_skipped)++; - mis_match = TRUE; - } - expected_value++; + } else { /* run the test */ - } else { + tv_ptr->skips = 0; /* reset the skips counter */ - if ( *ptr_1 != 0 ) { + /* we know that small_rank >= 1 and that large_rank > small_rank + * by the assertions at the head of this function. Thus no + * need for another inner loop. + */ + tv_ptr->start[0] = (hsize_t)i; + tv_ptr->start[1] = (hsize_t)j; + tv_ptr->start[2] = (hsize_t)k; + tv_ptr->start[3] = (hsize_t)l; + tv_ptr->start[4] = 0; + + ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid, + H5S_SELECT_SET, + tv_ptr->start_ptr, + tv_ptr->stride_ptr, + tv_ptr->count_ptr, + tv_ptr->block_ptr); + VRFY((ret != FAIL), + "H5Sselect_hyperslab(mem_large_ds_sid) succeeded"); + + + /* verify that H5S_select_shape_same() reports the two + * selections as having the same shape. + */ + check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_0, + tv_ptr->mem_large_ds_sid); + VRFY((check == TRUE), "H5S_select_shape_same_test passed"); + + + /* Read selection from disk */ +#if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG + HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", + fcnName, (int)(tv_ptr->mpi_rank), + (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), + (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), + (int)(tv_ptr->start[4])); + HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", + fcnName, tv_ptr->mpi_rank, + H5Sget_simple_extent_ndims(tv_ptr->mem_large_ds_sid), + H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_0)); +#endif /* CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG */ + ret = H5Dread(tv_ptr->small_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_large_ds_sid, + tv_ptr->file_small_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->large_ds_buf_1); + VRFY((ret >= 0), "H5Dread() slice from small ds succeeded."); + + /* verify that the expected data and only the + * expected data was read. + */ + ptr_1 = tv_ptr->large_ds_buf_1; + expected_value = (uint32_t) + ((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size); + start_index = (size_t)( + (i * tv_ptr->edge_size * tv_ptr->edge_size * + tv_ptr->edge_size * tv_ptr->edge_size) + + (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) + + (k * tv_ptr->edge_size * tv_ptr->edge_size) + + (l * tv_ptr->edge_size)); + stop_index = start_index + tv_ptr->small_ds_slice_size - 1; - mis_match = TRUE; + HDassert( start_index < stop_index ); + HDassert( stop_index <= tv_ptr->large_ds_size ); + + for ( n = 0; n < tv_ptr->large_ds_size; n++ ) { + + if ( ( n >= start_index ) && ( n <= stop_index ) ) { + + if ( *ptr_1 != expected_value ) { + + mis_match = TRUE; + } + expected_value++; + + } else { + + if ( *ptr_1 != 0 ) { + + mis_match = TRUE; + } } + /* zero out the value for the next pass */ + *ptr_1 = 0; + + ptr_1++; } - /* zero out the value for the next pass */ - *ptr_1 = 0; - ptr_1++; - } + VRFY((mis_match == FALSE), + "small slice read from large ds data good."); - VRFY((mis_match == FALSE), - "small slice read from large ds data good."); + (tv_ptr->tests_run)++; + } l++; - } while ( ( large_rank > 2 ) && - ( (small_rank - 1) <= 1 ) && - ( l < edge_size ) ); + (tv_ptr->total_tests)++; + + } while ( ( tv_ptr->large_rank > 2 ) && + ( (tv_ptr->small_rank - 1) <= 1 ) && + ( l < tv_ptr->edge_size ) ); k++; - } while ( ( large_rank > 3 ) && - ( (small_rank - 1) <= 2 ) && - ( k < edge_size ) ); + } while ( ( tv_ptr->large_rank > 3 ) && + ( (tv_ptr->small_rank - 1) <= 2 ) && + ( k < tv_ptr->edge_size ) ); j++; - } while ( ( large_rank > 4 ) && - ( (small_rank - 1) <= 3 ) && - ( j < edge_size ) ); + } while ( ( tv_ptr->large_rank > 4 ) && + ( (tv_ptr->small_rank - 1) <= 3 ) && + ( j < tv_ptr->edge_size ) ); + + return; + +} /* contig_hs_dr_pio_test__d2m_s2l() */ + + +/*------------------------------------------------------------------------- + * Function: contig_hs_dr_pio_test__m2d_l2s() + * + * Purpose: Part three of a series of tests of I/O to/from hyperslab + * selections of different rank in the parallel. + * + * Verify that we can write from memory to file using + * selections of different rank that H5S_select_shape_same() + * views as being of the same shape. + * + * Do this by writing small_rank - 1 dimensional slices from + * the in memory large data set to the on disk small cube + * dataset. After each write, read the slice of the small + * dataset back from disk, and verify that it contains + * the expected data. Verify that H5S_select_shape_same() + * returns true on the memory and file selections. + * + * Return: void + * + * Programmer: JRM -- 8/10/11 + * + * Modifications: + * + * None. + * + *------------------------------------------------------------------------- + */ + +#define CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG 0 + +static void +contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr) +{ +#if CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG + const char *fcnName = "contig_hs_dr_pio_test__m2d_l2s()"; +#endif /* CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG */ + hbool_t mis_match = FALSE; + int i, j, k, l; + size_t n; + int mpi_rank; /* needed by the VRFY macro */ + size_t start_index; + size_t stop_index; + uint32_t expected_value; + uint32_t * ptr_1; + htri_t check; /* Shape comparison return value */ + herr_t ret; /* Generic return value */ + + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; /* now we go in the opposite direction, verifying that we can write * from memory to file using selections of different rank that * H5S_select_shape_same() views as being of the same shape. * - * Start by writing small_rank - 1 D slices from the in memory large data - * set to the on disk small cube dataset. After each write, read the + * Start by writing small_rank - 1 dimensional slices from the in memory large + * data set to the on disk small cube dataset. After each write, read the * slice of the small dataset back from disk, and verify that it contains * the expected data. Verify that H5S_select_shape_same() returns true on * the memory and file selections. */ - start[0] = (hsize_t)mpi_rank; - stride[0] = (hsize_t)(2 * (mpi_size + 1)); - count[0] = 1; - block[0] = 1; + tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank); + tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1)); + tv_ptr->count[0] = 1; + tv_ptr->block[0] = 1; - for ( i = 1; i < large_rank; i++ ) { + for ( i = 1; i < tv_ptr->large_rank; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - block[i] = (hsize_t)edge_size; + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } - ret = H5Sselect_hyperslab(file_small_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0, H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid, set) suceeded"); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); + VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded"); - ret = H5Sselect_hyperslab(mem_small_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid, H5S_SELECT_SET, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded"); @@ -1100,28 +1410,28 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, */ for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) { + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) { - block[i] = 1; + tv_ptr->block[i] = 1; } else { - block[i] = (hsize_t)edge_size; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } } /* zero out the in memory small ds */ - HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size); + HDmemset(tv_ptr->small_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->small_ds_size); -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG +#if CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG HDfprintf(stdout, "%s writing slices from big ds to slices of small ds on disk.\n", fcnName); -#endif +#endif /* CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG */ /* in serial versions of this test, we loop through all the dimensions * of the large data set that don't appear in the small data set. @@ -1133,9 +1443,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) { - i = mpi_rank; + i = tv_ptr->mpi_rank; } else { @@ -1148,9 +1458,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, * test. */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) { - j = mpi_rank; + j = tv_ptr->mpi_rank; } else { @@ -1159,9 +1469,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, j = 0; do { - if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) { - k = mpi_rank; + k = tv_ptr->mpi_rank; } else { @@ -1181,136 +1491,207 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, l = 0; do { - /* we know that small_rank >= 1 and that large_rank > small_rank - * by the assertions at the head of this function. Thus no - * need for another inner loop. - */ - - /* zero out this rank's slice of the on disk small data set */ - ret = H5Dwrite(small_dataset, - H5T_NATIVE_UINT32, - mem_small_ds_sid, - file_small_ds_sid, - xfer_plist, - small_ds_buf_2); - VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded."); - - /* select the portion of the in memory large cube from which we - * are going to write data. - */ - start[0] = (hsize_t)i; - start[1] = (hsize_t)j; - start[2] = (hsize_t)k; - start[3] = (hsize_t)l; - start[4] = 0; - - ret = H5Sselect_hyperslab(mem_large_ds_sid, - H5S_SELECT_SET, - start_ptr, - stride_ptr, - count_ptr, - block_ptr); - VRFY((ret >= 0), - "H5Sselect_hyperslab() mem_large_ds_sid succeeded."); - - - /* verify that H5S_select_shape_same() reports the in - * memory slice through the cube selection and the - * on disk full square selections as having the same shape. - */ - check = H5S_select_shape_same_test(file_small_ds_sid, - mem_large_ds_sid); - VRFY((check == TRUE), "H5S_select_shape_same_test passed."); - - - /* write the slice from the in memory large data set to the - * slice of the on disk small dataset. */ -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", - fcnName, (int)mpi_rank, - (int)start[0], (int)start[1], (int)start[2], - (int)start[3], (int)start[4]); - HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", - fcnName, mpi_rank, - H5Sget_simple_extent_ndims(mem_large_ds_sid), - H5Sget_simple_extent_ndims(file_small_ds_sid)); -#endif - ret = H5Dwrite(small_dataset, - H5T_NATIVE_UINT32, - mem_large_ds_sid, - file_small_ds_sid, - xfer_plist, - large_ds_buf_0); - VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded."); + if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */ + + (tv_ptr->tests_skipped)++; + } else { /* run the test */ - /* read the on disk square into memory */ - ret = H5Dread(small_dataset, - H5T_NATIVE_UINT32, - mem_small_ds_sid, - file_small_ds_sid, - xfer_plist, - small_ds_buf_1); - VRFY((ret >= 0), "H5Dread() slice from small ds succeeded."); + tv_ptr->skips = 0; /* reset the skips counter */ + /* we know that small_rank >= 1 and that large_rank > small_rank + * by the assertions at the head of this function. Thus no + * need for another inner loop. + */ - /* verify that expected data is retrieved */ + /* zero out this rank's slice of the on disk small data set */ + ret = H5Dwrite(tv_ptr->small_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_small_ds_sid, + tv_ptr->file_small_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->small_ds_buf_2); + VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded."); + + /* select the portion of the in memory large cube from which we + * are going to write data. + */ + tv_ptr->start[0] = (hsize_t)i; + tv_ptr->start[1] = (hsize_t)j; + tv_ptr->start[2] = (hsize_t)k; + tv_ptr->start[3] = (hsize_t)l; + tv_ptr->start[4] = 0; + + ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid, + H5S_SELECT_SET, + tv_ptr->start_ptr, + tv_ptr->stride_ptr, + tv_ptr->count_ptr, + tv_ptr->block_ptr); + VRFY((ret >= 0), + "H5Sselect_hyperslab() mem_large_ds_sid succeeded."); + + + /* verify that H5S_select_shape_same() reports the in + * memory slice through the cube selection and the + * on disk full square selections as having the same shape. + */ + check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_0, + tv_ptr->mem_large_ds_sid); + VRFY((check == TRUE), "H5S_select_shape_same_test passed."); + + + /* write the slice from the in memory large data set to the + * slice of the on disk small dataset. */ +#if CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG + HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", + fcnName, (int)(tv_ptr->mpi_rank), + (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), + (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), + (int)(tv_ptr->start[4])); + HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", + fcnName, tv_ptr->mpi_rank, + H5Sget_simple_extent_ndims(tv_ptr->mem_large_ds_sid), + H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_0)); +#endif /* CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG */ + ret = H5Dwrite(tv_ptr->small_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_large_ds_sid, + tv_ptr->file_small_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->large_ds_buf_0); + VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded."); + + + /* read the on disk square into memory */ + ret = H5Dread(tv_ptr->small_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_small_ds_sid, + tv_ptr->file_small_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->small_ds_buf_1); + VRFY((ret >= 0), "H5Dread() slice from small ds succeeded."); + + + /* verify that expected data is retrieved */ + + mis_match = FALSE; + ptr_1 = tv_ptr->small_ds_buf_1; + + expected_value = (uint32_t)( + (i * tv_ptr->edge_size * tv_ptr->edge_size * + tv_ptr->edge_size * tv_ptr->edge_size) + + (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) + + (k * tv_ptr->edge_size * tv_ptr->edge_size) + + (l * tv_ptr->edge_size)); + + start_index = (size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size; + stop_index = start_index + tv_ptr->small_ds_slice_size - 1; + + HDassert( start_index < stop_index ); + HDassert( stop_index <= tv_ptr->small_ds_size ); + + for ( n = 0; n < tv_ptr->small_ds_size; n++ ) { + + if ( ( n >= start_index ) && ( n <= stop_index ) ) { + + if ( *ptr_1 != expected_value ) { + + mis_match = TRUE; + } + expected_value++; - mis_match = FALSE; - ptr_1 = small_ds_buf_1; + } else { - expected_value = (uint32_t)( - (i * edge_size * edge_size * edge_size * edge_size) + - (j * edge_size * edge_size * edge_size) + - (k * edge_size * edge_size) + - (l * edge_size)); + if ( *ptr_1 != 0 ) { - start_index = (size_t)mpi_rank * small_ds_slice_size; - stop_index = start_index + small_ds_slice_size - 1; + mis_match = TRUE; + } + } + /* zero out the value for the next pass */ + *ptr_1 = 0; - HDassert( start_index < stop_index ); - HDassert( stop_index <= small_ds_size ); + ptr_1++; + } - for ( n = 0; n < small_ds_size; n++ ) { + VRFY((mis_match == FALSE), + "small slice write from large ds data good."); - if ( ( n >= start_index ) && ( n <= stop_index ) ) { + (tv_ptr->tests_run)++; + } - if ( *ptr_1 != expected_value ) { + l++; - mis_match = TRUE; - } - expected_value++; + (tv_ptr->total_tests)++; - } else { + } while ( ( tv_ptr->large_rank > 2 ) && + ( (tv_ptr->small_rank - 1) <= 1 ) && + ( l < tv_ptr->edge_size ) ); + k++; + } while ( ( tv_ptr->large_rank > 3 ) && + ( (tv_ptr->small_rank - 1) <= 2 ) && + ( k < tv_ptr->edge_size ) ); + j++; + } while ( ( tv_ptr->large_rank > 4 ) && + ( (tv_ptr->small_rank - 1) <= 3 ) && + ( j < tv_ptr->edge_size ) ); - if ( *ptr_1 != 0 ) { + return; - mis_match = TRUE; - } - } - /* zero out the value for the next pass */ - *ptr_1 = 0; +} /* contig_hs_dr_pio_test__m2d_l2s() */ - ptr_1++; - } - VRFY((mis_match == FALSE), - "small slice write from large ds data good."); +/*------------------------------------------------------------------------- + * Function: contig_hs_dr_pio_test__m2d_s2l() + * + * Purpose: Part four of a series of tests of I/O to/from hyperslab + * selections of different rank in the parallel. + * + * Verify that we can write from memory to file using + * selections of different rank that H5S_select_shape_same() + * views as being of the same shape. + * + * Do this by writing the contents of the process's slice of + * the in memory small data set to slices of the on disk + * large data set. After each write, read the process's + * slice of the large data set back into memory, and verify + * that it contains the expected data. + * + * Verify that H5S_select_shape_same() returns true on the + * memory and file selections. + * + * Return: void + * + * Programmer: JRM -- 8/10/11 + * + * Modifications: + * + * None + * + *------------------------------------------------------------------------- + */ - l++; +#define CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG 0 - } while ( ( large_rank > 2 ) && - ( (small_rank - 1) <= 1 ) && - ( l < edge_size ) ); - k++; - } while ( ( large_rank > 3 ) && - ( (small_rank - 1) <= 2 ) && - ( k < edge_size ) ); - j++; - } while ( ( large_rank > 4 ) && - ( (small_rank - 1) <= 3 ) && - ( j < edge_size ) ); +static void +contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr) +{ +#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG + const char *fcnName = "contig_hs_dr_pio_test__m2d_s2l()"; +#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */ + hbool_t mis_match = FALSE; + int i, j, k, l; + size_t n; + int mpi_rank; /* needed by the VRFY macro */ + size_t start_index; + size_t stop_index; + uint32_t expected_value; + uint32_t * ptr_1; + htri_t check; /* Shape comparison return value */ + herr_t ret; /* Generic return value */ + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; /* Now write the contents of the process's slice of the in memory * small data set to slices of the on disk large data set. After @@ -1323,25 +1704,25 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, /* select the slice of the in memory small data set associated with * the process's mpi rank. */ - start[0] = (hsize_t)mpi_rank; - stride[0] = (hsize_t)(2 * (mpi_size + 1)); - count[0] = 1; - block[0] = 1; + tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank); + tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1)); + tv_ptr->count[0] = 1; + tv_ptr->block[0] = 1; - for ( i = 1; i < large_rank; i++ ) { + for ( i = 1; i < tv_ptr->large_rank; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - block[i] = (hsize_t)edge_size; + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } - ret = H5Sselect_hyperslab(mem_small_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid, H5S_SELECT_SET, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded"); @@ -1351,31 +1732,31 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, */ for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) { + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) { - block[i] = 1; + tv_ptr->block[i] = 1; } else { - block[i] = (hsize_t)edge_size; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } } /* zero out the in memory large ds */ - HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size); + HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size); -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG +#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG HDfprintf(stdout, "%s writing process slices of small ds to slices of large ds on disk.\n", fcnName); -#endif +#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) { - i = mpi_rank; + i = tv_ptr->mpi_rank; } else { @@ -1388,9 +1769,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, * test. */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) { - j = mpi_rank; + j = tv_ptr->mpi_rank; } else { @@ -1398,9 +1779,9 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, } do { - if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) { - k = mpi_rank; + k = tv_ptr->mpi_rank; } else { @@ -1420,216 +1801,410 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, l = 0; do { - /* we know that small_rank >= 1 and that large_rank > small_rank - * by the assertions at the head of this function. Thus no - * need for another inner loop. - */ - - /* Zero out this processes slice of the on disk large data set. - * Note that this will leave one slice with its original data - * as there is one more slice than processes. - */ - ret = H5Dwrite(large_dataset, - H5T_NATIVE_UINT32, - large_ds_slice_sid, - file_large_ds_process_slice_sid, - xfer_plist, - large_ds_buf_2); - VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded"); - - - /* select the portion of the in memory large cube to which we - * are going to write data. - */ - start[0] = (hsize_t)i; - start[1] = (hsize_t)j; - start[2] = (hsize_t)k; - start[3] = (hsize_t)l; - start[4] = 0; - - ret = H5Sselect_hyperslab(file_large_ds_sid, - H5S_SELECT_SET, - start_ptr, - stride_ptr, - count_ptr, - block_ptr); - VRFY((ret != FAIL), - "H5Sselect_hyperslab() target large ds slice succeeded"); - - - /* verify that H5S_select_shape_same() reports the in - * memory small data set slice selection and the - * on disk slice through the large data set selection - * as having the same shape. - */ - check = H5S_select_shape_same_test(mem_small_ds_sid, - file_large_ds_sid); - VRFY((check == TRUE), "H5S_select_shape_same_test passed"); - - - /* write the small data set slice from memory to the - * target slice of the disk data set - */ -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", - fcnName, (int)mpi_rank, - (int)start[0], (int)start[1], (int)start[2], - (int)start[3], (int)start[4]); - HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", - fcnName, mpi_rank, - H5Sget_simple_extent_ndims(mem_small_ds_sid), - H5Sget_simple_extent_ndims(file_large_ds_sid)); -#endif - ret = H5Dwrite(large_dataset, - H5T_NATIVE_UINT32, - mem_small_ds_sid, - file_large_ds_sid, - xfer_plist, - small_ds_buf_0); - VRFY((ret != FAIL), - "H5Dwrite of small ds slice to large ds succeeded"); + if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */ + + (tv_ptr->tests_skipped)++; + +#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG + tv_ptr->start[0] = (hsize_t)i; + tv_ptr->start[1] = (hsize_t)j; + tv_ptr->start[2] = (hsize_t)k; + tv_ptr->start[3] = (hsize_t)l; + tv_ptr->start[4] = 0; + + HDfprintf(stdout, + "%s:%d: skipping test with start = %d %d %d %d %d.\n", + fcnName, (int)(tv_ptr->mpi_rank), + (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), + (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), + (int)(tv_ptr->start[4])); + HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", + fcnName, tv_ptr->mpi_rank, + H5Sget_simple_extent_ndims(tv_ptr->mem_small_ds_sid), + H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0)); +#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */ + } else { /* run the test */ + + tv_ptr->skips = 0; /* reset the skips counter */ + + /* we know that small_rank >= 1 and that large_rank > small_rank + * by the assertions at the head of this function. Thus no + * need for another inner loop. + */ + /* Zero out this processes slice of the on disk large data set. + * Note that this will leave one slice with its original data + * as there is one more slice than processes. + */ + ret = H5Dwrite(tv_ptr->large_dataset, + H5T_NATIVE_UINT32, + tv_ptr->large_ds_slice_sid, + tv_ptr->file_large_ds_process_slice_sid, + tv_ptr->xfer_plist, + tv_ptr->large_ds_buf_2); + VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded"); - /* read this processes slice on the on disk large - * data set into memory. - */ - ret = H5Dread(large_dataset, - H5T_NATIVE_UINT32, - mem_large_ds_process_slice_sid, - file_large_ds_process_slice_sid, - xfer_plist, - large_ds_buf_1); - VRFY((ret != FAIL), - "H5Dread() of process slice of large ds succeeded"); + /* select the portion of the in memory large cube to which we + * are going to write data. + */ + tv_ptr->start[0] = (hsize_t)i; + tv_ptr->start[1] = (hsize_t)j; + tv_ptr->start[2] = (hsize_t)k; + tv_ptr->start[3] = (hsize_t)l; + tv_ptr->start[4] = 0; + + ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0, + H5S_SELECT_SET, + tv_ptr->start_ptr, + tv_ptr->stride_ptr, + tv_ptr->count_ptr, + tv_ptr->block_ptr); + VRFY((ret != FAIL), + "H5Sselect_hyperslab() target large ds slice succeeded"); + + + /* verify that H5S_select_shape_same() reports the in + * memory small data set slice selection and the + * on disk slice through the large data set selection + * as having the same shape. + */ + check = H5S_select_shape_same_test(tv_ptr->mem_small_ds_sid, + tv_ptr->file_large_ds_sid_0); + VRFY((check == TRUE), "H5S_select_shape_same_test passed"); - /* verify that the expected data and only the - * expected data was read. - */ - ptr_1 = large_ds_buf_1; - expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size); + /* write the small data set slice from memory to the + * target slice of the disk data set + */ +#if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG + HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", + fcnName, (int)(tv_ptr->mpi_rank), + (int)(tv_ptr->start[0]), (int)(tv_ptr->start[1]), + (int)(tv_ptr->start[2]), (int)(tv_ptr->start[3]), + (int)(tv_ptr->start[4])); + HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", + fcnName, tv_ptr->mpi_rank, + H5Sget_simple_extent_ndims(tv_ptr->mem_small_ds_sid), + H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0)); +#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */ + ret = H5Dwrite(tv_ptr->large_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_small_ds_sid, + tv_ptr->file_large_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->small_ds_buf_0); + VRFY((ret != FAIL), + "H5Dwrite of small ds slice to large ds succeeded"); + + + /* read this processes slice on the on disk large + * data set into memory. + */ - start_index = (size_t)((i * edge_size * edge_size * edge_size * edge_size) + - (j * edge_size * edge_size * edge_size) + - (k * edge_size * edge_size) + - (l * edge_size)); - stop_index = start_index + small_ds_slice_size - 1; + ret = H5Dread(tv_ptr->large_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_large_ds_process_slice_sid, + tv_ptr->file_large_ds_process_slice_sid, + tv_ptr->xfer_plist, + tv_ptr->large_ds_buf_1); + VRFY((ret != FAIL), + "H5Dread() of process slice of large ds succeeded"); - HDassert( start_index < stop_index ); - HDassert( stop_index < large_ds_size ); - for ( n = 0; n < large_ds_size; n++ ) { + /* verify that the expected data and only the + * expected data was read. + */ + ptr_1 = tv_ptr->large_ds_buf_1; + expected_value = (uint32_t) + ((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size); - if ( ( n >= start_index ) && ( n <= stop_index ) ) { + start_index = (size_t) + ((i * tv_ptr->edge_size * tv_ptr->edge_size * + tv_ptr->edge_size * tv_ptr->edge_size) + + (j * tv_ptr->edge_size * tv_ptr->edge_size * + tv_ptr->edge_size) + + (k * tv_ptr->edge_size * tv_ptr->edge_size) + + (l * tv_ptr->edge_size)); + stop_index = start_index + tv_ptr->small_ds_slice_size - 1; - if ( *ptr_1 != expected_value ) { + HDassert( start_index < stop_index ); + HDassert( stop_index < tv_ptr->large_ds_size ); - mis_match = TRUE; - } + for ( n = 0; n < tv_ptr->large_ds_size; n++ ) { - expected_value++; + if ( ( n >= start_index ) && ( n <= stop_index ) ) { - } else { + if ( *ptr_1 != expected_value ) { - if ( *ptr_1 != 0 ) { + mis_match = TRUE; + } - mis_match = TRUE; + expected_value++; + + } else { + + if ( *ptr_1 != 0 ) { + + mis_match = TRUE; + } } + /* zero out buffer for next test */ + *ptr_1 = 0; + ptr_1++; } - /* zero out buffer for next test */ - *ptr_1 = 0; - ptr_1++; - } - VRFY((mis_match == FALSE), - "small ds slice write to large ds slice data good."); + VRFY((mis_match == FALSE), + "small ds slice write to large ds slice data good."); + + (tv_ptr->tests_run)++; + } l++; - } while ( ( large_rank > 2 ) && - ( (small_rank - 1) <= 1 ) && - ( l < edge_size ) ); + (tv_ptr->total_tests)++; + + } while ( ( tv_ptr->large_rank > 2 ) && + ( (tv_ptr->small_rank - 1) <= 1 ) && + ( l < tv_ptr->edge_size ) ); k++; - } while ( ( large_rank > 3 ) && - ( (small_rank - 1) <= 2 ) && - ( k < edge_size ) ); + } while ( ( tv_ptr->large_rank > 3 ) && + ( (tv_ptr->small_rank - 1) <= 2 ) && + ( k < tv_ptr->edge_size ) ); j++; - } while ( ( large_rank > 4 ) && - ( (small_rank - 1) <= 3 ) && - ( j < edge_size ) ); + } while ( ( tv_ptr->large_rank > 4 ) && + ( (tv_ptr->small_rank - 1) <= 3 ) && + ( j < tv_ptr->edge_size ) ); + return; - /* Close dataspaces */ - ret = H5Sclose(full_mem_small_ds_sid); - VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded"); +} /* contig_hs_dr_pio_test__m2d_s2l() */ - ret = H5Sclose(full_file_small_ds_sid); - VRFY((ret != FAIL), "H5Sclose(full_file_small_ds_sid) succeeded"); - ret = H5Sclose(mem_small_ds_sid); - VRFY((ret != FAIL), "H5Sclose(mem_small_ds_sid) succeeded"); +/*------------------------------------------------------------------------- + * Function: contig_hs_dr_pio_test__run_test() + * + * Purpose: Test I/O to/from hyperslab selections of different rank in + * the parallel. + * + * Return: void + * + * Programmer: JRM -- 9/18/09 + * + * Modifications: + * + * JRM -- 9/16/10 + * Added express_test parameter. Use it to control whether + * we set up the chunks so that no chunk is shared between + * processes, and also whether we set an alignment when we + * create the test file. + * + * JRM -- 8/11/11 + * Refactored function heavily & broke it into six functions. + * Added the skips_ptr, max_skips, total_tests_ptr, + * tests_run_ptr, and tests_skiped_ptr parameters to support + * skipping portions of the test according to the express + * test value. + * + *------------------------------------------------------------------------- + */ - ret = H5Sclose(file_small_ds_sid); - VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid) succeeded"); +#define CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG 0 - ret = H5Sclose(small_ds_slice_sid); - VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded"); +static void +contig_hs_dr_pio_test__run_test(const int test_num, + const int edge_size, + const int chunk_edge_size, + const int small_rank, + const int large_rank, + const hbool_t use_collective_io, + const hid_t dset_type, + int express_test, + int * skips_ptr, + int max_skips, + int64_t * total_tests_ptr, + int64_t * tests_run_ptr, + int64_t * tests_skipped_ptr) +{ +#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG + const char *fcnName = "contig_hs_dr_pio_test__run_test()"; +#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ + int mpi_rank; + struct hs_dr_pio_test_vars_t test_vars = + { + /* int mpi_size = */ -1, + /* int mpi_rank = */ -1, + /* MPI_Comm mpi_comm = */ MPI_COMM_NULL, + /* MPI_Inf mpi_info = */ MPI_INFO_NULL, + /* int test_num = */ -1, + /* int edge_size = */ -1, + /* int checker_edge_size = */ -1, + /* int chunk_edge_size = */ -1, + /* int small_rank = */ -1, + /* int large_rank = */ -1, + /* hid_t dset_type = */ -1, + /* uint32_t * small_ds_buf_0 = */ NULL, + /* uint32_t * small_ds_buf_1 = */ NULL, + /* uint32_t * small_ds_buf_2 = */ NULL, + /* uint32_t * small_ds_slice_buf = */ NULL, + /* uint32_t * large_ds_buf_0 = */ NULL, + /* uint32_t * large_ds_buf_1 = */ NULL, + /* uint32_t * large_ds_buf_2 = */ NULL, + /* uint32_t * large_ds_slice_buf = */ NULL, + /* int small_ds_offset = */ -1, + /* int large_ds_offset = */ -1, + /* hid_t fid = */ -1, /* HDF5 file ID */ + /* hid_t xfer_plist = */ H5P_DEFAULT, + /* hid_t full_mem_small_ds_sid = */ -1, + /* hid_t full_file_small_ds_sid = */ -1, + /* hid_t mem_small_ds_sid = */ -1, + /* hid_t file_small_ds_sid_0 = */ -1, + /* hid_t file_small_ds_sid_1 = */ -1, + /* hid_t small_ds_slice_sid = */ -1, + /* hid_t full_mem_large_ds_sid = */ -1, + /* hid_t full_file_large_ds_sid = */ -1, + /* hid_t mem_large_ds_sid = */ -1, + /* hid_t file_large_ds_sid_0 = */ -1, + /* hid_t file_large_ds_sid_1 = */ -1, + /* hid_t file_large_ds_process_slice_sid = */ -1, + /* hid_t mem_large_ds_process_slice_sid = */ -1, + /* hid_t large_ds_slice_sid = */ -1, + /* hid_t small_dataset = */ -1, /* Dataset ID */ + /* hid_t large_dataset = */ -1, /* Dataset ID */ + /* size_t small_ds_size = */ 1, + /* size_t small_ds_slice_size = */ 1, + /* size_t large_ds_size = */ 1, + /* size_t large_ds_slice_size = */ 1, + /* hsize_t dims[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t chunk_dims[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t start[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t stride[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t count[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t block[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t * start_ptr = */ NULL, + /* hsize_t * stride_ptr = */ NULL, + /* hsize_t * count_ptr = */ NULL, + /* hsize_t * block_ptr = */ NULL, + /* int skips = */ 0, + /* int max_skips = */ 0, + /* int64_t total_tests = */ 0, + /* int64_t tests_run = */ 0, + /* int64_t tests_skipped = */ 0 + }; + struct hs_dr_pio_test_vars_t * tv_ptr = &test_vars; - ret = H5Sclose(full_mem_large_ds_sid); - VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded"); + hs_dr_pio_test__setup(test_num, edge_size, -1, chunk_edge_size, + small_rank, large_rank, use_collective_io, + dset_type, express_test, tv_ptr); - ret = H5Sclose(full_file_large_ds_sid); - VRFY((ret != FAIL), "H5Sclose(full_file_large_ds_sid) succeeded"); + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; - ret = H5Sclose(mem_large_ds_sid); - VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded"); + /* initialize skips & max_skips */ + tv_ptr->skips = *skips_ptr; + tv_ptr->max_skips = max_skips; - ret = H5Sclose(file_large_ds_sid); - VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded"); +#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG + if ( MAINPROCESS ) { + HDfprintf(stdout, "test %d: small rank = %d, large rank = %d.\n", + test_num, small_rank, large_rank); + HDfprintf(stdout, "test %d: Initialization complete.\n", test_num); + } +#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ - ret = H5Sclose(mem_large_ds_process_slice_sid); - VRFY((ret != FAIL), "H5Sclose(mem_large_ds_process_slice_sid) succeeded"); + /* first, verify that we can read from disk correctly using selections + * of different rank that H5S_select_shape_same() views as being of the + * same shape. + * + * Start by reading small_rank - 1 dimensional slice from the on disk + * large cube, and verifying that the data read is correct. Verify that + * H5S_select_shape_same() returns true on the memory and file selections. + */ - ret = H5Sclose(file_large_ds_process_slice_sid); - VRFY((ret != FAIL), "H5Sclose(file_large_ds_process_slice_sid) succeeded"); +#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG + if ( MAINPROCESS ) { + HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__d2m_l2s.\n", test_num); + } +#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ + contig_hs_dr_pio_test__d2m_l2s(tv_ptr); - ret = H5Sclose(large_ds_slice_sid); - VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded"); + /* Second, read slices of the on disk small data set into slices + * through the in memory large data set, and verify that the correct + * data (and only the correct data) is read. + */ - /* Close Datasets */ - ret = H5Dclose(small_dataset); - VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded"); +#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG + if ( MAINPROCESS ) { + HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__d2m_s2l.\n", test_num); + } +#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ + contig_hs_dr_pio_test__d2m_s2l(tv_ptr); - ret = H5Dclose(large_dataset); - VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded"); + /* now we go in the opposite direction, verifying that we can write + * from memory to file using selections of different rank that + * H5S_select_shape_same() views as being of the same shape. + * + * Start by writing small_rank - 1 D slices from the in memory large data + * set to the on disk small cube dataset. After each write, read the + * slice of the small dataset back from disk, and verify that it contains + * the expected data. Verify that H5S_select_shape_same() returns true on + * the memory and file selections. + */ - /* close the file collectively */ - MESG("about to close file."); - ret = H5Fclose(fid); - VRFY((ret != FAIL), "file close succeeded"); +#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG + if ( MAINPROCESS ) { + HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__m2d_l2s.\n", test_num); + } +#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ + contig_hs_dr_pio_test__m2d_l2s(tv_ptr); - /* Free memory buffers */ - if ( small_ds_buf_0 != NULL ) HDfree(small_ds_buf_0); - if ( small_ds_buf_1 != NULL ) HDfree(small_ds_buf_1); - if ( small_ds_buf_2 != NULL ) HDfree(small_ds_buf_2); - if ( small_ds_slice_buf != NULL ) HDfree(small_ds_slice_buf); + /* Now write the contents of the process's slice of the in memory + * small data set to slices of the on disk large data set. After + * each write, read the process's slice of the large data set back + * into memory, and verify that it contains the expected data. + * Verify that H5S_select_shape_same() returns true on the memory + * and file selections. + */ + +#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG + if ( MAINPROCESS ) { + HDfprintf(stdout, "test %d: running contig_hs_dr_pio_test__m2d_s2l.\n", test_num); + } +#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ + contig_hs_dr_pio_test__m2d_s2l(tv_ptr); + +#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG + if ( MAINPROCESS ) { + HDfprintf(stdout, + "test %d: Subtests complete -- tests run/skipped/total = %lld/%lld/%lld.\n", + test_num, (long long)(tv_ptr->tests_run), (long long)(tv_ptr->tests_skipped), + (long long)(tv_ptr->total_tests)); + } +#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ + + hs_dr_pio_test__takedown(tv_ptr); + +#if CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG + if ( MAINPROCESS ) { + HDfprintf(stdout, "test %d: Takedown complete.\n", test_num); + } +#endif /* CONTIG_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ - if ( large_ds_buf_0 != NULL ) HDfree(large_ds_buf_0); - if ( large_ds_buf_1 != NULL ) HDfree(large_ds_buf_1); - if ( large_ds_buf_2 != NULL ) HDfree(large_ds_buf_2); - if ( large_ds_slice_buf != NULL ) HDfree(large_ds_slice_buf); + *skips_ptr = tv_ptr->skips; + *total_tests_ptr += tv_ptr->total_tests; + *tests_run_ptr += tv_ptr->tests_run; + *tests_skipped_ptr += tv_ptr->tests_skipped; return; -} /* contig_hyperslab_dr_pio_test__run_test() */ +} /* contig_hs_dr_pio_test__run_test() */ /*------------------------------------------------------------------------- - * Function: contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type) + * Function: contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type) * * Purpose: Test I/O to/from hyperslab selections of different rank in * the parallel case. @@ -1655,43 +2230,37 @@ contig_hyperslab_dr_pio_test__run_test(const int test_num, *------------------------------------------------------------------------- */ +#define CONTIG_HS_DR_PIO_TEST__DEBUG 0 + void -contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type) +contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type) { + int express_test; + int local_express_test; + int mpi_rank = -1; int test_num = 0; int edge_size = 10; int chunk_edge_size = 0; int small_rank; int large_rank; - int skips[4] = {0, 0, 0, 0}; - int skip_counters[4] = {0, 0, 0, 0}; - int tests_skiped[4] = {0, 0, 0, 0}; int mpi_result; + int skips = 0; + int max_skips = 0; + /* The following table list the number of sub-tests skipped between + * each test that is actually executed as a function of the express + * test level. Note that any value in excess of 4880 will cause all + * sub tests to be skipped. + */ + int max_skips_tbl[4] = {0, 4, 16, 64}; hid_t dset_type = H5T_NATIVE_UINT; -#ifdef H5_HAVE_GETTIMEOFDAY - hbool_t time_tests = TRUE; - hbool_t display_skips = FALSE; - int local_express_test; - int express_test; - int i; - int samples = 0; - int sample_size = 1; - int mpi_size = -1; - int mpi_rank = -1; - int local_skips[4]; - const int ind_contig_idx = 0; - const int col_contig_idx = 1; - const int ind_chunked_idx = 2; - const int col_chunked_idx = 3; - const int test_types = 4; - long long max_test_time = 3000000; /* for one test */ - long long sample_times[4] = {0, 0, 0, 0}; - struct timeval timeval_a; - struct timeval timeval_b; -#endif /* H5_HAVE_GETTIMEOFDAY */ + int64_t total_tests = 0; + int64_t tests_run = 0; + int64_t tests_skipped = 0; HDcompile_assert(sizeof(uint32_t) == sizeof(unsigned)); + MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); + local_express_test = GetTestExpress(); mpi_result = MPI_Allreduce((void *)&local_express_test, @@ -1703,198 +2272,130 @@ contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type) VRFY((mpi_result == MPI_SUCCESS ), "MPI_Allreduce(0) succeeded"); + if ( local_express_test < 0 ) { + max_skips = max_skips_tbl[0]; + } else if ( local_express_test > 3 ) { + max_skips = max_skips_tbl[3]; + } else { + max_skips = max_skips_tbl[local_express_test]; + } + for ( large_rank = 3; large_rank <= PAR_SS_DR_MAX_RANK; large_rank++ ) { for ( small_rank = 2; small_rank < large_rank; small_rank++ ) { - switch(sstest_type){ - case IND_CONTIG: - /* contiguous data set, independent I/O */ - chunk_edge_size = 0; - if ( skip_counters[ind_contig_idx] < skips[ind_contig_idx] ) { - - skip_counters[ind_contig_idx]++; - tests_skiped[ind_contig_idx]++; - printf("Test skipped\n"); - } else { - skip_counters[ind_contig_idx] = 0; - START_TIMER(time_tests, timeval_a, "HDgettimeofday(0) succeeds."); - contig_hyperslab_dr_pio_test__run_test(test_num, + + switch(sstest_type){ + case IND_CONTIG: + /* contiguous data set, independent I/O */ + chunk_edge_size = 0; + + contig_hs_dr_pio_test__run_test(test_num, edge_size, chunk_edge_size, small_rank, large_rank, FALSE, dset_type, - express_test); - STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \ - "HDgettimeofday(1) succeeds.", \ - sample_times[col_contig_idx]); - } - test_num++; - break; - /* end of case IND_CONTIG */ - - case COL_CONTIG: - /* contiguous data set, collective I/O */ - chunk_edge_size = 0; - if ( skip_counters[col_contig_idx] < skips[col_contig_idx] ) { - - skip_counters[col_contig_idx]++; - tests_skiped[col_contig_idx]++; - printf("Test skipped\n"); - } else { - skip_counters[col_contig_idx] = 0; - START_TIMER(time_tests, timeval_a, "HDgettimeofday(2) succeeds."); - contig_hyperslab_dr_pio_test__run_test(test_num, + express_test, + &skips, + max_skips, + &total_tests, + &tests_run, + &tests_skipped); + test_num++; + break; + /* end of case IND_CONTIG */ + + case COL_CONTIG: + /* contiguous data set, collective I/O */ + chunk_edge_size = 0; + + contig_hs_dr_pio_test__run_test(test_num, edge_size, chunk_edge_size, small_rank, large_rank, TRUE, dset_type, - express_test); - STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \ - "HDgettimeofday(3) succeeds.", \ - sample_times[ind_contig_idx]); - } - test_num++; - break; - /* end of case COL_CONTIG */ - - case IND_CHUNKED: - /* chunked data set, independent I/O */ - chunk_edge_size = 5; - if ( skip_counters[ind_chunked_idx] < skips[ind_chunked_idx] ) { - - skip_counters[ind_chunked_idx]++; - tests_skiped[ind_chunked_idx]++; - printf("Test skipped\n"); - } else { - skip_counters[ind_chunked_idx] = 0; - START_TIMER(time_tests, timeval_a, "HDgettimeofday(4) succeeds."); - contig_hyperslab_dr_pio_test__run_test(test_num, + express_test, + &skips, + max_skips, + &total_tests, + &tests_run, + &tests_skipped); + test_num++; + break; + /* end of case COL_CONTIG */ + + case IND_CHUNKED: + /* chunked data set, independent I/O */ + chunk_edge_size = 5; + + contig_hs_dr_pio_test__run_test(test_num, edge_size, chunk_edge_size, small_rank, large_rank, FALSE, dset_type, - express_test); - STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \ - "HDgettimeofday(5) succeeds.", \ - sample_times[col_chunked_idx]); - } - test_num++; - break; - /* end of case IND_CHUNKED */ - - case COL_CHUNKED: - /* chunked data set, collective I/O */ - chunk_edge_size = 5; - if ( skip_counters[col_chunked_idx] < skips[col_chunked_idx] ) { - - skip_counters[col_chunked_idx]++; - tests_skiped[col_chunked_idx]++; - printf("Test skipped\n"); - } else { - skip_counters[col_chunked_idx] = 0; - START_TIMER(time_tests, timeval_a, "HDgettimeofday(6) succeeds."); - contig_hyperslab_dr_pio_test__run_test(test_num, + express_test, + &skips, + max_skips, + &total_tests, + &tests_run, + &tests_skipped); + test_num++; + break; + /* end of case IND_CHUNKED */ + + case COL_CHUNKED: + /* chunked data set, collective I/O */ + chunk_edge_size = 5; + + contig_hs_dr_pio_test__run_test(test_num, edge_size, chunk_edge_size, small_rank, large_rank, TRUE, dset_type, - express_test); - STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \ - "HDgettimeofday(7) succeeds.", \ - sample_times[ind_chunked_idx]); - } - test_num++; - break; - /* end of case COL_CHUNKED */ - } /* end of switch(sstest_type) */ - -#ifdef H5_HAVE_GETTIMEOFDAY - if ( time_tests ) { - - samples++; - - if ( samples >= sample_size ) { - - int result; - - time_tests = FALSE; - - max_test_time = ((long long)sample_size) * max_test_time; - - for ( i = 0; i < test_types; i++ ) { - - if ( ( express_test == 0 ) || - ( sample_times[i] <= max_test_time ) ) { - - local_skips[i] = 0; - - } else { - - local_skips[i] = (int)(sample_times[i] / max_test_time); - } - } - - /* do an MPI_Allreduce() with the skips vector to ensure that - * all processes agree on its contents. - */ - result = MPI_Allreduce((void *)local_skips, - (void *)skips, - test_types, - MPI_INT, - MPI_MAX, - MPI_COMM_WORLD); - VRFY((result == MPI_SUCCESS ), \ - "MPI_Allreduce(1) succeeded"); - } + express_test, + &skips, + max_skips, + &total_tests, + &tests_run, + &tests_skipped); + test_num++; + break; + /* end of case COL_CHUNKED */ + + default: + VRFY((FALSE), "unknown test type"); + break; + + } /* end of switch(sstest_type) */ +#if CONTIG_HS_DR_PIO_TEST__DEBUG + if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) { + HDfprintf(stdout, " run/skipped/total = %lld/%lld/%lld.\n", + tests_run, tests_skipped, total_tests); } -#endif /* H5_HAVE_GETTIMEOFDAY */ - +#endif /* CONTIG_HS_DR_PIO_TEST__DEBUG */ } } -#ifdef H5_HAVE_GETTIMEOFDAY - if ( ( MAINPROCESS ) && ( display_skips ) ) { - - HDfprintf(stdout, "***********************************\n"); - HDfprintf(stdout, "express_test = %d.\n", express_test); - HDfprintf(stdout, "sample_size = %d, max_test_time = %lld.\n", - sample_size, max_test_time); - HDfprintf(stdout, "sample_times[] = %lld, %lld, %lld, %lld.\n", - sample_times[ind_contig_idx], - sample_times[col_contig_idx], - sample_times[ind_chunked_idx], - sample_times[col_chunked_idx]); - HDfprintf(stdout, "skips[] = %d, %d, %d, %d.\n", - skips[ind_contig_idx], - skips[col_contig_idx], - skips[ind_chunked_idx], - skips[col_chunked_idx]); - HDfprintf(stdout, "tests_skiped[] = %d, %d, %d, %d.\n", - tests_skiped[ind_contig_idx], - tests_skiped[col_contig_idx], - tests_skiped[ind_chunked_idx], - tests_skiped[col_chunked_idx]); - HDfprintf(stdout, "test_num = %d.\n", test_num); - HDfprintf(stdout, "***********************************\n"); + if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) { + HDfprintf(stdout, " %lld of %lld subtests skipped to expedite testing.\n", + tests_skipped, total_tests); } -#endif /* H5_HAVE_GETTIMEOFDAY */ return; -} /* contig_hyperslab_dr_pio_test() */ +} /* contig_hs_dr_pio_test() */ /**************************************************************** ** -** checker_board_hyperslab_dr_pio_test__select_checker_board(): +** ckrbrd_hs_dr_pio_test__slct_ckrbrd(): ** Given a data space of tgt_rank, and dimensions: ** ** (mpi_size + 1), edge_size, ... , edge_size @@ -1915,21 +2416,19 @@ contig_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type) ** ****************************************************************/ -#define CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 0 +#define CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG 0 static void -checker_board_hyperslab_dr_pio_test__select_checker_board( - const int mpi_rank, - const hid_t tgt_sid, - const int tgt_rank, - const int edge_size, - const int checker_edge_size, - const int sel_rank, - hsize_t sel_start[]) +ckrbrd_hs_dr_pio_test__slct_ckrbrd(const int mpi_rank, + const hid_t tgt_sid, + const int tgt_rank, + const int edge_size, + const int checker_edge_size, + const int sel_rank, + hsize_t sel_start[]) { -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG - const char * fcnName = - "checker_board_hyperslab_dr_pio_test__select_checker_board():"; +#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG + const char * fcnName = "ckrbrd_hs_dr_pio_test__slct_ckrbrd():"; #endif hbool_t first_selection = TRUE; int i, j, k, l, m; @@ -1960,14 +2459,14 @@ checker_board_hyperslab_dr_pio_test__select_checker_board( HDassert( n_cube_offset >= 0 ); HDassert( n_cube_offset <= sel_offset ); -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG +#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG HDfprintf(stdout, "%s:%d: edge_size/checker_edge_size = %d/%d\n", fcnName, mpi_rank, edge_size, checker_edge_size); HDfprintf(stdout, "%s:%d: sel_rank/sel_offset = %d/%d.\n", fcnName, mpi_rank, sel_rank, sel_offset); HDfprintf(stdout, "%s:%d: tgt_rank/n_cube_offset = %d/%d.\n", fcnName, mpi_rank, tgt_rank, n_cube_offset); -#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */ +#endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */ /* First, compute the base count (which assumes start == 0 * for the associated offset) and offset_count (which @@ -2117,7 +2616,7 @@ checker_board_hyperslab_dr_pio_test__select_checker_board( if ( ((i + j + k + l + m) % 2) == 0 ) { -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG +#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG HDfprintf(stdout, "%s%d: *** first_selection = %d ***\n", fcnName, mpi_rank, (int)first_selection); HDfprintf(stdout, "%s:%d: i/j/k/l/m = %d/%d/%d/%d/%d\n", @@ -2204,10 +2703,10 @@ checker_board_hyperslab_dr_pio_test__select_checker_board( } while ( ( i <= 1 ) && ( 0 >= sel_offset ) ); -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG +#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG HDfprintf(stdout, "%s%d: H5Sget_select_npoints(tgt_sid) = %d.\n", fcnName, mpi_rank, (int)H5Sget_select_npoints(tgt_sid)); -#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */ +#endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */ /* Clip the selection back to the data space proper. */ @@ -2224,20 +2723,20 @@ checker_board_hyperslab_dr_pio_test__select_checker_board( VRFY((ret != FAIL), "H5Sselect_hyperslab(AND) succeeded"); -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG +#if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG HDfprintf(stdout, "%s%d: H5Sget_select_npoints(tgt_sid) = %d.\n", fcnName, mpi_rank, (int)H5Sget_select_npoints(tgt_sid)); HDfprintf(stdout, "%s%d: done.\n", fcnName, mpi_rank); -#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */ +#endif /* CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG */ return; -} /* checker_board_hyperslab_dr_pio_test__select_checker_board() */ +} /* ckrbrd_hs_dr_pio_test__slct_ckrbrd() */ /**************************************************************** ** -** checker_board_hyperslab_dr_pio_test__verify_data(): +** ckrbrd_hs_dr_pio_test__verify_data(): ** ** Examine the supplied buffer to see if it contains the ** expected data. Return TRUE if it does, and FALSE @@ -2291,19 +2790,18 @@ checker_board_hyperslab_dr_pio_test__select_checker_board( ** ****************************************************************/ -#define CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG 0 +#define CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 0 static hbool_t -checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr, - const int rank, - const int edge_size, - const int checker_edge_size, - uint32_t first_expected_val, - hbool_t buf_starts_in_checker) +ckrbrd_hs_dr_pio_test__verify_data(uint32_t * buf_ptr, + const int rank, + const int edge_size, + const int checker_edge_size, + uint32_t first_expected_val, + hbool_t buf_starts_in_checker) { -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG - const char * fcnName = - "checker_board_hyperslab_dr_pio_test__verify_data():"; +#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG + const char * fcnName = "ckrbrd_hs_dr_pio_test__verify_data():"; #endif hbool_t good_data = TRUE; hbool_t in_checker; @@ -2322,7 +2820,7 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr, HDassert( checker_edge_size <= edge_size ); HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK ); -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG +#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG int mpi_rank; @@ -2385,13 +2883,13 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr, m = 0; z = 0; -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG +#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG HDfprintf(stdout, "%d, %d, %d, %d, %d:", i, j, k, l, m); #endif in_checker = start_in_checker[3]; do { -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG +#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG HDfprintf(stdout, " %d", (int)(*val_ptr)); #endif if ( z >= checker_edge_size ) { @@ -2426,7 +2924,7 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr, } while ( ( rank >= (test_max_rank - 4) ) && ( m < edge_size ) ); -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__VERIFY_DATA__DEBUG +#if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG HDfprintf(stdout, "\n"); #endif l++; @@ -2448,668 +2946,118 @@ checker_board_hyperslab_dr_pio_test__verify_data(uint32_t * buf_ptr, return(good_data); -} /* checker_board_hyperslab_dr_pio_test__verify_data() */ +} /* ckrbrd_hs_dr_pio_test__verify_data() */ /*------------------------------------------------------------------------- - * Function: checker_board_hyperslab_dr_pio_test__run_test() + * Function: ckrbrd_hs_dr_pio_test__d2m_l2s() * - * Purpose: Test I/O to/from checkerboard selections of hyperslabs of - * different rank in the parallel. + * Purpose: Part one of a series of tests of I/O to/from hyperslab + * selections of different rank in the parallel. + * + * Verify that we can read from disk correctly using checker + * board selections of different rank that + * H5S_select_shape_same() views as being of the same shape. + * + * In this function, we test this by reading small_rank - 1 + * checker board slices from the on disk large cube, and + * verifying that the data read is correct. Verify that + * H5S_select_shape_same() returns true on the memory and + * file selections. * * Return: void * - * Programmer: JRM -- 10/10/09 + * Programmer: JRM -- 9/15/11 * * Modifications: * - * JRM -- 9/16/10 - * Added the express_test parameter. Use it to control - * whether we set an alignment, and whether we allocate - * chunks such that no two processes will normally touch - * the same chunk. + * None. * *------------------------------------------------------------------------- */ -#define PAR_SS_DR_MAX_RANK 5 -#define CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG 0 +#define CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG 0 static void -checker_board_hyperslab_dr_pio_test__run_test(const int test_num, - const int edge_size, - const int checker_edge_size, - const int chunk_edge_size, - const int small_rank, - const int large_rank, - const hbool_t use_collective_io, - const hid_t dset_type, - const int express_test) +ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t * tv_ptr) { -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - const char *fcnName = "checker_board_hyperslab_dr_pio_test__run_test()"; -#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ - const char *filename; - hbool_t use_gpfs = FALSE; /* Use GPFS hints */ +#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG + const char *fcnName = "ckrbrd_hs_dr_pio_test__d2m_l2s()"; + uint32_t * ptr_0; +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ hbool_t data_ok = FALSE; - hbool_t mis_match = FALSE; int i, j, k, l; - size_t u; - int mrc; - size_t start_index; - size_t stop_index; - int small_ds_offset; - int large_ds_offset; - const int test_max_rank = 5; /* must update code if this changes */ uint32_t expected_value; - uint32_t * small_ds_buf_0 = NULL; - uint32_t * small_ds_buf_1 = NULL; - uint32_t * small_ds_buf_2 = NULL; - uint32_t * small_ds_slice_buf = NULL; - uint32_t * large_ds_buf_0 = NULL; - uint32_t * large_ds_buf_1 = NULL; - uint32_t * large_ds_buf_2 = NULL; - uint32_t * large_ds_slice_buf = NULL; - uint32_t * ptr_0; - uint32_t * ptr_1; - int mpi_rank; - int mpi_size; - MPI_Comm mpi_comm = MPI_COMM_NULL; - MPI_Info mpi_info = MPI_INFO_NULL; - hid_t fid; /* HDF5 file ID */ - hid_t acc_tpl; /* File access templates */ - hid_t xfer_plist = H5P_DEFAULT; - hid_t full_mem_small_ds_sid; - hid_t full_file_small_ds_sid; - hid_t mem_small_ds_sid; - hid_t file_small_ds_sid_0; - hid_t file_small_ds_sid_1; - hid_t small_ds_slice_sid; - hid_t full_mem_large_ds_sid; - hid_t full_file_large_ds_sid; - hid_t mem_large_ds_sid; - hid_t file_large_ds_sid_0; - hid_t file_large_ds_sid_1; - hid_t file_large_ds_process_slice_sid; - hid_t mem_large_ds_process_slice_sid; - hid_t large_ds_slice_sid; - hid_t small_ds_dcpl_id = H5P_DEFAULT; - hid_t large_ds_dcpl_id = H5P_DEFAULT; - hid_t small_dataset; /* Dataset ID */ - hid_t large_dataset; /* Dataset ID */ - size_t small_ds_size = 1; - size_t small_ds_slice_size = 1; - size_t large_ds_size = 1; - size_t large_ds_slice_size = 1; - hsize_t dims[PAR_SS_DR_MAX_RANK]; - hsize_t chunk_dims[PAR_SS_DR_MAX_RANK]; - hsize_t start[PAR_SS_DR_MAX_RANK]; - hsize_t stride[PAR_SS_DR_MAX_RANK]; - hsize_t count[PAR_SS_DR_MAX_RANK]; - hsize_t block[PAR_SS_DR_MAX_RANK]; + int mpi_rank; /* needed by VRFY */ hsize_t sel_start[PAR_SS_DR_MAX_RANK]; htri_t check; /* Shape comparison return value */ herr_t ret; /* Generic return value */ - HDassert( edge_size >= 6 ); - HDassert( edge_size >= chunk_edge_size ); - HDassert( ( chunk_edge_size == 0 ) || ( chunk_edge_size >= 3 ) ); - HDassert( 1 < small_rank ); - HDassert( small_rank < large_rank ); - HDassert( large_rank <= test_max_rank ); - HDassert( test_max_rank <= PAR_SS_DR_MAX_RANK ); - - MPI_Comm_size(MPI_COMM_WORLD, &mpi_size); - MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); - - HDassert( mpi_size >= 1 ); - - mpi_comm = MPI_COMM_WORLD; - mpi_info = MPI_INFO_NULL; - - for ( i = 0; i < small_rank - 1; i++ ) - { - small_ds_size *= (size_t)edge_size; - small_ds_slice_size *= (size_t)edge_size; - } - small_ds_size *= (size_t)(mpi_size + 1); - - small_ds_offset = PAR_SS_DR_MAX_RANK - small_rank; - - HDassert( 0 < small_ds_offset ); - HDassert( small_ds_offset < PAR_SS_DR_MAX_RANK ); - - - for ( i = 0; i < large_rank - 1; i++ ) { - - large_ds_size *= (size_t)edge_size; - large_ds_slice_size *= (size_t)edge_size; - } - large_ds_size *= (size_t)(mpi_size + 1); - - large_ds_offset = PAR_SS_DR_MAX_RANK - large_rank; - - HDassert( 0 <= large_ds_offset ); - HDassert( large_ds_offset < PAR_SS_DR_MAX_RANK ); - - - /* Allocate buffers */ - small_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size); - VRFY((small_ds_buf_0 != NULL), "malloc of small_ds_buf_0 succeeded"); - - small_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size); - VRFY((small_ds_buf_1 != NULL), "malloc of small_ds_buf_1 succeeded"); - - small_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_size); - VRFY((small_ds_buf_2 != NULL), "malloc of small_ds_buf_2 succeeded"); - - small_ds_slice_buf = - (uint32_t *)HDmalloc(sizeof(uint32_t) * small_ds_slice_size); - VRFY((small_ds_slice_buf != NULL), "malloc of small_ds_slice_buf succeeded"); - - large_ds_buf_0 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size); - VRFY((large_ds_buf_0 != NULL), "malloc of large_ds_buf_0 succeeded"); - - large_ds_buf_1 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size); - VRFY((large_ds_buf_1 != NULL), "malloc of large_ds_buf_1 succeeded"); - - large_ds_buf_2 = (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_size); - VRFY((large_ds_buf_2 != NULL), "malloc of large_ds_buf_2 succeeded"); - - large_ds_slice_buf = - (uint32_t *)HDmalloc(sizeof(uint32_t) * large_ds_slice_size); - VRFY((large_ds_slice_buf != NULL), "malloc of large_ds_slice_buf succeeded"); - - /* initialize the buffers */ - - ptr_0 = small_ds_buf_0; - for(i = 0; i < (int)small_ds_size; i++) - *ptr_0++ = (uint32_t)i; - HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size); - HDmemset(small_ds_buf_2, 0, sizeof(uint32_t) * small_ds_size); - - HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size); - - ptr_0 = large_ds_buf_0; - for(i = 0; i < (int)large_ds_size; i++) - *ptr_0++ = (uint32_t)i; - HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size); - HDmemset(large_ds_buf_2, 0, sizeof(uint32_t) * large_ds_size); - - HDmemset(large_ds_slice_buf, 0, sizeof(uint32_t) * large_ds_slice_size); - - filename = (const char *)GetTestParameters(); - HDassert( filename != NULL ); - -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - if ( MAINPROCESS ) { - - HDfprintf(stdout, "%s:%d: test num = %d.\n", fcnName, mpi_rank, test_num); - HDfprintf(stdout, "%s:%d: mpi_size = %d.\n", fcnName, mpi_rank, mpi_size); - HDfprintf(stdout, - "%s:%d: small/large rank = %d/%d, use_collective_io = %d.\n", - fcnName, mpi_rank, small_rank, large_rank, (int)use_collective_io); - HDfprintf(stdout, "%s:%d: edge_size = %d, chunk_edge_size = %d.\n", - fcnName, mpi_rank, edge_size, chunk_edge_size); - HDfprintf(stdout, "%s:%d: checker_edge_size = %d.\n", - fcnName, mpi_rank, checker_edge_size); - HDfprintf(stdout, "%s:%d: small_ds_size = %d, large_ds_size = %d.\n", - fcnName, mpi_rank, (int)small_ds_size, (int)large_ds_size); - HDfprintf(stdout, "%s:%d: filename = %s.\n", fcnName, mpi_rank, filename); - } -#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ - - /* ---------------------------------------- - * CREATE AN HDF5 FILE WITH PARALLEL ACCESS - * ---------------------------------------*/ - /* setup file access template */ - acc_tpl = create_faccess_plist(mpi_comm, mpi_info, facc_type, use_gpfs); - VRFY((acc_tpl >= 0), "create_faccess_plist() succeeded"); - - /* set the alignment -- need it large so that we aren't always hitting the - * the same file system block. Do this only if express_test is greater - * than zero. - */ - if ( express_test > 0 ) { - - ret = H5Pset_alignment(acc_tpl, (hsize_t)0, SHAPE_SAME_TEST_ALIGNMENT); - VRFY((ret != FAIL), "H5Pset_alignment() succeeded"); - } - - /* create the file collectively */ - fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, acc_tpl); - VRFY((fid >= 0), "H5Fcreate succeeded"); - - MESG("File opened."); - - /* Release file-access template */ - ret = H5Pclose(acc_tpl); - VRFY((ret >= 0), "H5Pclose(acc_tpl) succeeded"); - - - /* setup dims: */ - dims[0] = (hsize_t)(mpi_size + 1); - dims[1] = dims[2] = dims[3] = dims[4] = (hsize_t)edge_size; - - - /* Create small ds dataspaces */ - full_mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL); - VRFY((full_mem_small_ds_sid != 0), - "H5Screate_simple() full_mem_small_ds_sid succeeded"); - - full_file_small_ds_sid = H5Screate_simple(small_rank, dims, NULL); - VRFY((full_file_small_ds_sid != 0), - "H5Screate_simple() full_file_small_ds_sid succeeded"); - - mem_small_ds_sid = H5Screate_simple(small_rank, dims, NULL); - VRFY((mem_small_ds_sid != 0), - "H5Screate_simple() mem_small_ds_sid succeeded"); - - file_small_ds_sid_0 = H5Screate_simple(small_rank, dims, NULL); - VRFY((file_small_ds_sid_0 != 0), - "H5Screate_simple() file_small_ds_sid_0 succeeded"); - - file_small_ds_sid_1 = H5Screate_simple(small_rank, dims, NULL); - VRFY((file_small_ds_sid_1 != 0), - "H5Screate_simple() file_small_ds_sid_1 succeeded"); - - small_ds_slice_sid = H5Screate_simple(small_rank - 1, &(dims[1]), NULL); - VRFY((small_ds_slice_sid != 0), - "H5Screate_simple() small_ds_slice_sid succeeded"); - - - /* Create large ds dataspaces */ - full_mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((full_mem_large_ds_sid != 0), - "H5Screate_simple() full_mem_large_ds_sid succeeded"); - - full_file_large_ds_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((full_file_large_ds_sid != FAIL), - "H5Screate_simple() full_file_large_ds_sid succeeded"); - - mem_large_ds_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((mem_large_ds_sid != FAIL), - "H5Screate_simple() mem_large_ds_sid succeeded"); - - file_large_ds_sid_0 = H5Screate_simple(large_rank, dims, NULL); - VRFY((file_large_ds_sid_0 != FAIL), - "H5Screate_simple() file_large_ds_sid_0 succeeded"); - - file_large_ds_sid_1 = H5Screate_simple(large_rank, dims, NULL); - VRFY((file_large_ds_sid_1 != FAIL), - "H5Screate_simple() file_large_ds_sid_1 succeeded"); - - mem_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((mem_large_ds_process_slice_sid != FAIL), - "H5Screate_simple() mem_large_ds_process_slice_sid succeeded"); - - file_large_ds_process_slice_sid = H5Screate_simple(large_rank, dims, NULL); - VRFY((file_large_ds_process_slice_sid != FAIL), - "H5Screate_simple() file_large_ds_process_slice_sid succeeded"); - - - large_ds_slice_sid = H5Screate_simple(large_rank - 1, &(dims[1]), NULL); - VRFY((large_ds_slice_sid != 0), - "H5Screate_simple() large_ds_slice_sid succeeded"); - - - /* if chunk edge size is greater than zero, set up the small and - * large data set creation property lists to specify chunked - * datasets. - */ - if ( chunk_edge_size > 0 ) { - - /* Under Lustre (and perhaps other parallel file systems?) we get - * locking delays when two or more processes attempt to access the - * same file system block. - * - * To minimize this problem, I have changed chunk_dims[0] - * from (mpi_size + 1) to just when any sort of express test is - * selected. Given the structure of the test, and assuming we - * set the alignment large enough, this avoids the contention - * issue by seeing to it that each chunk is only accessed by one - * process. - * - * One can argue as to whether this is a good thing to do in our - * tests, but for now it is necessary if we want the test to complete - * in a reasonable amount of time. - * - * JRM -- 9/16/10 - */ - if ( express_test == 0 ) { - - chunk_dims[0] = 1; - - } else { - - chunk_dims[0] = 1; - } - - chunk_dims[1] = chunk_dims[2] = - chunk_dims[3] = chunk_dims[4] = (hsize_t)chunk_edge_size; - - small_ds_dcpl_id = H5Pcreate(H5P_DATASET_CREATE); - VRFY((ret != FAIL), "H5Pcreate() small_ds_dcpl_id succeeded"); - - ret = H5Pset_layout(small_ds_dcpl_id, H5D_CHUNKED); - VRFY((ret != FAIL), "H5Pset_layout() small_ds_dcpl_id succeeded"); - - ret = H5Pset_chunk(small_ds_dcpl_id, small_rank, chunk_dims); - VRFY((ret != FAIL), "H5Pset_chunk() small_ds_dcpl_id succeeded"); - - - large_ds_dcpl_id = H5Pcreate(H5P_DATASET_CREATE); - VRFY((ret != FAIL), "H5Pcreate() large_ds_dcpl_id succeeded"); - - ret = H5Pset_layout(large_ds_dcpl_id, H5D_CHUNKED); - VRFY((ret != FAIL), "H5Pset_layout() large_ds_dcpl_id succeeded"); - - ret = H5Pset_chunk(large_ds_dcpl_id, large_rank, chunk_dims); - VRFY((ret != FAIL), "H5Pset_chunk() large_ds_dcpl_id succeeded"); - } - - /* create the small dataset */ - small_dataset = H5Dcreate2(fid, "small_dataset", dset_type, - file_small_ds_sid_0, H5P_DEFAULT, - small_ds_dcpl_id, H5P_DEFAULT); - VRFY((ret != FAIL), "H5Dcreate2() small_dataset succeeded"); - - /* create the large dataset */ - large_dataset = H5Dcreate2(fid, "large_dataset", dset_type, - file_large_ds_sid_0, H5P_DEFAULT, - large_ds_dcpl_id, H5P_DEFAULT); - VRFY((ret != FAIL), "H5Dcreate2() large_dataset succeeded"); - - - /* setup xfer property list */ - xfer_plist = H5Pcreate(H5P_DATASET_XFER); - VRFY((xfer_plist >= 0), "H5Pcreate(H5P_DATASET_XFER) succeeded"); - - if(use_collective_io) { - ret = H5Pset_dxpl_mpio(xfer_plist, H5FD_MPIO_COLLECTIVE); - VRFY((ret >= 0), "H5Pset_dxpl_mpio succeeded"); - } - - - /* setup selection to write initial data to the small and large data sets */ - start[0] = (hsize_t)mpi_rank; - stride[0] = (hsize_t)(2 * (mpi_size + 1)); - count[0] = 1; - block[0] = 1; - - for ( i = 1; i < large_rank; i++ ) { - - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - block[i] = (hsize_t)edge_size; - } - - /* setup selections for writing initial data to the small data set */ - ret = H5Sselect_hyperslab(mem_small_ds_sid, - H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded"); - - ret = H5Sselect_hyperslab(file_small_ds_sid_0, - H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded"); - - if ( MAINPROCESS ) { /* add an additional slice to the selections */ - - start[0] = (hsize_t)mpi_size; - - ret = H5Sselect_hyperslab(mem_small_ds_sid, - H5S_SELECT_OR, - start, - stride, - count, - block); - VRFY((ret>= 0), "H5Sselect_hyperslab(mem_small_ds_sid, or) suceeded"); - - ret = H5Sselect_hyperslab(file_small_ds_sid_0, - H5S_SELECT_OR, - start, - stride, - count, - block); - VRFY((ret>= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, or) suceeded"); - } - - - /* write the initial value of the small data set to file */ - ret = H5Dwrite(small_dataset, dset_type, mem_small_ds_sid, file_small_ds_sid_0, - xfer_plist, small_ds_buf_0); - VRFY((ret >= 0), "H5Dwrite() small_dataset initial write succeeded"); - - - /* sync with the other processes before checking data */ - if ( ! use_collective_io ) { - - mrc = MPI_Barrier(MPI_COMM_WORLD); - VRFY((mrc==MPI_SUCCESS), "Sync after small dataset writes"); - } - - /* read the small data set back to verify that it contains the - * expected data. Note that each process reads in the entire - * data set and verifies it. - */ - ret = H5Dread(small_dataset, - H5T_NATIVE_UINT32, - full_mem_small_ds_sid, - full_file_small_ds_sid, - xfer_plist, - small_ds_buf_1); - VRFY((ret >= 0), "H5Dread() small_dataset initial read succeeded"); - - - /* verify that the correct data was written to the small data set */ - expected_value = 0; - mis_match = FALSE; - ptr_1 = small_ds_buf_1; - - i = 0; - for ( i = 0; i < (int)small_ds_size; i++ ) { - - if ( *ptr_1 != expected_value ) { - - mis_match = TRUE; - } - ptr_1++; - expected_value++; - } - VRFY( (mis_match == FALSE), "small ds init data good."); - - - - /* setup selections for writing initial data to the large data set */ - - start[0] = (hsize_t)mpi_rank; - - ret = H5Sselect_hyperslab(mem_large_ds_sid, - H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), "H5Sselect_hyperslab(mem_large_ds_sid, set) suceeded"); - - ret = H5Sselect_hyperslab(file_large_ds_sid_0, - H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, set) suceeded"); - - /* In passing, setup the process slice data spaces as well */ - - ret = H5Sselect_hyperslab(mem_large_ds_process_slice_sid, - H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), - "H5Sselect_hyperslab(mem_large_ds_process_slice_sid, set) suceeded"); - - ret = H5Sselect_hyperslab(file_large_ds_process_slice_sid, - H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), - "H5Sselect_hyperslab(file_large_ds_process_slice_sid, set) suceeded"); - - if ( MAINPROCESS ) { /* add an additional slice to the selections */ - - start[0] = (hsize_t)mpi_size; - - ret = H5Sselect_hyperslab(mem_large_ds_sid, - H5S_SELECT_OR, - start, - stride, - count, - block); - VRFY((ret>= 0), "H5Sselect_hyperslab(mem_large_ds_sid, or) suceeded"); - - ret = H5Sselect_hyperslab(file_large_ds_sid_0, - H5S_SELECT_OR, - start, - stride, - count, - block); - VRFY((ret>= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, or) suceeded"); - } - - - /* write the initial value of the large data set to file */ - ret = H5Dwrite(large_dataset, dset_type, mem_large_ds_sid, file_large_ds_sid_0, - xfer_plist, large_ds_buf_0); - if ( ret < 0 ) H5Eprint2(H5E_DEFAULT, stderr); - VRFY((ret >= 0), "H5Dwrite() large_dataset initial write succeeded"); - - - /* sync with the other processes before checking data */ - if ( ! use_collective_io ) { - - mrc = MPI_Barrier(MPI_COMM_WORLD); - VRFY((mrc==MPI_SUCCESS), "Sync after large dataset writes"); - } - - - /* read the small data set back to verify that it contains the - * expected data. Note that each process reads in the entire - * data set. - */ - ret = H5Dread(large_dataset, - H5T_NATIVE_UINT32, - full_mem_large_ds_sid, - full_file_large_ds_sid, - xfer_plist, - large_ds_buf_1); - VRFY((ret >= 0), "H5Dread() large_dataset initial read succeeded"); - + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; - /* verify that the correct data was written to the small data set */ - expected_value = 0; - mis_match = FALSE; - ptr_1 = large_ds_buf_1; - - i = 0; - for ( i = 0; i < (int)large_ds_size; i++ ) { - - if ( *ptr_1 != expected_value ) { - - mis_match = TRUE; - } - ptr_1++; - expected_value++; - } - VRFY( (mis_match == FALSE), "large ds init data good."); - - /* sync with the other processes before changing data */ - - if ( ! use_collective_io ) { - - mrc = MPI_Barrier(MPI_COMM_WORLD); - VRFY((mrc==MPI_SUCCESS), "Sync after initial values check"); - } - - - /***********************************/ - /***** INITIALIZATION COMPLETE *****/ - /***********************************/ /* first, verify that we can read from disk correctly using selections * of different rank that H5S_select_shape_same() views as being of the * same shape. * - * Start by reading a (small_rank - 1)-D slice from this processes slice - * of the on disk large data set, and verifying that the data read is - * correct. Verify that H5S_select_shape_same() returns true on the - * memory and file selections. + * Start by reading a (small_rank - 1)-D checker board slice from this + * processes slice of the on disk large data set, and verifying that the + * data read is correct. Verify that H5S_select_shape_same() returns + * true on the memory and file selections. * * The first step is to set up the needed checker board selection in the * in memory small small cube */ sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0; - sel_start[small_ds_offset] = (hsize_t)mpi_rank; + sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank); - checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank, - small_ds_slice_sid, - small_rank - 1, - edge_size, - checker_edge_size, - small_rank - 1, - sel_start); + ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank, + tv_ptr->small_ds_slice_sid, + tv_ptr->small_rank - 1, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + tv_ptr->small_rank - 1, + sel_start); /* zero out the buffer we will be reading into */ - HDmemset(small_ds_slice_buf, 0, sizeof(uint32_t) * small_ds_slice_size); + HDmemset(tv_ptr->small_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->small_ds_slice_size); -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG +#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG HDfprintf(stdout, "%s:%d: initial small_ds_slice_buf = ", - fcnName, mpi_rank); - ptr_0 = small_ds_slice_buf; - for ( i = 0; i < (int)small_ds_slice_size; i++ ) { - HDfprintf(stdout, "%d ", (int)(*ptr_0)); + fcnName, tv_ptr->mpi_rank); + ptr_0 = tv_ptr->small_ds_slice_buf; + for ( i = 0; i < (int)(tv_ptr->small_ds_slice_size); i++ ) { + HDfprintf(stdout, "%d ", (int)(*ptr_0)); ptr_0++; } HDfprintf(stdout, "\n"); -#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ /* set up start, stride, count, and block -- note that we will * change start[] so as to read slices of the large cube. */ for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) { + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) { - block[i] = 1; + tv_ptr->block[i] = 1; } else { - block[i] = (hsize_t)edge_size; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } } -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG +#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG HDfprintf(stdout, "%s:%d: reading slice from big ds on disk into small ds slice.\n", - fcnName, mpi_rank); -#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ + fcnName, tv_ptr->mpi_rank); +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ /* in serial versions of this test, we loop through all the dimensions * of the large data set. However, in the parallel version, each * process only works with that slice of the large cube indicated @@ -3117,9 +3065,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num, * mpi_rank, and don't itterate over it. */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) { - i = mpi_rank; + i = tv_ptr->mpi_rank; } else { @@ -3132,9 +3080,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num, * test. */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) { - j = mpi_rank; + j = tv_ptr->mpi_rank; } else { @@ -3142,9 +3090,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num, } do { - if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) { - k = mpi_rank; + k = tv_ptr->mpi_rank; } else { @@ -3164,98 +3112,167 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num, l = 0; do { - /* we know that small_rank - 1 >= 1 and that - * large_rank > small_rank by the assertions at the head - * of this function. Thus no need for another inner loop. - */ - start[0] = (hsize_t)i; - start[1] = (hsize_t)j; - start[2] = (hsize_t)k; - start[3] = (hsize_t)l; - start[4] = 0; - - HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) ); - HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) ); - HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) ); - HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) ); - HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) ); - - checker_board_hyperslab_dr_pio_test__select_checker_board - ( - mpi_rank, - file_large_ds_sid_0, - large_rank, - edge_size, - checker_edge_size, - small_rank - 1, - start - ); - - /* verify that H5S_select_shape_same() reports the two - * selections as having the same shape. - */ - check = H5S_select_shape_same_test(small_ds_slice_sid, - file_large_ds_sid_0); - VRFY((check == TRUE), "H5S_select_shape_same_test passed"); - - - /* Read selection from disk */ -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", fcnName, - mpi_rank, start[0], start[1], start[2], start[3], - start[4]); - HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n", - fcnName, - H5Sget_simple_extent_ndims(small_ds_slice_sid), - H5Sget_simple_extent_ndims(file_large_ds_sid_0)); -#endif /* CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG */ - - ret = H5Dread(large_dataset, - H5T_NATIVE_UINT32, - small_ds_slice_sid, - file_large_ds_sid_0, - xfer_plist, - small_ds_slice_buf); - VRFY((ret >= 0), "H5Dread() slice from large ds succeeded."); - -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - HDfprintf(stdout, "%s:%d: H5Dread() returns.\n", - fcnName, mpi_rank); -#endif + if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */ + + (tv_ptr->tests_skipped)++; + + } else { /* run the test */ + + tv_ptr->skips = 0; /* reset the skips counter */ + + /* we know that small_rank - 1 >= 1 and that + * large_rank > small_rank by the assertions at the head + * of this function. Thus no need for another inner loop. + */ + tv_ptr->start[0] = (hsize_t)i; + tv_ptr->start[1] = (hsize_t)j; + tv_ptr->start[2] = (hsize_t)k; + tv_ptr->start[3] = (hsize_t)l; + tv_ptr->start[4] = 0; + + HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1)); + + ckrbrd_hs_dr_pio_test__slct_ckrbrd + ( + tv_ptr->mpi_rank, + tv_ptr->file_large_ds_sid_0, + tv_ptr->large_rank, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + tv_ptr->small_rank - 1, + tv_ptr->start + ); + + /* verify that H5S_select_shape_same() reports the two + * selections as having the same shape. + */ + check = H5S_select_shape_same_test(tv_ptr->small_ds_slice_sid, + tv_ptr->file_large_ds_sid_0); + VRFY((check == TRUE), "H5S_select_shape_same_test passed"); + + + /* Read selection from disk */ +#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG + HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", fcnName, + tv_ptr->mpi_rank, tv_ptr->start[0], tv_ptr->start[1], + tv_ptr->start[2], tv_ptr->start[3], tv_ptr->start[4]); + HDfprintf(stdout, "%s slice/file extent dims = %d/%d.\n", + fcnName, + H5Sget_simple_extent_ndims(tv_ptr->small_ds_slice_sid), + H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_0)); +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ + + ret = H5Dread(tv_ptr->large_dataset, + H5T_NATIVE_UINT32, + tv_ptr->small_ds_slice_sid, + tv_ptr->file_large_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->small_ds_slice_buf); + VRFY((ret >= 0), "H5Dread() slice from large ds succeeded."); + +#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG + HDfprintf(stdout, "%s:%d: H5Dread() returns.\n", + fcnName, tv_ptr->mpi_rank); +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */ + + /* verify that expected data is retrieved */ + + expected_value = (uint32_t) + ((i * tv_ptr->edge_size * tv_ptr->edge_size * + tv_ptr->edge_size * tv_ptr->edge_size) + + (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) + + (k * tv_ptr->edge_size * tv_ptr->edge_size) + + (l * tv_ptr->edge_size)); + + data_ok = ckrbrd_hs_dr_pio_test__verify_data + ( + tv_ptr->small_ds_slice_buf, + tv_ptr->small_rank - 1, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + expected_value, + (hbool_t)TRUE + ); + + VRFY((data_ok == TRUE), + "small slice read from large ds data good."); + + (tv_ptr->tests_run)++; + } - /* verify that expected data is retrieved */ - - expected_value = (uint32_t) - ((i * edge_size * edge_size * edge_size * edge_size) + - (j * edge_size * edge_size * edge_size) + - (k * edge_size * edge_size) + - (l * edge_size)); - - data_ok = checker_board_hyperslab_dr_pio_test__verify_data - ( - small_ds_slice_buf, - small_rank - 1, - edge_size, - checker_edge_size, - expected_value, - (hbool_t)TRUE - ); - - VRFY((data_ok == TRUE), - "small slice read from large ds data good."); l++; - } while ( ( large_rank > 2 ) && - ( (small_rank - 1) <= 1 ) && - ( l < edge_size ) ); + (tv_ptr->total_tests)++; + + } while ( ( tv_ptr->large_rank > 2 ) && + ( (tv_ptr->small_rank - 1) <= 1 ) && + ( l < tv_ptr->edge_size ) ); k++; - } while ( ( large_rank > 3 ) && - ( (small_rank - 1) <= 2 ) && - ( k < edge_size ) ); + } while ( ( tv_ptr->large_rank > 3 ) && + ( (tv_ptr->small_rank - 1) <= 2 ) && + ( k < tv_ptr->edge_size ) ); j++; - } while ( ( large_rank > 4 ) && - ( (small_rank - 1) <= 3 ) && - ( j < edge_size ) ); + } while ( ( tv_ptr->large_rank > 4 ) && + ( (tv_ptr->small_rank - 1) <= 3 ) && + ( j < tv_ptr->edge_size ) ); + + return; + +} /* ckrbrd_hs_dr_pio_test__d2m_l2s() */ + + +/*------------------------------------------------------------------------- + * Function: ckrbrd_hs_dr_pio_test__d2m_s2l() + * + * Purpose: Part two of a series of tests of I/O to/from hyperslab + * selections of different rank in the parallel. + * + * Verify that we can read from disk correctly using + * selections of different rank that H5S_select_shape_same() + * views as being of the same shape. + * + * In this function, we test this by reading checker board + * slices of the on disk small data set into slices through + * the in memory large data set, and verify that the correct + * data (and only the correct data) is read. + * + * Return: void + * + * Programmer: JRM -- 8/15/11 + * + * Modifications: + * + * None. + * + *------------------------------------------------------------------------- + */ + +#define CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG 0 + +static void +ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t * tv_ptr) +{ +#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG + const char *fcnName = "ckrbrd_hs_dr_pio_test__d2m_s2l()"; +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */ + hbool_t data_ok = FALSE; + int i, j, k, l; + size_t u; + size_t start_index; + size_t stop_index; + uint32_t expected_value; + uint32_t * ptr_1; + int mpi_rank; /* needed by VRFY */ + hsize_t sel_start[PAR_SS_DR_MAX_RANK]; + htri_t check; /* Shape comparison return value */ + herr_t ret; /* Generic return value */ + + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; /* similarly, read slices of the on disk small data set into slices @@ -3264,24 +3281,24 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num, */ sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0; - sel_start[small_ds_offset] = (hsize_t)mpi_rank; + sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank); - checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank, - file_small_ds_sid_0, - small_rank, - edge_size, - checker_edge_size, - small_rank - 1, - sel_start); + ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank, + tv_ptr->file_small_ds_sid_0, + tv_ptr->small_rank, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + tv_ptr->small_rank - 1, + sel_start); -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG +#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG HDfprintf(stdout, "%s reading slices of on disk small data set into slices of big data set.\n", fcnName); -#endif +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */ /* zero out the buffer we will be reading into */ - HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size); + HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size); /* set up start, stride, count, and block -- note that we will * change start[] so as to read the slice of the small data set @@ -3290,20 +3307,19 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num, */ for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) { + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) { - block[i] = 1; + tv_ptr->block[i] = 1; } else { - block[i] = (hsize_t)edge_size; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } } - /* in serial versions of this test, we loop through all the dimensions * of the large data set that don't appear in the small data set. * @@ -3314,9 +3330,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num, */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) { - i = mpi_rank; + i = tv_ptr->mpi_rank; } else { @@ -3329,9 +3345,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num, * test. */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) { - j = mpi_rank; + j = tv_ptr->mpi_rank; } else { @@ -3339,9 +3355,9 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num, } do { - if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) { - k = mpi_rank; + k = tv_ptr->mpi_rank; } else { @@ -3361,161 +3377,235 @@ checker_board_hyperslab_dr_pio_test__run_test(const int test_num, l = 0; do { - /* we know that small_rank >= 1 and that large_rank > small_rank - * by the assertions at the head of this function. Thus no - * need for another inner loop. - */ - start[0] = (hsize_t)i; - start[1] = (hsize_t)j; - start[2] = (hsize_t)k; - start[3] = (hsize_t)l; - start[4] = 0; - - HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) ); - HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) ); - HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) ); - HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) ); - HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) ); - - checker_board_hyperslab_dr_pio_test__select_checker_board - ( - mpi_rank, - mem_large_ds_sid, - large_rank, - edge_size, - checker_edge_size, - small_rank - 1, - start - ); - - - /* verify that H5S_select_shape_same() reports the two - * selections as having the same shape. - */ - check = H5S_select_shape_same_test(file_small_ds_sid_0, - mem_large_ds_sid); - VRFY((check == TRUE), "H5S_select_shape_same_test passed"); - - - /* Read selection from disk */ -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", - fcnName, mpi_rank, - start[0], start[1], start[2], start[3], start[4]); - HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", - fcnName, mpi_rank, - H5Sget_simple_extent_ndims(large_ds_slice_sid), - H5Sget_simple_extent_ndims(file_small_ds_sid_0)); -#endif - ret = H5Dread(small_dataset, - H5T_NATIVE_UINT32, - mem_large_ds_sid, - file_small_ds_sid_0, - xfer_plist, - large_ds_buf_1); - VRFY((ret >= 0), "H5Dread() slice from small ds succeeded."); - - /* verify that the expected data and only the - * expected data was read. - */ - data_ok = TRUE; - ptr_1 = large_ds_buf_1; - expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size); - start_index = (size_t)( - (i * edge_size * edge_size * edge_size * edge_size) + - (j * edge_size * edge_size * edge_size) + - (k * edge_size * edge_size) + - (l * edge_size)); - stop_index = start_index + small_ds_slice_size - 1; - -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG -{ -int m, n; - - HDfprintf(stdout, "%s:%d: expected_value = %d.\n", - fcnName, mpi_rank, expected_value); - HDfprintf(stdout, "%s:%d: start/stop index = %d/%d.\n", - fcnName, mpi_rank, start_index, stop_index); - n = 0; - for ( m = 0; m < large_ds_size; m ++ ) { - HDfprintf(stdout, "%d ", (int)(*ptr_1)); - ptr_1++; - n++; - if ( n >= edge_size ) { - HDfprintf(stdout, "\n"); + if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */ + + (tv_ptr->tests_skipped)++; + + } else { /* run the test */ + + tv_ptr->skips = 0; /* reset the skips counter */ + + /* we know that small_rank >= 1 and that large_rank > small_rank + * by the assertions at the head of this function. Thus no + * need for another inner loop. + */ + tv_ptr->start[0] = (hsize_t)i; + tv_ptr->start[1] = (hsize_t)j; + tv_ptr->start[2] = (hsize_t)k; + tv_ptr->start[3] = (hsize_t)l; + tv_ptr->start[4] = 0; + + HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1)); + + ckrbrd_hs_dr_pio_test__slct_ckrbrd + ( + tv_ptr->mpi_rank, + tv_ptr->mem_large_ds_sid, + tv_ptr->large_rank, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + tv_ptr->small_rank - 1, + tv_ptr->start + ); + + + /* verify that H5S_select_shape_same() reports the two + * selections as having the same shape. + */ + check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_0, + tv_ptr->mem_large_ds_sid); + VRFY((check == TRUE), "H5S_select_shape_same_test passed"); + + + /* Read selection from disk */ +#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG + HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", + fcnName, tv_ptr->mpi_rank, + tv_ptr->start[0], tv_ptr->start[1], tv_ptr->start[2], + tv_ptr->start[3], tv_ptr->start[4]); + HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", + fcnName, tv_ptr->mpi_rank, + H5Sget_simple_extent_ndims(tv_ptr->large_ds_slice_sid), + H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_0)); +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */ + ret = H5Dread(tv_ptr->small_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_large_ds_sid, + tv_ptr->file_small_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->large_ds_buf_1); + VRFY((ret >= 0), "H5Dread() slice from small ds succeeded."); + + /* verify that the expected data and only the + * expected data was read. + */ + data_ok = TRUE; + ptr_1 = tv_ptr->large_ds_buf_1; + expected_value = + (uint32_t)((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size); + start_index = (size_t)( + (i * tv_ptr->edge_size * tv_ptr->edge_size * + tv_ptr->edge_size * tv_ptr->edge_size) + + (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) + + (k * tv_ptr->edge_size * tv_ptr->edge_size) + + (l * tv_ptr->edge_size)); + stop_index = start_index + tv_ptr->small_ds_slice_size - 1; + +#if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG + { + int m, n; + + HDfprintf(stdout, "%s:%d: expected_value = %d.\n", + fcnName, tv_ptr->mpi_rank, expected_value); + HDfprintf(stdout, "%s:%d: start/stop index = %d/%d.\n", + fcnName, tv_ptr->mpi_rank, start_index, stop_index); n = 0; + for ( m = 0; (unsigned)m < tv_ptr->large_ds_size; m ++ ) { + HDfprintf(stdout, "%d ", (int)(*ptr_1)); + ptr_1++; + n++; + if ( n >= tv_ptr->edge_size ) { + HDfprintf(stdout, "\n"); + n = 0; + } + } + HDfprintf(stdout, "\n"); + ptr_1 = tv_ptr->large_ds_buf_1; } - } - HDfprintf(stdout, "\n"); - fsync(stdout); - ptr_1 = large_ds_buf_1; -} -#endif +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */ - HDassert( start_index < stop_index ); - HDassert( stop_index <= large_ds_size ); + HDassert( start_index < stop_index ); + HDassert( stop_index <= tv_ptr->large_ds_size ); - for ( u = 0; u < start_index; u++ ) { + for ( u = 0; u < start_index; u++ ) { - if ( *ptr_1 != 0 ) { + if ( *ptr_1 != 0 ) { - data_ok = FALSE; - } + data_ok = FALSE; + } - /* zero out the value for the next pass */ - *ptr_1 = 0; + /* zero out the value for the next pass */ + *ptr_1 = 0; - ptr_1++; - } + ptr_1++; + } - VRFY((data_ok == TRUE), - "slice read from small to large ds data good(1)."); + VRFY((data_ok == TRUE), + "slice read from small to large ds data good(1)."); - data_ok = checker_board_hyperslab_dr_pio_test__verify_data - ( - ptr_1, - small_rank - 1, - edge_size, - checker_edge_size, - expected_value, - (hbool_t)TRUE - ); + data_ok = ckrbrd_hs_dr_pio_test__verify_data + ( + ptr_1, + tv_ptr->small_rank - 1, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + expected_value, + (hbool_t)TRUE + ); - VRFY((data_ok == TRUE), - "slice read from small to large ds data good(2)."); + VRFY((data_ok == TRUE), + "slice read from small to large ds data good(2)."); - ptr_1 = large_ds_buf_1 + stop_index + 1; + ptr_1 = tv_ptr->large_ds_buf_1 + stop_index + 1; - for ( u = stop_index + 1; u < large_ds_size; u++ ) { + for ( u = stop_index + 1; u < tv_ptr->large_ds_size; u++ ) { - if ( *ptr_1 != 0 ) { + if ( *ptr_1 != 0 ) { - data_ok = FALSE; - } + data_ok = FALSE; + } - /* zero out the value for the next pass */ - *ptr_1 = 0; + /* zero out the value for the next pass */ + *ptr_1 = 0; - *ptr_1++; - } + ptr_1++; + } + + VRFY((data_ok == TRUE), + "slice read from small to large ds data good(3)."); - VRFY((data_ok == TRUE), - "slice read from small to large ds data good(3)."); + (tv_ptr->tests_run)++; + } l++; - } while ( ( large_rank > 2 ) && - ( (small_rank - 1) <= 1 ) && - ( l < edge_size ) ); + (tv_ptr->total_tests)++; + + } while ( ( tv_ptr->large_rank > 2 ) && + ( (tv_ptr->small_rank - 1) <= 1 ) && + ( l < tv_ptr->edge_size ) ); k++; - } while ( ( large_rank > 3 ) && - ( (small_rank - 1) <= 2 ) && - ( k < edge_size ) ); + } while ( ( tv_ptr->large_rank > 3 ) && + ( (tv_ptr->small_rank - 1) <= 2 ) && + ( k < tv_ptr->edge_size ) ); j++; - } while ( ( large_rank > 4 ) && - ( (small_rank - 1) <= 3 ) && - ( j < edge_size ) ); + } while ( ( tv_ptr->large_rank > 4 ) && + ( (tv_ptr->small_rank - 1) <= 3 ) && + ( j < tv_ptr->edge_size ) ); + + return; + +} /* ckrbrd_hs_dr_pio_test__d2m_s2l() */ + + +/*------------------------------------------------------------------------- + * Function: ckrbrd_hs_dr_pio_test__m2d_l2s() + * + * Purpose: Part three of a series of tests of I/O to/from checker + * board hyperslab selections of different rank in the + * parallel. + * + * Verify that we can write from memory to file using checker + * board selections of different rank that + * H5S_select_shape_same() views as being of the same shape. + * + * Do this by writing small_rank - 1 dimensional checker + * board slices from the in memory large data set to the on + * disk small cube dataset. After each write, read the + * slice of the small dataset back from disk, and verify + * that it contains the expected data. Verify that + * H5S_select_shape_same() returns true on the memory and + * file selections. + * + * Return: void + * + * Programmer: JRM -- 8/15/11 + * + * Modifications: + * + * None. + * + *------------------------------------------------------------------------- + */ + +#define CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG 0 + +static void +ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t * tv_ptr) +{ +#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG + const char *fcnName = "ckrbrd_hs_dr_pio_test__m2d_l2s()"; +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG */ + hbool_t data_ok = FALSE; + hbool_t mis_match = FALSE; + int i, j, k, l; + size_t u; + size_t start_index; + size_t stop_index; + uint32_t expected_value; + uint32_t * ptr_1; + int mpi_rank; /* needed by VRFY */ + hsize_t sel_start[PAR_SS_DR_MAX_RANK]; + htri_t check; /* Shape comparison return value */ + herr_t ret; /* Generic return value */ + + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; /* now we go in the opposite direction, verifying that we can write @@ -3529,46 +3619,46 @@ int m, n; * the memory and file selections. */ - start[0] = (hsize_t)mpi_rank; - stride[0] = (hsize_t)(2 * (mpi_size + 1)); - count[0] = 1; - block[0] = 1; + tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank); + tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1)); + tv_ptr->count[0] = 1; + tv_ptr->block[0] = 1; - for ( i = 1; i < large_rank; i++ ) { + for ( i = 1; i < tv_ptr->large_rank; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - block[i] = (hsize_t)edge_size; + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } - ret = H5Sselect_hyperslab(file_small_ds_sid_0, + ret = H5Sselect_hyperslab(tv_ptr->file_small_ds_sid_0, H5S_SELECT_SET, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret >= 0), "H5Sselect_hyperslab(file_small_ds_sid_0, set) suceeded"); - ret = H5Sselect_hyperslab(mem_small_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->mem_small_ds_sid, H5S_SELECT_SET, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded"); sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0; - sel_start[small_ds_offset] = (hsize_t)mpi_rank; + sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank); - checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank, - file_small_ds_sid_1, - small_rank, - edge_size, - checker_edge_size, - small_rank - 1, - sel_start); + ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank, + tv_ptr->file_small_ds_sid_1, + tv_ptr->small_rank, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + tv_ptr->small_rank - 1, + sel_start); /* set up start, stride, count, and block -- note that we will @@ -3576,28 +3666,28 @@ int m, n; */ for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) { + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) { - block[i] = 1; + tv_ptr->block[i] = 1; } else { - block[i] = (hsize_t)edge_size; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } } /* zero out the in memory small ds */ - HDmemset(small_ds_buf_1, 0, sizeof(uint32_t) * small_ds_size); + HDmemset(tv_ptr->small_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->small_ds_size); -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG +#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG HDfprintf(stdout, "%s writing checker boards selections of slices from big ds to slices of small ds on disk.\n", fcnName); -#endif +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG */ /* in serial versions of this test, we loop through all the dimensions * of the large data set that don't appear in the small data set. @@ -3609,9 +3699,9 @@ int m, n; */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) { - i = mpi_rank; + i = tv_ptr->mpi_rank; } else { @@ -3624,9 +3714,9 @@ int m, n; * test. */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) { - j = mpi_rank; + j = tv_ptr->mpi_rank; } else { @@ -3635,9 +3725,9 @@ int m, n; j = 0; do { - if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) { - k = mpi_rank; + k = tv_ptr->mpi_rank; } else { @@ -3657,154 +3747,228 @@ int m, n; l = 0; do { - /* we know that small_rank >= 1 and that large_rank > small_rank - * by the assertions at the head of this function. Thus no - * need for another inner loop. - */ - - /* zero out this rank's slice of the on disk small data set */ - ret = H5Dwrite(small_dataset, - H5T_NATIVE_UINT32, - mem_small_ds_sid, - file_small_ds_sid_0, - xfer_plist, - small_ds_buf_2); - VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded."); - - /* select the portion of the in memory large cube from which we - * are going to write data. - */ - start[0] = (hsize_t)i; - start[1] = (hsize_t)j; - start[2] = (hsize_t)k; - start[3] = (hsize_t)l; - start[4] = 0; - - HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) ); - HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) ); - HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) ); - HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) ); - HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) ); - - checker_board_hyperslab_dr_pio_test__select_checker_board - ( - mpi_rank, - mem_large_ds_sid, - large_rank, - edge_size, - checker_edge_size, - small_rank - 1, - start - ); - - - /* verify that H5S_select_shape_same() reports the in - * memory checkerboard selection of the slice through the - * large dataset and the checkerboard selection of the process - * slice of the small data set as having the same shape. - */ - check = H5S_select_shape_same_test(file_small_ds_sid_1, - mem_large_ds_sid); - VRFY((check == TRUE), "H5S_select_shape_same_test passed."); - - - /* write the checker board selection of the slice from the in - * memory large data set to the slice of the on disk small - * dataset. - */ -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", - fcnName, mpi_rank, - start[0], start[1], start[2], start[3], start[4]); - HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", - fcnName, mpi_rank, - H5Sget_simple_extent_ndims(mem_large_ds_sid), - H5Sget_simple_extent_ndims(file_small_ds_sid_1)); -#endif - ret = H5Dwrite(small_dataset, - H5T_NATIVE_UINT32, - mem_large_ds_sid, - file_small_ds_sid_1, - xfer_plist, - large_ds_buf_0); - VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded."); + if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */ + (tv_ptr->tests_skipped)++; - /* read the on disk process slice of the small dataset into memory */ - ret = H5Dread(small_dataset, - H5T_NATIVE_UINT32, - mem_small_ds_sid, - file_small_ds_sid_0, - xfer_plist, - small_ds_buf_1); - VRFY((ret >= 0), "H5Dread() slice from small ds succeeded."); + } else { /* run the test */ + tv_ptr->skips = 0; /* reset the skips counter */ - /* verify that expected data is retrieved */ + /* we know that small_rank >= 1 and that large_rank > small_rank + * by the assertions at the head of this function. Thus no + * need for another inner loop. + */ + + /* zero out this rank's slice of the on disk small data set */ + ret = H5Dwrite(tv_ptr->small_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_small_ds_sid, + tv_ptr->file_small_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->small_ds_buf_2); + VRFY((ret >= 0), "H5Dwrite() zero slice to small ds succeeded."); + + /* select the portion of the in memory large cube from which we + * are going to write data. + */ + tv_ptr->start[0] = (hsize_t)i; + tv_ptr->start[1] = (hsize_t)j; + tv_ptr->start[2] = (hsize_t)k; + tv_ptr->start[3] = (hsize_t)l; + tv_ptr->start[4] = 0; + + HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1)); + + ckrbrd_hs_dr_pio_test__slct_ckrbrd + ( + tv_ptr->mpi_rank, + tv_ptr->mem_large_ds_sid, + tv_ptr->large_rank, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + tv_ptr->small_rank - 1, + tv_ptr->start + ); + + + /* verify that H5S_select_shape_same() reports the in + * memory checkerboard selection of the slice through the + * large dataset and the checkerboard selection of the process + * slice of the small data set as having the same shape. + */ + check = H5S_select_shape_same_test(tv_ptr->file_small_ds_sid_1, + tv_ptr->mem_large_ds_sid); + VRFY((check == TRUE), "H5S_select_shape_same_test passed."); + + + /* write the checker board selection of the slice from the in + * memory large data set to the slice of the on disk small + * dataset. + */ +#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG + HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", + fcnName, tv_ptr->mpi_rank, + tv_ptr->start[0], tv_ptr->start[1], tv_ptr->start[2], + tv_ptr->start[3], tv_ptr->start[4]); + HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", + fcnName, tv_ptr->mpi_rank, + H5Sget_simple_extent_ndims(tv_ptr->mem_large_ds_sid), + H5Sget_simple_extent_ndims(tv_ptr->file_small_ds_sid_1)); +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG */ + ret = H5Dwrite(tv_ptr->small_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_large_ds_sid, + tv_ptr->file_small_ds_sid_1, + tv_ptr->xfer_plist, + tv_ptr->large_ds_buf_0); + VRFY((ret >= 0), "H5Dwrite() slice to large ds succeeded."); + + + /* read the on disk process slice of the small dataset into memory */ + ret = H5Dread(tv_ptr->small_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_small_ds_sid, + tv_ptr->file_small_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->small_ds_buf_1); + VRFY((ret >= 0), "H5Dread() slice from small ds succeeded."); + + + /* verify that expected data is retrieved */ + + mis_match = FALSE; + + expected_value = (uint32_t)( + (i * tv_ptr->edge_size * tv_ptr->edge_size * + tv_ptr->edge_size * tv_ptr->edge_size) + + (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) + + (k * tv_ptr->edge_size * tv_ptr->edge_size) + + (l * tv_ptr->edge_size)); + + start_index = (size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size; + stop_index = start_index + tv_ptr->small_ds_slice_size - 1; + + HDassert( start_index < stop_index ); + HDassert( stop_index <= tv_ptr->small_ds_size ); + + data_ok = TRUE; + + ptr_1 = tv_ptr->small_ds_buf_1; + for ( u = 0; u < start_index; u++, ptr_1++ ) { + + if ( *ptr_1 != 0 ) { - mis_match = FALSE; + data_ok = FALSE; + *ptr_1 = 0; + } + } - expected_value = (uint32_t)( - (i * edge_size * edge_size * edge_size * edge_size) + - (j * edge_size * edge_size * edge_size) + - (k * edge_size * edge_size) + - (l * edge_size)); + data_ok &= ckrbrd_hs_dr_pio_test__verify_data + ( + tv_ptr->small_ds_buf_1 + start_index, + tv_ptr->small_rank - 1, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + expected_value, + (hbool_t)TRUE + ); - start_index = (size_t)mpi_rank * small_ds_slice_size; - stop_index = start_index + small_ds_slice_size - 1; - HDassert( start_index < stop_index ); - HDassert( stop_index <= small_ds_size ); + ptr_1 = tv_ptr->small_ds_buf_1; + for ( u = stop_index; u < tv_ptr->small_ds_size; u++, ptr_1++ ) { - data_ok = TRUE; + if ( *ptr_1 != 0 ) { - ptr_1 = small_ds_buf_1; - for ( u = 0; u < start_index; u++, ptr_1++ ) { + data_ok = FALSE; + *ptr_1 = 0; + } + } - if ( *ptr_1 != 0 ) { + VRFY((data_ok == TRUE), + "large slice write slice to small slice data good."); - data_ok = FALSE; - *ptr_1 = 0; - } + (tv_ptr->tests_run)++; } - data_ok &= checker_board_hyperslab_dr_pio_test__verify_data - ( - small_ds_buf_1 + start_index, - small_rank - 1, - edge_size, - checker_edge_size, - expected_value, - (hbool_t)TRUE - ); + l++; + (tv_ptr->total_tests)++; - ptr_1 = small_ds_buf_1; - for ( u = stop_index; u < small_ds_size; u++, ptr_1++ ) { + } while ( ( tv_ptr->large_rank > 2 ) && + ( (tv_ptr->small_rank - 1) <= 1 ) && + ( l < tv_ptr->edge_size ) ); + k++; + } while ( ( tv_ptr->large_rank > 3 ) && + ( (tv_ptr->small_rank - 1) <= 2 ) && + ( k < tv_ptr->edge_size ) ); + j++; + } while ( ( tv_ptr->large_rank > 4 ) && + ( (tv_ptr->small_rank - 1) <= 3 ) && + ( j < tv_ptr->edge_size ) ); - if ( *ptr_1 != 0 ) { + return; - data_ok = FALSE; - *ptr_1 = 0; - } - } +} /* ckrbrd_hs_dr_pio_test__m2d_l2s() */ - VRFY((data_ok == TRUE), - "large slice write slice to small slice data good."); - l++; +/*------------------------------------------------------------------------- + * Function: ckrbrd_hs_dr_pio_test__m2d_s2l() + * + * Purpose: Part four of a series of tests of I/O to/from checker + * board hyperslab selections of different rank in the parallel. + * + * Verify that we can write from memory to file using + * selections of different rank that H5S_select_shape_same() + * views as being of the same shape. + * + * Do this by writing checker board selections of the contents + * of the process's slice of the in memory small data set to + * slices of the on disk large data set. After each write, + * read the process's slice of the large data set back into + * memory, and verify that it contains the expected data. + * + * Verify that H5S_select_shape_same() returns true on the + * memory and file selections. + * + * Return: void + * + * Programmer: JRM -- 8/15/11 + * + * Modifications: + * + * None + * + *------------------------------------------------------------------------- + */ - } while ( ( large_rank > 2 ) && - ( (small_rank - 1) <= 1 ) && - ( l < edge_size ) ); - k++; - } while ( ( large_rank > 3 ) && - ( (small_rank - 1) <= 2 ) && - ( k < edge_size ) ); - j++; - } while ( ( large_rank > 4 ) && - ( (small_rank - 1) <= 3 ) && - ( j < edge_size ) ); +#define CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG 0 + +static void +ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t * tv_ptr) +{ +#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG + const char *fcnName = "ckrbrd_hs_dr_pio_test__m2d_s2l()"; +#endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */ + hbool_t data_ok = FALSE; + hbool_t mis_match = FALSE; + int i, j, k, l; + size_t u; + size_t start_index; + size_t stop_index; + uint32_t expected_value; + uint32_t * ptr_1; + int mpi_rank; /* needed by VRFY */ + hsize_t sel_start[PAR_SS_DR_MAX_RANK]; + htri_t check; /* Shape comparison return value */ + herr_t ret; /* Generic return value */ + + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; /* Now write the contents of the process's slice of the in memory @@ -3815,49 +3979,49 @@ int m, n; * and file selections. */ - start[0] = (hsize_t)mpi_rank; - stride[0] = (hsize_t)(2 * (mpi_size + 1)); - count[0] = 1; - block[0] = 1; + tv_ptr->start[0] = (hsize_t)(tv_ptr->mpi_rank); + tv_ptr->stride[0] = (hsize_t)(2 * (tv_ptr->mpi_size + 1)); + tv_ptr->count[0] = 1; + tv_ptr->block[0] = 1; - for ( i = 1; i < large_rank; i++ ) { + for ( i = 1; i < tv_ptr->large_rank; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - block[i] = (hsize_t)edge_size; + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } - ret = H5Sselect_hyperslab(file_large_ds_sid_0, + ret = H5Sselect_hyperslab(tv_ptr->file_large_ds_sid_0, H5S_SELECT_SET, - start, - stride, - count, - block); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); VRFY((ret >= 0), "H5Sselect_hyperslab(file_large_ds_sid_0, set) suceeded"); - ret = H5Sselect_hyperslab(mem_large_ds_sid, + ret = H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid, H5S_SELECT_SET, - start, - stride, - count, - block); - VRFY((ret >= 0), "H5Sselect_hyperslab(mem_small_ds_sid, set) suceeded"); + tv_ptr->start, + tv_ptr->stride, + tv_ptr->count, + tv_ptr->block); + VRFY((ret >= 0), "H5Sselect_hyperslab(tv_ptr->mem_large_ds_sid, set) suceeded"); /* setup a checkerboard selection of the slice of the in memory small * data set associated with the process's mpi rank. */ sel_start[0] = sel_start[1] = sel_start[2] = sel_start[3] = sel_start[4] = 0; - sel_start[small_ds_offset] = (hsize_t)mpi_rank; + sel_start[tv_ptr->small_ds_offset] = (hsize_t)(tv_ptr->mpi_rank); - checker_board_hyperslab_dr_pio_test__select_checker_board(mpi_rank, - mem_small_ds_sid, - small_rank, - edge_size, - checker_edge_size, - small_rank - 1, - sel_start); + ckrbrd_hs_dr_pio_test__slct_ckrbrd(tv_ptr->mpi_rank, + tv_ptr->mem_small_ds_sid, + tv_ptr->small_rank, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + tv_ptr->small_rank - 1, + sel_start); /* set up start, stride, count, and block -- note that we will * change start[] so as to write checkerboard selections of slices @@ -3865,31 +4029,31 @@ int m, n; */ for ( i = 0; i < PAR_SS_DR_MAX_RANK; i++ ) { - start[i] = 0; - stride[i] = (hsize_t)(2 * edge_size); - count[i] = 1; - if ( (PAR_SS_DR_MAX_RANK - i) > (small_rank - 1) ) { + tv_ptr->start[i] = 0; + tv_ptr->stride[i] = (hsize_t)(2 * tv_ptr->edge_size); + tv_ptr->count[i] = 1; + if ( (PAR_SS_DR_MAX_RANK - i) > (tv_ptr->small_rank - 1) ) { - block[i] = 1; + tv_ptr->block[i] = 1; } else { - block[i] = (hsize_t)edge_size; + tv_ptr->block[i] = (hsize_t)(tv_ptr->edge_size); } } /* zero out the in memory large ds */ - HDmemset(large_ds_buf_1, 0, sizeof(uint32_t) * large_ds_size); + HDmemset(tv_ptr->large_ds_buf_1, 0, sizeof(uint32_t) * tv_ptr->large_ds_size); -#if CONTIG_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG +#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG HDfprintf(stdout, "%s writing process checkerboard selections of slices of small ds to process slices of large ds on disk.\n", fcnName); -#endif +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 0 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 0 ) { - i = mpi_rank; + i = tv_ptr->mpi_rank; } else { @@ -3902,9 +4066,9 @@ int m, n; * test. */ - if ( PAR_SS_DR_MAX_RANK - large_rank == 1 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 1 ) { - j = mpi_rank; + j = tv_ptr->mpi_rank; } else { @@ -3912,9 +4076,9 @@ int m, n; } do { - if ( PAR_SS_DR_MAX_RANK - large_rank == 2 ) { + if ( PAR_SS_DR_MAX_RANK - tv_ptr->large_rank == 2 ) { - k = mpi_rank; + k = tv_ptr->mpi_rank; } else { @@ -3934,240 +4098,395 @@ int m, n; l = 0; do { - /* we know that small_rank >= 1 and that large_rank > small_rank - * by the assertions at the head of this function. Thus no - * need for another inner loop. - */ - - /* Zero out this processes slice of the on disk large data set. - * Note that this will leave one slice with its original data - * as there is one more slice than processes. - */ - ret = H5Dwrite(large_dataset, - H5T_NATIVE_UINT32, - mem_large_ds_sid, - file_large_ds_sid_0, - xfer_plist, - large_ds_buf_2); - VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded"); - - - /* select the portion of the in memory large cube to which we - * are going to write data. - */ - start[0] = (hsize_t)i; - start[1] = (hsize_t)j; - start[2] = (hsize_t)k; - start[3] = (hsize_t)l; - start[4] = 0; - - HDassert( ( start[0] == 0 ) || ( 0 < small_ds_offset + 1 ) ); - HDassert( ( start[1] == 0 ) || ( 1 < small_ds_offset + 1 ) ); - HDassert( ( start[2] == 0 ) || ( 2 < small_ds_offset + 1 ) ); - HDassert( ( start[3] == 0 ) || ( 3 < small_ds_offset + 1 ) ); - HDassert( ( start[4] == 0 ) || ( 4 < small_ds_offset + 1 ) ); - - checker_board_hyperslab_dr_pio_test__select_checker_board - ( - mpi_rank, - file_large_ds_sid_1, - large_rank, - edge_size, - checker_edge_size, - small_rank - 1, - start - ); - - - /* verify that H5S_select_shape_same() reports the in - * memory small data set slice selection and the - * on disk slice through the large data set selection - * as having the same shape. - */ - check = H5S_select_shape_same_test(mem_small_ds_sid, - file_large_ds_sid_1); - VRFY((check == TRUE), "H5S_select_shape_same_test passed"); - - - /* write the small data set slice from memory to the - * target slice of the disk data set - */ -#if CHECKER_BOARD_HYPERSLAB_DR_PIO_TEST__RUN_TEST__DEBUG - HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", - fcnName, mpi_rank, - start[0], start[1], start[2], start[3], start[4]); - HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", - fcnName, mpi_rank, - H5Sget_simple_extent_ndims(mem_small_ds_sid), - H5Sget_simple_extent_ndims(file_large_ds_sid_1)); -#endif - ret = H5Dwrite(large_dataset, - H5T_NATIVE_UINT32, - mem_small_ds_sid, - file_large_ds_sid_1, - xfer_plist, - small_ds_buf_0); - VRFY((ret != FAIL), - "H5Dwrite of small ds slice to large ds succeeded"); + if ( (tv_ptr->skips)++ < tv_ptr->max_skips ) { /* skip the test */ + (tv_ptr->tests_skipped)++; - /* read this processes slice on the on disk large - * data set into memory. - */ + } else { /* run the test */ - ret = H5Dread(large_dataset, - H5T_NATIVE_UINT32, - mem_large_ds_sid, - file_large_ds_sid_0, - xfer_plist, - large_ds_buf_1); - VRFY((ret != FAIL), - "H5Dread() of process slice of large ds succeeded"); + tv_ptr->skips = 0; /* reset the skips counter */ + /* we know that small_rank >= 1 and that large_rank > small_rank + * by the assertions at the head of this function. Thus no + * need for another inner loop. + */ - /* verify that the expected data and only the - * expected data was read. - */ - expected_value = (uint32_t)((size_t)mpi_rank * small_ds_slice_size); + /* Zero out this processes slice of the on disk large data set. + * Note that this will leave one slice with its original data + * as there is one more slice than processes. + */ + ret = H5Dwrite(tv_ptr->large_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_large_ds_sid, + tv_ptr->file_large_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->large_ds_buf_2); + VRFY((ret != FAIL), "H5Dwrite() to zero large ds suceeded"); - start_index = (size_t)((i * edge_size * edge_size * edge_size * edge_size) + - (j * edge_size * edge_size * edge_size) + - (k * edge_size * edge_size) + - (l * edge_size)); - stop_index = start_index + small_ds_slice_size - 1; - HDassert( start_index < stop_index ); - HDassert( stop_index < large_ds_size ); + /* select the portion of the in memory large cube to which we + * are going to write data. + */ + tv_ptr->start[0] = (hsize_t)i; + tv_ptr->start[1] = (hsize_t)j; + tv_ptr->start[2] = (hsize_t)k; + tv_ptr->start[3] = (hsize_t)l; + tv_ptr->start[4] = 0; + + HDassert((tv_ptr->start[0] == 0)||(0 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[1] == 0)||(1 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[2] == 0)||(2 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[3] == 0)||(3 < tv_ptr->small_ds_offset + 1)); + HDassert((tv_ptr->start[4] == 0)||(4 < tv_ptr->small_ds_offset + 1)); + + ckrbrd_hs_dr_pio_test__slct_ckrbrd + ( + tv_ptr->mpi_rank, + tv_ptr->file_large_ds_sid_1, + tv_ptr->large_rank, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + tv_ptr->small_rank - 1, + tv_ptr->start + ); + + + /* verify that H5S_select_shape_same() reports the in + * memory small data set slice selection and the + * on disk slice through the large data set selection + * as having the same shape. + */ + check = H5S_select_shape_same_test(tv_ptr->mem_small_ds_sid, + tv_ptr->file_large_ds_sid_1); + VRFY((check == TRUE), "H5S_select_shape_same_test passed"); - mis_match = FALSE; + /* write the small data set slice from memory to the + * target slice of the disk data set + */ +#if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG + HDfprintf(stdout, "%s:%d: start = %d %d %d %d %d.\n", + fcnName, tv_ptr->mpi_rank, + tv_ptr->start[0], tv_ptr->start[1], tv_ptr->start[2], + tv_ptr->start[3], tv_ptr->start[4]); + HDfprintf(stdout, "%s:%d: mem/file extent dims = %d/%d.\n", + fcnName, tv_ptr->mpi_rank, + H5Sget_simple_extent_ndims(tv_ptr->mem_small_ds_sid), + H5Sget_simple_extent_ndims(tv_ptr->file_large_ds_sid_1)); +#endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG */ + ret = H5Dwrite(tv_ptr->large_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_small_ds_sid, + tv_ptr->file_large_ds_sid_1, + tv_ptr->xfer_plist, + tv_ptr->small_ds_buf_0); + VRFY((ret != FAIL), + "H5Dwrite of small ds slice to large ds succeeded"); + + + /* read this processes slice on the on disk large + * data set into memory. + */ - data_ok = TRUE; + ret = H5Dread(tv_ptr->large_dataset, + H5T_NATIVE_UINT32, + tv_ptr->mem_large_ds_sid, + tv_ptr->file_large_ds_sid_0, + tv_ptr->xfer_plist, + tv_ptr->large_ds_buf_1); + VRFY((ret != FAIL), + "H5Dread() of process slice of large ds succeeded"); - ptr_1 = large_ds_buf_1; - for ( u = 0; u < start_index; u++, ptr_1++ ) { - if ( *ptr_1 != 0 ) { + /* verify that the expected data and only the + * expected data was read. + */ + expected_value = + (uint32_t)((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size); - data_ok = FALSE; - *ptr_1 = 0; + start_index = (size_t) + ((i * tv_ptr->edge_size * tv_ptr->edge_size * + tv_ptr->edge_size * tv_ptr->edge_size) + + (j * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size) + + (k * tv_ptr->edge_size * tv_ptr->edge_size) + + (l * tv_ptr->edge_size)); + stop_index = start_index + tv_ptr->small_ds_slice_size - 1; + + HDassert( start_index < stop_index ); + HDassert( stop_index < tv_ptr->large_ds_size ); + + + mis_match = FALSE; + + data_ok = TRUE; + + ptr_1 = tv_ptr->large_ds_buf_1; + for ( u = 0; u < start_index; u++, ptr_1++ ) { + + if ( *ptr_1 != 0 ) { + + data_ok = FALSE; + *ptr_1 = 0; + } } - } - data_ok &= checker_board_hyperslab_dr_pio_test__verify_data - ( - large_ds_buf_1 + start_index, - small_rank - 1, - edge_size, - checker_edge_size, - expected_value, - (hbool_t)TRUE - ); + data_ok &= ckrbrd_hs_dr_pio_test__verify_data + ( + tv_ptr->large_ds_buf_1 + start_index, + tv_ptr->small_rank - 1, + tv_ptr->edge_size, + tv_ptr->checker_edge_size, + expected_value, + (hbool_t)TRUE + ); - ptr_1 = large_ds_buf_1; - for ( u = stop_index; u < small_ds_size; u++, ptr_1++ ) { + ptr_1 = tv_ptr->large_ds_buf_1; + for ( u = stop_index; u < tv_ptr->small_ds_size; u++, ptr_1++ ) { - if ( *ptr_1 != 0 ) { + if ( *ptr_1 != 0 ) { - data_ok = FALSE; - *ptr_1 = 0; + data_ok = FALSE; + *ptr_1 = 0; + } } - } - VRFY((data_ok == TRUE), - "small ds cb slice write to large ds slice data good."); + VRFY((data_ok == TRUE), + "small ds cb slice write to large ds slice data good."); + + (tv_ptr->tests_run)++; + } l++; - } while ( ( large_rank > 2 ) && - ( (small_rank - 1) <= 1 ) && - ( l < edge_size ) ); + (tv_ptr->total_tests)++; + + } while ( ( tv_ptr->large_rank > 2 ) && + ( (tv_ptr->small_rank - 1) <= 1 ) && + ( l < tv_ptr->edge_size ) ); k++; - } while ( ( large_rank > 3 ) && - ( (small_rank - 1) <= 2 ) && - ( k < edge_size ) ); + } while ( ( tv_ptr->large_rank > 3 ) && + ( (tv_ptr->small_rank - 1) <= 2 ) && + ( k < tv_ptr->edge_size ) ); j++; - } while ( ( large_rank > 4 ) && - ( (small_rank - 1) <= 3 ) && - ( j < edge_size ) ); + } while ( ( tv_ptr->large_rank > 4 ) && + ( (tv_ptr->small_rank - 1) <= 3 ) && + ( j < tv_ptr->edge_size ) ); + return; - /* Close dataspaces */ - ret = H5Sclose(full_mem_small_ds_sid); - VRFY((ret != FAIL), "H5Sclose(full_mem_small_ds_sid) succeeded"); +} /* ckrbrd_hs_dr_pio_test__m2d_s2l() */ - ret = H5Sclose(full_file_small_ds_sid); - VRFY((ret != FAIL), "H5Sclose(full_file_small_ds_sid) succeeded"); - ret = H5Sclose(mem_small_ds_sid); - VRFY((ret != FAIL), "H5Sclose(mem_small_ds_sid) succeeded"); +/*------------------------------------------------------------------------- + * Function: ckrbrd_hs_dr_pio_test__run_test() + * + * Purpose: Test I/O to/from checkerboard selections of hyperslabs of + * different rank in the parallel. + * + * Return: void + * + * Programmer: JRM -- 10/10/09 + * + * Modifications: + * + * JRM -- 9/16/10 + * Added the express_test parameter. Use it to control + * whether we set an alignment, and whether we allocate + * chunks such that no two processes will normally touch + * the same chunk. + * + *------------------------------------------------------------------------- + */ - ret = H5Sclose(file_small_ds_sid_0); - VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_0) succeeded"); +#define CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG 0 - ret = H5Sclose(file_small_ds_sid_1); - VRFY((ret != FAIL), "H5Sclose(file_small_ds_sid_1) succeeded"); +static void +ckrbrd_hs_dr_pio_test__run_test(const int test_num, + const int edge_size, + const int checker_edge_size, + const int chunk_edge_size, + const int small_rank, + const int large_rank, + const hbool_t use_collective_io, + const hid_t dset_type, + const int express_test, + int * skips_ptr, + int max_skips, + int64_t * total_tests_ptr, + int64_t * tests_run_ptr, + int64_t * tests_skipped_ptr) - ret = H5Sclose(small_ds_slice_sid); - VRFY((ret != FAIL), "H5Sclose(small_ds_slice_sid) succeeded"); +{ +#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG + const char *fcnName = "ckrbrd_hs_dr_pio_test__run_test()"; +#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ + int mpi_rank; /* needed by VRFY */ + struct hs_dr_pio_test_vars_t test_vars = + { + /* int mpi_size = */ -1, + /* int mpi_rank = */ -1, + /* MPI_Comm mpi_comm = */ MPI_COMM_NULL, + /* MPI_Inf mpi_info = */ MPI_INFO_NULL, + /* int test_num = */ -1, + /* int edge_size = */ -1, + /* int checker_edge_size = */ -1, + /* int chunk_edge_size = */ -1, + /* int small_rank = */ -1, + /* int large_rank = */ -1, + /* hid_t dset_type = */ -1, + /* uint32_t * small_ds_buf_0 = */ NULL, + /* uint32_t * small_ds_buf_1 = */ NULL, + /* uint32_t * small_ds_buf_2 = */ NULL, + /* uint32_t * small_ds_slice_buf = */ NULL, + /* uint32_t * large_ds_buf_0 = */ NULL, + /* uint32_t * large_ds_buf_1 = */ NULL, + /* uint32_t * large_ds_buf_2 = */ NULL, + /* uint32_t * large_ds_slice_buf = */ NULL, + /* int small_ds_offset = */ -1, + /* int large_ds_offset = */ -1, + /* hid_t fid = */ -1, /* HDF5 file ID */ + /* hid_t xfer_plist = */ H5P_DEFAULT, + /* hid_t full_mem_small_ds_sid = */ -1, + /* hid_t full_file_small_ds_sid = */ -1, + /* hid_t mem_small_ds_sid = */ -1, + /* hid_t file_small_ds_sid_0 = */ -1, + /* hid_t file_small_ds_sid_1 = */ -1, + /* hid_t small_ds_slice_sid = */ -1, + /* hid_t full_mem_large_ds_sid = */ -1, + /* hid_t full_file_large_ds_sid = */ -1, + /* hid_t mem_large_ds_sid = */ -1, + /* hid_t file_large_ds_sid_0 = */ -1, + /* hid_t file_large_ds_sid_1 = */ -1, + /* hid_t file_large_ds_process_slice_sid = */ -1, + /* hid_t mem_large_ds_process_slice_sid = */ -1, + /* hid_t large_ds_slice_sid = */ -1, + /* hid_t small_dataset = */ -1, /* Dataset ID */ + /* hid_t large_dataset = */ -1, /* Dataset ID */ + /* size_t small_ds_size = */ 1, + /* size_t small_ds_slice_size = */ 1, + /* size_t large_ds_size = */ 1, + /* size_t large_ds_slice_size = */ 1, + /* hsize_t dims[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t chunk_dims[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t start[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t stride[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t count[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t block[PAR_SS_DR_MAX_RANK] = */ {0,0,0,0,0}, + /* hsize_t * start_ptr = */ NULL, + /* hsize_t * stride_ptr = */ NULL, + /* hsize_t * count_ptr = */ NULL, + /* hsize_t * block_ptr = */ NULL, + /* int skips = */ 0, + /* int max_skips = */ 0, + /* int64_t total_tests = */ 0, + /* int64_t tests_run = */ 0, + /* int64_t tests_skipped = */ 0 + }; + struct hs_dr_pio_test_vars_t * tv_ptr = &test_vars; - ret = H5Sclose(full_mem_large_ds_sid); - VRFY((ret != FAIL), "H5Sclose(full_mem_large_ds_sid) succeeded"); + hs_dr_pio_test__setup(test_num, edge_size, checker_edge_size, + chunk_edge_size, small_rank, large_rank, + use_collective_io, dset_type, express_test, + tv_ptr); - ret = H5Sclose(full_file_large_ds_sid); - VRFY((ret != FAIL), "H5Sclose(full_file_large_ds_sid) succeeded"); - ret = H5Sclose(mem_large_ds_sid); - VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded"); + /* initialize the local copy of mpi_rank */ + mpi_rank = tv_ptr->mpi_rank; - ret = H5Sclose(file_large_ds_sid_0); - VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded"); - ret = H5Sclose(file_large_ds_sid_1); - VRFY((ret != FAIL), "H5Sclose(mem_large_ds_sid) succeeded"); + /* initialize skips & max_skips */ + tv_ptr->skips = *skips_ptr; + tv_ptr->max_skips = max_skips; - ret = H5Sclose(mem_large_ds_process_slice_sid); - VRFY((ret != FAIL), "H5Sclose(mem_large_ds_process_slice_sid) succeeded"); - ret = H5Sclose(file_large_ds_process_slice_sid); - VRFY((ret != FAIL), "H5Sclose(file_large_ds_process_slice_sid) succeeded"); +#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG + if ( MAINPROCESS ) { + HDfprintf(stdout, "test %d: small rank = %d, large rank = %d.\n", + test_num, small_rank, large_rank); + HDfprintf(stdout, "test %d: Initialization complete.\n", test_num); + } +#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ - ret = H5Sclose(large_ds_slice_sid); - VRFY((ret != FAIL), "H5Sclose(large_ds_slice_sid) succeeded"); + /* first, verify that we can read from disk correctly using selections + * of different rank that H5S_select_shape_same() views as being of the + * same shape. + * + * Start by reading a (small_rank - 1)-D slice from this processes slice + * of the on disk large data set, and verifying that the data read is + * correct. Verify that H5S_select_shape_same() returns true on the + * memory and file selections. + * + * The first step is to set up the needed checker board selection in the + * in memory small small cube + */ - /* Close Datasets */ - ret = H5Dclose(small_dataset); - VRFY((ret != FAIL), "H5Dclose(small_dataset) succeeded"); + ckrbrd_hs_dr_pio_test__d2m_l2s(tv_ptr); - ret = H5Dclose(large_dataset); - VRFY((ret != FAIL), "H5Dclose(large_dataset) succeeded"); + /* similarly, read slices of the on disk small data set into slices + * through the in memory large data set, and verify that the correct + * data (and only the correct data) is read. + */ - /* close the file collectively */ - MESG("about to close file."); - ret = H5Fclose(fid); - VRFY((ret != FAIL), "file close succeeded"); + ckrbrd_hs_dr_pio_test__d2m_s2l(tv_ptr); - /* Free memory buffers */ - if ( small_ds_buf_0 != NULL ) HDfree(small_ds_buf_0); - if ( small_ds_buf_1 != NULL ) HDfree(small_ds_buf_1); - if ( small_ds_buf_2 != NULL ) HDfree(small_ds_buf_2); - if ( small_ds_slice_buf != NULL ) HDfree(small_ds_slice_buf); - if ( large_ds_buf_0 != NULL ) HDfree(large_ds_buf_0); - if ( large_ds_buf_1 != NULL ) HDfree(large_ds_buf_1); - if ( large_ds_buf_2 != NULL ) HDfree(large_ds_buf_2); - if ( large_ds_slice_buf != NULL ) HDfree(large_ds_slice_buf); + /* now we go in the opposite direction, verifying that we can write + * from memory to file using selections of different rank that + * H5S_select_shape_same() views as being of the same shape. + * + * Start by writing small_rank - 1 D slices from the in memory large data + * set to the on disk small dataset. After each write, read the slice of + * the small dataset back from disk, and verify that it contains the + * expected data. Verify that H5S_select_shape_same() returns true on + * the memory and file selections. + */ + + ckrbrd_hs_dr_pio_test__m2d_l2s(tv_ptr); + + + /* Now write the contents of the process's slice of the in memory + * small data set to slices of the on disk large data set. After + * each write, read the process's slice of the large data set back + * into memory, and verify that it contains the expected data. + * Verify that H5S_select_shape_same() returns true on the memory + * and file selections. + */ + + ckrbrd_hs_dr_pio_test__m2d_s2l(tv_ptr); + + +#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG + if ( MAINPROCESS ) { + HDfprintf(stdout, + "test %d: Subtests complete -- tests run/skipped/total = %lld/%lld/%lld.\n", + test_num, (long long)(tv_ptr->tests_run), (long long)(tv_ptr->tests_skipped), + (long long)(tv_ptr->total_tests)); + } +#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ + + hs_dr_pio_test__takedown(tv_ptr); + +#if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG + if ( MAINPROCESS ) { + HDfprintf(stdout, "test %d: Takedown complete.\n", test_num); + } +#endif /* CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG */ + + *skips_ptr = tv_ptr->skips; + *total_tests_ptr += tv_ptr->total_tests; + *tests_run_ptr += tv_ptr->tests_run; + *tests_skipped_ptr += tv_ptr->tests_skipped; return; -} /* checker_board_hyperslab_dr_pio_test__run_test() */ +} /* ckrbrd_hs_dr_pio_test__run_test() */ /*------------------------------------------------------------------------- - * Function: checker_board_hyperslab_dr_pio_test() + * Function: ckrbrd_hs_dr_pio_test() * * Purpose: Test I/O to/from hyperslab selections of different rank in * the parallel case. @@ -4193,44 +4512,35 @@ int m, n; *------------------------------------------------------------------------- */ -void -checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type) +static void +ckrbrd_hs_dr_pio_test(ShapeSameTestMethods sstest_type) { + int express_test; + int local_express_test; + int mpi_size = -1; + int mpi_rank = -1; int test_num = 0; int edge_size = 10; int checker_edge_size = 3; int chunk_edge_size = 0; int small_rank = 3; int large_rank = 4; - int skips[4] = {0, 0, 0, 0}; - int skip_counters[4] = {0, 0, 0, 0}; - int tests_skiped[4] = {0, 0, 0, 0}; int mpi_result; hid_t dset_type = H5T_NATIVE_UINT; -#ifdef H5_HAVE_GETTIMEOFDAY - hbool_t time_tests = TRUE; - hbool_t display_skips = FALSE; - int local_express_test; - int express_test; - int i; - int samples = 0; - int sample_size = 1; - int mpi_size = -1; - int mpi_rank = -1; - int local_skips[4]; - const int ind_contig_idx = 0; - const int col_contig_idx = 1; - const int ind_chunked_idx = 2; - const int col_chunked_idx = 3; - const int test_types = 4; - long long max_test_time = 3000000; /* for one test */ - long long sample_times[4] = {0, 0, 0, 0}; - struct timeval timeval_a; - struct timeval timeval_b; + int skips = 0; + int max_skips = 0; + /* The following table list the number of sub-tests skipped between + * each test that is actually executed as a function of the express + * test level. Note that any value in excess of 4880 will cause all + * sub tests to be skipped. + */ + int max_skips_tbl[4] = {0, 4, 16, 64}; + int64_t total_tests = 0; + int64_t tests_run = 0; + int64_t tests_skipped = 0; MPI_Comm_size(MPI_COMM_WORLD, &mpi_size); MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank); -#endif /* H5_HAVE_GETTIMEOFDAY */ local_express_test = GetTestExpress(); @@ -4245,6 +4555,14 @@ checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type) VRFY((mpi_result == MPI_SUCCESS ), "MPI_Allreduce(0) succeeded"); + if ( local_express_test < 0 ) { + max_skips = max_skips_tbl[0]; + } else if ( local_express_test > 3 ) { + max_skips = max_skips_tbl[3]; + } else { + max_skips = max_skips_tbl[local_express_test]; + } + #if 0 { int DebugWait = 1; @@ -4256,201 +4574,113 @@ checker_board_hyperslab_dr_pio_test(ShapeSameTestMethods sstest_type) for ( large_rank = 3; large_rank <= PAR_SS_DR_MAX_RANK; large_rank++ ) { for ( small_rank = 2; small_rank < large_rank; small_rank++ ) { - switch(sstest_type){ - case IND_CONTIG: - /* contiguous data set, independent I/O */ - chunk_edge_size = 0; - if ( skip_counters[ind_contig_idx] < skips[ind_contig_idx] ) { - - skip_counters[ind_contig_idx]++; - tests_skiped[ind_contig_idx]++; - printf("Test skipped\n"); - } else { - skip_counters[ind_contig_idx] = 0; - START_TIMER(time_tests, timeval_a, "HDgettimeofday(0) succeeds."); - - checker_board_hyperslab_dr_pio_test__run_test(test_num, - edge_size, - checker_edge_size, - chunk_edge_size, - small_rank, - large_rank, - FALSE, - dset_type, - express_test); - STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \ - "HDgettimeofday(1) succeeds.", \ - sample_times[ind_contig_idx]); - + switch(sstest_type){ + case IND_CONTIG: + /* contiguous data set, independent I/O */ + chunk_edge_size = 0; + ckrbrd_hs_dr_pio_test__run_test(test_num, + edge_size, + checker_edge_size, + chunk_edge_size, + small_rank, + large_rank, + FALSE, + dset_type, + express_test, + &skips, + max_skips, + &total_tests, + &tests_run, + &tests_skipped); + test_num++; + break; + /* end of case IND_CONTIG */ + + case COL_CONTIG: + /* contiguous data set, collective I/O */ + chunk_edge_size = 0; + ckrbrd_hs_dr_pio_test__run_test(test_num, + edge_size, + checker_edge_size, + chunk_edge_size, + small_rank, + large_rank, + TRUE, + dset_type, + express_test, + &skips, + max_skips, + &total_tests, + &tests_run, + &tests_skipped); + test_num++; + break; + /* end of case COL_CONTIG */ + + case IND_CHUNKED: + /* chunked data set, independent I/O */ + chunk_edge_size = 5; + ckrbrd_hs_dr_pio_test__run_test(test_num, + edge_size, + checker_edge_size, + chunk_edge_size, + small_rank, + large_rank, + FALSE, + dset_type, + express_test, + &skips, + max_skips, + &total_tests, + &tests_run, + &tests_skipped); + test_num++; + break; + /* end of case IND_CHUNKED */ + + case COL_CHUNKED: + /* chunked data set, collective I/O */ + chunk_edge_size = 5; + ckrbrd_hs_dr_pio_test__run_test(test_num, + edge_size, + checker_edge_size, + chunk_edge_size, + small_rank, + large_rank, + TRUE, + dset_type, + express_test, + &skips, + max_skips, + &total_tests, + &tests_run, + &tests_skipped); + test_num++; + break; + /* end of case COL_CHUNKED */ + + default: + VRFY((FALSE), "unknown test type"); + break; + + } /* end of switch(sstest_type) */ +#if CONTIG_HS_DR_PIO_TEST__DEBUG + if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) { + HDfprintf(stdout, " run/skipped/total = %lld/%lld/%lld.\n", + tests_run, tests_skipped, total_tests); } - test_num++; - break; - /* end of case IND_CONTIG */ - - case COL_CONTIG: - /* contiguous data set, collective I/O */ - chunk_edge_size = 0; - if ( skip_counters[col_contig_idx] < skips[col_contig_idx] ) { - - skip_counters[col_contig_idx]++; - tests_skiped[col_contig_idx]++; - printf("Test skipped\n"); - } else { - skip_counters[col_contig_idx] = 0; - START_TIMER(time_tests, timeval_a, "HDgettimeofday(2) succeeds."); - - checker_board_hyperslab_dr_pio_test__run_test(test_num, - edge_size, - checker_edge_size, - chunk_edge_size, - small_rank, - large_rank, - TRUE, - dset_type, - express_test); - STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \ - "HDgettimeofday(3) succeeds.", \ - sample_times[col_contig_idx]); - - } - test_num++; - break; - /* end of case COL_CONTIG */ - - case IND_CHUNKED: - /* chunked data set, independent I/O */ - chunk_edge_size = 5; - if ( skip_counters[ind_chunked_idx] < skips[ind_chunked_idx] ) { - - skip_counters[ind_chunked_idx]++; - tests_skiped[ind_chunked_idx]++; - printf("Test skipped\n"); - } else { - skip_counters[ind_chunked_idx] = 0; - START_TIMER(time_tests, timeval_a, "HDgettimeofday(4) succeeds."); - - checker_board_hyperslab_dr_pio_test__run_test(test_num, - edge_size, - checker_edge_size, - chunk_edge_size, - small_rank, - large_rank, - FALSE, - dset_type, - express_test); - STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \ - "HDgettimeofday(5) succeeds.", \ - sample_times[ind_chunked_idx]); - - } - test_num++; - break; - /* end of case IND_CHUNKED */ - - case COL_CHUNKED: - /* chunked data set, collective I/O */ - chunk_edge_size = 5; - if ( skip_counters[col_chunked_idx] < skips[col_chunked_idx] ) { - - skip_counters[col_chunked_idx]++; - tests_skiped[col_chunked_idx]++; - printf("Test skipped\n"); - } else { - skip_counters[col_chunked_idx] = 0; - START_TIMER(time_tests, timeval_a, "HDgettimeofday(6) succeeds."); - - checker_board_hyperslab_dr_pio_test__run_test(test_num, - edge_size, - checker_edge_size, - chunk_edge_size, - small_rank, - large_rank, - TRUE, - dset_type, - express_test); - STOP_TIMER_AND_UPDATE(time_tests, timeval_b, \ - "HDgettimeofday(7) succeeds.", \ - sample_times[col_chunked_idx]); - - } - test_num++; - break; - /* end of case COL_CHUNKED */ - } /* end of switch(sstest_type) */ - -#ifdef H5_HAVE_GETTIMEOFDAY - if ( time_tests ) { - - samples++; - - if ( samples >= sample_size ) { - - int result; - - time_tests = FALSE; - - max_test_time = ((long long)sample_size) * max_test_time; - - for ( i = 0; i < test_types; i++ ) { - - if ( ( express_test == 0 ) || - ( sample_times[i] <= max_test_time ) ) { - - local_skips[i] = 0; - - } else { - - local_skips[i] = (int)(sample_times[i] / max_test_time); - } - } - - /* do an MPI_Allreduce() with the skips vector to ensure that - * all processes agree on its contents. - */ - result = MPI_Allreduce((void *)local_skips, - (void *)skips, - test_types, - MPI_INT, - MPI_MAX, - MPI_COMM_WORLD); - VRFY((result == MPI_SUCCESS ), "MPI_Allreduce() succeeded"); - } - } -#endif /* H5_HAVE_GETTIMEOFDAY */ - +#endif /* CONTIG_HS_DR_PIO_TEST__DEBUG */ } } -#ifdef H5_HAVE_GETTIMEOFDAY - if ( ( MAINPROCESS ) && ( display_skips ) ) { - - HDfprintf(stdout, "***********************************\n"); - HDfprintf(stdout, "express test = %d.\n", express_test); - HDfprintf(stdout, "sample_size = %d, max_test_time = %lld.\n", - sample_size, max_test_time); - HDfprintf(stdout, "sample_times[] = %lld, %lld, %lld, %lld.\n", - sample_times[ind_contig_idx], - sample_times[col_contig_idx], - sample_times[ind_chunked_idx], - sample_times[col_chunked_idx]); - HDfprintf(stdout, "skips[] = %d, %d, %d, %d.\n", - skips[ind_contig_idx], - skips[col_contig_idx], - skips[ind_chunked_idx], - skips[col_chunked_idx]); - HDfprintf(stdout, "tests_skiped[] = %d, %d, %d, %d.\n", - tests_skiped[ind_contig_idx], - tests_skiped[col_contig_idx], - tests_skiped[ind_chunked_idx], - tests_skiped[col_chunked_idx]); - HDfprintf(stdout, "test_num = %d.\n", test_num); - HDfprintf(stdout, "***********************************\n"); + if ( ( MAINPROCESS ) && ( tests_skipped > 0 ) ) { + HDfprintf(stdout, " %lld of %lld subtests skipped to expedite testing.\n", + tests_skipped, total_tests); } -#endif /* H5_HAVE_GETTIMEOFDAY */ return; -} /* checker_board_hyperslab_dr_pio_test() */ +} /* ckrbrd_hs_dr_pio_test() */ /* Main Body. Here for now, may have to move them to a separated file later. */ @@ -4756,28 +4986,28 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type, static void sscontig1(void) { - contig_hyperslab_dr_pio_test(IND_CONTIG); + contig_hs_dr_pio_test(IND_CONTIG); } /* Shape Same test using contigous hyperslab using collective IO on contigous datasets */ static void sscontig2(void) { - contig_hyperslab_dr_pio_test(COL_CONTIG); + contig_hs_dr_pio_test(COL_CONTIG); } /* Shape Same test using contigous hyperslab using independent IO on chunked datasets */ static void sscontig3(void) { - contig_hyperslab_dr_pio_test(IND_CHUNKED); + contig_hs_dr_pio_test(IND_CHUNKED); } /* Shape Same test using contigous hyperslab using collective IO on chunked datasets */ static void sscontig4(void) { - contig_hyperslab_dr_pio_test(COL_CHUNKED); + contig_hs_dr_pio_test(COL_CHUNKED); } @@ -4785,38 +5015,34 @@ sscontig4(void) static void sschecker1(void) { - checker_board_hyperslab_dr_pio_test(IND_CONTIG); + ckrbrd_hs_dr_pio_test(IND_CONTIG); } /* Shape Same test using checker hyperslab using collective IO on contigous datasets */ static void sschecker2(void) { - checker_board_hyperslab_dr_pio_test(COL_CONTIG); + ckrbrd_hs_dr_pio_test(COL_CONTIG); } /* Shape Same test using checker hyperslab using independent IO on chunked datasets */ static void sschecker3(void) { - checker_board_hyperslab_dr_pio_test(IND_CHUNKED); + ckrbrd_hs_dr_pio_test(IND_CHUNKED); } /* Shape Same test using checker hyperslab using collective IO on chunked datasets */ static void sschecker4(void) { - checker_board_hyperslab_dr_pio_test(COL_CHUNKED); + ckrbrd_hs_dr_pio_test(COL_CHUNKED); } int main(int argc, char **argv) { int mpi_size, mpi_rank; /* mpi variables */ - H5Ptest_param_t ndsets_params, ngroups_params; - H5Ptest_param_t collngroups_params; - H5Ptest_param_t io_mode_confusion_params; - H5Ptest_param_t rr_obj_flush_confusion_params; /* Un-buffer the stdout and stderr */ setbuf(stderr, NULL); @@ -4832,6 +5058,7 @@ int main(int argc, char **argv) if (MAINPROCESS){ printf("===================================\n"); printf("Shape Same Tests Start\n"); + printf(" express_test = %d.\n", GetTestExpress()); printf("===================================\n"); } @@ -4841,7 +5068,7 @@ int main(int argc, char **argv) * calls. By then, MPI calls may not work. */ if (H5dont_atexit() < 0){ - printf("Failed to turn off atexit processing. Continue.\n", mpi_rank); + printf("%d: Failed to turn off atexit processing. Continue.\n", mpi_rank); }; H5open(); h5_show_hostname(); @@ -4850,6 +5077,7 @@ int main(int argc, char **argv) TestInit(argv[0], usage, parse_options); /* Shape Same tests using contigous hyperslab */ +#if 1 AddTest("sscontig1", sscontig1, NULL, "Shape Same, contigous hyperslab, ind IO, contig datasets", PARATESTFILE); AddTest("sscontig2", sscontig2, NULL, @@ -4858,6 +5086,7 @@ int main(int argc, char **argv) "Shape Same, contigous hyperslab, ind IO, chunked datasets", PARATESTFILE); AddTest("sscontig4", sscontig4, NULL, "Shape Same, contigous hyperslab, col IO, chunked datasets", PARATESTFILE); +#endif /* Shape Same tests using checker board hyperslab */ AddTest("sschecker1", sschecker1, NULL, @@ -4919,9 +5148,9 @@ int main(int argc, char **argv) if (MAINPROCESS){ /* only process 0 reports */ printf("===================================\n"); if (nerrors) - printf("***PHDF5 tests detected %d errors***\n", nerrors); + printf("***Shape Same tests detected %d errors***\n", nerrors); else - printf("PHDF5 tests finished with no errors\n"); + printf("Shape Same tests finished with no errors\n"); printf("===================================\n"); } /* close HDF5 library */ |