From 0c1ad6cb2533ddb3d67f1b328c42116c471d65ba Mon Sep 17 00:00:00 2001 From: Larry Knox Date: Thu, 10 Aug 2023 06:02:38 -0700 Subject: [PATCH] Merges from 1.14 Aug 4-9 (#3366) * Make h5dump spacing consistent when printing VLEN datatype (#3351) (#3352) * Add Fortran H5ES module to deploy list (#3342) * Fix for the bug exposed from running test/set_extent.c when selection I/O is enabled. (#3319) The test/set_extent.c is modified to test for selection I/O enabled. * Merge Implementation of the mpio driver with selection I/O. (#3360) * Work around a testphdf5 failure on Cray MPICH machines (#3361) (#3362) * set H5_PAC_C_MAX_REAL_PRECISION default to 0 when cross compiling (#3365) with CMake to fix Fortran build failures. --- config/cmake/ConfigureChecks.cmake | 24 +- fortran/src/CMakeLists.txt | 74 +- hl/fortran/src/CMakeLists.txt | 30 +- release_docs/RELEASE.txt | 11 + release_docs/USING_HDF5_VS.txt | 5 +- src/H5Dchunk.c | 44 +- src/H5Dcompact.c | 5 +- src/H5Defl.c | 3 + src/H5Dio.c | 30 +- src/H5Dmpio.c | 22 +- src/H5Dscatgath.c | 175 ++- src/H5FD.c | 402 ++++++- src/H5FDdevelop.h | 12 + src/H5FDint.c | 700 +++++++++-- src/H5FDmpio.c | 1026 +++++++++++++++- src/H5FDprivate.h | 35 +- src/H5Ppublic.h | 8 +- test/select_io_dset.c | 24 +- test/set_extent.c | 187 ++- testpar/t_coll_chunk.c | 2 +- testpar/t_dset.c | 2 +- testpar/t_file.c | 31 +- testpar/t_select_io_dset.c | 417 ++++++- testpar/t_vfd.c | 1805 ++++++++++++++++++++++++++-- tools/lib/h5tools_dump.c | 2 +- tools/testfiles/tarray6.ddl | 2 +- tools/testfiles/tarray7.ddl | 2 +- tools/testfiles/tempty.ddl | 2 +- tools/testfiles/tfill.ddl | 2 +- tools/testfiles/tmultifile.ddl | 4 +- tools/testfiles/treference.ddl | 24 +- tools/testfiles/tvldtypes1.ddl | 6 +- tools/testfiles/tvldtypes2.ddl | 2 +- tools/testfiles/tvldtypes3.ddl | 2 +- tools/testfiles/tvldtypes4.ddl | 2 +- tools/testfiles/tvldtypes5.ddl | 2 +- 36 files changed, 4585 insertions(+), 541 deletions(-) diff --git a/config/cmake/ConfigureChecks.cmake b/config/cmake/ConfigureChecks.cmake index e5192f54496..4da401a8174 100644 --- a/config/cmake/ConfigureChecks.cmake +++ b/config/cmake/ConfigureChecks.cmake @@ -858,21 +858,23 @@ if (HDF5_BUILD_FORTRAN) list (GET PROG_OUTPUT4 0 H5_LDBL_DIG) list (GET PROG_OUTPUT4 1 H5_FLT128_DIG) - endif () - if (${HDF_PREFIX}_SIZEOF___FLOAT128 EQUAL "0" OR FLT128_DIG EQUAL "0") - set (${HDF_PREFIX}_HAVE_FLOAT128 0) - set (${HDF_PREFIX}_SIZEOF___FLOAT128 0) - set (_PAC_C_MAX_REAL_PRECISION ${H5_LDBL_DIG}) + if (${HDF_PREFIX}_SIZEOF___FLOAT128 EQUAL "0" OR FLT128_DIG EQUAL "0") + set (${HDF_PREFIX}_HAVE_FLOAT128 0) + set (${HDF_PREFIX}_SIZEOF___FLOAT128 0) + set (_PAC_C_MAX_REAL_PRECISION ${H5_LDBL_DIG}) + else () + set (_PAC_C_MAX_REAL_PRECISION ${H5_FLT128_DIG}) + endif () + if (NOT ${_PAC_C_MAX_REAL_PRECISION}) + set (${HDF_PREFIX}_PAC_C_MAX_REAL_PRECISION 0) + else () + set (${HDF_PREFIX}_PAC_C_MAX_REAL_PRECISION ${_PAC_C_MAX_REAL_PRECISION}) + endif () + message (STATUS "maximum decimal precision for C var - ${${HDF_PREFIX}_PAC_C_MAX_REAL_PRECISION}") else () - set (_PAC_C_MAX_REAL_PRECISION ${H5_FLT128_DIG}) - endif () - if (NOT ${_PAC_C_MAX_REAL_PRECISION}) set (${HDF_PREFIX}_PAC_C_MAX_REAL_PRECISION 0) - else () - set (${HDF_PREFIX}_PAC_C_MAX_REAL_PRECISION ${_PAC_C_MAX_REAL_PRECISION}) endif () - message (STATUS "maximum decimal precision for C var - ${${HDF_PREFIX}_PAC_C_MAX_REAL_PRECISION}") endif() diff --git a/fortran/src/CMakeLists.txt b/fortran/src/CMakeLists.txt index fbe946843c1..977d036d4c1 100644 --- a/fortran/src/CMakeLists.txt +++ b/fortran/src/CMakeLists.txt @@ -427,29 +427,34 @@ else () ) endif () +set (mod_export_files + h5fortran_types.mod + hdf5.mod + h5fortkit.mod + h5global.mod + h5a.mod + h5d.mod + h5e.mod + h5es.mod + h5f.mod + h5g.mod + h5i.mod + h5l.mod + h5lib.mod + h5o.mod + h5p.mod + h5r.mod + h5s.mod + h5t.mod + h5vl.mod + h5z.mod + h5_gen.mod +) + if (BUILD_STATIC_LIBS) - set (mod_files - ${MOD_BUILD_DIR}/h5fortran_types.mod - ${MOD_BUILD_DIR}/hdf5.mod - ${MOD_BUILD_DIR}/h5fortkit.mod - ${MOD_BUILD_DIR}/h5global.mod - ${MOD_BUILD_DIR}/h5a.mod - ${MOD_BUILD_DIR}/h5d.mod - ${MOD_BUILD_DIR}/h5e.mod - ${MOD_BUILD_DIR}/h5f.mod - ${MOD_BUILD_DIR}/h5g.mod - ${MOD_BUILD_DIR}/h5i.mod - ${MOD_BUILD_DIR}/h5l.mod - ${MOD_BUILD_DIR}/h5lib.mod - ${MOD_BUILD_DIR}/h5o.mod - ${MOD_BUILD_DIR}/h5p.mod - ${MOD_BUILD_DIR}/h5r.mod - ${MOD_BUILD_DIR}/h5s.mod - ${MOD_BUILD_DIR}/h5t.mod - ${MOD_BUILD_DIR}/h5vl.mod - ${MOD_BUILD_DIR}/h5z.mod - ${MOD_BUILD_DIR}/h5_gen.mod - ) + foreach (mod_file ${mod_export_files}) + set (mod_files ${mod_files} ${MOD_BUILD_DIR}/${mod_file}) + endforeach () install ( FILES ${mod_files} @@ -471,28 +476,9 @@ if (BUILD_STATIC_LIBS) endif () if (BUILD_SHARED_LIBS) - set (modsh_files - ${MODSH_BUILD_DIR}/h5fortran_types.mod - ${MODSH_BUILD_DIR}/hdf5.mod - ${MODSH_BUILD_DIR}/h5fortkit.mod - ${MODSH_BUILD_DIR}/h5global.mod - ${MODSH_BUILD_DIR}/h5a.mod - ${MODSH_BUILD_DIR}/h5d.mod - ${MODSH_BUILD_DIR}/h5e.mod - ${MODSH_BUILD_DIR}/h5f.mod - ${MODSH_BUILD_DIR}/h5g.mod - ${MODSH_BUILD_DIR}/h5i.mod - ${MODSH_BUILD_DIR}/h5l.mod - ${MODSH_BUILD_DIR}/h5lib.mod - ${MODSH_BUILD_DIR}/h5o.mod - ${MODSH_BUILD_DIR}/h5p.mod - ${MODSH_BUILD_DIR}/h5r.mod - ${MODSH_BUILD_DIR}/h5s.mod - ${MODSH_BUILD_DIR}/h5t.mod - ${MODSH_BUILD_DIR}/h5vl.mod - ${MODSH_BUILD_DIR}/h5z.mod - ${MODSH_BUILD_DIR}/h5_gen.mod - ) + foreach (mod_file ${mod_export_files}) + set (modsh_files ${modsh_files} ${MODSH_BUILD_DIR}/${mod_file}) + endforeach () install ( FILES ${modsh_files} diff --git a/hl/fortran/src/CMakeLists.txt b/hl/fortran/src/CMakeLists.txt index 705a37a1bb1..0aa0f151203 100644 --- a/hl/fortran/src/CMakeLists.txt +++ b/hl/fortran/src/CMakeLists.txt @@ -235,16 +235,19 @@ endif () # Add file(s) to CMake Install #----------------------------------------------------------------------------- +set (mod_export_files + h5ds.mod + h5tb.mod + h5tb_const.mod + h5lt.mod + h5lt_const.mod + h5im.mod +) if (BUILD_STATIC_LIBS) - set (mod_files - ${MOD_BUILD_DIR}/h5ds.mod - ${MOD_BUILD_DIR}/h5tb.mod - ${MOD_BUILD_DIR}/h5tb_const.mod - ${MOD_BUILD_DIR}/h5lt.mod - ${MOD_BUILD_DIR}/h5lt_const.mod - ${MOD_BUILD_DIR}/h5im.mod - ) + foreach (mod_file ${mod_export_files}) + set (mod_files ${mod_files} ${MOD_BUILD_DIR}/${mod_file}) + endforeach () install ( FILES ${mod_files} @@ -265,14 +268,9 @@ if (BUILD_STATIC_LIBS) endif () endif () if (BUILD_SHARED_LIBS) - set (modsh_files - ${MODSH_BUILD_DIR}/h5ds.mod - ${MODSH_BUILD_DIR}/h5tb.mod - ${MODSH_BUILD_DIR}/h5tb_const.mod - ${MODSH_BUILD_DIR}/h5lt.mod - ${MODSH_BUILD_DIR}/h5lt_const.mod - ${MODSH_BUILD_DIR}/h5im.mod - ) + foreach (mod_file ${mod_export_files}) + set (modsh_files ${modsh_files} ${MODSH_BUILD_DIR}/${mod_file}) + endforeach () install ( FILES ${modsh_files} diff --git a/release_docs/RELEASE.txt b/release_docs/RELEASE.txt index 32694fcb4ca..86b398c72a9 100644 --- a/release_docs/RELEASE.txt +++ b/release_docs/RELEASE.txt @@ -260,6 +260,17 @@ Bug Fixes since HDF5-1.14.1 release Testing ------- + - Fixed a testing failure in testphdf5 on Cray machines + + On some Cray machines, what appears to be a bug in Cray MPICH was causing + calls to H5Fis_accessible to create a 0-byte file with strange Unix + permissions. This was causing an H5Fdelete file deletion test in the + testphdf5 program to fail due to a just-deleted HDF5 file appearing to + still be accessible on the file system. The issue in Cray MPICH has been + worked around for the time being by resetting the MPI_Info object on the + File Access Property List used to MPI_INFO_NULL before passing it to the + H5Fis_accessible call. + - A bug was fixed in the HDF5 API test random datatype generation code A bug in the random datatype generation code could cause test failures diff --git a/release_docs/USING_HDF5_VS.txt b/release_docs/USING_HDF5_VS.txt index d604806298d..3375a7746df 100644 --- a/release_docs/USING_HDF5_VS.txt +++ b/release_docs/USING_HDF5_VS.txt @@ -38,7 +38,10 @@ Using Visual Studio 2010 and above with HDF5 Libraries built with Visual Studio library, and then optionally the HDF5 High Level, Fortran or C++ libraries. For example, to compile a C++ application, enter: - szip.lib zlib.lib hdf5.lib hdf5_cpp.lib + hdf5.lib hdf5_cpp.lib + + For static linking: + libszaec.lib libaec.lib libzlib.lib libhdf5.lib libhdf5_cpp.lib ========================================================================== diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c index be8ded47223..8f34c2f4295 100644 --- a/src/H5Dchunk.c +++ b/src/H5Dchunk.c @@ -2731,11 +2731,20 @@ H5D__chunk_read(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) } } /* end if */ else if (!skip_missing_chunks) { + /* Set up nonexistent dataset info for (fill value) read from nonexistent chunk */ + nonexistent_dset_info.layout_io_info.contig_piece_info = chunk_info; + nonexistent_dset_info.file_space = chunk_info->fspace; + nonexistent_dset_info.mem_space = chunk_info->mspace; + nonexistent_dset_info.nelmts = chunk_info->piece_points; + + /* Set request_nelmts. This is not normally set by the upper layers because selection I/O + * usually does not use strip mining (H5D__scatgath_write), and instead allocates buffers + * large enough for the entire I/O. Set request_nelmts to be large enough for all selected + * elements in this chunk because it must be at least that large */ + nonexistent_dset_info.type_info.request_nelmts = nonexistent_dset_info.nelmts; + /* Perform the actual read operation from the nonexistent chunk */ - nonexistent_dset_info.file_space = chunk_info->fspace; - nonexistent_dset_info.mem_space = chunk_info->mspace; - nonexistent_dset_info.nelmts = chunk_info->piece_points; if ((dset_info->io_ops.single_read)(&nonexistent_io_info, &nonexistent_dset_info) < 0) HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "chunked read failed"); } /* end if */ @@ -2866,9 +2875,10 @@ H5D__chunk_read(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) /* Perform the actual read operation */ assert(chk_io_info->count == 1); - chk_io_info->dsets_info[0].file_space = chunk_info->fspace; - chk_io_info->dsets_info[0].mem_space = chunk_info->mspace; - chk_io_info->dsets_info[0].nelmts = chunk_info->piece_points; + chk_io_info->dsets_info[0].layout_io_info.contig_piece_info = chunk_info; + chk_io_info->dsets_info[0].file_space = chunk_info->fspace; + chk_io_info->dsets_info[0].mem_space = chunk_info->mspace; + chk_io_info->dsets_info[0].nelmts = chunk_info->piece_points; if ((dset_info->io_ops.single_read)(chk_io_info, &chk_io_info->dsets_info[0]) < 0) HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "chunked read failed"); @@ -3055,10 +3065,19 @@ H5D__chunk_write(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) /* Set up the storage buffer information for this chunk */ cpt_store.compact.buf = chunk; + /* Set up compact dataset info for write to cached chunk */ + cpt_dset_info.layout_io_info.contig_piece_info = chunk_info; + cpt_dset_info.file_space = chunk_info->fspace; + cpt_dset_info.mem_space = chunk_info->mspace; + cpt_dset_info.nelmts = chunk_info->piece_points; + + /* Set request_nelmts. This is not normally set by the upper layers because selection I/O + * usually does not use strip mining (H5D__scatgath_write), and instead allocates buffers + * large enough for the entire I/O. Set request_nelmts to be large enough for all selected + * elements in this chunk because it must be at least that large */ + cpt_dset_info.type_info.request_nelmts = cpt_dset_info.nelmts; + /* Perform the actual write operation */ - cpt_dset_info.file_space = chunk_info->fspace; - cpt_dset_info.mem_space = chunk_info->mspace; - cpt_dset_info.nelmts = chunk_info->piece_points; if ((dset_info->io_ops.single_write)(&cpt_io_info, &cpt_dset_info) < 0) HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "chunked write failed"); @@ -3253,9 +3272,10 @@ H5D__chunk_write(H5D_io_info_t *io_info, H5D_dset_io_info_t *dset_info) /* Perform the actual write operation */ assert(chk_io_info->count == 1); - chk_io_info->dsets_info[0].file_space = chunk_info->fspace; - chk_io_info->dsets_info[0].mem_space = chunk_info->mspace; - chk_io_info->dsets_info[0].nelmts = chunk_info->piece_points; + chk_io_info->dsets_info[0].layout_io_info.contig_piece_info = chunk_info; + chk_io_info->dsets_info[0].file_space = chunk_info->fspace; + chk_io_info->dsets_info[0].mem_space = chunk_info->mspace; + chk_io_info->dsets_info[0].nelmts = chunk_info->piece_points; if ((dset_info->io_ops.single_write)(chk_io_info, &chk_io_info->dsets_info[0]) < 0) HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "chunked write failed"); diff --git a/src/H5Dcompact.c b/src/H5Dcompact.c index 96a9123b949..c16b24ba90e 100644 --- a/src/H5Dcompact.c +++ b/src/H5Dcompact.c @@ -233,8 +233,9 @@ H5D__compact_io_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo) { FUNC_ENTER_PACKAGE_NOERR - dinfo->store->compact.buf = dinfo->dset->shared->layout.storage.u.compact.buf; - dinfo->store->compact.dirty = &dinfo->dset->shared->layout.storage.u.compact.dirty; + dinfo->store->compact.buf = dinfo->dset->shared->layout.storage.u.compact.buf; + dinfo->store->compact.dirty = &dinfo->dset->shared->layout.storage.u.compact.dirty; + dinfo->layout_io_info.contig_piece_info = NULL; /* Disable selection I/O */ io_info->use_select_io = H5D_SELECTION_IO_MODE_OFF; diff --git a/src/H5Defl.c b/src/H5Defl.c index 84a304262c7..84f00ede313 100644 --- a/src/H5Defl.c +++ b/src/H5Defl.c @@ -198,6 +198,9 @@ H5D__efl_io_init(H5D_io_info_t *io_info, H5D_dset_io_info_t *dinfo) H5MM_memcpy(&dinfo->store->efl, &(dinfo->dset->shared->dcpl_cache.efl), sizeof(H5O_efl_t)); + /* No "pieces" selected */ + dinfo->layout_io_info.contig_piece_info = NULL; + /* Disable selection I/O */ io_info->use_select_io = H5D_SELECTION_IO_MODE_OFF; io_info->no_selection_io_cause |= H5D_SEL_IO_NOT_CONTIGUOUS_OR_CHUNKED_DATASET; diff --git a/src/H5Dio.c b/src/H5Dio.c index 89afde53f83..b978139a8a7 100644 --- a/src/H5Dio.c +++ b/src/H5Dio.c @@ -415,8 +415,14 @@ H5D__read(size_t count, H5D_dset_io_info_t *dset_info) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get MPI-I/O transfer mode"); /* Only report the collective I/O mode if we're actually performing collective I/O */ - if (xfer_mode == H5FD_MPIO_COLLECTIVE) + if (xfer_mode == H5FD_MPIO_COLLECTIVE) { H5CX_set_mpio_actual_io_mode(io_info.actual_io_mode); + + /* If we did selection I/O, report that we used "link chunk" mode, since that's the most + * analogous to what selection I/O does */ + if (io_info.use_select_io == H5D_SELECTION_IO_MODE_ON) + H5CX_set_mpio_actual_chunk_opt(H5D_MPIO_LINK_CHUNK); + } } #endif /* H5_HAVE_PARALLEL */ } @@ -1131,20 +1137,16 @@ H5D__typeinfo_init_phase2(H5D_io_info_t *io_info) assert(io_info); /* If selection I/O mode is default (auto), enable it here if the VFD supports it (it will be turned off - * later if something else conflicts), otherwise disable it. If we're using the MPIO VFD, the automatic - * selection will happen in H5D__mpio_opt_possible() inside H5D__ioinfo_adjust(). */ -#ifdef H5_HAVE_PARALLEL - if (!io_info->using_mpi_vfd) -#endif /* H5_HAVE_PARALLEL */ - if (io_info->use_select_io == H5D_SELECTION_IO_MODE_DEFAULT) { - if (H5F_has_vector_select_io(io_info->dsets_info[0].dset->oloc.file, - io_info->op_type == H5D_IO_OP_WRITE)) - io_info->use_select_io = H5D_SELECTION_IO_MODE_ON; - else { - io_info->use_select_io = H5D_SELECTION_IO_MODE_OFF; - io_info->no_selection_io_cause |= H5D_SEL_IO_DEFAULT_OFF; - } + * later if something else conflicts), otherwise disable it */ + if (io_info->use_select_io == H5D_SELECTION_IO_MODE_DEFAULT) { + if (H5F_has_vector_select_io(io_info->dsets_info[0].dset->oloc.file, + io_info->op_type == H5D_IO_OP_WRITE)) + io_info->use_select_io = H5D_SELECTION_IO_MODE_ON; + else { + io_info->use_select_io = H5D_SELECTION_IO_MODE_OFF; + io_info->no_selection_io_cause |= H5D_SEL_IO_DEFAULT_OFF; } + } /* If we're doing type conversion and we might be doing selection I/O, check if the buffers are large * enough to handle the whole I/O */ diff --git a/src/H5Dmpio.c b/src/H5Dmpio.c index 901907ceaba..82bcf024374 100644 --- a/src/H5Dmpio.c +++ b/src/H5Dmpio.c @@ -622,6 +622,9 @@ H5D__mpio_opt_possible(H5D_io_info_t *io_info) if (!H5FD_mpi_opt_types_g) local_cause[0] |= H5D_MPIO_MPI_OPT_TYPES_ENV_VAR_DISABLED; + /* Decision on whether to use selection I/O should have been made by now */ + assert(io_info->use_select_io != H5D_SELECTION_IO_MODE_DEFAULT); + /* Datatype conversions and transformations are allowed with selection I/O. If the selection I/O mode * is auto (default), disable collective for now and re-enable later if we can */ if (io_info->use_select_io != H5D_SELECTION_IO_MODE_ON) { @@ -731,25 +734,6 @@ H5D__mpio_opt_possible(H5D_io_info_t *io_info) HMPI_GOTO_ERROR(FAIL, "MPI_Allreduce failed", mpi_code) } /* end else */ - /* If the selection I/O mode is default (auto), decide here whether it should be on or off */ - if (io_info->use_select_io == H5D_SELECTION_IO_MODE_DEFAULT) { - /* If the only reason(s) we've disabled collective are type conversions and/or transforms, enable - * selection I/O and re-enable collective I/O since it's supported by selection I/O */ - if (global_cause[0] && !(global_cause[0] & ~((unsigned)H5D_MPIO_DATATYPE_CONVERSION | - (unsigned)H5D_MPIO_DATA_TRANSFORMS))) { - assert(!(local_cause[0] & - ~((unsigned)H5D_MPIO_DATATYPE_CONVERSION | (unsigned)H5D_MPIO_DATA_TRANSFORMS))); - local_cause[0] = 0; - global_cause[0] = 0; - io_info->use_select_io = H5D_SELECTION_IO_MODE_ON; - } - else { - /* Otherwise, there's currently no benefit to selection I/O, so leave it off */ - io_info->use_select_io = H5D_SELECTION_IO_MODE_OFF; - io_info->no_selection_io_cause |= H5D_SEL_IO_DEFAULT_OFF; - } - } - /* Set the local & global values of no-collective-cause in the API context */ H5CX_set_mpio_local_no_coll_cause(local_cause[0]); H5CX_set_mpio_global_no_coll_cause(global_cause[0]); diff --git a/src/H5Dscatgath.c b/src/H5Dscatgath.c index 59b5944ea45..cf6b4fd4530 100644 --- a/src/H5Dscatgath.c +++ b/src/H5Dscatgath.c @@ -32,9 +32,15 @@ /****************/ /* Macro to determine if we're using H5D__compound_opt_read() */ -#define H5D__SCATGATH_USE_CMPD_OPT_READ(DSET_INFO, PIECE_INFO) \ +#define H5D__SCATGATH_USE_CMPD_OPT_READ(DSET_INFO, IN_PLACE_TCONV) \ ((DSET_INFO)->type_info.cmpd_subset && H5T_SUBSET_FALSE != (DSET_INFO)->type_info.cmpd_subset->subset && \ - !(PIECE_INFO)->in_place_tconv) + !(IN_PLACE_TCONV)) + +/* Macro to determine if we're using H5D__compound_opt_write() */ +#define H5D__SCATGATH_USE_CMPD_OPT_WRITE(DSET_INFO, IN_PLACE_TCONV) \ + ((DSET_INFO)->type_info.cmpd_subset && H5T_SUBSET_DST == (DSET_INFO)->type_info.cmpd_subset->subset && \ + (DSET_INFO)->type_info.dst_type_size == (DSET_INFO)->type_info.cmpd_subset->copy_size && \ + !(IN_PLACE_TCONV)) /******************/ /* Local Typedefs */ @@ -49,7 +55,7 @@ static size_t H5D__gather_file(const H5D_io_info_t *io_info, const H5D_dset_io_i H5S_sel_iter_t *file_iter, size_t nelmts, void *buf); static herr_t H5D__compound_opt_read(size_t nelmts, H5S_sel_iter_t *iter, const H5D_type_info_t *type_info, uint8_t *tconv_buf, void *user_buf /*out*/); -static herr_t H5D__compound_opt_write(size_t nelmts, const H5D_type_info_t *type_info, uint8_t *tconv_buf); +static herr_t H5D__compound_opt_write(size_t nelmts, const H5D_type_info_t *type_info, void *tconv_buf); /*********************/ /* Package Variables */ @@ -440,6 +446,7 @@ herr_t H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_info) { void *buf; /* Local pointer to application buffer */ + void *tmp_buf; /* Buffer to use for type conversion */ H5S_sel_iter_t *mem_iter = NULL; /* Memory selection iteration info*/ hbool_t mem_iter_init = FALSE; /* Memory selection iteration info has been initialized */ H5S_sel_iter_t *bkg_iter = NULL; /* Background iteration info*/ @@ -448,6 +455,7 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_ hbool_t file_iter_init = FALSE; /* File selection iteration info has been initialized */ hsize_t smine_start; /* Strip mine start loc */ size_t smine_nelmts; /* Elements per strip */ + hbool_t in_place_tconv; /* Whether to perform in-place type_conversion */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_PACKAGE @@ -466,6 +474,10 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_ if (dset_info->nelmts == 0) HGOTO_DONE(SUCCEED); + /* Check for in-place type conversion */ + in_place_tconv = dset_info->layout_io_info.contig_piece_info && + dset_info->layout_io_info.contig_piece_info->in_place_tconv; + /* Allocate the iterators */ if (NULL == (mem_iter = H5FL_MALLOC(H5S_sel_iter_t))) HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate memory iterator"); @@ -490,9 +502,34 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_ for (smine_start = 0; smine_start < dset_info->nelmts; smine_start += smine_nelmts) { size_t n; /* Elements operated on */ - /* Go figure out how many elements to read from the file */ assert(H5S_SELECT_ITER_NELMTS(file_iter) == (dset_info->nelmts - smine_start)); - smine_nelmts = (size_t)MIN(dset_info->type_info.request_nelmts, (dset_info->nelmts - smine_start)); + + /* Determine strip mine size. First check if we're doing in-place type conversion */ + if (in_place_tconv) { + /* If this is not a selection I/O operation and there is a background buffer, we cannot exceed + * request_nelmts. It could be part of a selection I/O operation if this read is used to fill in + * a nonexistent chunk */ + assert(!H5D__SCATGATH_USE_CMPD_OPT_READ(dset_info, in_place_tconv)); + if (dset_info->type_info.need_bkg && (io_info->use_select_io != H5D_SELECTION_IO_MODE_ON)) + smine_nelmts = + (size_t)MIN(dset_info->type_info.request_nelmts, (dset_info->nelmts - smine_start)); + else { + assert(smine_start == 0); + smine_nelmts = dset_info->nelmts; + } + + /* Calculate buffer position in user buffer */ + tmp_buf = (uint8_t *)buf + dset_info->layout_io_info.contig_piece_info->buf_off + + (smine_start * dset_info->type_info.dst_type_size); + } + else { + /* Do type conversion using intermediate buffer */ + tmp_buf = io_info->tconv_buf; + + /* Go figure out how many elements to read from the file */ + smine_nelmts = + (size_t)MIN(dset_info->type_info.request_nelmts, (dset_info->nelmts - smine_start)); + } /* * Gather the data from disk into the datatype conversion @@ -500,10 +537,19 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_ * if necessary. */ + /* Fill background buffer here unless we will use H5D__compound_opt_read(). Must do this before + * the read so the read buffer doesn't get wiped out if we're using in-place type conversion */ + if ((H5T_BKG_YES == dset_info->type_info.need_bkg) && + !H5D__SCATGATH_USE_CMPD_OPT_READ(dset_info, in_place_tconv)) { + n = H5D__gather_mem(buf, bkg_iter, smine_nelmts, io_info->bkg_buf /*out*/); + if (n != smine_nelmts) + HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "mem gather failed"); + } + /* * Gather data */ - n = H5D__gather_file(io_info, dset_info, file_iter, smine_nelmts, io_info->tconv_buf /*out*/); + n = H5D__gather_file(io_info, dset_info, file_iter, smine_nelmts, tmp_buf /*out*/); if (n != smine_nelmts) HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "file gather failed"); @@ -511,25 +557,18 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_ * and no conversion is needed, copy the data directly into user's buffer and * bypass the rest of steps. */ - if (dset_info->type_info.cmpd_subset && - H5T_SUBSET_FALSE != dset_info->type_info.cmpd_subset->subset) { - if (H5D__compound_opt_read(smine_nelmts, mem_iter, &dset_info->type_info, io_info->tconv_buf, - buf /*out*/) < 0) + if (H5D__SCATGATH_USE_CMPD_OPT_READ(dset_info, in_place_tconv)) { + if (H5D__compound_opt_read(smine_nelmts, mem_iter, &dset_info->type_info, tmp_buf, buf /*out*/) < + 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "datatype conversion failed"); } /* end if */ else { - if (H5T_BKG_YES == dset_info->type_info.need_bkg) { - n = H5D__gather_mem(buf, bkg_iter, smine_nelmts, io_info->bkg_buf /*out*/); - if (n != smine_nelmts) - HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "mem gather failed"); - } /* end if */ - /* * Perform datatype conversion. */ if (H5T_convert(dset_info->type_info.tpath, dset_info->type_info.src_type_id, - dset_info->type_info.dst_type_id, smine_nelmts, (size_t)0, (size_t)0, - io_info->tconv_buf, io_info->bkg_buf) < 0) + dset_info->type_info.dst_type_id, smine_nelmts, (size_t)0, (size_t)0, tmp_buf, + io_info->bkg_buf) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTCONVERT, FAIL, "datatype conversion failed"); /* Do the data transform after the conversion (since we're using type mem_type) */ @@ -540,14 +579,14 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_ if (H5CX_get_data_transform(&data_transform) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get data transform info"); - if (H5Z_xform_eval(data_transform, io_info->tconv_buf, smine_nelmts, - dset_info->type_info.mem_type) < 0) + if (H5Z_xform_eval(data_transform, tmp_buf, smine_nelmts, dset_info->type_info.mem_type) < 0) HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "Error performing data transform"); } - /* Scatter the data into memory */ - if (H5D__scatter_mem(io_info->tconv_buf, mem_iter, smine_nelmts, buf /*out*/) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "scatter failed"); + /* Scatter the data into memory if this was not an in-place conversion */ + if (!in_place_tconv) + if (H5D__scatter_mem(tmp_buf, mem_iter, smine_nelmts, buf /*out*/) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "scatter failed"); } /* end else */ } /* end for */ @@ -582,6 +621,7 @@ herr_t H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset_info) { const void *buf; /* Local pointer to application buffer */ + void *tmp_buf; /* Buffer to use for type conversion */ H5S_sel_iter_t *mem_iter = NULL; /* Memory selection iteration info*/ hbool_t mem_iter_init = FALSE; /* Memory selection iteration info has been initialized */ H5S_sel_iter_t *bkg_iter = NULL; /* Background iteration info*/ @@ -590,6 +630,7 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset hbool_t file_iter_init = FALSE; /* File selection iteration info has been initialized */ hsize_t smine_start; /* Strip mine start loc */ size_t smine_nelmts; /* Elements per strip */ + hbool_t in_place_tconv; /* Whether to perform in-place type_conversion */ herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_PACKAGE @@ -599,7 +640,7 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset assert(dset_info); assert(dset_info->mem_space); assert(dset_info->file_space); - assert(dset_info->buf.vp); + assert(dset_info->buf.cvp); /* Set buf pointer */ buf = dset_info->buf.cvp; @@ -608,6 +649,10 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset if (dset_info->nelmts == 0) HGOTO_DONE(SUCCEED); + /* Check for in-place type conversion */ + in_place_tconv = dset_info->layout_io_info.contig_piece_info && + dset_info->layout_io_info.contig_piece_info->in_place_tconv; + /* Allocate the iterators */ if (NULL == (mem_iter = H5FL_MALLOC(H5S_sel_iter_t))) HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "can't allocate memory iterator"); @@ -633,29 +678,56 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset for (smine_start = 0; smine_start < dset_info->nelmts; smine_start += smine_nelmts) { size_t n; /* Elements operated on */ - /* Go figure out how many elements to read from the file */ assert(H5S_SELECT_ITER_NELMTS(file_iter) == (dset_info->nelmts - smine_start)); - smine_nelmts = (size_t)MIN(dset_info->type_info.request_nelmts, (dset_info->nelmts - smine_start)); - /* - * Gather data from application buffer into the datatype conversion - * buffer. Also gather data from the file into the background buffer - * if necessary. - */ - n = H5D__gather_mem(buf, mem_iter, smine_nelmts, io_info->tconv_buf /*out*/); - if (n != smine_nelmts) - HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "mem gather failed"); + /* Determine strip mine size. First check if we're doing in-place type conversion */ + if (in_place_tconv) { + /* If this is not a selection I/O operation and there is a background buffer, we cannot exceed + * request_nelmts. It could be part of a selection I/O operation if this is used to write the + * fill value to a cached chunk that will immediately be evicted. */ + assert(!H5D__SCATGATH_USE_CMPD_OPT_WRITE(dset_info, in_place_tconv)); + if (dset_info->type_info.need_bkg && (io_info->use_select_io != H5D_SELECTION_IO_MODE_ON)) + smine_nelmts = + (size_t)MIN(dset_info->type_info.request_nelmts, (dset_info->nelmts - smine_start)); + else { + assert(smine_start == 0); + smine_nelmts = dset_info->nelmts; + } + + /* Calculate buffer position in user buffer */ + /* Use "vp" field of union to twiddle away const. OK because if we're doing this it means the + * user explicitly allowed us to modify this buffer via H5Pset_modify_write_buf(). */ + tmp_buf = (uint8_t *)dset_info->buf.vp + dset_info->layout_io_info.contig_piece_info->buf_off + + (smine_start * dset_info->type_info.dst_type_size); + } + else { + /* Do type conversion using intermediate buffer */ + tmp_buf = io_info->tconv_buf; + + /* Go figure out how many elements to read from the file */ + smine_nelmts = + (size_t)MIN(dset_info->type_info.request_nelmts, (dset_info->nelmts - smine_start)); + + /* + * Gather data from application buffer into the datatype conversion + * buffer. Also gather data from the file into the background buffer + * if necessary. + */ + n = H5D__gather_mem(buf, mem_iter, smine_nelmts, tmp_buf /*out*/); + if (n != smine_nelmts) + HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "mem gather failed"); + } /* If the source and destination are compound types and the destination is * is a subset of the source and no conversion is needed, copy the data - * directly into user's buffer and bypass the rest of steps. If the source + * directly from user's buffer and bypass the rest of steps. If the source * is a subset of the destination, the optimization is done in conversion * function H5T_conv_struct_opt to protect the background data. */ - if (dset_info->type_info.cmpd_subset && H5T_SUBSET_DST == dset_info->type_info.cmpd_subset->subset && - dset_info->type_info.dst_type_size == dset_info->type_info.cmpd_subset->copy_size) { - if (H5D__compound_opt_write(smine_nelmts, &dset_info->type_info, io_info->tconv_buf) < 0) + if (H5D__SCATGATH_USE_CMPD_OPT_WRITE(dset_info, in_place_tconv)) { + if (H5D__compound_opt_write(smine_nelmts, &dset_info->type_info, tmp_buf) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "datatype conversion failed"); + } /* end if */ else { if (H5T_BKG_YES == dset_info->type_info.need_bkg) { @@ -673,8 +745,7 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset if (H5CX_get_data_transform(&data_transform) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get data transform info"); - if (H5Z_xform_eval(data_transform, io_info->tconv_buf, smine_nelmts, - dset_info->type_info.mem_type) < 0) + if (H5Z_xform_eval(data_transform, tmp_buf, smine_nelmts, dset_info->type_info.mem_type) < 0) HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "Error performing data transform"); } @@ -682,15 +753,15 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_dset_io_info_t *dset * Perform datatype conversion. */ if (H5T_convert(dset_info->type_info.tpath, dset_info->type_info.src_type_id, - dset_info->type_info.dst_type_id, smine_nelmts, (size_t)0, (size_t)0, - io_info->tconv_buf, io_info->bkg_buf) < 0) + dset_info->type_info.dst_type_id, smine_nelmts, (size_t)0, (size_t)0, tmp_buf, + io_info->bkg_buf) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTCONVERT, FAIL, "datatype conversion failed"); } /* end else */ /* * Scatter the data out to the file. */ - if (H5D__scatter_file(io_info, dset_info, file_iter, smine_nelmts, io_info->tconv_buf) < 0) + if (H5D__scatter_file(io_info, dset_info, file_iter, smine_nelmts, tmp_buf) < 0) HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "scatter failed"); } /* end for */ @@ -795,7 +866,7 @@ H5D__scatgath_read_select(H5D_io_info_t *io_info) /* Fill background buffer here unless we will use H5D__compound_opt_read(). Must do this before * the read so the read buffer doesn't get wiped out if we're using in-place type conversion */ - if (!H5D__SCATGATH_USE_CMPD_OPT_READ(dset_info, io_info->sel_pieces[i])) { + if (!H5D__SCATGATH_USE_CMPD_OPT_READ(dset_info, io_info->sel_pieces[i]->in_place_tconv)) { /* Check for background buffer */ if (dset_info->type_info.need_bkg) { assert(io_info->bkg_buf); @@ -864,7 +935,7 @@ H5D__scatgath_read_select(H5D_io_info_t *io_info) * and no conversion is needed, copy the data directly into user's buffer and * bypass the rest of steps. */ - if (H5D__SCATGATH_USE_CMPD_OPT_READ(dset_info, io_info->sel_pieces[i])) { + if (H5D__SCATGATH_USE_CMPD_OPT_READ(dset_info, io_info->sel_pieces[i]->in_place_tconv)) { if (H5D__compound_opt_read((size_t)io_info->sel_pieces[i]->piece_points, mem_iter, &dset_info->type_info, tmp_bufs[i], io_info->rbufs[i] /*out*/) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "datatype conversion failed"); @@ -1064,18 +1135,11 @@ H5D__scatgath_write_select(H5D_io_info_t *io_info) * destination, the optimization is done in conversion function H5T_conv_struct_opt to * protect the background data. */ - if (dset_info->type_info.cmpd_subset && - H5T_SUBSET_DST == dset_info->type_info.cmpd_subset->subset && - dset_info->type_info.dst_type_size == dset_info->type_info.cmpd_subset->copy_size && - !io_info->sel_pieces[i]->in_place_tconv) { + if (H5D__SCATGATH_USE_CMPD_OPT_WRITE(dset_info, io_info->sel_pieces[i]->in_place_tconv)) { if (H5D__compound_opt_write((size_t)io_info->sel_pieces[i]->piece_points, &dset_info->type_info, tmp_write_buf) < 0) HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "datatype conversion failed"); - /* No background buffer necessary, prevent this element from being considered in the second - * loop */ - /* Add this to H5Tconv.c? -NAF */ - dset_info->type_info.need_bkg = H5T_BKG_NO; } /* end if */ else { /* Check for background buffer */ @@ -1180,7 +1244,8 @@ H5D__scatgath_write_select(H5D_io_info_t *io_info) for (i = 0; i < io_info->pieces_added; i++) { H5D_dset_io_info_t *dset_info = io_info->sel_pieces[i]->dset_info; - if (H5T_BKG_YES == dset_info->type_info.need_bkg) { + if ((H5T_BKG_YES == dset_info->type_info.need_bkg) && + !H5D__SCATGATH_USE_CMPD_OPT_WRITE(dset_info, io_info->sel_pieces[i]->in_place_tconv)) { /* Non-const write_buf[i]. Use pointer math here to avoid const warnings. When * there's a background buffer write_buf[i] always points inside the non-const tconv * buf so this is OK. */ @@ -1422,7 +1487,7 @@ H5D__compound_opt_read(size_t nelmts, H5S_sel_iter_t *iter, const H5D_type_info_ *------------------------------------------------------------------------- */ static herr_t -H5D__compound_opt_write(size_t nelmts, const H5D_type_info_t *type_info, uint8_t *tconv_buf) +H5D__compound_opt_write(size_t nelmts, const H5D_type_info_t *type_info, void *tconv_buf) { uint8_t *xsbuf, *xdbuf; /* Source & destination pointers into dataset buffer */ size_t src_stride, dst_stride; /* Strides through source & destination datatypes */ diff --git a/src/H5FD.c b/src/H5FD.c index 4909a257716..e2c32c6df1a 100644 --- a/src/H5FD.c +++ b/src/H5FD.c @@ -1723,8 +1723,8 @@ H5FDread_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, /* Call private function */ /* (Note compensating for base address addition in internal routine) */ - if (H5FD_read_selection_id(file, type, count, mem_space_ids, file_space_ids, offsets, element_sizes, - bufs) < 0) + if (H5FD_read_selection_id(SKIP_NO_CB, file, type, count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs) < 0) HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "file selection read request failed"); done: @@ -1820,14 +1820,408 @@ H5FDwrite_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count /* Call private function */ /* (Note compensating for base address addition in internal routine) */ - if (H5FD_write_selection_id(file, type, count, mem_space_ids, file_space_ids, offsets, element_sizes, - bufs) < 0) + + if (H5FD_write_selection_id(SKIP_NO_CB, file, type, count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs) < 0) HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "file selection write request failed"); done: FUNC_LEAVE_API(ret_value) } /* end H5FDwrite_selection() */ +/*------------------------------------------------------------------------- + * Purpose: This is similar to H5FDread_selection() with the + * exception noted below. + * + * Perform count reads from the specified file at the + * locations selected in the dataspaces in the file_spaces + * array, with each of those dataspaces starting at the file + * address specified by the corresponding element of the + * offsets array, and with the size of each element in the + * dataspace specified by the corresponding element of the + * element_sizes array. The memory type provided by type is + * the same for all selections. Data read is returned in + * the locations selected in the dataspaces in the + * mem_spaces array, within the buffers provided in the + * corresponding elements of the bufs array. + * + * If i > 0 and element_sizes[i] == 0, presume + * element_sizes[n] = element_sizes[i-1] for all n >= i and + * < count. + * + * Note: + * It will skip selection read call whether the underlying VFD + * supports selection reads or not. + * + * It will translate the selection read to a vector read call + * if vector reads are supported, or a series of scalar read + * calls otherwise. + * + * All reads are done according to the data transfer property + * list dxpl_id (which may be the constant H5P_DEFAULT). + * + * Return: Success: SUCCEED + * All reads have completed successfully, and + * the results have been written into the supplied + * buffers. + * + * Failure: FAIL + * The contents of supplied buffers are undefined. + * + *------------------------------------------------------------------------- + */ +herr_t +H5FDread_vector_from_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], + size_t element_sizes[], void *bufs[] /* out */) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_API(FAIL) + H5TRACE9("e", "*#MtiIu*i*i*a*zx", file, type, dxpl_id, count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs); + + /* Check arguments */ + if (!file) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL"); + + if (!file->cls) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL"); + + if ((!mem_space_ids) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "mem_spaces parameter can't be NULL if count is positive"); + + if ((!file_space_ids) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file_spaces parameter can't be NULL if count is positive"); + + if ((!offsets) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "offsets parameter can't be NULL if count is positive"); + + if ((!element_sizes) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, + "element_sizes parameter can't be NULL if count is positive"); + + if ((!bufs) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bufs parameter can't be NULL if count is positive"); + + if ((count > 0) && (element_sizes[0] == 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "sizes[0] can't be 0"); + + if ((count > 0) && (bufs[0] == NULL)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bufs[0] can't be NULL"); + + /* Get the default dataset transfer property list if the user didn't provide one */ + if (H5P_DEFAULT == dxpl_id) { + dxpl_id = H5P_DATASET_XFER_DEFAULT; + } + else { + if (TRUE != H5P_isa_class(dxpl_id, H5P_DATASET_XFER)) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data transfer property list"); + } + + /* Call private function */ + /* (Note compensating for base address addition in internal routine) */ + if (H5FD_read_vector_from_selection(file, type, count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "file selection read request failed"); + +done: + FUNC_LEAVE_API(ret_value) +} /* end H5FDread_vector_from_selection() */ + +/*------------------------------------------------------------------------- + * Purpose: This is similar to H5FDwrite_selection() with the + * exception noted below. + * + * Perform count writes to the specified file at the + * locations selected in the dataspaces in the file_spaces + * array, with each of those dataspaces starting at the file + * address specified by the corresponding element of the + * offsets array, and with the size of each element in the + * dataspace specified by the corresponding element of the + * element_sizes array. The memory type provided by type is + * the same for all selections. Data write is from + * the locations selected in the dataspaces in the + * mem_spaces array, within the buffers provided in the + * corresponding elements of the bufs array. + * + * If i > 0 and element_sizes[i] == 0, presume + * element_sizes[n] = element_sizes[i-1] for all n >= i and + * < count. + * + * Note: + * It will skip selection write call whether the underlying VFD + * supports selection writes or not. + * + * It will translate the selection write to a vector write call + * if vector writes are supported, or a series of scalar write + * calls otherwise. + * + * All writes are done according to the data transfer property + * list dxpl_id (which may be the constant H5P_DEFAULT). + * + * Return: Success: SUCCEED + * All writes have completed successfully + * + * Failure: FAIL + * One or more of the writes failed. + * + *------------------------------------------------------------------------- + */ +herr_t +H5FDwrite_vector_from_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], + size_t element_sizes[], const void *bufs[]) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_API(FAIL) + H5TRACE9("e", "*#MtiIu*i*i*a*z**x", file, type, dxpl_id, count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs); + + /* Check arguments */ + if (!file) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL"); + + if (!file->cls) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL"); + + if ((!mem_space_ids) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "mem_spaces parameter can't be NULL if count is positive"); + + if ((!file_space_ids) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file_spaces parameter can't be NULL if count is positive"); + + if ((!offsets) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "offsets parameter can't be NULL if count is positive"); + + if ((!element_sizes) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, + "element_sizes parameter can't be NULL if count is positive"); + + if ((!bufs) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bufs parameter can't be NULL if count is positive"); + + if ((count > 0) && (element_sizes[0] == 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "sizes[0] can't be 0"); + + if ((count > 0) && (bufs[0] == NULL)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bufs[0] can't be NULL"); + + /* Get the default dataset transfer property list if the user didn't provide one */ + if (H5P_DEFAULT == dxpl_id) { + dxpl_id = H5P_DATASET_XFER_DEFAULT; + } + else { + if (TRUE != H5P_isa_class(dxpl_id, H5P_DATASET_XFER)) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data transfer property list"); + } + + /* Call private function */ + /* (Note compensating for base address addition in internal routine) */ + if (H5FD_write_vector_from_selection(file, type, count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "file selection write request failed"); + +done: + FUNC_LEAVE_API(ret_value) +} /* end H5FDwrite_vector_from_selection() */ + +/*------------------------------------------------------------------------- + * Purpose: This is similar to H5FDread_selection() with the + * exception noted below. + * + * Perform count reads from the specified file at the + * locations selected in the dataspaces in the file_spaces + * array, with each of those dataspaces starting at the file + * address specified by the corresponding element of the + * offsets array, and with the size of each element in the + * dataspace specified by the corresponding element of the + * element_sizes array. The memory type provided by type is + * the same for all selections. Data read is returned in + * the locations selected in the dataspaces in the + * mem_spaces array, within the buffers provided in the + * corresponding elements of the bufs array. + * + * If i > 0 and element_sizes[i] == 0, presume + * element_sizes[n] = element_sizes[i-1] for all n >= i and + * < count. + * + * Note: + * It will skip selection and vector read calls whether the underlying + * VFD supports selection and vector reads or not. + * + * It will translate the selection read to a series of + * scalar read calls. + * + * All reads are done according to the data transfer property + * list dxpl_id (which may be the constant H5P_DEFAULT). + * + * Return: Success: SUCCEED + * All reads have completed successfully, and + * the results have been written into the supplied + * buffers. + * + * Failure: FAIL + * The contents of supplied buffers are undefined. + * + *------------------------------------------------------------------------- + */ +herr_t +H5FDread_from_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, hid_t mem_space_ids[], + hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], void *bufs[]) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_API(FAIL) + H5TRACE9("e", "*#MtiIu*i*i*a*z**x", file, type, dxpl_id, count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs); + + /* Check arguments */ + if (!file) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL"); + + if (!file->cls) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL"); + + if ((!mem_space_ids) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "mem_spaces parameter can't be NULL if count is positive"); + + if ((!file_space_ids) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file_spaces parameter can't be NULL if count is positive"); + + if ((!offsets) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "offsets parameter can't be NULL if count is positive"); + + if ((!element_sizes) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, + "element_sizes parameter can't be NULL if count is positive"); + + if ((!bufs) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bufs parameter can't be NULL if count is positive"); + + if ((count > 0) && (element_sizes[0] == 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "sizes[0] can't be 0"); + + if ((count > 0) && (bufs[0] == NULL)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bufs[0] can't be NULL"); + + /* Get the default dataset transfer property list if the user didn't provide one */ + if (H5P_DEFAULT == dxpl_id) { + dxpl_id = H5P_DATASET_XFER_DEFAULT; + } + else { + if (TRUE != H5P_isa_class(dxpl_id, H5P_DATASET_XFER)) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data transfer property list"); + } + + /* Call private function */ + /* (Note compensating for base address addition in internal routine) */ + if (H5FD_read_from_selection(file, type, count, mem_space_ids, file_space_ids, offsets, element_sizes, + bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "file selection read request failed"); + +done: + FUNC_LEAVE_API(ret_value) +} /* end H5FDread_from_selection() */ + +/*------------------------------------------------------------------------- + * Purpose: This is similar to H5FDwrite_selection() with the + * exception noted below. + * + * Perform count writes to the specified file at the + * locations selected in the dataspaces in the file_spaces + * array, with each of those dataspaces starting at the file + * address specified by the corresponding element of the + * offsets array, and with the size of each element in the + * dataspace specified by the corresponding element of the + * element_sizes array. The memory type provided by type is + * the same for all selections. Data write is from + * the locations selected in the dataspaces in the + * mem_spaces array, within the buffers provided in the + * corresponding elements of the bufs array. + * + * If i > 0 and element_sizes[i] == 0, presume + * element_sizes[n] = element_sizes[i-1] for all n >= i and + * < count. + * + * Note: + * It will skip selection and vector write calls whether the underlying + * VFD supports selection and vector writes or not. + * + * It will translate the selection write to a series of + * scalar write calls. + * + * All writes are done according to the data transfer property + * list dxpl_id (which may be the constant H5P_DEFAULT). + * + * Return: Success: SUCCEED + * All writes have completed successfully + * + * Failure: FAIL + * One or more of the writes failed. + * + *------------------------------------------------------------------------- + */ +herr_t +H5FDwrite_from_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, hid_t mem_space_ids[], + hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], + const void *bufs[]) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_API(FAIL) + H5TRACE9("e", "*#MtiIu*i*i*a*z**x", file, type, dxpl_id, count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs); + + /* Check arguments */ + if (!file) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file pointer cannot be NULL"); + + if (!file->cls) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file class pointer cannot be NULL"); + + if ((!mem_space_ids) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "mem_spaces parameter can't be NULL if count is positive"); + + if ((!file_space_ids) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "file_spaces parameter can't be NULL if count is positive"); + + if ((!offsets) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "offsets parameter can't be NULL if count is positive"); + + if ((!element_sizes) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, + "element_sizes parameter can't be NULL if count is positive"); + + if ((!bufs) && (count > 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bufs parameter can't be NULL if count is positive"); + + if ((count > 0) && (element_sizes[0] == 0)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "sizes[0] can't be 0"); + + if ((count > 0) && (bufs[0] == NULL)) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "bufs[0] can't be NULL"); + + /* Get the default dataset transfer property list if the user didn't provide one */ + if (H5P_DEFAULT == dxpl_id) { + dxpl_id = H5P_DATASET_XFER_DEFAULT; + } + else { + if (TRUE != H5P_isa_class(dxpl_id, H5P_DATASET_XFER)) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data transfer property list"); + } + + /* Call private function */ + /* (Note compensating for base address addition in internal routine) */ + if (H5FD_write_from_selection(file, type, count, mem_space_ids, file_space_ids, offsets, element_sizes, + bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "file selection write request failed"); + +done: + FUNC_LEAVE_API(ret_value) +} /* end H5FDwrite_from_selection() */ + /*------------------------------------------------------------------------- * Function: H5FDflush * diff --git a/src/H5FDdevelop.h b/src/H5FDdevelop.h index cba27031990..75e63b14c07 100644 --- a/src/H5FDdevelop.h +++ b/src/H5FDdevelop.h @@ -281,6 +281,18 @@ H5_DLL herr_t H5FDread_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, H5_DLL herr_t H5FDwrite_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, hid_t mem_spaces[], hid_t file_spaces[], haddr_t offsets[], size_t element_sizes[], const void *bufs[]); +H5_DLL herr_t H5FDread_vector_from_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, + hid_t mem_spaces[], hid_t file_spaces[], haddr_t offsets[], + size_t element_sizes[], void *bufs[] /* out */); +H5_DLL herr_t H5FDwrite_vector_from_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, + hid_t mem_spaces[], hid_t file_spaces[], haddr_t offsets[], + size_t element_sizes[], const void *bufs[] /* in */); +H5_DLL herr_t H5FDread_from_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], + size_t element_sizes[], void *bufs[] /* out */); +H5_DLL herr_t H5FDwrite_from_selection(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], + size_t element_sizes[], const void *bufs[] /* in */); H5_DLL herr_t H5FDflush(H5FD_t *file, hid_t dxpl_id, hbool_t closing); H5_DLL herr_t H5FDtruncate(H5FD_t *file, hid_t dxpl_id, hbool_t closing); H5_DLL herr_t H5FDlock(H5FD_t *file, hbool_t rw); diff --git a/src/H5FDint.c b/src/H5FDint.c index 65b1424e48a..fcc1b6c6fcd 100644 --- a/src/H5FDint.c +++ b/src/H5FDint.c @@ -62,17 +62,17 @@ /************************************************************************* * - * H5FD_vsrt_tmp_t + * H5FD_srt_tmp_t * - * Structure used to store vector I/O request addresses and the associated + * Structure used to store I/O request addresses and the associated * indexes in the addrs[] array for the purpose of determine the sorted * order. * - * This is done by allocating an array of H5FD_vsrt_tmp_t of length + * This is done by allocating an array of H5FD_srt_tmp_t of length * count, loading it with the contents of the addrs[] array and the * associated indices, and then sorting it. * - * This sorted array of H5FD_vsrt_tmp_t is then used to populate sorted + * This sorted array of H5FD_srt_tmp_t is then used to populate sorted * versions of the types[], addrs[], sizes[] and bufs[] vectors. * * addr: haddr_t containing the value of addrs[i], @@ -82,10 +82,10 @@ * *************************************************************************/ -typedef struct H5FD_vsrt_tmp_t { +typedef struct H5FD_srt_tmp_t { haddr_t addr; size_t index; -} H5FD_vsrt_tmp_t; +} H5FD_srt_tmp_t; /* Information needed for iterating over the registered VFD hid_t IDs. * The name or value of the new VFD that is being registered is stored @@ -109,12 +109,14 @@ typedef struct H5FD_get_driver_ud_t { /* Local Prototypes */ /********************/ static int H5FD__get_driver_cb(void *obj, hid_t id, void *_op_data); -static herr_t H5FD__read_selection_translate(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, - H5S_t **mem_spaces, H5S_t **file_spaces, haddr_t offsets[], - size_t element_sizes[], void *bufs[] /* out */); -static herr_t H5FD__write_selection_translate(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, - H5S_t **mem_spaces, H5S_t **file_spaces, haddr_t offsets[], - size_t element_sizes[], const void *bufs[]); +static herr_t H5FD__read_selection_translate(uint32_t skip_vector_cb, H5FD_t *file, H5FD_mem_t type, + hid_t dxpl_id, uint32_t count, H5S_t **mem_spaces, + H5S_t **file_spaces, haddr_t offsets[], size_t element_sizes[], + void *bufs[] /* out */); +static herr_t H5FD__write_selection_translate(uint32_t skip_vector_cb, H5FD_t *file, H5FD_mem_t type, + hid_t dxpl_id, uint32_t count, H5S_t **mem_spaces, + H5S_t **file_spaces, haddr_t offsets[], size_t element_sizes[], + const void *bufs[]); /*********************/ /* Package Variables */ @@ -734,8 +736,8 @@ H5FD_write_vector(H5FD_t *file, uint32_t count, H5FD_mem_t types[], haddr_t addr * Function: H5FD__read_selection_translate * * Purpose: Translates a selection read call to a vector read call if - * vector reads are supported, or a series of scalar read - * calls otherwise. + * vector reads are supported and !skip_vector_cb, + * or a series of scalar read calls otherwise. * * Return: Success: SUCCEED * All reads have completed successfully, and @@ -748,8 +750,8 @@ H5FD_write_vector(H5FD_t *file, uint32_t count, H5FD_mem_t types[], haddr_t addr *------------------------------------------------------------------------- */ static herr_t -H5FD__read_selection_translate(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, - H5S_t **mem_spaces, H5S_t **file_spaces, haddr_t offsets[], +H5FD__read_selection_translate(uint32_t skip_vector_cb, H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, + uint32_t count, H5S_t **mem_spaces, H5S_t **file_spaces, haddr_t offsets[], size_t element_sizes[], void *bufs[] /* out */) { hbool_t extend_sizes = FALSE; @@ -797,7 +799,7 @@ H5FD__read_selection_translate(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uin assert((bufs) || (count == 0)); /* Check if we're using vector I/O */ - use_vector = file->cls->read_vector != NULL; + use_vector = (file->cls->read_vector != NULL) && (!skip_vector_cb); if (count > 0) { /* Verify that the first elements of the element_sizes and bufs arrays are @@ -1063,8 +1065,8 @@ H5FD__read_selection_translate(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uin * If the underlying VFD supports selection reads, pass the * call through directly. * - * If it doesn't, convert the vector read into a sequence - * of individual reads. + * If it doesn't, convert the selection read into a sequence + * of vector or scalar reads. * * Return: Success: SUCCEED * All reads have completed successfully, and @@ -1189,8 +1191,8 @@ H5FD_read_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, H5S_t **mem_s /* Otherwise, implement the selection read as a sequence of regular * or vector read calls. */ - if (H5FD__read_selection_translate(file, type, dxpl_id, count, mem_spaces, file_spaces, offsets, - element_sizes, bufs) < 0) + if (H5FD__read_selection_translate(SKIP_NO_CB, file, type, dxpl_id, count, mem_spaces, file_spaces, + offsets, element_sizes, bufs) < 0) HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "translation to vector or scalar read failed"); done: @@ -1228,6 +1230,15 @@ H5FD_read_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, H5S_t **mem_s * Purpose: Like H5FD_read_selection(), but takes hid_t arrays instead * of H5S_t * arrays for the dataspaces. * + * Depending on the parameter skip_cb which is translated into + * skip_selection_cb and skip_vector_cb: + * + * --If the underlying VFD supports selection reads and !skip_selection_cb, + * pass the call through directly. + * + * --If it doesn't, convert the selection reads into a sequence of vector or + * scalar reads depending on skip_vector_cb. + * * Return: Success: SUCCEED * All reads have completed successfully, and * the results havce been into the supplied @@ -1239,7 +1250,7 @@ H5FD_read_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, H5S_t **mem_s *------------------------------------------------------------------------- */ herr_t -H5FD_read_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], +H5FD_read_selection_id(uint32_t skip_cb, H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], void *bufs[] /* out */) { @@ -1250,6 +1261,8 @@ H5FD_read_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_ H5S_t **file_spaces = file_spaces_local; hid_t dxpl_id = H5I_INVALID_HID; /* DXPL for operation */ uint32_t i; + uint32_t skip_selection_cb; + uint32_t skip_vector_cb; herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) @@ -1282,6 +1295,9 @@ H5FD_read_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_ } #endif /* H5_HAVE_PARALLEL */ + skip_selection_cb = skip_cb & SKIP_SELECTION_CB; + skip_vector_cb = skip_cb & SKIP_VECTOR_CB; + if (file->base_addr > 0) { /* apply the base_addr offset to the offsets array. Must undo before @@ -1320,7 +1336,7 @@ H5FD_read_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_ } /* if the underlying VFD supports selection read, make the call */ - if (file->cls->read_selection) { + if (!skip_selection_cb && file->cls->read_selection) { if ((file->cls->read_selection)(file, type, dxpl_id, count, mem_space_ids, file_space_ids, offsets, element_sizes, bufs) < 0) HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "driver read selection request failed"); @@ -1348,8 +1364,9 @@ H5FD_read_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_ } /* Translate to vector or scalar I/O */ - if (H5FD__read_selection_translate(file, type, dxpl_id, count, mem_spaces, file_spaces, offsets, - element_sizes, bufs) < 0) + + if (H5FD__read_selection_translate(skip_vector_cb, file, type, dxpl_id, count, mem_spaces, + file_spaces, offsets, element_sizes, bufs) < 0) HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "translation to vector or scalar read failed"); } @@ -1378,8 +1395,8 @@ H5FD_read_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_ * Function: H5FD__write_selection_translate * * Purpose: Translates a selection write call to a vector write call - * if vector writes are supported, or a series of scalar - * write calls otherwise. + * if vector writes are supported and !skip_vector_cb, + * or a series of scalar write calls otherwise. * * Return: Success: SUCCEED * All writes have completed successfully. @@ -1390,8 +1407,8 @@ H5FD_read_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_ *------------------------------------------------------------------------- */ static herr_t -H5FD__write_selection_translate(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, uint32_t count, - H5S_t **mem_spaces, H5S_t **file_spaces, haddr_t offsets[], +H5FD__write_selection_translate(uint32_t skip_vector_cb, H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, + uint32_t count, H5S_t **mem_spaces, H5S_t **file_spaces, haddr_t offsets[], size_t element_sizes[], const void *bufs[]) { hbool_t extend_sizes = FALSE; @@ -1439,7 +1456,7 @@ H5FD__write_selection_translate(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, ui assert((bufs) || (count == 0)); /* Check if we're using vector I/O */ - use_vector = file->cls->write_vector != NULL; + use_vector = (file->cls->write_vector != NULL) && (!skip_vector_cb); if (count > 0) { /* Verify that the first elements of the element_sizes and bufs arrays are @@ -1705,8 +1722,8 @@ H5FD__write_selection_translate(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, ui * If the underlying VFD supports selection writes, pass the * call through directly. * - * If it doesn't, convert the vector write into a sequence - * of individual writes. + * If it doesn't, convert the selection write into a sequence + * of vector or scalar writes. * * Return: Success: SUCCEED * All writes have completed successfully. @@ -1823,8 +1840,9 @@ H5FD_write_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, H5S_t **mem_ /* Otherwise, implement the selection write as a sequence of regular * or vector write calls. */ - if (H5FD__write_selection_translate(file, type, dxpl_id, count, mem_spaces, file_spaces, offsets, - element_sizes, bufs) < 0) + + if (H5FD__write_selection_translate(SKIP_NO_CB, file, type, dxpl_id, count, mem_spaces, file_spaces, + offsets, element_sizes, bufs) < 0) HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "translation to vector or scalar write failed"); done: @@ -1862,6 +1880,15 @@ H5FD_write_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, H5S_t **mem_ * Purpose: Like H5FD_write_selection(), but takes hid_t arrays * instead of H5S_t * arrays for the dataspaces. * + * Depending on the parameter skip_cb which is translated into + * skip_selection_cb and skip_vector_cb: + * + * --If the underlying VFD supports selection writes and !skip_selection_cb, + * pass the call through directly. + * + * --If it doesn't, convert the selection writes into a sequence of vector or + * scalar reads depending on skip_vector_cb. + * * Return: Success: SUCCEED * All writes have completed successfully. * @@ -1871,8 +1898,9 @@ H5FD_write_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, H5S_t **mem_ *------------------------------------------------------------------------- */ herr_t -H5FD_write_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], - hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], const void *bufs[]) +H5FD_write_selection_id(uint32_t skip_cb, H5FD_t *file, H5FD_mem_t type, uint32_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], + size_t element_sizes[], const void *bufs[]) { hbool_t offsets_cooked = FALSE; H5S_t *mem_spaces_local[H5FD_LOCAL_SEL_ARR_LEN]; @@ -1881,6 +1909,8 @@ H5FD_write_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem H5S_t **file_spaces = file_spaces_local; hid_t dxpl_id = H5I_INVALID_HID; /* DXPL for operation */ uint32_t i; + uint32_t skip_selection_cb; + uint32_t skip_vector_cb; herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(FAIL) @@ -1913,6 +1943,9 @@ H5FD_write_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem } #endif /* H5_HAVE_PARALLEL */ + skip_selection_cb = skip_cb & SKIP_SELECTION_CB; + skip_vector_cb = skip_cb & SKIP_VECTOR_CB; + if (file->base_addr > 0) { /* apply the base_addr offset to the offsets array. Must undo before @@ -1945,7 +1978,7 @@ H5FD_write_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem } /* if the underlying VFD supports selection write, make the call */ - if (file->cls->write_selection) { + if (!skip_selection_cb && file->cls->write_selection) { if ((file->cls->write_selection)(file, type, dxpl_id, count, mem_space_ids, file_space_ids, offsets, element_sizes, bufs) < 0) HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "driver write selection request failed"); @@ -1973,8 +2006,9 @@ H5FD_write_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem } /* Translate to vector or scalar I/O */ - if (H5FD__write_selection_translate(file, type, dxpl_id, count, mem_spaces, file_spaces, offsets, - element_sizes, bufs) < 0) + + if (H5FD__write_selection_translate(skip_vector_cb, file, type, dxpl_id, count, mem_spaces, + file_spaces, offsets, element_sizes, bufs) < 0) HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "translation to vector or scalar write failed"); } @@ -1999,6 +2033,209 @@ H5FD_write_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_write_selection_id() */ +/*------------------------------------------------------------------------- + * Function: H5FD_read_vector_from_selection + * + * Purpose: Internal routine for H5FDread_vector_from_selection() + * + * It will translate the selection read to a vector read call + * if vector reads are supported, or a series of scalar read + * calls otherwise. + * + * Return: Success: SUCCEED + * All writes have completed successfully. + * + * Failure: FAIL + * One or more writes failed. + * + *------------------------------------------------------------------------- + */ +herr_t +H5FD_read_vector_from_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], + hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], + void *bufs[]) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(FAIL) + + /* Sanity checks */ + assert(file); + assert(file->cls); + assert((mem_space_ids) || (count == 0)); + assert((file_space_ids) || (count == 0)); + assert((offsets) || (count == 0)); + assert((element_sizes) || (count == 0)); + assert((bufs) || (count == 0)); + + /* Verify that the first elements of the element_sizes and bufs arrays are + * valid. */ + assert((count == 0) || (element_sizes[0] != 0)); + assert((count == 0) || (bufs[0] != NULL)); + + /* Call private function */ + /* (Note compensating for base address addition in internal routine) */ + if (H5FD_read_selection_id(SKIP_SELECTION_CB, file, type, count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "file selection read request failed"); + +done: + FUNC_LEAVE_NOAPI(ret_value) + +} /* end H5FD_read_vector_from_selection() */ + +/*------------------------------------------------------------------------- + * Function: H5FD_write_vector_from_selection + * + * Purpose: Internal routine for H5FDwrite_vector_from_selection() + * + * It will translate the selection write to a vector write call + * if vector writes are supported, or a series of scalar write + * calls otherwise. + * + * Return: Success: SUCCEED + * All writes have completed successfully. + * + * Failure: FAIL + * One or more writes failed. + * + *------------------------------------------------------------------------- + */ +herr_t +H5FD_write_vector_from_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], + hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], + const void *bufs[]) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(FAIL) + + /* Sanity checks */ + assert(file); + assert(file->cls); + assert((mem_space_ids) || (count == 0)); + assert((file_space_ids) || (count == 0)); + assert((offsets) || (count == 0)); + assert((element_sizes) || (count == 0)); + assert((bufs) || (count == 0)); + + /* Verify that the first elements of the element_sizes and bufs arrays are + * valid. */ + assert((count == 0) || (element_sizes[0] != 0)); + assert((count == 0) || (bufs[0] != NULL)); + + /* Call private function */ + /* (Note compensating for base address addition in internal routine) */ + if (H5FD_write_selection_id(SKIP_SELECTION_CB, file, type, count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "file selection write request failed"); + +done: + FUNC_LEAVE_NOAPI(ret_value) + +} /* end H5FD_write_vector_from_selection() */ + +/*------------------------------------------------------------------------- + * Function: H5FD_read_from_selection + * + * Purpose: Internal routine for H5FDread_from_selection() + * + * It will translate the selection read to a series of + * scalar read calls. + * + * Return: Success: SUCCEED + * All writes have completed successfully. + * + * Failure: FAIL + * One or more writes failed. + * + *------------------------------------------------------------------------- + */ +herr_t +H5FD_read_from_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], + hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], void *bufs[]) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(FAIL) + + /* Sanity checks */ + assert(file); + assert(file->cls); + assert((mem_space_ids) || (count == 0)); + assert((file_space_ids) || (count == 0)); + assert((offsets) || (count == 0)); + assert((element_sizes) || (count == 0)); + assert((bufs) || (count == 0)); + + /* Verify that the first elements of the element_sizes and bufs arrays are + * valid. */ + assert((count == 0) || (element_sizes[0] != 0)); + assert((count == 0) || (bufs[0] != NULL)); + + /* Call private function */ + /* (Note compensating for base address addition in internal routine) */ + if (H5FD_read_selection_id(SKIP_SELECTION_CB | SKIP_VECTOR_CB, file, type, count, mem_space_ids, + file_space_ids, offsets, element_sizes, bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "file selection read request failed"); + +done: + + FUNC_LEAVE_NOAPI(ret_value) + +} /* end H5FD_read_from_selection() */ + +/*------------------------------------------------------------------------- + * Function: H5FD_write_from_selection + * + * Purpose: Internal routine for H5FDwrite_from_selection() + * + * It will translate the selection write to a series of + * scalar write calls. + * + * Return: Success: SUCCEED + * All writes have completed successfully. + * + * Failure: FAIL + * One or more writes failed. + * + *------------------------------------------------------------------------- + */ +herr_t +H5FD_write_from_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], + hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], + const void *bufs[]) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(FAIL) + + /* Sanity checks */ + assert(file); + assert(file->cls); + assert((mem_space_ids) || (count == 0)); + assert((file_space_ids) || (count == 0)); + assert((offsets) || (count == 0)); + assert((element_sizes) || (count == 0)); + assert((bufs) || (count == 0)); + + /* Verify that the first elements of the element_sizes and bufs arrays are + * valid. */ + assert((count == 0) || (element_sizes[0] != 0)); + assert((count == 0) || (bufs[0] != NULL)); + + /* Call private function */ + /* (Note compensating for base address addition in internal routine) */ + if (H5FD_write_selection_id(SKIP_SELECTION_CB | SKIP_VECTOR_CB, file, type, count, mem_space_ids, + file_space_ids, offsets, element_sizes, bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "file selection write request failed"); + +done: + + FUNC_LEAVE_NOAPI(ret_value) + +} /* end H5FD_write_from_selection() */ + /*------------------------------------------------------------------------- * Function: H5FD_set_eoa * @@ -2138,6 +2375,119 @@ H5FD_driver_query(const H5FD_class_t *driver, unsigned long *flags /*out*/) FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD_driver_query() */ +/*------------------------------------------------------------------------ + * Function: H5FD__vstr_tmp_cmp() + * + * Purpose: This is the comparison callback function used by qsort() + * in H5FD__sort_io_req_real( ) + * + *------------------------------------------------------------------------- + */ +static int +H5FD__srt_tmp_cmp(const void *element_1, const void *element_2) +{ + haddr_t addr_1 = ((const H5FD_srt_tmp_t *)element_1)->addr; + haddr_t addr_2 = ((const H5FD_srt_tmp_t *)element_2)->addr; + int ret_value = 0; /* Return value */ + + FUNC_ENTER_PACKAGE_NOERR + + /* Sanity checks */ + assert(H5_addr_defined(addr_1)); + assert(H5_addr_defined(addr_2)); + + /* Compare the addresses */ + if (H5_addr_gt(addr_1, addr_2)) + ret_value = 1; + else if (H5_addr_lt(addr_1, addr_2)) + ret_value = -1; + + FUNC_LEAVE_NOAPI(ret_value) +} /* H5FD__srt_tmp_cmp() */ + +/*------------------------------------------------------------------------- + * Function: H5FD__sort_io_req_real() + * + * Purpose: Scan the addrs array to see if it is sorted. + * + * If sorted, return TRUE in *was_sorted. + * + * If not sorted, use qsort() to sort the array. + * Do this by allocating an array of struct H5FD_srt_tmp_t, + * where each instance of H5FD_srt_tmp_t has two fields, + * addr and index. Load the array with the contents of the + * addrs array and the index of the associated entry. + * Then sort the array using qsort(). + * Return *FALSE in was_sorted. + * + * This is a common routine used by: + * --H5FD_sort_vector_io_req () + * --H5FD_sort_selection_io_req() + * + * Return: SUCCEED/FAIL + * + *------------------------------------------------------------------------- + */ +static herr_t +H5FD__sort_io_req_real(size_t count, haddr_t *addrs, hbool_t *was_sorted, struct H5FD_srt_tmp_t **srt_tmp) +{ + size_t i; + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_PACKAGE + + /* Sanity checks */ + + /* scan the offsets array to see if it is sorted */ + for (i = 1; i < count; i++) { + assert(H5_addr_defined(addrs[i - 1])); + + if (H5_addr_gt(addrs[i - 1], addrs[i])) + break; + else if (H5_addr_eq(addrs[i - 1], addrs[i])) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "duplicate addr in selections"); + } + + /* if we traversed the entire array without breaking out, then + * the array was already sorted */ + if (i >= count) + *was_sorted = TRUE; + else + *was_sorted = FALSE; + + if (!(*was_sorted)) { + size_t srt_tmp_size; + + srt_tmp_size = (count * sizeof(struct H5FD_srt_tmp_t)); + + if (NULL == (*srt_tmp = (H5FD_srt_tmp_t *)malloc(srt_tmp_size))) + + HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't alloc srt_tmp"); + + for (i = 0; i < count; i++) { + (*srt_tmp)[i].addr = addrs[i]; + (*srt_tmp)[i].index = i; + } + + /* sort the srt_tmp array */ + qsort(*srt_tmp, count, sizeof(struct H5FD_srt_tmp_t), H5FD__srt_tmp_cmp); + + /* verify no duplicate entries */ + i = 1; + + for (i = 1; i < count; i++) { + assert(H5_addr_lt((*srt_tmp)[i - 1].addr, (*srt_tmp)[i].addr)); + + if (H5_addr_eq(addrs[i - 1], addrs[i])) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "duplicate addrs in array"); + } + } + +done: + FUNC_LEAVE_NOAPI(ret_value) + +} /* H5FD__sort_io_req_real() */ + /*------------------------------------------------------------------------- * Function: H5FD_sort_vector_io_req * @@ -2169,38 +2519,15 @@ H5FD_driver_query(const H5FD_class_t *driver, unsigned long *flags /*out*/) * *------------------------------------------------------------------------- */ - -static int -H5FD__vsrt_tmp_cmp(const void *element_1, const void *element_2) -{ - haddr_t addr_1 = ((const H5FD_vsrt_tmp_t *)element_1)->addr; - haddr_t addr_2 = ((const H5FD_vsrt_tmp_t *)element_2)->addr; - int ret_value = 0; /* Return value */ - - FUNC_ENTER_PACKAGE_NOERR - - /* Sanity checks */ - assert(H5_addr_defined(addr_1)); - assert(H5_addr_defined(addr_2)); - - /* Compare the addresses */ - if (H5_addr_gt(addr_1, addr_2)) - ret_value = 1; - else if (H5_addr_lt(addr_1, addr_2)) - ret_value = -1; - - FUNC_LEAVE_NOAPI(ret_value) -} /* H5FD__vsrt_tmp_cmp() */ - herr_t H5FD_sort_vector_io_req(hbool_t *vector_was_sorted, uint32_t _count, H5FD_mem_t types[], haddr_t addrs[], size_t sizes[], H5_flexible_const_ptr_t bufs[], H5FD_mem_t **s_types_ptr, haddr_t **s_addrs_ptr, size_t **s_sizes_ptr, H5_flexible_const_ptr_t **s_bufs_ptr) { - herr_t ret_value = SUCCEED; /* Return value */ - size_t count = (size_t)_count; - size_t i; - struct H5FD_vsrt_tmp_t *srt_tmp = NULL; + herr_t ret_value = SUCCEED; /* Return value */ + size_t count = (size_t)_count; + size_t i; + struct H5FD_srt_tmp_t *srt_tmp = NULL; FUNC_ENTER_NOAPI(FAIL) @@ -2224,22 +2551,12 @@ H5FD_sort_vector_io_req(hbool_t *vector_was_sorted, uint32_t _count, H5FD_mem_t assert((count == 0) || ((s_sizes_ptr) && (NULL == *s_sizes_ptr))); assert((count == 0) || ((s_bufs_ptr) && (NULL == *s_bufs_ptr))); - /* scan the addrs array to see if it is sorted */ - for (i = 1; i < count; i++) { - assert(H5_addr_defined(addrs[i - 1])); - - if (H5_addr_gt(addrs[i - 1], addrs[i])) - break; - else if (H5_addr_eq(addrs[i - 1], addrs[i])) - HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "duplicate addr in vector"); - } - - /* if we traversed the entire array without breaking out, then - * the array was already sorted */ - if (i >= count) - *vector_was_sorted = TRUE; - else - *vector_was_sorted = FALSE; + /* Sort the addrs array in increasing addr order, while + * maintaining the association between each addr, and the + * sizes[], types[], and bufs[] values at the same index. + */ + if (H5FD__sort_io_req_real(count, addrs, vector_was_sorted, &srt_tmp) < 0) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "sorting error in selection offsets"); if (*vector_was_sorted) { @@ -2250,46 +2567,14 @@ H5FD_sort_vector_io_req(hbool_t *vector_was_sorted, uint32_t _count, H5FD_mem_t } else { - /* must sort the addrs array in increasing addr order, while - * maintaining the association between each addr, and the - * sizes[], types[], and bufs[] values at the same index. - * - * Do this by allocating an array of struct H5FD_vsrt_tmp_t, where - * each instance of H5FD_vsrt_tmp_t has two fields, addr and index. - * Load the array with the contents of the addrs array and - * the index of the associated entry. Sort the array, allocate - * the s_types_ptr, s_addrs_ptr, s_sizes_ptr, and s_bufs_ptr + /* + * Allocate the s_types_ptr, s_addrs_ptr, s_sizes_ptr, and s_bufs_ptr * arrays and populate them using the mapping provided by - * the sorted array of H5FD_vsrt_tmp_t. + * the sorted array of H5FD_srt_tmp_t. */ size_t j; size_t fixed_size_index = count; size_t fixed_type_index = count; - size_t srt_tmp_size; - - srt_tmp_size = (count * sizeof(struct H5FD_vsrt_tmp_t)); - - if (NULL == (srt_tmp = (H5FD_vsrt_tmp_t *)malloc(srt_tmp_size))) - - HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't alloc srt_tmp"); - - for (i = 0; i < count; i++) { - srt_tmp[i].addr = addrs[i]; - srt_tmp[i].index = i; - } - - /* sort the srt_tmp array */ - qsort(srt_tmp, count, sizeof(struct H5FD_vsrt_tmp_t), H5FD__vsrt_tmp_cmp); - - /* verify no duplicate entries */ - i = 1; - - for (i = 1; i < count; i++) { - assert(H5_addr_lt(srt_tmp[i - 1].addr, srt_tmp[i].addr)); - - if (H5_addr_eq(addrs[i - 1], addrs[i])) - HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "duplicate addr in vector"); - } if ((NULL == (*s_types_ptr = (H5FD_mem_t *)malloc(count * sizeof(H5FD_mem_t)))) || (NULL == (*s_addrs_ptr = (haddr_t *)malloc(count * sizeof(haddr_t)))) || @@ -2378,6 +2663,187 @@ H5FD_sort_vector_io_req(hbool_t *vector_was_sorted, uint32_t _count, H5FD_mem_t } /* end H5FD_sort_vector_io_req() */ +/*------------------------------------------------------------------------- + * Purpose: Determine whether the supplied selection I/O request is + * sorted. + * + * if is is, set *selection_was_sorted to TRUE, set: + * + * *s_mem_space_ids_ptr = mem_space_ids; + * *s_file_space_ids_ptr = file_space_ids; + * *s_offsets_ptr = offsets; + * *s_element_sizes_ptr = element_sizes; + * *s_bufs_ptr = bufs; + * + * and return. + * + * If it is not sorted, duplicate the mem_space_ids, file_space_ids, + * offsets, element_sizes and bufs arrays, storing the base + * addresses of the new arrays in *s_mem_space_ids_ptr, + * s_file_space_ids_ptr, s_offsets_ptr, *s_element_sizes_ptr, + * and s_bufs_ptr respectively. Determine the sorted order + * of the selection I/O request, and load it into the new + * selections in sorted order. + * + * Note that in this case, it is the caller's responsibility + * to free the sorted vectors. + * + * Return: SUCCEED/FAIL + * + *------------------------------------------------------------------------- + */ +herr_t +H5FD_sort_selection_io_req(hbool_t *selection_was_sorted, size_t count, hid_t mem_space_ids[], + hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], + H5_flexible_const_ptr_t bufs[], hid_t **s_mem_space_ids_ptr, + hid_t **s_file_space_ids_ptr, haddr_t **s_offsets_ptr, + size_t **s_element_sizes_ptr, H5_flexible_const_ptr_t **s_bufs_ptr) +{ + size_t i; + struct H5FD_srt_tmp_t *srt_tmp = NULL; + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(FAIL) + + /* Sanity checks */ + + assert(selection_was_sorted); + + assert((mem_space_ids) || (count == 0)); + assert((file_space_ids) || (count == 0)); + assert((offsets) || (count == 0)); + assert((element_sizes) || (count == 0)); + assert((bufs) || (count == 0)); + + /* verify that the first elements of the element_sizes and bufs arrays are + * valid. + */ + assert((count == 0) || (element_sizes[0] != 0)); + assert((count == 0) || (bufs[0].cvp != NULL)); + + assert((count == 0) || ((s_mem_space_ids_ptr) && (NULL == *s_mem_space_ids_ptr))); + assert((count == 0) || ((s_file_space_ids_ptr) && (NULL == *s_file_space_ids_ptr))); + assert((count == 0) || ((s_offsets_ptr) && (NULL == *s_offsets_ptr))); + assert((count == 0) || ((s_element_sizes_ptr) && (NULL == *s_element_sizes_ptr))); + assert((count == 0) || ((s_bufs_ptr) && (NULL == *s_bufs_ptr))); + + /* Sort the offsets array in increasing offset order, while + * maintaining the association between each offset, and the + * mem_space_ids[], file_space_ids[], element_sizes and bufs[] + * values at the same index. + */ + if (H5FD__sort_io_req_real(count, offsets, selection_was_sorted, &srt_tmp) < 0) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "sorting error in selection offsets"); + + if (*selection_was_sorted) { + + *s_mem_space_ids_ptr = mem_space_ids; + *s_file_space_ids_ptr = file_space_ids; + *s_offsets_ptr = offsets; + *s_element_sizes_ptr = element_sizes; + *s_bufs_ptr = bufs; + } + else { + + /* + * Allocate the s_mem_space_ids_ptr, s_file_space_ids_ptr, s_offsets_ptr, + * s_element_sizes_ptr and s_bufs_ptr arrays and populate them using the + * mapping provided by the sorted array of H5FD_srt_tmp_t. + */ + size_t j; + size_t fixed_element_sizes_index = count; + size_t fixed_bufs_index = count; + + if ((NULL == (*s_mem_space_ids_ptr = (hid_t *)malloc(count * sizeof(hid_t)))) || + (NULL == (*s_file_space_ids_ptr = (hid_t *)malloc(count * sizeof(hid_t)))) || + (NULL == (*s_offsets_ptr = (haddr_t *)malloc(count * sizeof(haddr_t)))) || + (NULL == (*s_element_sizes_ptr = (size_t *)malloc(count * sizeof(size_t)))) || + (NULL == + (*s_bufs_ptr = (H5_flexible_const_ptr_t *)malloc(count * sizeof(H5_flexible_const_ptr_t))))) { + + HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "can't alloc sorted selection(s)"); + } + + assert(element_sizes[0] != 0); + assert(bufs[0].cvp != NULL); + + /* Scan the element_sizes and bufs array to determine if the fixed + * element_sizes / bufs optimization is in use, and if so, to determine + * the index of the last valid value on each array. + * We have already verified that the first + * elements of these arrays are valid so we can start at the second + * element (if it exists). + */ + for (i = 1; i < count && ((fixed_element_sizes_index == count) || (fixed_bufs_index == count)); i++) { + if ((fixed_element_sizes_index == count) && (element_sizes[i] == 0)) + fixed_element_sizes_index = i - 1; + if ((fixed_bufs_index == count) && (bufs[i].cvp == NULL)) + fixed_bufs_index = i - 1; + } + + assert(fixed_element_sizes_index <= count); + assert(fixed_bufs_index <= count); + + /* Populate the sorted arrays. Note that the index stored in srt_tmp + * refers to the index in the unsorted array, while the position of + * srt_tmp within the sorted array is the index in the sorted arrays */ + for (i = 0; i < count; i++) { + + j = srt_tmp[i].index; + + (*s_mem_space_ids_ptr)[i] = mem_space_ids[j]; + (*s_file_space_ids_ptr)[i] = file_space_ids[j]; + (*s_offsets_ptr)[i] = offsets[j]; + (*s_element_sizes_ptr)[i] = element_sizes[MIN(j, fixed_element_sizes_index)]; + (*s_bufs_ptr)[i] = bufs[MIN(j, fixed_bufs_index)]; + } + } + +done: + if (srt_tmp) { + free(srt_tmp); + srt_tmp = NULL; + } + + /* On failure, free the sorted arrays if they were allocated. + * Note that we only allocate these arrays if the original array + * was not sorted -- thus we check both for failure, and for + * the flag indicating that the original array was not sorted + * in increasing address order. + */ + if ((ret_value != SUCCEED) && (!(*selection_was_sorted))) { + + /* free space allocated for sorted arrays */ + if (*s_mem_space_ids_ptr) { + free(*s_mem_space_ids_ptr); + *s_mem_space_ids_ptr = NULL; + } + + if (*s_file_space_ids_ptr) { + free(*s_file_space_ids_ptr); + *s_file_space_ids_ptr = NULL; + } + + if (*s_offsets_ptr) { + free(*s_offsets_ptr); + *s_offsets_ptr = NULL; + } + + if (*s_element_sizes_ptr) { + free(*s_element_sizes_ptr); + *s_element_sizes_ptr = NULL; + } + + if (*s_bufs_ptr) { + free(*s_bufs_ptr); + *s_bufs_ptr = NULL; + } + } + + FUNC_LEAVE_NOAPI(ret_value) + +} /* end H5FD_sort_selection_io_req() */ + /*------------------------------------------------------------------------- * Function: H5FD_delete * diff --git a/src/H5FDmpio.c b/src/H5FDmpio.c index a76b183dfb1..aa83be4a5bb 100644 --- a/src/H5FDmpio.c +++ b/src/H5FDmpio.c @@ -88,11 +88,20 @@ static herr_t H5FD__mpio_read_vector(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_i static herr_t H5FD__mpio_write_vector(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, uint32_t count, H5FD_mem_t types[], haddr_t addrs[], size_t sizes[], const void *bufs[]); -static herr_t H5FD__mpio_flush(H5FD_t *_file, hid_t dxpl_id, hbool_t closing); -static herr_t H5FD__mpio_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing); -static herr_t H5FD__mpio_delete(const char *filename, hid_t fapl_id); -static herr_t H5FD__mpio_ctl(H5FD_t *_file, uint64_t op_code, uint64_t flags, const void *input, - void **output); + +static herr_t H5FD__mpio_read_selection(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, + size_t count, hid_t mem_space_ids[], hid_t file_space_ids[], + haddr_t offsets[], size_t element_sizes[], void *bufs[]); + +static herr_t H5FD__mpio_write_selection(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, + size_t count, hid_t mem_space_ids[], hid_t file_space_ids[], + haddr_t offsets[], size_t element_sizes[], const void *bufs[]); + +static herr_t H5FD__mpio_flush(H5FD_t *_file, hid_t dxpl_id, hbool_t closing); +static herr_t H5FD__mpio_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing); +static herr_t H5FD__mpio_delete(const char *filename, hid_t fapl_id); +static herr_t H5FD__mpio_ctl(H5FD_t *_file, uint64_t op_code, uint64_t flags, const void *input, + void **output); /* Other functions */ static herr_t H5FD__mpio_vector_build_types( @@ -101,48 +110,55 @@ static herr_t H5FD__mpio_vector_build_types( MPI_Offset *mpi_off, H5_flexible_const_ptr_t *mpi_bufs_base, int *size_i, MPI_Datatype *buf_type, hbool_t *buf_type_created, MPI_Datatype *file_type, hbool_t *file_type_created, char *unused); +static herr_t H5FD__selection_build_types(hbool_t io_op_write, size_t num_pieces, H5_flexible_const_ptr_t mbb, + H5S_t **file_spaces, H5S_t **mem_spaces, haddr_t offsets[], + H5_flexible_const_ptr_t bufs[], size_t src_element_sizes[], + size_t dst_element_sizes[], MPI_Datatype *final_ftype, + hbool_t *final_ftype_is_derived, MPI_Datatype *final_mtype, + hbool_t *final_mtype_is_derived); + /* The MPIO file driver information */ static const H5FD_class_t H5FD_mpio_g = { - H5FD_CLASS_VERSION, /* struct version */ - H5_VFD_MPIO, /* value */ - "mpio", /* name */ - HADDR_MAX, /* maxaddr */ - H5F_CLOSE_SEMI, /* fc_degree */ - H5FD__mpio_term, /* terminate */ - NULL, /* sb_size */ - NULL, /* sb_encode */ - NULL, /* sb_decode */ - 0, /* fapl_size */ - NULL, /* fapl_get */ - NULL, /* fapl_copy */ - NULL, /* fapl_free */ - 0, /* dxpl_size */ - NULL, /* dxpl_copy */ - NULL, /* dxpl_free */ - H5FD__mpio_open, /* open */ - H5FD__mpio_close, /* close */ - NULL, /* cmp */ - H5FD__mpio_query, /* query */ - NULL, /* get_type_map */ - NULL, /* alloc */ - NULL, /* free */ - H5FD__mpio_get_eoa, /* get_eoa */ - H5FD__mpio_set_eoa, /* set_eoa */ - H5FD__mpio_get_eof, /* get_eof */ - H5FD__mpio_get_handle, /* get_handle */ - H5FD__mpio_read, /* read */ - H5FD__mpio_write, /* write */ - H5FD__mpio_read_vector, /* read_vector */ - H5FD__mpio_write_vector, /* write_vector */ - NULL, /* read_selection */ - NULL, /* write_selection */ - H5FD__mpio_flush, /* flush */ - H5FD__mpio_truncate, /* truncate */ - NULL, /* lock */ - NULL, /* unlock */ - H5FD__mpio_delete, /* del */ - H5FD__mpio_ctl, /* ctl */ - H5FD_FLMAP_DICHOTOMY /* fl_map */ + H5FD_CLASS_VERSION, /* struct version */ + H5_VFD_MPIO, /* value */ + "mpio", /* name */ + HADDR_MAX, /* maxaddr */ + H5F_CLOSE_SEMI, /* fc_degree */ + H5FD__mpio_term, /* terminate */ + NULL, /* sb_size */ + NULL, /* sb_encode */ + NULL, /* sb_decode */ + 0, /* fapl_size */ + NULL, /* fapl_get */ + NULL, /* fapl_copy */ + NULL, /* fapl_free */ + 0, /* dxpl_size */ + NULL, /* dxpl_copy */ + NULL, /* dxpl_free */ + H5FD__mpio_open, /* open */ + H5FD__mpio_close, /* close */ + NULL, /* cmp */ + H5FD__mpio_query, /* query */ + NULL, /* get_type_map */ + NULL, /* alloc */ + NULL, /* free */ + H5FD__mpio_get_eoa, /* get_eoa */ + H5FD__mpio_set_eoa, /* set_eoa */ + H5FD__mpio_get_eof, /* get_eof */ + H5FD__mpio_get_handle, /* get_handle */ + H5FD__mpio_read, /* read */ + H5FD__mpio_write, /* write */ + H5FD__mpio_read_vector, /* read_vector */ + H5FD__mpio_write_vector, /* write_vector */ + H5FD__mpio_read_selection, /* read_selection */ + H5FD__mpio_write_selection, /* write_selection */ + H5FD__mpio_flush, /* flush */ + H5FD__mpio_truncate, /* truncate */ + NULL, /* lock */ + NULL, /* unlock */ + H5FD__mpio_delete, /* del */ + H5FD__mpio_ctl, /* ctl */ + H5FD_FLMAP_DICHOTOMY /* fl_map */ }; #ifdef H5FDmpio_DEBUG @@ -2716,6 +2732,926 @@ H5FD__mpio_write_vector(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, uint32_t co FUNC_LEAVE_NOAPI(ret_value) } /* end H5FD__mpio_write_vector() */ +/*------------------------------------------------------------------------- + * Function: H5FD__selection_build_types + * + * Purpose: Build MPI derived datatype for each piece and then + * build MPI final derived datatype for file and memory. + * + * Note: This is derived from H5D__link_piece_collective_io() in + * src/H5Dmpio.c. + * + * Return: Non-negative on success/Negative on failure + * + *------------------------------------------------------------------------- + */ +static herr_t +H5FD__selection_build_types(hbool_t io_op_write, size_t num_pieces, H5_flexible_const_ptr_t mbb, + H5S_t **file_spaces, H5S_t **mem_spaces, haddr_t offsets[], + H5_flexible_const_ptr_t bufs[], size_t src_element_sizes[], + size_t dst_element_sizes[], MPI_Datatype *final_ftype, + hbool_t *final_ftype_is_derived, MPI_Datatype *final_mtype, + hbool_t *final_mtype_is_derived) +{ + + MPI_Datatype *piece_mtype = NULL; + MPI_Datatype *piece_ftype = NULL; + MPI_Aint *piece_file_disp_array = NULL; + MPI_Aint *piece_mem_disp_array = NULL; + hbool_t *piece_mft_is_derived_array = + NULL; /* Flags to indicate each piece's MPI file datatype is derived */ + ; + hbool_t *piece_mmt_is_derived_array = + NULL; /* Flags to indicate each piece's MPI memory datatype is derived */ + int *piece_mpi_file_counts = NULL; /* Count of MPI file datatype for each piece */ + int *piece_mpi_mem_counts = NULL; /* Count of MPI memory datatype for each piece */ + + haddr_t base_file_addr; + size_t i; /* Local index variable */ + int mpi_code; /* MPI return code */ + + hbool_t extend_src_sizes = FALSE; + hbool_t extend_dst_sizes = FALSE; + hbool_t extend_bufs = FALSE; + H5_flexible_const_ptr_t buf; + size_t src_element_size, dst_element_size; + + herr_t ret_value = SUCCEED; + + FUNC_ENTER_PACKAGE + + /* Allocate information for num_pieces */ + if (NULL == (piece_mtype = (MPI_Datatype *)H5MM_malloc(num_pieces * sizeof(MPI_Datatype)))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate piece memory datatype buffer"); + if (NULL == (piece_ftype = (MPI_Datatype *)H5MM_malloc(num_pieces * sizeof(MPI_Datatype)))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate piece file datatype buffer"); + if (NULL == (piece_file_disp_array = (MPI_Aint *)H5MM_malloc(num_pieces * sizeof(MPI_Aint)))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate piece file displacement buffer"); + if (NULL == (piece_mem_disp_array = (MPI_Aint *)H5MM_calloc(num_pieces * sizeof(MPI_Aint)))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate piece memory displacement buffer"); + if (NULL == (piece_mpi_mem_counts = (int *)H5MM_calloc(num_pieces * sizeof(int)))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate piece memory counts buffer"); + if (NULL == (piece_mpi_file_counts = (int *)H5MM_calloc(num_pieces * sizeof(int)))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate piece file counts buffer"); + if (NULL == (piece_mmt_is_derived_array = (hbool_t *)H5MM_calloc(num_pieces * sizeof(hbool_t)))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, + "couldn't allocate piece memory is derived datatype flags buffer"); + if (NULL == (piece_mft_is_derived_array = (hbool_t *)H5MM_calloc(num_pieces * sizeof(hbool_t)))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, + "couldn't allocate piece file is derived datatype flags buffer"); + + /* save lowest file address */ + base_file_addr = offsets[0]; + + /* Obtain MPI derived datatype from all individual pieces */ + /* Iterate over selected pieces for this process */ + for (i = 0; i < num_pieces; i++) { + hsize_t *permute_map = NULL; /* array that holds the mapping from the old, + out-of-order displacements to the in-order + displacements of the MPI datatypes of the + point selection of the file space */ + hbool_t is_permuted = FALSE; + + if (!extend_src_sizes) { + if (src_element_sizes[i] == 0) { + extend_src_sizes = TRUE; + src_element_size = src_element_sizes[i - 1]; + } + else + src_element_size = src_element_sizes[i]; + } + + if (!extend_dst_sizes) { + if (dst_element_sizes[i] == 0) { + extend_dst_sizes = TRUE; + dst_element_size = dst_element_sizes[i - 1]; + } + else + dst_element_size = src_element_sizes[i]; + } + + if (!extend_bufs) { + if (bufs[i].cvp == NULL) { + extend_bufs = TRUE; + buf = bufs[i - 1]; + } + else + buf = bufs[i]; + } + + /* Obtain disk and memory MPI derived datatype */ + /* NOTE: The permute_map array can be allocated within H5S_mpio_space_type + * and will be fed into the next call to H5S_mpio_space_type + * where it will be freed. + */ + if (H5S_mpio_space_type(file_spaces[i], src_element_size, &piece_ftype[i], /* OUT: datatype created */ + &piece_mpi_file_counts[i], /* OUT */ + &(piece_mft_is_derived_array[i]), /* OUT */ + TRUE, /* this is a file space, + so permute the + datatype if the point + selections are out of + order */ + &permute_map, /* OUT: a map to indicate the + permutation of points + selected in case they + are out of order */ + &is_permuted /* OUT */) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "couldn't create MPI file type"); + + /* Sanity check */ + if (is_permuted) + assert(permute_map); + + if (H5S_mpio_space_type(mem_spaces[i], dst_element_size, &piece_mtype[i], &piece_mpi_mem_counts[i], + &(piece_mmt_is_derived_array[i]), FALSE, /* this is a memory + space, so if the file + space is not + permuted, there is no + need to permute the + datatype if the point + selections are out of + order*/ + &permute_map, /* IN: the permutation map + generated by the + file_space selection + and applied to the + memory selection */ + &is_permuted /* IN */) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "couldn't create MPI buf type"); + + /* Sanity check */ + if (is_permuted) + assert(!permute_map); + + /* Piece address relative to the first piece addr + * Assign piece address to MPI displacement + * (assume MPI_Aint big enough to hold it) */ + piece_file_disp_array[i] = (MPI_Aint)offsets[i] - (MPI_Aint)base_file_addr; + + if (io_op_write) { + piece_mem_disp_array[i] = (MPI_Aint)buf.cvp - (MPI_Aint)mbb.cvp; + } + else { + piece_mem_disp_array[i] = (MPI_Aint)buf.vp - (MPI_Aint)mbb.vp; + } + } /* end for */ + + /* Create final MPI derived datatype for the file */ + if (MPI_SUCCESS != (mpi_code = MPI_Type_create_struct((int)num_pieces, piece_mpi_file_counts, + piece_file_disp_array, piece_ftype, final_ftype))) + HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_struct failed", mpi_code); + + if (MPI_SUCCESS != (mpi_code = MPI_Type_commit(final_ftype))) + HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code); + *final_ftype_is_derived = TRUE; + + /* Create final MPI derived datatype for memory */ + if (MPI_SUCCESS != (mpi_code = MPI_Type_create_struct((int)num_pieces, piece_mpi_mem_counts, + piece_mem_disp_array, piece_mtype, final_mtype))) + HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_struct failed", mpi_code); + + if (MPI_SUCCESS != (mpi_code = MPI_Type_commit(final_mtype))) + HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code); + *final_mtype_is_derived = TRUE; + + /* Free the file & memory MPI datatypes for each piece */ + for (i = 0; i < num_pieces; i++) { + if (piece_mmt_is_derived_array[i]) + if (MPI_SUCCESS != (mpi_code = MPI_Type_free(piece_mtype + i))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); + + if (piece_mft_is_derived_array[i]) + if (MPI_SUCCESS != (mpi_code = MPI_Type_free(piece_ftype + i))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); + } /* end for */ + +done: + + /* Release resources */ + if (piece_mtype) + H5MM_xfree(piece_mtype); + if (piece_ftype) + H5MM_xfree(piece_ftype); + if (piece_file_disp_array) + H5MM_xfree(piece_file_disp_array); + if (piece_mem_disp_array) + H5MM_xfree(piece_mem_disp_array); + if (piece_mpi_mem_counts) + H5MM_xfree(piece_mpi_mem_counts); + if (piece_mpi_file_counts) + H5MM_xfree(piece_mpi_file_counts); + if (piece_mmt_is_derived_array) + H5MM_xfree(piece_mmt_is_derived_array); + if (piece_mft_is_derived_array) + H5MM_xfree(piece_mft_is_derived_array); + + FUNC_LEAVE_NOAPI(ret_value); + +} /* H5FD__selection_build_types() */ + +/*------------------------------------------------------------------------- + * Function: H5FD__mpio_read_selection + * + * Purpose: The behaviour of this function dependes on the value of + * the transfer mode obtained from the context. + * + * If the transfer mode is H5FD_MPIO_COLLECTIVE: + * --sort the selections + * --set mpi_bufs_base + * --build the MPI derived types + * --perform MPI_File_set_view() + * --perform MPI_File_read_at_all() or MPI_File_read_at() + * depending on whether this is a H5FD_MPIO_COLLECTIVE_IO + * + * If this is not H5FD_MPIO_COLLECTIVE: + * --undo possible base address addition in internal routines + * --call H5FD_read_vector_from_selection() to perform vector + * or scalar writes for the selections + * + * Return: Success: SUCCEED. + * Failure: FAIL. + * + *------------------------------------------------------------------------- + */ +static herr_t +H5FD__mpio_read_selection(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, size_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], + size_t element_sizes[], void *bufs[] /* out */) +{ + H5FD_mpio_t *file = (H5FD_mpio_t *)_file; + MPI_Offset mpi_off; + MPI_Status mpi_stat; /* Status from I/O operation */ + int size_i; /* Integer copy of 'size' to read */ + + H5FD_mpio_xfer_t xfer_mode; /* I/O transfer mode */ + H5FD_mpio_collective_opt_t coll_opt_mode; + + MPI_Datatype final_mtype; /* Final memory MPI datatype for all pieces with selection */ + hbool_t final_mtype_is_derived = FALSE; + + MPI_Datatype final_ftype; /* Final file MPI datatype for all pieces with selection */ + hbool_t final_ftype_is_derived = FALSE; + + hid_t *s_mem_space_ids = NULL; + hid_t *s_file_space_ids = NULL; + haddr_t *s_offsets = NULL; + size_t *s_element_sizes = NULL; + H5_flexible_const_ptr_t *s_bufs = NULL; + hbool_t selection_was_sorted = TRUE; + + uint32_t i, j; + H5S_t **s_mem_spaces = NULL; + H5S_t **s_file_spaces = NULL; + haddr_t tmp_offset = 0; + void *mpi_bufs_base = NULL; + char unused = 0; /* Unused, except for non-NULL pointer value */ + +#if H5_CHECK_MPI_VERSION(3, 0) + MPI_Count bytes_read = 0; /* Number of bytes read in */ + MPI_Count type_size; /* MPI datatype used for I/O's size */ + MPI_Count io_size; /* Actual number of bytes requested */ + MPI_Count n; +#else + int bytes_read = 0; /* Number of bytes read in */ + int type_size; /* MPI datatype used for I/O's size */ + int io_size; /* Actual number of bytes requested */ + int n; +#endif + hbool_t rank0_bcast = FALSE; /* If read-with-rank0-and-bcast flag was used */ +#ifdef H5FDmpio_DEBUG + hbool_t H5FD_mpio_debug_t_flag = (H5FD_mpio_debug_flags_s[(int)'t'] && H5FD_MPIO_TRACE_THIS_RANK(file)); + hbool_t H5FD_mpio_debug_r_flag = (H5FD_mpio_debug_flags_s[(int)'r'] && H5FD_MPIO_TRACE_THIS_RANK(file)); +#endif + int mpi_code; /* MPI return code */ + H5_flexible_const_ptr_t mbb; + herr_t ret_value = SUCCEED; + + FUNC_ENTER_PACKAGE + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_t_flag) + fprintf(stderr, "%s: (%d) Entering\n", __func__, file->mpi_rank); +#endif + + /* Sanity checks */ + assert(file); + assert(H5FD_MPIO == file->pub.driver_id); + assert((count == 0) || (mem_space_ids)); + assert((count == 0) || (file_space_ids)); + assert((count == 0) || (offsets)); + assert((count == 0) || (element_sizes)); + assert((count == 0) || (bufs)); + + /* Verify that the first elements of the element_sizes and bufs arrays are + * valid. */ + assert((count == 0) || (element_sizes[0] != 0)); + assert((count == 0) || (bufs[0] != NULL)); + + /* Portably initialize MPI status variable */ + memset(&mpi_stat, 0, sizeof(MPI_Status)); + + /* Get the transfer mode from the API context */ + if (H5CX_get_io_xfer_mode(&xfer_mode) < 0) + HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "can't get MPI-I/O transfer mode"); + + /* + * Set up for a fancy xfer using complex types, or single byte block. We + * wouldn't need to rely on the use_view field if MPI semantics allowed + * us to test that btype=ftype=MPI_BYTE (or even MPI_TYPE_NULL, which + * could mean "use MPI_BYTE" by convention). + */ + if (xfer_mode == H5FD_MPIO_COLLECTIVE) { + + if (count) { + if (H5FD_sort_selection_io_req(&selection_was_sorted, count, mem_space_ids, file_space_ids, + offsets, element_sizes, (H5_flexible_const_ptr_t *)bufs, + &s_mem_space_ids, &s_file_space_ids, &s_offsets, &s_element_sizes, + &s_bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "can't sort selection I/O request"); + + tmp_offset = s_offsets[0]; + + if (NULL == (s_file_spaces = H5MM_malloc(count * sizeof(H5S_t *)))) + HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, + "memory allocation failed for file space list"); + if (NULL == (s_mem_spaces = H5MM_malloc(count * sizeof(H5S_t *)))) + HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, + "memory allocation failed for memory space list"); + + for (i = 0; i < count; i++) { + if (NULL == (s_mem_spaces[i] = (H5S_t *)H5I_object_verify(s_mem_space_ids[i], H5I_DATASPACE))) + HGOTO_ERROR(H5E_VFL, H5E_BADTYPE, H5I_INVALID_HID, + "can't retrieve memory dataspace from ID"); + if (NULL == + (s_file_spaces[i] = (H5S_t *)H5I_object_verify(s_file_space_ids[i], H5I_DATASPACE))) + HGOTO_ERROR(H5E_VFL, H5E_BADTYPE, H5I_INVALID_HID, + "can't retrieve file dataspace from ID"); + } + + /* when we setup mpi_bufs[] below, all addresses are offsets from + * mpi_bufs_base. + * + * Since these offsets must all be positive, we must scan through + * s_bufs[] to find the smallest value, and choose that for + * mpi_bufs_base. + */ + j = 0; /* guess at the index of the smallest value of s_bufs[] */ + + if (s_bufs[j + 1].vp != NULL) { + for (i = 1; i < count; i++) + if (s_bufs[i].vp < s_bufs[j].vp) + j = i; + } + + mpi_bufs_base = s_bufs[j].vp; + mbb.vp = mpi_bufs_base; + + if (H5FD__selection_build_types(FALSE, count, mbb, s_file_spaces, s_mem_spaces, s_offsets, s_bufs, + s_element_sizes, s_element_sizes, &final_ftype, + &final_ftype_is_derived, &final_mtype, + &final_mtype_is_derived) < 0) + HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "couldn't build type for MPI-IO"); + + /* We have a single, complicated MPI datatype for both memory & file */ + size_i = 1; + } + else { + + /* No chunks selected for this process */ + size_i = 0; + + mpi_bufs_base = &unused; + + /* Set the MPI datatype */ + final_ftype = MPI_BYTE; + final_mtype = MPI_BYTE; + } + + /* some numeric conversions */ + if (H5FD_mpi_haddr_to_MPIOff(tmp_offset, &mpi_off /*out*/) < 0) + HGOTO_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't convert from haddr to MPI off"); + + /* + * Set the file view when we are using MPI derived types + */ + if (MPI_SUCCESS != (mpi_code = MPI_File_set_view(file->f, mpi_off, MPI_BYTE, final_ftype, + H5FD_mpi_native_g, file->info))) + HMPI_GOTO_ERROR(FAIL, "MPI_File_set_view failed", mpi_code); + + /* When using types, use the address as the displacement for + * MPI_File_set_view and reset the address for the read to zero + */ + /* Reset mpi_off to 0 since the view now starts at the data offset */ + if (H5FD_mpi_haddr_to_MPIOff((haddr_t)0, &mpi_off) < 0) + HGOTO_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't set MPI off to 0"); + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_r_flag) + fprintf(stderr, "%s: (%d) using MPIO collective mode\n", __func__, file->mpi_rank); +#endif + /* Get the collective_opt property to check whether the application wants to do IO individually. */ + if (H5CX_get_mpio_coll_opt(&coll_opt_mode) < 0) + HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "can't get MPI-I/O collective_op property"); + + if (coll_opt_mode == H5FD_MPIO_COLLECTIVE_IO) { +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_r_flag) + fprintf(stderr, "%s: (%d) doing MPI collective IO\n", __func__, file->mpi_rank); +#endif + /* Check whether we should read from rank 0 and broadcast to other ranks */ + if (H5CX_get_mpio_rank0_bcast()) { +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_r_flag) + fprintf(stderr, "%s: (%d) doing read-rank0-and-MPI_Bcast\n", __func__, file->mpi_rank); +#endif + /* Indicate path we've taken */ + rank0_bcast = TRUE; + + /* Read on rank 0 Bcast to other ranks */ + if (file->mpi_rank == 0) { + /* If MPI_File_read_at fails, push an error, but continue + * to participate in following MPI_Bcast */ + if (MPI_SUCCESS != (mpi_code = MPI_File_read_at(file->f, mpi_off, mpi_bufs_base, size_i, + final_mtype, &mpi_stat))) + HMPI_DONE_ERROR(FAIL, "MPI_File_read_at failed", mpi_code); + } + + if (MPI_SUCCESS != (mpi_code = MPI_Bcast(mpi_bufs_base, size_i, final_mtype, 0, file->comm))) + HMPI_GOTO_ERROR(FAIL, "MPI_Bcast failed", mpi_code); + } /* end if */ + else + /* Perform collective read operation */ + if (MPI_SUCCESS != (mpi_code = MPI_File_read_at_all(file->f, mpi_off, mpi_bufs_base, size_i, + final_mtype, &mpi_stat))) + HMPI_GOTO_ERROR(FAIL, "MPI_File_read_at_all failed", mpi_code); + } /* end if */ + else { +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_r_flag) + fprintf(stderr, "%s: (%d) doing MPI independent IO\n", __func__, file->mpi_rank); +#endif + + /* Perform independent read operation */ + if (MPI_SUCCESS != (mpi_code = MPI_File_read_at(file->f, mpi_off, mpi_bufs_base, size_i, + final_mtype, &mpi_stat))) + HMPI_GOTO_ERROR(FAIL, "MPI_File_read_at failed", mpi_code); + } /* end else */ + + /* + * Reset the file view when we used MPI derived types + */ + if (MPI_SUCCESS != (mpi_code = MPI_File_set_view(file->f, (MPI_Offset)0, MPI_BYTE, MPI_BYTE, + H5FD_mpi_native_g, file->info))) + HMPI_GOTO_ERROR(FAIL, "MPI_File_set_view failed", mpi_code); + + /* Only retrieve bytes read if this rank _actually_ participated in I/O */ + if (!rank0_bcast || (rank0_bcast && file->mpi_rank == 0)) { + /* How many bytes were actually read? */ +#if H5_CHECK_MPI_VERSION(3, 0) + if (MPI_SUCCESS != (mpi_code = MPI_Get_elements_x(&mpi_stat, final_mtype, &bytes_read))) { +#else + if (MPI_SUCCESS != (mpi_code = MPI_Get_elements(&mpi_stat, MPI_BYTE, &bytes_read))) { +#endif + if (rank0_bcast && file->mpi_rank == 0) { + /* If MPI_Get_elements(_x) fails for a rank 0 bcast strategy, + * push an error, but continue to participate in the following + * MPI_Bcast. + */ + bytes_read = -1; + HMPI_DONE_ERROR(FAIL, "MPI_Get_elements failed", mpi_code); + } + else + HMPI_GOTO_ERROR(FAIL, "MPI_Get_elements failed", mpi_code); + } + } /* end if */ + + /* If the rank0-bcast feature was used, broadcast the # of bytes read to + * other ranks, which didn't perform any I/O. + */ + /* NOTE: This could be optimized further to be combined with the broadcast + * of the data. (QAK - 2019/1/2) + */ + if (rank0_bcast) +#if H5_CHECK_MPI_VERSION(3, 0) + if (MPI_SUCCESS != MPI_Bcast(&bytes_read, 1, MPI_COUNT, 0, file->comm)) +#else + if (MPI_SUCCESS != MPI_Bcast(&bytes_read, 1, MPI_INT, 0, file->comm)) +#endif + HMPI_GOTO_ERROR(FAIL, "MPI_Bcast failed", 0); + + /* Get the type's size */ +#if H5_CHECK_MPI_VERSION(3, 0) + if (MPI_SUCCESS != (mpi_code = MPI_Type_size_x(final_mtype, &type_size))) +#else + if (MPI_SUCCESS != (mpi_code = MPI_Type_size(final_mtype, &type_size))) +#endif + HMPI_GOTO_ERROR(FAIL, "MPI_Type_size failed", mpi_code); + + /* Compute the actual number of bytes requested */ + io_size = type_size * size_i; + + /* Check for read failure */ + if (bytes_read < 0 || bytes_read > io_size) + HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "file read failed"); + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_r_flag) + fprintf(stderr, "%s: (%d) mpi_off = %ld bytes_read = %lld type = %s\n", __func__, + file->mpi_rank, (long)mpi_off, (long long)bytes_read, H5FD__mem_t_to_str(type)); +#endif + + /* + * This gives us zeroes beyond end of physical MPI file. + */ + if ((n = (io_size - bytes_read)) > 0) + memset((char *)bufs[0] + bytes_read, 0, (size_t)n); + + } /* end if */ + else { +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_r_flag) + fprintf(stderr, "%s: (%d) doing MPI independent IO\n", __func__, file->mpi_rank); +#endif + if (_file->base_addr > 0) { + /* Undo base address addition in internal routines before passing down to the mpio driver */ + for (i = 0; i < count; i++) { + assert(offsets[i] >= _file->base_addr); + offsets[i] -= _file->base_addr; + } + } + + if (H5FD_read_from_selection(_file, type, (uint32_t)count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "read vector from selection failed"); + } + +done: + /* Free the MPI buf and file types, if they were derived */ + if (final_mtype_is_derived && MPI_SUCCESS != (mpi_code = MPI_Type_free(&final_mtype))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); + if (final_ftype_is_derived && MPI_SUCCESS != (mpi_code = MPI_Type_free(&final_ftype))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); + + /* Cleanup dataspace arrays */ + if (s_mem_spaces) + s_mem_spaces = H5MM_xfree(s_mem_spaces); + if (s_file_spaces) + s_file_spaces = H5MM_xfree(s_file_spaces); + + if (!selection_was_sorted) { + free(s_mem_space_ids); + s_mem_space_ids = NULL; + free(s_file_space_ids); + s_file_space_ids = NULL; + free(s_offsets); + s_offsets = NULL; + free(s_element_sizes); + s_element_sizes = NULL; + free(s_bufs); + s_bufs = NULL; + } + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_t_flag) + fprintf(stderr, "%s: (%d) Leaving\n", __func__, file->mpi_rank); +#endif + + FUNC_LEAVE_NOAPI(ret_value) + +} /* end H5FD__mpio_read_selection() */ + +/*------------------------------------------------------------------------- + * Function: H5FD__mpio_write_selection + * + * Purpose: The behaviour of this function dependes on the value of + * the transfer mode obtained from the context. + * + * If the transfer mode is H5FD_MPIO_COLLECTIVE: + * --sort the selections + * --set mpi_bufs_base + * --build the MPI derived types + * --perform MPI_File_set_view() + * --perform MPI_File_write_at_all() or MPI_File_write_at() + * depending on whether this is a H5FD_MPIO_COLLECTIVE_IO + * --calculate and set the file's eof for the bytes written + * + * If this is not H5FD_MPIO_COLLECTIVE: + * --undo possible base address addition in internal routines + * --call H5FD_write_vector_from_selection() to perform vector + * or scalar writes for the selections + * + * Return: Success: SUCCEED. + * Failure: FAIL. + * + *------------------------------------------------------------------------- + */ +static herr_t +H5FD__mpio_write_selection(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id, size_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], + size_t element_sizes[], const void *bufs[]) +{ + H5FD_mpio_t *file = (H5FD_mpio_t *)_file; + MPI_Offset mpi_off; + MPI_Offset save_mpi_off; /* Use at the end of the routine for setting local_eof */ + MPI_Status mpi_stat; /* Status from I/O operation */ + + int size_i; + H5FD_mpio_xfer_t xfer_mode; /* I/O transfer mode */ + H5FD_mpio_collective_opt_t coll_opt_mode; + + MPI_Datatype final_mtype; /* Final memory MPI datatype for all pieces with selection */ + hbool_t final_mtype_is_derived = FALSE; + + MPI_Datatype final_ftype; /* Final file MPI datatype for all pieces with selection */ + hbool_t final_ftype_is_derived = FALSE; + + hid_t *s_mem_space_ids = NULL; + hid_t *s_file_space_ids = NULL; + haddr_t *s_offsets = NULL; + size_t *s_element_sizes = NULL; + H5_flexible_const_ptr_t *s_bufs = NULL; + hbool_t selection_was_sorted = TRUE; + const void *mpi_bufs_base = NULL; + + uint32_t i, j; + H5S_t **s_mem_spaces = NULL; + H5S_t **s_file_spaces = NULL; + haddr_t tmp_offset = 0; + char unused = 0; /* Unused, except for non-NULL pointer value */ + H5_flexible_const_ptr_t mbb; + +#if H5_CHECK_MPI_VERSION(3, 0) + MPI_Count bytes_written; + MPI_Count type_size; /* MPI datatype used for I/O's size */ + MPI_Count io_size; /* Actual number of bytes requested */ +#else + int bytes_written; + int type_size; /* MPI datatype used for I/O's size */ + int io_size; /* Actual number of bytes requested */ +#endif + +#ifdef H5FDmpio_DEBUG + hbool_t H5FD_mpio_debug_t_flag = (H5FD_mpio_debug_flags_s[(int)'t'] && H5FD_MPIO_TRACE_THIS_RANK(file)); + hbool_t H5FD_mpio_debug_w_flag = (H5FD_mpio_debug_flags_s[(int)'w'] && H5FD_MPIO_TRACE_THIS_RANK(file)); +#endif + int mpi_code; /* MPI return code */ + herr_t ret_value = SUCCEED; + + FUNC_ENTER_PACKAGE + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_t_flag) + fprintf(stderr, "%s: (%d) Entering\n", __func__, file->mpi_rank); +#endif + + /* Sanity checks */ + assert(file); + assert(H5FD_MPIO == file->pub.driver_id); + assert((count == 0) || (mem_space_ids)); + assert((count == 0) || (file_space_ids)); + assert((count == 0) || (offsets)); + assert((count == 0) || (element_sizes)); + assert((count == 0) || (bufs)); + + /* Verify that the first elements of the element_sizes and bufs arrays are + * valid. */ + assert((count == 0) || (element_sizes[0] != 0)); + assert((count == 0) || (bufs[0] != NULL)); + + /* Verify that no data is written when between MPI_Barrier()s during file flush */ + assert(!H5CX_get_mpi_file_flushing()); + + /* Portably initialize MPI status variable */ + memset(&mpi_stat, 0, sizeof(MPI_Status)); + + /* Get the transfer mode from the API context */ + if (H5CX_get_io_xfer_mode(&xfer_mode) < 0) + HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "can't get MPI-I/O transfer mode"); + + if (xfer_mode == H5FD_MPIO_COLLECTIVE) { + + if (count) { + if (H5FD_sort_selection_io_req(&selection_was_sorted, count, mem_space_ids, file_space_ids, + offsets, element_sizes, (H5_flexible_const_ptr_t *)bufs, + &s_mem_space_ids, &s_file_space_ids, &s_offsets, &s_element_sizes, + &s_bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "can't sort selection I/O request"); + + tmp_offset = s_offsets[0]; + + if (NULL == (s_file_spaces = H5MM_malloc(count * sizeof(H5S_t *)))) + HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, + "memory allocation failed for file space list"); + if (NULL == (s_mem_spaces = H5MM_malloc(count * sizeof(H5S_t *)))) + HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, + "memory allocation failed for memory space list"); + + for (i = 0; i < count; i++) { + if (NULL == + (s_file_spaces[i] = (H5S_t *)H5I_object_verify(s_file_space_ids[i], H5I_DATASPACE))) + HGOTO_ERROR(H5E_VFL, H5E_BADTYPE, H5I_INVALID_HID, + "can't retrieve file dataspace from ID"); + if (NULL == (s_mem_spaces[i] = (H5S_t *)H5I_object_verify(s_mem_space_ids[i], H5I_DATASPACE))) + HGOTO_ERROR(H5E_VFL, H5E_BADTYPE, H5I_INVALID_HID, + "can't retrieve memory dataspace from ID"); + } + + /* when we setup mpi_bufs[] below, all addresses are offsets from + * mpi_bufs_base. + * + * Since these offsets must all be positive, we must scan through + * s_bufs[] to find the smallest value, and choose that for + * mpi_bufs_base. + */ + j = 0; /* guess at the index of the smallest value of s_bufs[] */ + + if (s_bufs[j + 1].cvp != NULL) { + for (i = 1; i < count; i++) + if (s_bufs[i].cvp < s_bufs[j].cvp) + j = i; + } + + mpi_bufs_base = s_bufs[j].cvp; + mbb.cvp = mpi_bufs_base; + + if (H5FD__selection_build_types(TRUE, count, mbb, s_file_spaces, s_mem_spaces, s_offsets, s_bufs, + s_element_sizes, s_element_sizes, &final_ftype, + &final_ftype_is_derived, &final_mtype, + &final_mtype_is_derived) < 0) + HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "couldn't build type for MPI-IO"); + + /* We have a single, complicated MPI datatype for both memory & file */ + size_i = 1; + } + else { + + /* No chunks selected for this process */ + size_i = 0; + + mpi_bufs_base = &unused; + + /* Set the MPI datatype */ + final_ftype = MPI_BYTE; + final_mtype = MPI_BYTE; + } + + /* some numeric conversions */ + if (H5FD_mpi_haddr_to_MPIOff(tmp_offset, &mpi_off /*out*/) < 0) + HGOTO_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't convert from haddr to MPI off"); + + /* To be used at the end of the routine for setting local_eof */ + save_mpi_off = mpi_off; + + /* + * Set the file view when we are using MPI derived types + */ + if (MPI_SUCCESS != (mpi_code = MPI_File_set_view(file->f, mpi_off, MPI_BYTE, final_ftype, + H5FD_mpi_native_g, file->info))) + HMPI_GOTO_ERROR(FAIL, "MPI_File_set_view failed", mpi_code); + + /* Reset mpi_off to 0 since the view now starts at the data offset */ + if (H5FD_mpi_haddr_to_MPIOff((haddr_t)0, &mpi_off) < 0) + HGOTO_ERROR(H5E_INTERNAL, H5E_BADRANGE, FAIL, "can't set MPI off to 0"); + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_w_flag) + fprintf(stderr, "%s: (%d) using MPIO collective mode\n", __func__, file->mpi_rank); +#endif + + /* Get the collective_opt property to check whether the application wants to do IO individually. */ + if (H5CX_get_mpio_coll_opt(&coll_opt_mode) < 0) + HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "can't get MPI-I/O collective_op property"); + + if (coll_opt_mode == H5FD_MPIO_COLLECTIVE_IO) { + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_w_flag) + fprintf(stderr, "%s: (%d) doing MPI collective IO\n", __func__, file->mpi_rank); +#endif + + /* Perform collective write operation */ + if (MPI_SUCCESS != (mpi_code = MPI_File_write_at_all(file->f, mpi_off, mpi_bufs_base, size_i, + final_mtype, &mpi_stat))) + HMPI_GOTO_ERROR(FAIL, "MPI_File_write_at_all failed", mpi_code); + + /* Do MPI_File_sync when needed by underlying ROMIO driver */ + if (file->mpi_file_sync_required) { + if (MPI_SUCCESS != (mpi_code = MPI_File_sync(file->f))) + HMPI_GOTO_ERROR(FAIL, "MPI_File_sync failed", mpi_code); + } + } + else { + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_w_flag) + fprintf(stderr, "%s: (%d) doing MPI independent IO\n", __func__, file->mpi_rank); +#endif + /* Perform independent write operation */ + if (MPI_SUCCESS != (mpi_code = MPI_File_write_at(file->f, mpi_off, mpi_bufs_base, size_i, + final_mtype, &mpi_stat))) + HMPI_GOTO_ERROR(FAIL, "MPI_File_write_at failed", mpi_code); + } /* end else */ + + /* Reset the file view when we used MPI derived types */ + if (MPI_SUCCESS != (mpi_code = MPI_File_set_view(file->f, (MPI_Offset)0, MPI_BYTE, MPI_BYTE, + H5FD_mpi_native_g, file->info))) + HMPI_GOTO_ERROR(FAIL, "MPI_File_set_view failed", mpi_code); + + /* How many bytes were actually written */ +#if H5_CHECK_MPI_VERSION(3, 0) + if (MPI_SUCCESS != (mpi_code = MPI_Get_elements_x(&mpi_stat, final_mtype, &bytes_written))) +#else + if (MPI_SUCCESS != (mpi_code = MPI_Get_elements(&mpi_stat, MPI_BYTE, &bytes_written))) +#endif + HMPI_GOTO_ERROR(FAIL, "MPI_Get_elements failed", mpi_code); + + /* Get the type's size */ +#if H5_CHECK_MPI_VERSION(3, 0) + if (MPI_SUCCESS != (mpi_code = MPI_Type_size_x(final_mtype, &type_size))) +#else + if (MPI_SUCCESS != (mpi_code = MPI_Type_size(final_mtype, &type_size))) +#endif + HMPI_GOTO_ERROR(FAIL, "MPI_Type_size failed", mpi_code); + + /* Compute the actual number of bytes requested */ + io_size = type_size * size_i; + + /* Check for write failure */ + if (bytes_written != io_size || bytes_written < 0) + HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "file write failed"); + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_w_flag) + fprintf(stderr, "%s: (%d) mpi_off = %ld bytes_written = %lld type = %s\n", __func__, + file->mpi_rank, (long)mpi_off, (long long)bytes_written, H5FD__mem_t_to_str(type)); +#endif + + /* Each process will keep track of its perceived EOF value locally, and + * ultimately we will reduce this value to the maximum amongst all + * processes, but until then keep the actual eof at HADDR_UNDEF just in + * case something bad happens before that point. (rather have a value + * we know is wrong sitting around rather than one that could only + * potentially be wrong.) */ + file->eof = HADDR_UNDEF; + + if (bytes_written && (((haddr_t)bytes_written + (haddr_t)save_mpi_off) > file->local_eof)) + file->local_eof = (haddr_t)save_mpi_off + (haddr_t)bytes_written; + } + else { /* Not H5FD_MPIO_COLLECTIVE */ + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_w_flag) + fprintf(stderr, "%s: (%d) doing MPI independent IO\n", __func__, file->mpi_rank); +#endif + if (_file->base_addr > 0) { + /* Undo base address addition in internal routines before passing down to the mpio driver */ + for (i = 0; i < count; i++) { + assert(offsets[i] >= _file->base_addr); + offsets[i] -= _file->base_addr; + } + } + + if (H5FD_write_from_selection(_file, type, (uint32_t)count, mem_space_ids, file_space_ids, offsets, + element_sizes, bufs) < 0) + HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "write vector from selection failed"); + } + +done: + /* Free the MPI buf and file types, if they were derived */ + if (final_mtype_is_derived && MPI_SUCCESS != (mpi_code = MPI_Type_free(&final_mtype))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); + if (final_ftype_is_derived && MPI_SUCCESS != (mpi_code = MPI_Type_free(&final_ftype))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); + + /* Cleanup dataspace arrays */ + if (s_mem_spaces) + s_mem_spaces = H5MM_xfree(s_mem_spaces); + if (s_file_spaces) + s_file_spaces = H5MM_xfree(s_file_spaces); + + if (!selection_was_sorted) { + free(s_mem_space_ids); + s_mem_space_ids = NULL; + free(s_file_space_ids); + s_file_space_ids = NULL; + free(s_offsets); + s_offsets = NULL; + free(s_element_sizes); + s_element_sizes = NULL; + free(s_bufs); + s_bufs = NULL; + } + +#ifdef H5FDmpio_DEBUG + if (H5FD_mpio_debug_t_flag) + fprintf(stderr, "%s: (%d) Leaving: ret_value = %d\n", __func__, file->mpi_rank, ret_value); +#endif + + FUNC_LEAVE_NOAPI(ret_value) + +} /* end H5FD__mpio_write_selection() */ + /*------------------------------------------------------------------------- * Function: H5FD__mpio_flush * diff --git a/src/H5FDprivate.h b/src/H5FDprivate.h index c4ccfdd6f9d..6b8e2dac7fa 100644 --- a/src/H5FDprivate.h +++ b/src/H5FDprivate.h @@ -77,6 +77,10 @@ typedef struct { } \ } +#define SKIP_NO_CB 0x00u +#define SKIP_SELECTION_CB 0x01u +#define SKIP_VECTOR_CB 0x02u + /* Define structure to hold driver ID, info & configuration string for FAPLs */ typedef struct { hid_t driver_id; /* Driver's ID */ @@ -149,12 +153,27 @@ H5_DLL herr_t H5FD_read_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count H5_DLL herr_t H5FD_write_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, struct H5S_t **mem_spaces, struct H5S_t **file_spaces, haddr_t offsets[], size_t element_sizes[], const void *bufs[]); -H5_DLL herr_t H5FD_read_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], - hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], - void *bufs[] /* out */); -H5_DLL herr_t H5FD_write_selection_id(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], +H5_DLL herr_t H5FD_read_selection_id(uint32_t skip_cb, H5FD_t *file, H5FD_mem_t type, uint32_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], + size_t element_sizes[], void *bufs[] /* out */); +H5_DLL herr_t H5FD_write_selection_id(uint32_t skip_cb, H5FD_t *file, H5FD_mem_t type, uint32_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], + size_t element_sizes[], const void *bufs[]); +H5_DLL herr_t H5FD_read_vector_from_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], + haddr_t offsets[], size_t element_sizes[], void *bufs[]); + +H5_DLL herr_t H5FD_write_vector_from_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, + hid_t mem_space_ids[], hid_t file_space_ids[], + haddr_t offsets[], size_t element_sizes[], const void *bufs[]); + +H5_DLL herr_t H5FD_read_from_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], - const void *bufs[]); + void *bufs[]); + +H5_DLL herr_t H5FD_write_from_selection(H5FD_t *file, H5FD_mem_t type, uint32_t count, hid_t mem_space_ids[], + hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], + const void *bufs[]); H5_DLL herr_t H5FD_flush(H5FD_t *file, hbool_t closing); H5_DLL herr_t H5FD_truncate(H5FD_t *file, hbool_t closing); H5_DLL herr_t H5FD_lock(H5FD_t *file, hbool_t rw); @@ -171,6 +190,12 @@ H5_DLL herr_t H5FD_sort_vector_io_req(hbool_t *vector_was_sorted, uint32_t count haddr_t addrs[], size_t sizes[], H5_flexible_const_ptr_t bufs[], H5FD_mem_t **s_types_ptr, haddr_t **s_addrs_ptr, size_t **s_sizes_ptr, H5_flexible_const_ptr_t **s_bufs_ptr); + +H5_DLL herr_t H5FD_sort_selection_io_req(hbool_t *selection_was_sorted, size_t count, hid_t mem_space_ids[], + hid_t file_space_ids[], haddr_t offsets[], size_t element_sizes[], + H5_flexible_const_ptr_t bufs[], hid_t **s_mem_space_ids, + hid_t **s_file_space_ids, haddr_t **s_offsets_ptr, + size_t **s_element_sizes_ptr, H5_flexible_const_ptr_t **s_bufs_ptr); H5_DLL herr_t H5FD_init(void); /* Function prototypes for MPI based VFDs*/ diff --git a/src/H5Ppublic.h b/src/H5Ppublic.h index 2c26d6e02de..124f6614c74 100644 --- a/src/H5Ppublic.h +++ b/src/H5Ppublic.h @@ -8411,11 +8411,9 @@ H5_DLL herr_t H5Pget_no_selection_io_cause(hid_t plist_id, uint32_t *no_selectio * default value for modify_write_buf is FALSE. * * This function can be used to allow the library to perform in-place - * type conversion on write operations to save memory space. This is - * currently only used for selection I/O operations, which are used for - * collective I/O with type conversion. After making an API call with - * this parameter set to TRUE, the contents of the write buffer are - * undefined. + * type conversion on write operations to save memory space. After making an + * API call with this parameter set to TRUE, the contents of the write buffer + * are undefined. * * \note When modify_write_buf is set to TRUE the library may violate the * const qualifier on the API parameter for the write buffer. diff --git a/test/select_io_dset.c b/test/select_io_dset.c index b498458c03c..0f38aba8297 100644 --- a/test/select_io_dset.c +++ b/test/select_io_dset.c @@ -2751,9 +2751,6 @@ test_set_get_select_io_mode(hid_t fid) if (H5Pget_selection_io(dxpl, &selection_io_mode) < 0) TEST_ERROR; - if (selection_io_mode != H5D_SELECTION_IO_MODE_DEFAULT) - TEST_ERROR; - /* Disable case */ if (H5Pset_selection_io(dxpl, H5D_SELECTION_IO_MODE_OFF) < 0) TEST_ERROR; @@ -3063,11 +3060,29 @@ static herr_t test_get_no_selection_io_cause(const char *filename, hid_t fapl) { - int errs = 0; + hid_t dxpl = H5I_INVALID_HID; + H5D_selection_io_mode_t selection_io_mode; + int errs = 0; printf("\n"); TESTING("H5Pget_no_selection_io_cause()"); + if ((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) + FAIL_STACK_ERROR; + + if (H5Pget_selection_io(dxpl, &selection_io_mode) < 0) + TEST_ERROR; + + if (H5Pclose(dxpl) < 0) + FAIL_STACK_ERROR; + + /* The following tests are based on H5D_SELECTION_IO_MODE_DEFAULT as the + default setting in the library; skip the tests if that is not true */ + if (selection_io_mode != H5D_SELECTION_IO_MODE_DEFAULT) { + SKIPPED(); + return SUCCEED; + } + errs += test_no_selection_io_cause_mode(filename, fapl, TEST_DISABLE_BY_API); errs += test_no_selection_io_cause_mode(filename, fapl, TEST_NOT_CONTIGUOUS_OR_CHUNKED_DATASET); errs += test_no_selection_io_cause_mode(filename, fapl, TEST_CONTIGUOUS_SIEVE_BUFFER); @@ -3083,6 +3098,7 @@ test_get_no_selection_io_cause(const char *filename, hid_t fapl) errs += test_no_selection_io_cause_mode(filename, fapl, TEST_PAGE_BUFFER); #endif +error: if (errs) { printf(" FAILED\n"); return FAIL; diff --git a/test/set_extent.c b/test/set_extent.c index 9f8e182a517..661ef4e4031 100644 --- a/test/set_extent.c +++ b/test/set_extent.c @@ -78,22 +78,22 @@ typedef enum rank4_index_t { RANK4_NINDICES, /* Must be last */ } rank4_index_t; -static int do_ranks(hid_t fapl, hbool_t new_format); -static int do_layouts(hid_t fapl); +static int do_ranks(hid_t fapl, hbool_t new_format, hbool_t use_select_io); +static int do_layouts(hid_t fapl, hbool_t use_select_io); -static int test_rank1(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_filters, +static int test_rank1(hid_t fapl, hid_t dcpl, hid_t dxpl, hbool_t do_fill_value, hbool_t disable_edge_filters, hbool_t set_istore_k); -static int test_rank2(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_filters, +static int test_rank2(hid_t fapl, hid_t dcpl, hid_t dxpl, hbool_t do_fill_value, hbool_t disable_edge_filters, hbool_t set_istore_k); -static int test_rank3(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_filters, +static int test_rank3(hid_t fapl, hid_t dcpl, hid_t dxpl, hbool_t do_fill_value, hbool_t disable_edge_filters, hbool_t set_istore_k); -static int test_random_rank4(hid_t fapl, hid_t dcpl, hbool_t do_fillvalue, hbool_t disable_edge_filters, - hbool_t do_sparse, rank4_index_t index_type); -static int test_random_rank4_vl(hid_t fapl, hid_t dcpl, hbool_t do_fillvalue, hbool_t disable_edge_filters, - hbool_t do_sparse, rank4_index_t index_type); +static int test_random_rank4(hid_t fapl, hid_t dcpl, hid_t dxpl, hbool_t do_fillvalue, + hbool_t disable_edge_filters, hbool_t do_sparse, rank4_index_t index_type); +static int test_random_rank4_vl(hid_t fapl, hid_t dcpl, hid_t dxpl, hbool_t do_fillvalue, + hbool_t disable_edge_filters, hbool_t do_sparse, rank4_index_t index_type); -static int test_external(hid_t fapl); -static int test_layouts(H5D_layout_t layout, hid_t fapl); +static int test_external(hid_t fapl, hbool_t use_select_io); +static int test_layouts(H5D_layout_t layout, hid_t fapl, hid_t dxpl); static void test_random_rank4_dump(unsigned ndim_sets, hsize_t dim_log[][4], hsize_t cdims[4], int j, int k, int l, int m); @@ -177,14 +177,21 @@ main(void) TEST_ERROR; /* Tests which use chunked datasets */ - if (!new_format || (new_format && contig_addr_vfd)) - nerrors += do_ranks(my_fapl, new_format) < 0 ? 1 : 0; + if (!new_format || (new_format && contig_addr_vfd)) { + /* Run do_ranks() with H5D_SELECTION_IO_MODE_DEFAULT/H5D_SELECTION_IO_MODE_ON */ + nerrors += do_ranks(my_fapl, new_format, FALSE) < 0 ? 1 : 0; + nerrors += do_ranks(my_fapl, new_format, TRUE) < 0 ? 1 : 0; + } } /* end for */ /* Tests which do not use chunked datasets */ if (!new_format || (new_format && contig_addr_vfd)) { - nerrors += test_external(fapl) < 0 ? 1 : 0; - nerrors += do_layouts(fapl) < 0 ? 1 : 0; + /* Run test_external() with H5D_SELECTION_IO_MODE_DEFAULT/H5D_SELECTION_IO_MODE_ON */ + nerrors += test_external(fapl, FALSE) < 0 ? 1 : 0; + nerrors += test_external(fapl, TRUE) < 0 ? 1 : 0; + /* Run do_layouts() with H5D_SELECTION_IO_MODE_DEFAULT/H5D_SELECTION_IO_MODE_ON */ + nerrors += do_layouts(fapl, FALSE) < 0 ? 1 : 0; + nerrors += do_layouts(fapl, TRUE) < 0 ? 1 : 0; } } /* end for */ @@ -217,18 +224,32 @@ main(void) *------------------------------------------------------------------------- */ static int -do_ranks(hid_t fapl, hbool_t new_format) +do_ranks(hid_t fapl, hbool_t new_format, hbool_t use_select_io) { hbool_t do_fillvalue = FALSE; hbool_t disable_edge_filters = FALSE; rank4_index_t index_type; hid_t dcpl = -1; + hid_t dxpl = -1; int fillvalue = FILL_VALUE; unsigned config; hbool_t driver_is_parallel; - TESTING_2("datasets with ranks 1 to 4 (all configurations)"); + if ((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) + TEST_ERROR; + + if (use_select_io) { + TESTING_2("datasets with ranks 1 to 4 (all configurations)"); + printf("\n With H5D_SELECTION_IO_MODE_ON "); + + if (H5Pset_selection_io(dxpl, H5D_SELECTION_IO_MODE_ON) < 0) + TEST_ERROR; + } + else { + TESTING_2("datasets with ranks 1 to 4 (all configurations)"); + printf("\n With H5D_SELECTION_IO_MODE_DEFAULT "); + } if (h5_using_parallel_driver(fapl, &driver_is_parallel) < 0) TEST_ERROR; @@ -280,22 +301,22 @@ do_ranks(hid_t fapl, hbool_t new_format) else if (H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) TEST_ERROR; - if (test_rank1(fapl, dcpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { + if (test_rank1(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { DO_RANKS_PRINT_CONFIG("Rank 1") printf(" Fill time: %s\n", (ifset ? "H5D_FILL_TIME_IFSET" : "H5D_FILL_TIME_ALLOC")); goto error; } /* end if */ - if (test_rank2(fapl, dcpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { + if (test_rank2(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { DO_RANKS_PRINT_CONFIG("Rank 2") printf(" Fill time: %s\n", (ifset ? "H5D_FILL_TIME_IFSET" : "H5D_FILL_TIME_ALLOC")); goto error; } /* end if */ - if (test_rank3(fapl, dcpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { + if (test_rank3(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { DO_RANKS_PRINT_CONFIG("Rank 3") printf(" Fill time: %s\n", (ifset ? "H5D_FILL_TIME_IFSET" : "H5D_FILL_TIME_ALLOC")); goto error; } /* end if */ - if (test_rank2(fapl, dcpl, do_fillvalue, disable_edge_filters, TRUE) < 0) { + if (test_rank2(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, TRUE) < 0) { DO_RANKS_PRINT_CONFIG("Rank 2 with non-default indexed storage B-tree") printf(" Fill time: %s\n", (ifset ? "H5D_FILL_TIME_IFSET" : "H5D_FILL_TIME_ALLOC")); goto error; @@ -308,19 +329,19 @@ do_ranks(hid_t fapl, hbool_t new_format) if (H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) TEST_ERROR; - if (test_rank1(fapl, dcpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { + if (test_rank1(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { DO_RANKS_PRINT_CONFIG("Rank 1") goto error; } /* end if */ - if (test_rank2(fapl, dcpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { + if (test_rank2(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { DO_RANKS_PRINT_CONFIG("Rank 2") goto error; } /* end if */ - if (test_rank3(fapl, dcpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { + if (test_rank3(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, FALSE) < 0) { DO_RANKS_PRINT_CONFIG("Rank 3") goto error; } /* end if */ - if (test_rank2(fapl, dcpl, do_fillvalue, disable_edge_filters, TRUE) < 0) { + if (test_rank2(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, TRUE) < 0) { DO_RANKS_PRINT_CONFIG("Rank 2 with non-default indexed storage B-tree") goto error; } /* end if */ @@ -335,7 +356,8 @@ do_ranks(hid_t fapl, hbool_t new_format) */ for (index_type = RANK4_INDEX_BTREE; index_type < RANK4_NINDICES; index_type++) { /* Standard test */ - if (test_random_rank4(fapl, dcpl, do_fillvalue, disable_edge_filters, FALSE, index_type) < 0) { + if (test_random_rank4(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, FALSE, index_type) < + 0) { DO_RANKS_PRINT_CONFIG("Randomized rank 4") printf(" Index: %s\n", index_type == RANK4_INDEX_BTREE ? "btree" @@ -345,8 +367,8 @@ do_ranks(hid_t fapl, hbool_t new_format) if (!driver_is_parallel) { /* VL test */ - if (test_random_rank4_vl(fapl, dcpl, do_fillvalue, disable_edge_filters, FALSE, index_type) < - 0) { + if (test_random_rank4_vl(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, FALSE, + index_type) < 0) { DO_RANKS_PRINT_CONFIG("Randomized rank 4 variable length") printf(" Index: %s\n", index_type == RANK4_INDEX_BTREE ? "btree" @@ -357,7 +379,8 @@ do_ranks(hid_t fapl, hbool_t new_format) /* Sparse allocation test (regular and VL) */ if (!(config & CONFIG_EARLY_ALLOC)) { - if (test_random_rank4(fapl, dcpl, do_fillvalue, disable_edge_filters, TRUE, index_type) < 0) { + if (test_random_rank4(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, TRUE, + index_type) < 0) { DO_RANKS_PRINT_CONFIG("Randomized rank 4 with sparse allocation") printf(" Index: %s\n", index_type == RANK4_INDEX_BTREE ? "btree" @@ -366,7 +389,7 @@ do_ranks(hid_t fapl, hbool_t new_format) } /* end if */ if (!driver_is_parallel) { - if (test_random_rank4_vl(fapl, dcpl, do_fillvalue, disable_edge_filters, TRUE, + if (test_random_rank4_vl(fapl, dcpl, dxpl, do_fillvalue, disable_edge_filters, TRUE, index_type) < 0) { DO_RANKS_PRINT_CONFIG("Randomized rank 4 variable length with sparse allocation") printf(" Index: %s\n", @@ -388,6 +411,10 @@ do_ranks(hid_t fapl, hbool_t new_format) TEST_ERROR; } /* end for */ + /* Close dxpl */ + if (H5Pclose(dxpl) < 0) + TEST_ERROR; + PASSED(); return 0; @@ -396,6 +423,7 @@ do_ranks(hid_t fapl, hbool_t new_format) H5E_BEGIN_TRY { H5Pclose(dcpl); + H5Pclose(dxpl); } H5E_END_TRY @@ -407,13 +435,26 @@ do_ranks(hid_t fapl, hbool_t new_format) *------------------------------------------------------------------------- */ static int -do_layouts(hid_t fapl) +do_layouts(hid_t fapl, hbool_t use_select_io) { hid_t new_fapl = -1; + hid_t dxpl = -1; H5F_libver_t low, high; /* Low and high bounds */ herr_t ret; /* Generic return value */ TESTING("storage layout use - tested with all low/high library format bounds"); + + if ((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) + TEST_ERROR; + + if (use_select_io) { + printf("\n With H5D_SELECTION_IO_MODE_ON "); + if (H5Pset_selection_io(dxpl, H5D_SELECTION_IO_MODE_ON) < 0) + TEST_ERROR; + } + else + printf("\n With H5D_SELECTION_IO_MODE_DEFAULT "); + /* Loop through all the combinations of low/high library format bounds */ for (low = H5F_LIBVER_EARLIEST; low < H5F_LIBVER_NBOUNDS; low++) { for (high = H5F_LIBVER_EARLIEST; high < H5F_LIBVER_NBOUNDS; high++) { @@ -435,10 +476,10 @@ do_layouts(hid_t fapl) continue; } - if (test_layouts(H5D_COMPACT, new_fapl) < 0) + if (test_layouts(H5D_COMPACT, new_fapl, dxpl) < 0) goto error; - if (test_layouts(H5D_CONTIGUOUS, new_fapl) < 0) + if (test_layouts(H5D_CONTIGUOUS, new_fapl, dxpl) < 0) goto error; if (H5Pclose(new_fapl) < 0) @@ -446,6 +487,9 @@ do_layouts(hid_t fapl) } /* end for high */ } /* end for low */ + if (H5Pclose(dxpl) < 0) + goto error; + PASSED(); return 0; @@ -454,6 +498,7 @@ do_layouts(hid_t fapl) H5E_BEGIN_TRY { H5Pclose(new_fapl); + H5Pclose(dxpl); } H5E_END_TRY return -1; @@ -465,7 +510,8 @@ do_layouts(hid_t fapl) */ static int -test_rank1(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_filters, hbool_t set_istore_k) +test_rank1(hid_t fapl, hid_t dcpl, hid_t dxpl, hbool_t do_fill_value, hbool_t disable_edge_filters, + hbool_t set_istore_k) { hid_t fid = -1; @@ -536,7 +582,7 @@ test_rank1(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f TEST_ERROR; /* write */ - if (H5Dwrite(did, H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) + if (H5Dwrite(did, H5T_NATIVE_INT, sid, H5S_ALL, dxpl, buf_o) < 0) TEST_ERROR; #if defined(H5_SET_EXTENT_DEBUG) @@ -575,7 +621,7 @@ test_rank1(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f TEST_ERROR; /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_e) < 0) TEST_ERROR; #if defined(H5_SET_EXTENT_DEBUG) @@ -644,7 +690,7 @@ test_rank1(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f */ /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_s) < 0) TEST_ERROR; #if defined(H5_SET_EXTENT_DEBUG) @@ -688,7 +734,7 @@ test_rank1(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f TEST_ERROR; /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_r) < 0) TEST_ERROR; #if defined(H5_SET_EXTENT_DEBUG) @@ -798,7 +844,8 @@ test_rank1(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f */ static int -test_rank2(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_filters, hbool_t set_istore_k) +test_rank2(hid_t fapl, hid_t dcpl, hid_t dxpl, hbool_t do_fill_value, hbool_t disable_edge_filters, + hbool_t set_istore_k) { hid_t fid = -1; @@ -891,7 +938,7 @@ test_rank2(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f } /* write */ - if (H5Dwrite(did, H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) { + if (H5Dwrite(did, H5T_NATIVE_INT, sid, H5S_ALL, dxpl, buf_o) < 0) { TEST_ERROR; } @@ -950,7 +997,7 @@ test_rank2(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f } /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_e) < 0) TEST_ERROR; #if defined(H5_SET_EXTENT_DEBUG2) @@ -1046,7 +1093,7 @@ test_rank2(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f */ /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s) < 0) { + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_s) < 0) { TEST_ERROR; } @@ -1114,7 +1161,7 @@ test_rank2(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f */ /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_r) < 0) TEST_ERROR; #if defined(H5_SET_EXTENT_DEBUG2) @@ -1292,7 +1339,8 @@ test_rank2(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f */ static int -test_rank3(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_filters, hbool_t set_istore_k) +test_rank3(hid_t fapl, hid_t dcpl, hid_t dxpl, hbool_t do_fill_value, hbool_t disable_edge_filters, + hbool_t set_istore_k) { hid_t fid = -1; @@ -1378,7 +1426,7 @@ test_rank3(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f } /* write */ - if (H5Dwrite(did, H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) { + if (H5Dwrite(did, H5T_NATIVE_INT, sid, H5S_ALL, dxpl, buf_o) < 0) { TEST_ERROR; } @@ -1432,7 +1480,7 @@ test_rank3(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f } /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_e) < 0) TEST_ERROR; #if defined(H5_SET_EXTENT_DEBUG3) @@ -1523,7 +1571,7 @@ test_rank3(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f */ /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s) < 0) { + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_s) < 0) { TEST_ERROR; } @@ -1585,7 +1633,7 @@ test_rank3(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f } /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_r) < 0) TEST_ERROR; #if defined(H5_SET_EXTENT_DEBUG3) @@ -1726,13 +1774,14 @@ test_rank3(hid_t fapl, hid_t dcpl, hbool_t do_fill_value, hbool_t disable_edge_f *------------------------------------------------------------------------- */ static int -test_external(hid_t fapl) +test_external(hid_t fapl, hbool_t use_select_io) { hid_t fid = -1; hid_t did = -1; hid_t sid = -1; hid_t dcpl = -1; + hid_t dxpl = -1; hsize_t dims_o[RANK2] = {DIM0, DIM1}; /* original dimensions */ hsize_t dims_s[RANK2] = {DIMS0, DIMS1}; /* shrinking dimensions */ hsize_t dims_e[RANK2] = {DIME0, DIM1}; /* extended dimensions, dimension 1 is the original */ @@ -1761,6 +1810,18 @@ test_external(hid_t fapl) TESTING("external file use"); + if ((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) + TEST_ERROR; + + if (use_select_io) { + printf("\n With H5D_SELECTION_IO_MODE_ON "); + if (H5Pset_selection_io(dxpl, H5D_SELECTION_IO_MODE_ON) < 0) + TEST_ERROR; + } + else { + printf("\n With H5D_SELECTION_IO_MODE_DEFAULT "); + } + /* create a new file */ h5_fixname(FILENAME[3], fapl, filename, sizeof filename); if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) @@ -1804,7 +1865,7 @@ test_external(hid_t fapl) FAIL_STACK_ERROR; if ((did = H5Dcreate2(fid, "dset1", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) FAIL_STACK_ERROR; - if (H5Dwrite(did, H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) + if (H5Dwrite(did, H5T_NATIVE_INT, sid, H5S_ALL, dxpl, buf_o) < 0) FAIL_STACK_ERROR; if (H5Sclose(sid) < 0) FAIL_STACK_ERROR; @@ -1815,7 +1876,7 @@ test_external(hid_t fapl) */ /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_ro) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_ro) < 0) FAIL_STACK_ERROR; #if defined(H5_SET_EXTENT_DEBUG) @@ -1870,7 +1931,7 @@ test_external(hid_t fapl) } /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_e) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_e) < 0) FAIL_STACK_ERROR; #if defined(H5_SET_EXTENT_DEBUG) @@ -1938,7 +1999,7 @@ test_external(hid_t fapl) */ /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_s) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_s) < 0) FAIL_STACK_ERROR; #if defined(H5_SET_EXTENT_DEBUG) @@ -2016,7 +2077,7 @@ test_external(hid_t fapl) *------------------------------------------------------------------------- */ static int -test_layouts(H5D_layout_t layout, hid_t fapl) +test_layouts(H5D_layout_t layout, hid_t fapl, hid_t dxpl) { hid_t fid = -1; @@ -2065,7 +2126,7 @@ test_layouts(H5D_layout_t layout, hid_t fapl) } /* write */ - if (H5Dwrite(did, H5T_NATIVE_INT, sid, H5S_ALL, H5P_DEFAULT, buf_o) < 0) { + if (H5Dwrite(did, H5T_NATIVE_INT, sid, H5S_ALL, dxpl, buf_o) < 0) { TEST_ERROR; } @@ -2119,7 +2180,7 @@ test_layouts(H5D_layout_t layout, hid_t fapl) } /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_r) < 0) TEST_ERROR; #if defined(H5_SET_EXTENT_DEBUG4) @@ -2173,7 +2234,7 @@ test_layouts(H5D_layout_t layout, hid_t fapl) */ /* read */ - if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf_r) < 0) { + if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, buf_r) < 0) { TEST_ERROR; } @@ -2232,7 +2293,7 @@ test_layouts(H5D_layout_t layout, hid_t fapl) *------------------------------------------------------------------------- */ static int -test_random_rank4(hid_t fapl, hid_t dcpl, hbool_t do_fillvalue, hbool_t disable_edge_filters, +test_random_rank4(hid_t fapl, hid_t dcpl, hid_t dxpl, hbool_t do_fillvalue, hbool_t disable_edge_filters, hbool_t do_sparse, rank4_index_t index_type) { hid_t file = -1; @@ -2332,7 +2393,7 @@ test_random_rank4(hid_t fapl, hid_t dcpl, hbool_t do_fillvalue, hbool_t disable_ wbuf->arr[j][k][l][m] = HDrandom(); /* Write data */ - if (H5Dwrite(dset, H5T_NATIVE_INT, mspace, H5S_ALL, H5P_DEFAULT, wbuf) < 0) + if (H5Dwrite(dset, H5T_NATIVE_INT, mspace, H5S_ALL, dxpl, wbuf) < 0) RAND4_FAIL_DUMP(i + 1, -1, -1, -1, -1) } /* end if */ @@ -2361,7 +2422,7 @@ test_random_rank4(hid_t fapl, hid_t dcpl, hbool_t do_fillvalue, hbool_t disable_ /* Read data from resized dataset */ if (H5Sselect_hyperslab(mspace, H5S_SELECT_SET, start, NULL, dims, NULL) < 0) RAND4_FAIL_DUMP(i + 2, -1, -1, -1, -1) - if (H5Dread(dset, H5T_NATIVE_INT, mspace, H5S_ALL, H5P_DEFAULT, rbuf) < 0) + if (H5Dread(dset, H5T_NATIVE_INT, mspace, H5S_ALL, dxpl, rbuf) < 0) RAND4_FAIL_DUMP(i + 2, -1, -1, -1, -1) /* Verify correctness of read data */ @@ -2449,7 +2510,7 @@ test_random_rank4(hid_t fapl, hid_t dcpl, hbool_t do_fillvalue, hbool_t disable_ *------------------------------------------------------------------------- */ static int -test_random_rank4_vl(hid_t fapl, hid_t dcpl, hbool_t do_fillvalue, hbool_t disable_edge_filters, +test_random_rank4_vl(hid_t fapl, hid_t dcpl, hid_t dxpl, hbool_t do_fillvalue, hbool_t disable_edge_filters, hbool_t do_sparse, rank4_index_t index_type) { hid_t file = -1; @@ -2594,7 +2655,7 @@ test_random_rank4_vl(hid_t fapl, hid_t dcpl, hbool_t do_fillvalue, hbool_t disab } /* end for */ /* Write data */ - if (H5Dwrite(dset, type, mspace, H5S_ALL, H5P_DEFAULT, wbuf) < 0) + if (H5Dwrite(dset, type, mspace, H5S_ALL, dxpl, wbuf) < 0) RAND4_FAIL_DUMP(i + 1, -1, -1, -1, -1) } /* end if */ @@ -2623,7 +2684,7 @@ test_random_rank4_vl(hid_t fapl, hid_t dcpl, hbool_t do_fillvalue, hbool_t disab /* Read data from resized dataset */ if (H5Sselect_hyperslab(mspace, H5S_SELECT_SET, start, NULL, dims, NULL) < 0) RAND4_FAIL_DUMP(i + 2, -1, -1, -1, -1) - if (H5Dread(dset, type, mspace, H5S_ALL, H5P_DEFAULT, rbuf) < 0) + if (H5Dread(dset, type, mspace, H5S_ALL, dxpl, rbuf) < 0) RAND4_FAIL_DUMP(i + 2, -1, -1, -1, -1) /* Verify correctness of read data */ diff --git a/testpar/t_coll_chunk.c b/testpar/t_coll_chunk.c index fd7798823ab..1ff7a8e2c15 100644 --- a/testpar/t_coll_chunk.c +++ b/testpar/t_coll_chunk.c @@ -782,7 +782,7 @@ coll_chunktest(const char *filename, int chunk_factor, int select_factor, int ap status = H5Pget_selection_io(xfer_plist, &selection_io_mode); VRFY((status >= 0), "testing property list get succeeded"); - if (facc_type == FACC_MPIO && (selection_io_mode != H5D_SELECTION_IO_MODE_ON)) { + if (facc_type == FACC_MPIO && (selection_io_mode == H5D_SELECTION_IO_MODE_OFF)) { switch (api_option) { case API_LINK_HARD: status = H5Pget(xfer_plist, H5D_XFER_COLL_CHUNK_LINK_HARD_NAME, &prop_value); diff --git a/testpar/t_dset.c b/testpar/t_dset.c index e401cd56cb8..b75b6aefa97 100644 --- a/testpar/t_dset.c +++ b/testpar/t_dset.c @@ -3356,7 +3356,7 @@ actual_io_mode_tests(void) ret = H5Pclose(dxpl_id); VRFY((ret >= 0), "H5Pclose succeeded"); - if (selection_io_mode != H5D_SELECTION_IO_MODE_ON) { + if (selection_io_mode == H5D_SELECTION_IO_MODE_OFF) { test_actual_io_mode(TEST_ACTUAL_IO_NO_COLLECTIVE); /* diff --git a/testpar/t_file.c b/testpar/t_file.c index b743936de13..314a60c74cb 100644 --- a/testpar/t_file.c +++ b/testpar/t_file.c @@ -950,13 +950,13 @@ test_file_properties(void) void test_delete(void) { - hid_t fid = H5I_INVALID_HID; /* HDF5 file ID */ - hid_t fapl_id = H5I_INVALID_HID; /* File access plist */ - const char *filename = NULL; - MPI_Comm comm = MPI_COMM_WORLD; - MPI_Info info = MPI_INFO_NULL; - htri_t is_hdf5 = FAIL; /* Whether a file is an HDF5 file */ - herr_t ret; /* Generic return value */ + hid_t fid = H5I_INVALID_HID; /* HDF5 file ID */ + hid_t fapl_id = H5I_INVALID_HID; /* File access plist */ + const char *filename = NULL; + MPI_Comm comm = MPI_COMM_WORLD; + MPI_Info info = MPI_INFO_NULL; + htri_t is_accessible = FAIL; /* Whether a file is accessible */ + herr_t ret; /* Generic return value */ filename = (const char *)GetTestParameters(); @@ -979,21 +979,30 @@ test_delete(void) VRFY((SUCCEED == ret), "H5Fclose"); /* Verify that the file is an HDF5 file */ - is_hdf5 = H5Fis_accessible(filename, fapl_id); - VRFY((TRUE == is_hdf5), "H5Fis_accessible"); + is_accessible = H5Fis_accessible(filename, fapl_id); + VRFY((TRUE == is_accessible), "H5Fis_accessible"); /* Delete the file */ ret = H5Fdelete(filename, fapl_id); VRFY((SUCCEED == ret), "H5Fdelete"); + /* + * Work around a Cray MPICH bug that causes + * H5Fis_accessible to re-create the just-deleted + * file as a 0-byte file with strange Unix + * permissions, causing the routine to return + * false here instead of FAIL. + */ + H5Pset_fapl_mpio(fapl_id, comm, info); + /* Verify that the file is NO LONGER an HDF5 file */ /* This should fail since there is no file */ H5E_BEGIN_TRY { - is_hdf5 = H5Fis_accessible(filename, fapl_id); + is_accessible = H5Fis_accessible(filename, fapl_id); } H5E_END_TRY - VRFY((is_hdf5 != SUCCEED), "H5Fis_accessible"); + VRFY((FAIL == is_accessible), "H5Fis_accessible failed as expected"); /* Release file-access plist */ ret = H5Pclose(fapl_id); diff --git a/testpar/t_select_io_dset.c b/testpar/t_select_io_dset.c index eb64bfe8cfe..daeacf01270 100644 --- a/testpar/t_select_io_dset.c +++ b/testpar/t_select_io_dset.c @@ -128,6 +128,11 @@ typedef enum { #define TEST_TCONV_BUF_TOO_SMALL 0x008 #define TEST_IN_PLACE_TCONV 0x010 +/* Definitions used by test_bug_optimized_bufs() and test_bug_api_library() */ +#define DIMS 10000 +#define BIG_X_FACTOR 1048576 +#define BIG_Y_FACTOR 32 + /* * Helper routine to set dxpl * --selection I/O mode @@ -2960,6 +2965,8 @@ test_multi_dsets_all(int niter, hid_t fid, unsigned chunked, unsigned mwbuf) const void *wbufs[MULTI_NUM_DSETS]; void *rbufs[MULTI_NUM_DSETS]; + curr_nerrors = nerrors; + /* for n niter to ensure that all randomized dset_types with multi_dset_type_t will be covered */ for (n = 0; n < niter; n++) { @@ -3434,6 +3441,19 @@ test_no_selection_io_cause_mode(const char *filename, hid_t fapl, uint32_t test_ /* Datatype conversion */ if (test_mode & TEST_DATATYPE_CONVERSION) { + + /* With one exception, all will land at H5FD__mpio_read/write_selection(). + * As the xfer mode is H5FD_MPIO_INDEPENDENT, this will call + * H5FD__read/write_from_selection() triggering H5D_SEL_IO_NO_VECTOR_OR_SELECTION_IO_CB. + */ + no_selection_io_cause_read_expected |= H5D_SEL_IO_NO_VECTOR_OR_SELECTION_IO_CB; + + /* Exception case: This will turn off selection I/O landing at H5FD__mpio_write() */ + if ((test_mode & TEST_TCONV_BUF_TOO_SMALL) && !(test_mode & TEST_IN_PLACE_TCONV)) + no_selection_io_cause_write_expected |= H5D_SEL_IO_TCONV_BUF_TOO_SMALL; + else + no_selection_io_cause_write_expected |= H5D_SEL_IO_NO_VECTOR_OR_SELECTION_IO_CB; + if (H5Pset_selection_io(dxpl, H5D_SELECTION_IO_MODE_ON) < 0) P_TEST_ERROR; tid = H5T_NATIVE_UINT; @@ -3443,18 +3463,12 @@ test_no_selection_io_cause_mode(const char *filename, hid_t fapl, uint32_t test_ if (H5Pset_buffer(dxpl, sizeof(int), NULL, NULL) < 0) P_TEST_ERROR; - /* If we're using in-place type conversion sel io will succeed */ if (test_mode & TEST_IN_PLACE_TCONV) { if (H5Pset_modify_write_buf(dxpl, TRUE) < 0) P_TEST_ERROR; } - else - no_selection_io_cause_write_expected |= H5D_SEL_IO_TCONV_BUF_TOO_SMALL; - /* In-place type conversion for read doesn't require modify_write_buf */ } - - /* If the tconv buf is largge enough sel io will succeed */ } /* Create 1d data space */ @@ -3521,6 +3535,31 @@ test_no_selection_io_cause_mode(const char *filename, hid_t fapl, uint32_t test_ static void test_get_no_selection_io_cause(const char *filename, hid_t fapl) { + hid_t dxpl = H5I_INVALID_HID; + H5D_selection_io_mode_t selection_io_mode; + + if (MAINPROCESS) { + printf("\n"); + TESTING("for H5Pget_no_selection_io_cause()"); + } + + curr_nerrors = nerrors; + + if ((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) + P_TEST_ERROR; + if (H5Pget_selection_io(dxpl, &selection_io_mode) < 0) + P_TEST_ERROR; + if (H5Pclose(dxpl) < 0) + P_TEST_ERROR; + + /* The following tests are based on H5D_SELECTION_IO_MODE_DEFAULT as the + * default setting in the library; skip the tests if that is not true */ + if (selection_io_mode != H5D_SELECTION_IO_MODE_DEFAULT) { + if (MAINPROCESS) + SKIPPED(); + return; + } + test_no_selection_io_cause_mode(filename, fapl, TEST_DISABLE_BY_API); test_no_selection_io_cause_mode(filename, fapl, TEST_NOT_CONTIGUOUS_OR_CHUNKED_DATASET); test_no_selection_io_cause_mode(filename, fapl, TEST_DATATYPE_CONVERSION); @@ -3533,6 +3572,366 @@ test_get_no_selection_io_cause(const char *filename, hid_t fapl) return; } /* test_get_no_selection_io_cause() */ +/* + * This bug is exposed when running testpar/t_coll_md.c via testphdf5. + * + * Optimized bufs (bufs[1] is NULL) is used when passing as a parameter to the mpio driver + * for selection I/O. When computing mpi_bufs_base in that routine, it is not accounted + * for and therefore causing segmentation fault when running the test. + * + * Fix: + * Check for optimized bufs when computing mpi_bufs_base. + */ +static void +test_bug_optimized_bufs(const char *filename, hid_t fapl) +{ + hid_t dxpl = H5I_INVALID_HID; + hid_t dcpl = H5I_INVALID_HID; + hid_t fid = H5I_INVALID_HID; + hid_t did = H5I_INVALID_HID; + hid_t fspace_id = H5I_INVALID_HID; + hid_t mspace_id = H5I_INVALID_HID; + hsize_t dims[1]; + hsize_t cdims[1]; + hsize_t start[1]; + hsize_t stride[1]; + hsize_t count[1]; + hsize_t block[1]; + int *wbuf; + + if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) + P_TEST_ERROR; + + if ((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) + P_TEST_ERROR; + + dims[0] = (hsize_t)mpi_size * (hsize_t)DIMS; + + fspace_id = H5Screate_simple(1, dims, NULL); + + cdims[0] = (hsize_t)mpi_size; + + if (H5Pset_chunk(dcpl, 1, cdims) < 0) + P_TEST_ERROR; + + if ((did = H5Dcreate2(fid, "bug_optimized_bufs", H5T_NATIVE_INT, fspace_id, H5P_DEFAULT, dcpl, + H5P_DEFAULT)) < 0) + P_TEST_ERROR; + + start[0] = (hsize_t)mpi_rank; + stride[0] = (hsize_t)mpi_size; + count[0] = DIMS; + block[0] = 1; + + if (H5Sselect_hyperslab(fspace_id, H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + if ((mspace_id = H5Screate_simple(1, count, NULL)) < 0) + P_TEST_ERROR; + + if ((wbuf = calloc(1, count[0] * sizeof(int))) == NULL) + P_TEST_ERROR; + + if ((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) + P_TEST_ERROR; + + /* Enable collection transfer mode */ + if (H5Pset_dxpl_mpio(dxpl, H5FD_MPIO_COLLECTIVE) < 0) + P_TEST_ERROR; + + /* Enable selection I/O */ + if (H5Pset_selection_io(dxpl, H5D_SELECTION_IO_MODE_ON) < 0) + P_TEST_ERROR; + + if (H5Dwrite(did, H5T_NATIVE_INT, mspace_id, fspace_id, dxpl, wbuf) < 0) + P_TEST_ERROR; + + if (H5Dclose(did) < 0) + P_TEST_ERROR; + + if (H5Pclose(dcpl) < 0) + P_TEST_ERROR; + + if (H5Pclose(dxpl) < 0) + P_TEST_ERROR; + + if (H5Sclose(fspace_id) < 0) + P_TEST_ERROR; + + if (H5Sclose(mspace_id) < 0) + P_TEST_ERROR; + + if (H5Fclose(fid) < 0) + P_TEST_ERROR; + + return; + +} /* test_bug_optimized_bufs() */ + +/* + * The bug is exposed when running testpar/t_pread.c. + * + * The file is created with userblock. Before passing down to the mpio driver for + * selection I/O, the parameter offsets[] is added by base_addr (size of the uesrblock). + * For the independent case in the mpio driver for selection I/O, + * the intermediate routine for the API H5FDread/write_vector_from_selection() is called. + * The parameter offsets[] is passed as is to the intermediate routine which will + * be added again by base_addr causing incorrect data retrieval. + * + * Fix: + * The parameter offsets[] needs to be adjusted by the base_addr addition before calling + * the intermediate routine. + */ +static void +test_bug_base_addr(const char *filename, hid_t fapl) +{ + hid_t dxpl = H5I_INVALID_HID; + hid_t dxpl_read = H5I_INVALID_HID; + hid_t fid = H5I_INVALID_HID; + hid_t did = H5I_INVALID_HID; + hid_t sid = H5I_INVALID_HID; + hid_t fcpl = H5I_INVALID_HID; + hsize_t dims[1]; + hid_t tid = H5T_NATIVE_INT; + int wbuf[DSET_SELECT_DIM]; + int rbuf[DSET_SELECT_DIM]; + int i; + + /* Create user block */ + if ((fcpl = H5Pcreate(H5P_FILE_CREATE)) < 0) + P_TEST_ERROR; + + if (H5Pset_userblock(fcpl, 512) < 0) + P_TEST_ERROR; + + if ((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) + P_TEST_ERROR; + + /* Create the file with userblock */ + if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl, fapl)) < 0) + P_TEST_ERROR; + + /* Create 1d data space */ + dims[0] = DSET_SELECT_DIM; + + if ((sid = H5Screate_simple(1, dims, NULL)) < 0) + P_TEST_ERROR; + + if ((did = H5Dcreate2(fid, "bug_base_addr", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < + 0) + P_TEST_ERROR; + + /* Initialize data */ + for (i = 0; i < DSET_SELECT_DIM; i++) + wbuf[i] = i; + + if ((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) + P_TEST_ERROR; + + /* Enable selection I/O */ + if (H5Pset_selection_io(dxpl, H5D_SELECTION_IO_MODE_ON) < 0) + P_TEST_ERROR; + + /* Independent by default and with selection I/O ON for reading */ + if ((dxpl_read = H5Pcopy(dxpl)) < 0) + P_TEST_ERROR; + + /* Enable collective and with selection I/O ON for writing */ + if (H5Pset_dxpl_mpio(dxpl, H5FD_MPIO_COLLECTIVE) < 0) + P_TEST_ERROR; + + if (H5Dwrite(did, tid, H5S_ALL, H5S_ALL, dxpl, wbuf) < 0) + P_TEST_ERROR; + + if (H5Dread(did, tid, H5S_ALL, H5S_ALL, dxpl_read, rbuf) < 0) + P_TEST_ERROR; + + if (H5Dclose(did) < 0) + P_TEST_ERROR; + + if (H5Pclose(dxpl) < 0) + P_TEST_ERROR; + + if (H5Pclose(dxpl_read) < 0) + P_TEST_ERROR; + + if (H5Sclose(sid) < 0) + P_TEST_ERROR; + + if (H5Pclose(fcpl) < 0) + P_TEST_ERROR; + + if (H5Fclose(fid) < 0) + P_TEST_ERROR; + return; + +} /* test_bug_base_addr() */ + +/* + * This bug is exposed when running testpar/t_2Gio.c with at least 2 processes. + * + * The root problem is from calling an API function from within the library i.e. + * calling H5FDread/write_vector_from_selection() for independent access in the + * mpio driver for selection I/O. + * + * The test scenario is described below with the test writing to a dataset + * via H5Dwrite(): + * --running with 2 processes + * --with selection I/O on + * --with COLLECTIVE xfer mode + * + * For process 1: + * The library internal calls H5D__write(): + * --io_info.use_select_io is ON + * --io_info.use_select_io is OFF after calling H5D__typeinfo_init_phase2() + * due to H5D_SEL_IO_TCONV_BUF_TOO_SMALL + * --H5D__mpio_opt_possible() returns 0 so xfer mode is set to + * H5FD_MPIO_INDEPENDENT + * The library eventually calls H5FD__mpio_write() performing scalar calls for the writes + * + * For process 0: + * The library internal calls H5D__write(): + * --io_info.use_select_io is ON + * --H5D__mpio_opt_possible() returns 0 so xfer mode is set to + * H5FD_MPIO_INDEPENDENT + * The library eventually calls H5FD__mpio_write_selection(): + * --since the xfer mode is INDEPENDENT it calls the API + * H5FDwrite_vector_from_selection(), which eventually calls + * H5FD__mpio_write_vector(). This routine obtains the + * xfer mode via API context which returns COLLECTIVE. + * Then the test hangs when trying to do MPI_File_set_view(). + * + * Fix: + * Create wrapper functions for the API H5FDread/write_vector_from_selection() and + * they will be called by H5FD__mpio_read/write_selection() for independent access. + * + */ +static void +test_bug_api_library(const char *filename, hid_t fapl) +{ + hid_t dxpl = H5I_INVALID_HID; + hid_t fid = H5I_INVALID_HID; + hid_t did = H5I_INVALID_HID; + hid_t sid = H5I_INVALID_HID; + hid_t fspace_id = H5I_INVALID_HID; + hid_t mspace_id = H5I_INVALID_HID; + hsize_t dims[2]; + hsize_t start[2]; + hsize_t stride[2]; + hsize_t count[2]; + hsize_t block[2]; + int *wbuf; + hsize_t i, j; + + if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) + P_TEST_ERROR; + + dims[0] = (hsize_t)BIG_X_FACTOR; + dims[1] = (hsize_t)BIG_Y_FACTOR; + + if ((sid = H5Screate_simple(2, dims, NULL)) < 0) + P_TEST_ERROR; + + if ((did = H5Dcreate2(fid, "bug_coll_to_ind", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, + H5P_DEFAULT)) < 0) + P_TEST_ERROR; + + if ((wbuf = malloc((size_t)dims[0] * (size_t)dims[1] * sizeof(int))) == NULL) + P_TEST_ERROR; + + /* Each process takes a slabs of rows. */ + block[0] = (hsize_t)dims[0] / (hsize_t)mpi_size; + block[1] = (hsize_t)dims[1]; + stride[0] = block[0]; + stride[1] = block[1]; + count[0] = 1; + count[1] = 1; + start[0] = (hsize_t)mpi_rank * block[0]; + start[1] = 0; + + if ((fspace_id = H5Dget_space(did)) < 0) + P_TEST_ERROR; + if (MAINPROCESS) { + if (H5Sselect_none(fspace_id) < 0) + P_TEST_ERROR; + } /* end if */ + else { + if (H5Sselect_hyperslab(fspace_id, H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + } /* end else */ + + if ((mspace_id = H5Screate_simple(2, block, NULL)) < 0) + P_TEST_ERROR; + if (MAINPROCESS) { + if (H5Sselect_none(mspace_id) < 0) + P_TEST_ERROR; + } /* end if */ + + if ((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) + P_TEST_ERROR; + + /* Enable collective transfer */ + if (H5Pset_dxpl_mpio(dxpl, H5FD_MPIO_COLLECTIVE) < 0) + P_TEST_ERROR; + + /* Enable selection I/O */ + if (H5Pset_selection_io(dxpl, H5D_SELECTION_IO_MODE_ON) < 0) + P_TEST_ERROR; + + /* Put some trivial data in wbuf */ + for (i = 0; i < block[0]; i++) { + for (j = 0; j < block[1]; j++) { + *wbuf = (int)((i + start[0]) * 100 + (j + start[1] + 1)); + wbuf++; + } + } + + /* With datatype conversion */ + if (H5Dwrite(did, H5T_NATIVE_UCHAR, mspace_id, fspace_id, dxpl, wbuf) < 0) + P_TEST_ERROR; + + if (H5Dclose(did) < 0) + P_TEST_ERROR; + + if (H5Pclose(dxpl) < 0) + P_TEST_ERROR; + + if (H5Sclose(fspace_id) < 0) + P_TEST_ERROR; + + if (H5Sclose(mspace_id) < 0) + P_TEST_ERROR; + + if (H5Fclose(fid) < 0) + P_TEST_ERROR; + + return; + +} /* test_bug_api_library() */ + +/* + * Verify bugs exposed when H5D_SELECTION_IO_MODE_ON is set as the + * default in the library. + */ +static void +test_bugs_select_on(const char *filename, hid_t fapl) +{ + if (MAINPROCESS) { + printf("\n"); + TESTING("to verify bugs exposed when H5D_SELECTION_IO_MODE_ON is set as library default"); + } + + curr_nerrors = nerrors; + + test_bug_optimized_bufs(filename, fapl); + test_bug_base_addr(filename, fapl); + test_bug_api_library(filename, fapl); + + CHECK_PASSED(); + return; + +} /* test_bugs_select_on() */ + /*------------------------------------------------------------------------- * Function: main * @@ -3740,12 +4139,10 @@ main(int argc, char *argv[]) if (H5Fclose(fid) < 0) P_TEST_ERROR; - if (MAINPROCESS) { - printf("\n"); - TESTING("Testing for H5Pget_no_selection_io_cause()"); - } test_get_no_selection_io_cause(FILENAME, fapl); + test_bugs_select_on(FILENAME, fapl); + /* Barrier to make sure all ranks are done before deleting the file, and * also to clean up output (make sure PASSED is printed before any of the * following messages) */ diff --git a/testpar/t_vfd.c b/testpar/t_vfd.c index 827faf4cd31..5e9070d651e 100644 --- a/testpar/t_vfd.c +++ b/testpar/t_vfd.c @@ -100,6 +100,100 @@ static unsigned vector_write_test_6(int file_name_id, int mpi_rank, int mpi_size H5FD_mpio_collective_opt_t coll_opt_mode, const char *vfd_name); static unsigned vector_write_test_7(int file_name_id, int mpi_rank, int mpi_size, H5FD_mpio_xfer_t xfer_mode, H5FD_mpio_collective_opt_t coll_opt_mode, const char *vfd_name); +/* + * Tests for selection I/O: + * They are derived from test_selection_io() in test/vfd.c and modified for parallel testing. + */ + +/* + * Global declarations for selection I/O tests` + */ + +/* Number of errors */ +int nerrors = 0; +int curr_nerrors = 0; + +/* Test file name */ +#define SELECT_FNAME "mpio_select_test_file" + +/* Dimemsion sizes */ +#define SEL_IO_DIM0 4 +#define SEL_IO_DIM1 8 +int sel_dim0 = SEL_IO_DIM0; +int sel_dim1 = SEL_IO_DIM1; + +/* Write buffers */ +int *wbuf1 = NULL; +int *wbuf2 = NULL; +int *wbufs[2] = {NULL, NULL}; + +/* File buffers */ +int *fbuf1 = NULL; +int *fbuf2 = NULL; +int *fbufs[2] = {NULL, NULL}; /* Array of file buffers */ + +/* Expected read buffers */ +int *erbuf1 = NULL; +int *erbuf2 = NULL; +int *erbufs[2] = {NULL, NULL}; /* Array of expected read buffers */ + +/* iotypes for testing: + H5FD_MPIO_INDEPENDENT + H5FD_MPIO_COLLECTIVE + --H5FD_MPIO_COLLECTIVE_IO + --H5FD_MPIO_INDIVIDUAL_IO +*/ +#define iotypes 3 + +#define P_TEST_ERROR \ + do { \ + nerrors++; \ + H5_FAILED(); \ + AT(); \ + } while (0) + +#define CHECK_PASSED() \ + do { \ + int err_result = (nerrors > curr_nerrors); \ + \ + MPI_Allreduce(MPI_IN_PLACE, &err_result, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD); \ + \ + if (MAINPROCESS) { \ + if (err_result == 0) \ + PASSED(); \ + else \ + HDputs(" ***TEST FAILED***"); \ + } \ + } while (0) + +/* Utility functions for selection I/O */ +static herr_t test_selection_io_read_verify(hid_t dxpl, int mpi_rank, hsize_t start[], hsize_t block[], + H5FD_t *lf, H5FD_mem_t type, uint32_t count, hid_t mem_spaces[], + hid_t file_spaces[], haddr_t offsets[], size_t element_sizes[], + uint32_t rbufcount, int *erb[], hbool_t shorten_rbufs); + +static herr_t test_selection_io_write(hid_t dxpl, H5FD_t *lf, H5FD_mem_t type, uint32_t count, + hid_t mem_spaces[], hid_t file_spaces[], haddr_t offsets[], + size_t element_sizes[], int *wb[]); + +/* Test functions for selection I/O */ +static void test_selection_io(int mpi_rank, int mpi_size); +static void test_selection_io_real(int mpi_rank, int mpi_size, H5FD_t *lf, hid_t dxpl); +static void test_selection_io_types_1d(int mpi_rank, int mpi_size, H5FD_t *lf, hid_t dxpl, H5FD_mem_t type, + haddr_t addrs[], size_t element_sizes[], hid_t mem_spaces[], + hid_t file_spaces[], hsize_t dims1[]); +static void test_selection_io_types_2d(int mpi_rank, int mpi_size, H5FD_t *lf, hid_t dxpl, H5FD_mem_t type, + haddr_t addrs[], size_t element_sizes[], hid_t mem_spaces[], + hid_t file_spaces[], hsize_t dims2[]); +static void test_selection_io_types_1d_2d(int mpi_rank, int mpi_size, H5FD_t *lf, hid_t dxpl, H5FD_mem_t type, + haddr_t addrs[], size_t element_sizes[], hid_t mem_spaces[], + hid_t file_spaces[], hsize_t dims1[], hsize_t dims2[]); +static void test_selection_io_types_shorten(int mpi_rank, int mpi_size, H5FD_t *lf, hid_t dxpl, + H5FD_mem_t type, haddr_t addrs[], size_t element_sizes[], + hid_t mem_spaces[], hid_t file_spaces[], hsize_t dims1[], + hsize_t dims2[]); + +/****************************************************************************/ /****************************************************************************/ /***************************** Utility Functions ****************************/ @@ -4065,86 +4159,22 @@ vector_write_test_7(int file_name_id, int mpi_rank, int mpi_size, H5FD_mpio_xfer } /* vector_write_test_7() */ -/*------------------------------------------------------------------------- - * Function: main - * - * Purpose: Run parallel VFD tests. - * - * Return: Success: 0 - * - * Failure: 1 - * - *------------------------------------------------------------------------- - */ - -int -main(int argc, char **argv) +static void +test_vector_io(int mpi_rank, int mpi_size) { unsigned nerrs = 0; -#ifdef H5_HAVE_SUBFILING_VFD - int required = MPI_THREAD_MULTIPLE; - int provided = 0; -#endif - int mpi_size; - int mpi_rank = 0; - -#ifdef H5_HAVE_SUBFILING_VFD - if (MPI_SUCCESS != MPI_Init_thread(&argc, &argv, required, &provided)) { - printf(" MPI doesn't support MPI_Init_thread with MPI_THREAD_MULTIPLE. Exiting\n"); - goto finish; - } - - if (provided != required) { - printf(" MPI doesn't support MPI_Init_thread with MPI_THREAD_MULTIPLE. Exiting\n"); - goto finish; - } -#else - if (MPI_SUCCESS != MPI_Init(&argc, &argv)) { - printf(" MPI_Init failed. Exiting\n"); - goto finish; - } -#endif - - MPI_Comm_size(comm, &mpi_size); - MPI_Comm_rank(comm, &mpi_rank); - /* Attempt to turn off atexit post processing so that in case errors - * occur during the test and the process is aborted, it will not hang - * in the atexit post processing. If it does, it may try to make MPI - * calls which may not work. - */ - if (H5dont_atexit() < 0) - printf("%d:Failed to turn off atexit processing. Continue.\n", mpi_rank); - - H5open(); - - if (mpi_rank == 0) { - printf("=========================================\n"); - printf("Parallel virtual file driver (VFD) tests\n"); - printf(" mpi_size = %d\n", mpi_size); - printf("=========================================\n"); - } - - if (mpi_size < 2) { - if (mpi_rank == 0) - printf(" Need at least 2 processes. Exiting.\n"); - goto finish; - } - - alloc_and_init_file_images(mpi_size); + nerrs += alloc_and_init_file_images(mpi_size); if (!pass) { printf("\nAllocation and initialize of file image buffers failed. Test aborted.\n"); + nerrors += (int)nerrs; + return; } MPI_Barrier(comm); - if (mpi_rank == 0) { - - printf("\n\n --- TESTING MPIO VFD --- \n\n"); - } - nerrs += vector_read_test_1(0, mpi_rank, mpi_size, H5FD_MPIO_INDEPENDENT, H5FD_MPIO_INDIVIDUAL_IO, "mpio"); nerrs += vector_read_test_1(0, mpi_rank, mpi_size, H5FD_MPIO_COLLECTIVE, H5FD_MPIO_INDIVIDUAL_IO, "mpio"); @@ -4312,18 +4342,1643 @@ main(int argc, char **argv) H5FD_SUBFILING_NAME); #endif + nerrors += (int)nerrs; + + /* return(nerrs);*/ + +} /* test_vector_io() */ + +/* + * Utility routine to perform the actual selection I/O read + */ +static herr_t +test_selection_io_read_verify(hid_t dxpl, int mpi_rank, hsize_t start[], hsize_t block[], H5FD_t *lf, + H5FD_mem_t type, uint32_t count, hid_t mem_spaces[], hid_t file_spaces[], + haddr_t offsets[], size_t element_sizes[], uint32_t rbufcount, int *erb[], + hbool_t shorten_rbufs) +{ + int *rbuf1 = NULL; + int *rbuf2 = NULL; + int *rbufs[2] = {NULL, NULL}; + size_t bufsize; + int i; + int j; + + bufsize = (hsize_t)(sel_dim0 * sel_dim1) * sizeof(int); + if ((rbuf1 = malloc(bufsize)) == NULL) + goto error; + if ((rbuf2 = malloc(bufsize)) == NULL) + goto error; + rbufs[0] = rbuf1; + rbufs[1] = rbuf2; + + /* Initialize read buffer */ + for (i = 0; i < (int)rbufcount; i++) + for (j = 0; j < sel_dim0 * sel_dim1; j++) + rbufs[i][j] = -1; + + /* Handle elements in count that are not part of rbufcount */ + for (i = (int)rbufcount; i < (int)count; i++) + if (shorten_rbufs) + rbufs[i] = NULL; + else + rbufs[i] = rbufs[rbufcount - 1]; + + /* Issue read call */ + if (H5FDread_selection(lf, type, dxpl, count, mem_spaces, file_spaces, offsets, element_sizes, + (void **)rbufs) < 0) + goto error; + + /* Verify result */ + for (i = 0; i < (int)rbufcount; i++) { + hsize_t endblock = MIN((start[i] + block[i]), (hsize_t)(sel_dim0 * sel_dim1)); + for (j = (int)start[i]; j < (int)endblock; j++) + if (rbufs[i][j] != erb[i][j]) { + H5_FAILED(); + AT(); + printf( + "data read from file does not match expected values at mapping array location %d: %d\n", + i, mpi_rank); + printf("expected data: \n"); + for (j = 0; j < sel_dim0 * sel_dim1; j++) { + printf("%6d", erb[i][j]); + if (!((j + 1) % sel_dim1)) + printf("\n"); + } + printf("read data: \n"); + for (j = 0; j < (sel_dim0 * sel_dim1); j++) { + printf("%6d", rbufs[i][j]); + if (!((j + 1) % sel_dim1)) + printf("\n"); + } + goto error; + } + } + + if (rbuf1) + free(rbuf1); + if (rbuf2) + free(rbuf2); + return 0; + +error: + if (rbuf1) + free(rbuf1); + if (rbuf2) + free(rbuf2); + return -1; + +} /* end test_selection_io_read_verify() */ + +/* + * Utility routine to perform the actual selection I/O write + */ +static herr_t +test_selection_io_write(hid_t dxpl, H5FD_t *lf, H5FD_mem_t type, uint32_t count, hid_t mem_spaces[], + hid_t file_spaces[], haddr_t offsets[], size_t element_sizes[], int *wb[]) +{ + const void **bufs = NULL; /* Avoids cast/const warnings */ + int i; + int j; + + if (NULL == (bufs = calloc(count, sizeof(void *)))) + goto error; + + /* Update write buffer */ + for (i = 0; i < (int)count; i++) { + if (wb[i] && (i == 0 || wb[i] != wb[i - 1])) + for (j = 0; j < (sel_dim0 * sel_dim1); j++) + wb[i][j] += 2 * (sel_dim0 * sel_dim1); + bufs[i] = wb[i]; + } + + /* Issue write call */ + if (H5FDwrite_selection(lf, type, dxpl, count, mem_spaces, file_spaces, offsets, element_sizes, bufs) < 0) + goto error; + + if (bufs) + free(bufs); + + return 0; + +error: + if (bufs) + free(bufs); + return -1; + +} /* end test_selection_io_write() */ + +/* + * Perform the following tests that use shortened arrays for wbuf and element sizes + * --Test 1: Strided <> Strided 1D and 2D I/O for both file and memory spaces + * --Reset selections + * --Test 2: Strided <> Strided 2D I/O, 2 different selections in the same memory buffer + * --Reset selections + */ +static void +test_selection_io_types_shorten(int mpi_rank, int mpi_size, H5FD_t *lf, hid_t dxpl, H5FD_mem_t type, + haddr_t addrs[], size_t element_sizes[], hid_t mem_spaces[], + hid_t file_spaces[], hsize_t dims1[], hsize_t dims2[]) +{ + hsize_t start[2]; /* start for hyperslab */ + hsize_t stride[2]; /* stride for hyperslab */ + hsize_t count[2]; /* count for hyperslab */ + hsize_t block[2]; /* block for hyperslab */ + hsize_t verify_start[2] = {0, 0}; /* Starting block for verified data */ + hsize_t verify_block[2] = {0, 0}; /* Block size for verified data */ + int i; + int j; + int i2; + int j2; + + int shorten_element_sizes; /* Whether to shorten the element sizes array */ + + for (shorten_element_sizes = 0; shorten_element_sizes <= 1; shorten_element_sizes++) { + /* + * Test 1: Strided <> Strided 1D and 2D I/O + */ + /* sel_dim1 must be even */ + assert(sel_dim1 / 2 == (sel_dim1 + 1) / 2); + + /* Strided selection in memory (1D) */ + block[0] = 1; + count[0] = (hsize_t)(((sel_dim0 * sel_dim1) / 2) / mpi_size); + stride[0] = 2; + start[0] = (hsize_t)mpi_rank * stride[0] * count[0]; + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + verify_start[0] = start[0]; + verify_block[0] = (count[0] * stride[0]); + + /* Strided selection in file (1D) */ + start[0] = 1 + ((hsize_t)mpi_rank * stride[0] * count[0]); + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Strided selection (across dim 1) in file (2D) */ + block[0] = 1; + block[1] = 1; + count[0] = (hsize_t)(sel_dim0 / mpi_size); + count[1] = (hsize_t)sel_dim1 / 2; + stride[0] = 1; + stride[1] = 2; + start[0] = (hsize_t)mpi_rank * count[0]; + start[1] = 1; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Strided selection (across dim 0) in memory (2D) */ + block[0] = 1; + block[1] = 1; + count[0] = (hsize_t)((sel_dim0 / 2) / mpi_size); + count[1] = (hsize_t)sel_dim1; + stride[0] = 2; + stride[1] = 1; + start[0] = 1 + ((hsize_t)mpi_rank * stride[0] * count[0]); + start[1] = 0; + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + verify_start[1] = start[0] * count[1]; + verify_block[1] = (count[0] * count[1] * stride[0]); + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 2, mem_spaces, file_spaces, addrs, element_sizes, + (int **)wbufs) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file bufs */ + for (i = 0; i < (sel_dim0 * sel_dim1) / 2; i++) + fbuf1[(2 * i) + 1] = wbuf1[2 * i]; + for (i = 1, i2 = 0, j2 = 1; i < sel_dim0; i += 2) + for (j = 0; j < sel_dim1; j++) { + assert(i2 < sel_dim0); + fbuf2[i2 * sel_dim1 + j2] = wbuf2[i * sel_dim1 + j]; + j2 += 2; + if (j2 >= sel_dim1) { + i2++; + j2 = 1; + } + } + + /* Update expected read bufs */ + for (i = 0; i < (sel_dim0 * sel_dim1); i++) + erbuf1[i] = -1; + for (i = 0; i < (sel_dim0 * sel_dim1) / 2; i++) + erbuf1[2 * i] = wbuf1[2 * i]; + for (i = 0; i < sel_dim0; i++) + for (j = 0; j < sel_dim1; j++) + erbuf2[i * sel_dim1 + j] = -1; + for (i = 1; i < sel_dim0; i += 2) + for (j = 0; j < sel_dim1; j++) + erbuf2[i * sel_dim1 + j] = wbuf2[i * sel_dim1 + j]; + + /* Read and verify */ + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 2, mem_spaces, + file_spaces, addrs, element_sizes, 2, (int **)erbufs, FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Reset selections + */ + if (H5Sselect_all(mem_spaces[0]) < 0) + P_TEST_ERROR; + if (H5Sselect_all(file_spaces[0]) < 0) + P_TEST_ERROR; + + /* Each process takes x number of elements */ + block[0] = dims1[0] / (hsize_t)mpi_size; + count[0] = 1; + stride[0] = block[0]; + start[0] = (hsize_t)mpi_rank * block[0]; + + verify_start[0] = start[0]; + verify_block[0] = block[0]; + + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + if (H5Sselect_all(mem_spaces[1]) < 0) + P_TEST_ERROR; + if (H5Sselect_all(file_spaces[1]) < 0) + P_TEST_ERROR; + + /* Each process takes x number of elements */ + block[0] = dims2[0] / (hsize_t)mpi_size; + block[1] = dims2[1]; + count[0] = 1; + count[1] = 1; + stride[0] = block[0]; + stride[1] = block[1]; + start[0] = (hsize_t)mpi_rank * block[0]; + start[1] = 0; + + verify_start[1] = start[0] * block[1]; + verify_block[1] = (block[0] * block[1]); + + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Read entire file buffer and verify */ + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 2, mem_spaces, + file_spaces, addrs, element_sizes, 2, (int **)fbufs, FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Test 2: Strided <> Strided 2D I/O, 2 different selections in the same memory buffer + */ + /* Switch mem and file spaces to both be 2D */ + if (H5Sset_extent_simple(mem_spaces[0], 2, dims2, NULL) < 0) + P_TEST_ERROR; + if (H5Sset_extent_simple(file_spaces[0], 2, dims2, NULL) < 0) + P_TEST_ERROR; + + /* Strided selection in memory (1st) */ + block[0] = 1; + block[1] = 1; + count[0] = (hsize_t)((sel_dim0 / 2) / mpi_size); + count[1] = (hsize_t)sel_dim1; + stride[0] = 2; + stride[1] = 1; + start[0] = (hsize_t)mpi_rank * count[0] * stride[0]; + start[1] = 0; + + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + verify_start[0] = start[0] * count[1]; + verify_block[0] = (count[0] * count[1] * stride[0]); + + /* Strided selection (across dim 0) in memory (2nd) */ + start[0] = 1 + ((hsize_t)mpi_rank * count[0] * stride[0]); + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + verify_start[1] = start[0] * count[1]; + verify_block[1] = (count[0] * count[1] * stride[0]); + + /* Strided selection in file (1st) */ + block[0] = 1; + block[1] = 1; + count[0] = (hsize_t)(sel_dim0 / mpi_size); + count[1] = (hsize_t)sel_dim1 / 2; + stride[0] = 1; + stride[1] = 2; + start[0] = (hsize_t)mpi_rank * count[0]; + start[1] = 0; + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Strided selection (across dim 1) in file (2nd) */ + block[0] = 1; + block[1] = 1; + count[0] = (hsize_t)(sel_dim0 / mpi_size); + count[1] = (hsize_t)sel_dim1 / 2; + stride[0] = 1; + stride[1] = 2; + start[0] = (hsize_t)mpi_rank * count[0]; + start[1] = 1; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Use the same memory buffer for both selections */ + wbufs[0] = wbuf2; + + /* Shorten wbuf array */ + if (shorten_element_sizes) + wbufs[1] = NULL; + else + wbufs[1] = wbufs[0]; + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 2, mem_spaces, file_spaces, addrs, element_sizes, + (int **)wbufs) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file bufs - need to reuse 1D array so data stays consistent, so use math to + * find 1D index into 2D array */ + for (i = 0, i2 = 0, j2 = 0; i < sel_dim0; i += 2) + for (j = 0; j < sel_dim1; j++) { + assert(i2 < sel_dim0); + fbuf1[(i2 * sel_dim1) + j2] = wbuf2[i * sel_dim1 + j]; + j2 += 2; + if (j2 >= sel_dim1) { + i2++; + j2 = 0; + } + } + for (i = 1, i2 = 0, j2 = 1; i < sel_dim0; i += 2) + for (j = 0; j < sel_dim1; j++) { + assert(i2 < sel_dim0); + fbuf2[i2 * sel_dim1 + j2] = wbuf2[i * sel_dim1 + j]; + j2 += 2; + if (j2 >= sel_dim1) { + i2++; + j2 = 1; + } + } + + /* Update expected read buf */ + for (i = 0; i < sel_dim0; i++) + for (j = 0; j < sel_dim1; j++) + erbuf2[i * sel_dim1 + j] = -1; + for (i = 0; i < sel_dim0; i += 2) + for (j = 0; j < sel_dim1; j++) + erbuf2[i * sel_dim1 + j] = wbuf2[i * sel_dim1 + j]; + for (i = 1; i < sel_dim0; i += 2) + for (j = 0; j < sel_dim1; j++) + erbuf2[i * sel_dim1 + j] = wbuf2[i * sel_dim1 + j]; + + /* Read and verify */ + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 2, mem_spaces, + file_spaces, addrs, element_sizes, 1, (int **)&erbufs[1], + shorten_element_sizes ? TRUE : FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Reset selections + */ + if (H5Sselect_all(mem_spaces[0]) < 0) + P_TEST_ERROR; + if (H5Sselect_all(file_spaces[0]) < 0) + P_TEST_ERROR; + + if (H5Sselect_all(mem_spaces[1]) < 0) + P_TEST_ERROR; + if (H5Sselect_all(file_spaces[1]) < 0) + P_TEST_ERROR; + + /* Each process takes x number of elements */ + block[0] = dims2[0] / (hsize_t)mpi_size; + block[1] = dims2[1]; + count[0] = 1; + count[1] = 1; + stride[0] = block[0]; + stride[1] = block[1]; + start[0] = (hsize_t)mpi_rank * block[0]; + start[1] = 0; + + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Read entire file buffer and verify */ + verify_start[0] = start[0] * block[1]; + verify_block[0] = (block[0] * block[1]); + verify_start[1] = start[0] * block[1]; + verify_block[1] = (block[0] * block[1]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 2, mem_spaces, + file_spaces, addrs, element_sizes, 2, (int **)fbufs, FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Reset first spaces to 1D */ + if (H5Sset_extent_simple(mem_spaces[0], 1, dims1, NULL) < 0) + P_TEST_ERROR; + if (H5Sset_extent_simple(file_spaces[0], 1, dims1, NULL) < 0) + P_TEST_ERROR; + + /* Reset write buffer array */ + wbufs[0] = wbuf1; + wbufs[1] = wbuf2; + + /* Change to shortened element sizes array */ + element_sizes[1] = 0; + + MPI_Barrier(comm); + } + + /* Reset element sizes array */ + element_sizes[1] = element_sizes[0]; + + return; + +} /* test_selection_io_types_shorten() */ + +/* + * Perform the following tests for 1 & 2 dimensional spaces: + * --Test 1: Strided 1D (memory) <> Strided 2D (file) I/O + * --Reset selections + * --Test 2: Strided 2D (memory) <> Strided 1D (file) I/O + * --Reset selections + */ +static void +test_selection_io_types_1d_2d(int mpi_rank, int mpi_size, H5FD_t *lf, hid_t dxpl, H5FD_mem_t type, + haddr_t addrs[], size_t element_sizes[], hid_t mem_spaces[], + hid_t file_spaces[], hsize_t dims1[], hsize_t dims2[]) +{ + hsize_t start[2]; /* start for hyperslab */ + hsize_t stride[2]; /* stride for hyperslab */ + hsize_t count[2]; /* count for hyperslab */ + hsize_t block[2]; /* block for hyperslab */ + hsize_t verify_start[2] = {0, 0}; /* Starting block for verified data */ + hsize_t verify_block[2] = {0, 0}; /* Block size for verified data */ + int i; + int j; + int i2; + int j2; + + /* + * Test 1: Strided 1D (memory) <> Strided 2D (file) I/O + */ + /* Strided selection (across dim 1) in file */ + block[0] = 1; + block[1] = 1; + count[0] = (hsize_t)(sel_dim0 / mpi_size); + count[1] = (hsize_t)sel_dim1 / 2; + stride[0] = 1; + stride[1] = 2; + start[0] = (hsize_t)mpi_rank * count[0]; + start[1] = 1; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Strided selection in memory */ + block[0] = 1; + count[0] = (hsize_t)(((sel_dim0 * sel_dim1) / 2) / mpi_size); + stride[0] = 2; + start[0] = 1 + ((hsize_t)mpi_rank * stride[0] * count[0]); + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 1, &mem_spaces[0], &file_spaces[1], &addrs[1], element_sizes, + (int **)&wbufs[0]) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file buf */ + for (i = 1, i2 = 0, j2 = 1; i < (sel_dim0 * sel_dim1); i += 2) { + assert(i2 < sel_dim0); + fbuf2[(i2 * sel_dim1) + j2] = wbuf1[i]; + j2 += 2; + if (j2 >= sel_dim1) { + i2++; + j2 = 1; + } + } + + /* Update expected read buf */ + for (i = 0; i < (sel_dim0 * sel_dim1); i++) + erbuf1[i] = -1; + for (i = 1; i < (sel_dim0 * sel_dim1); i += 2) + erbuf1[i] = wbuf1[i]; + + /* Read and verify */ + verify_start[0] = start[0]; + verify_block[0] = (count[0] * stride[0]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[0], + &file_spaces[1], &addrs[1], element_sizes, 1, (int **)&erbufs[0], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Reset selections + */ + if (H5Sselect_all(file_spaces[1]) < 0) + P_TEST_ERROR; + + if (H5Sselect_all(mem_spaces[0]) < 0) + P_TEST_ERROR; + + block[0] = dims2[0] / (hsize_t)mpi_size; + block[1] = dims2[1]; + count[0] = 1; + count[1] = 1; + stride[0] = block[0]; + stride[1] = block[1]; + start[0] = (hsize_t)mpi_rank * block[0]; + start[1] = 0; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + block[0] = dims1[0] / (hsize_t)mpi_size; + count[0] = 1; + stride[0] = block[0]; + start[0] = (hsize_t)mpi_rank * block[0]; + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Read entire file buffer and verify */ + verify_start[0] = start[0]; + verify_block[0] = block[0]; + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[0], + &file_spaces[1], &addrs[1], element_sizes, 1, (int **)&fbufs[1], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Test 2: Strided 2D (memory) <> Strided 1D (file) I/O + */ + /* Strided selection in file */ + block[0] = 1; + count[0] = (hsize_t)(((sel_dim0 * sel_dim1) / 2) / mpi_size); + stride[0] = 2; + start[0] = (hsize_t)mpi_rank * stride[0] * count[0]; + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Strided selection (across dim 0) in memory */ + block[0] = 1; + block[1] = 1; + count[0] = (hsize_t)((sel_dim0 / 2) / mpi_size); + count[1] = (hsize_t)sel_dim1; + stride[0] = 2; + stride[1] = 1; + start[0] = (hsize_t)mpi_rank * count[0] * stride[0]; + start[1] = 0; + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 1, &mem_spaces[1], &file_spaces[0], &addrs[0], element_sizes, + (int **)&wbufs[1]) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file buf */ + for (i = 0, i2 = 0; i < sel_dim0; i += 2) + for (j = 0; j < sel_dim1; j++) { + assert(i2 < (sel_dim0 * sel_dim1)); + fbuf1[i2] = wbuf2[i * sel_dim1 + j]; + i2 += 2; + } + + /* Update expected read buf */ + for (i = 0; i < sel_dim0; i++) + for (j = 0; j < sel_dim1; j++) + erbuf2[(i * sel_dim1) + j] = -1; + for (i = 0; i < sel_dim0; i += 2) + for (j = 0; j < sel_dim1; j++) + erbuf2[(i * sel_dim1) + j] = wbuf2[i * sel_dim1 + j]; + + /* Read and verify */ + verify_start[0] = start[0] * count[1]; + verify_block[0] = (count[0] * count[1] * stride[0]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[1], + &file_spaces[0], &addrs[0], element_sizes, 1, (int **)&erbufs[1], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Reset selections + */ + if (H5Sselect_all(file_spaces[0]) < 0) + P_TEST_ERROR; + + if (H5Sselect_all(mem_spaces[1]) < 0) + P_TEST_ERROR; + + /* Each process takes x number of elements */ + block[0] = dims1[0] / (hsize_t)mpi_size; + count[0] = 1; + stride[0] = block[0]; + start[0] = (hsize_t)mpi_rank * block[0]; + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Each process takes x number of elements */ + block[0] = dims2[0] / (hsize_t)mpi_size; + block[1] = dims2[1]; + count[0] = 1; + count[1] = 1; + stride[0] = block[0]; + stride[1] = block[1]; + start[0] = (hsize_t)mpi_rank * block[0]; + start[1] = 0; + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Read entire file buffer and verify */ + verify_start[0] = start[0] * block[1]; + verify_block[0] = (block[0] * block[1]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[1], + &file_spaces[0], &addrs[0], element_sizes, 1, (int **)&fbufs[0], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + return; + +} /* test_selection_io_types_1d_2d() */ + +/* + * Perform the following tests for 2 dimensional spaces: + * --Test 1: Simple 2D contiguous I/O for both file and memory spaces + * --Test 2: Strided (memory) <> Contiguous(file) 2D I/O + * --Reset selections + * --Test 3: Contiguous (memory) <> Strided (file) 2D I/O + * --Reset selections + * --Test 4: Strided (memory) <> Strided (file) 2D I/O + * --Reset selections + */ +static void +test_selection_io_types_2d(int mpi_rank, int mpi_size, H5FD_t *lf, hid_t dxpl, H5FD_mem_t type, + haddr_t addrs[], size_t element_sizes[], hid_t mem_spaces[], hid_t file_spaces[], + hsize_t dims2[]) +{ + hsize_t start[2]; /* start for hyperslab */ + hsize_t stride[2]; /* stride for hyperslab */ + hsize_t count[2]; /* count for hyperslab */ + hsize_t block[2]; /* block for hyperslab */ + hsize_t verify_start[2] = {0, 0}; /* Starting block for verified data */ + hsize_t verify_block[2] = {0, 0}; /* Block size for verified data */ + int i; + int j; + int i2; + int j2; + + /* + * Test 1: Simple 2D contiguous I/O + */ + + /* Contiguous selection in file and memory */ + block[0] = dims2[0] / (hsize_t)mpi_size; + block[1] = dims2[1]; + count[0] = 1; + count[1] = 1; + stride[0] = block[0]; + stride[1] = block[1]; + start[0] = (hsize_t)mpi_rank * block[0]; + start[1] = 0; + + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + if (test_selection_io_write(dxpl, lf, type, 1, &mem_spaces[1], &file_spaces[1], &addrs[1], element_sizes, + (int **)&wbufs[1]) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file buf */ + for (i = 0; i < sel_dim0; i++) + for (j = 0; j < sel_dim1; j++) + fbuf2[(i * sel_dim1) + j] = wbuf2[(i * sel_dim1) + j]; + + /* Read and verify */ + verify_start[0] = start[0] * block[1]; + verify_block[0] = (block[0] * block[1]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[1], + &file_spaces[1], &addrs[1], element_sizes, 1, (int **)&fbufs[1], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Test 2: Strided (memory) <> Contiguous(file) 2D I/O + */ + /* Contiguous selection in file */ + count[0] = (hsize_t)((sel_dim0 / 2) / mpi_size); + count[1] = (hsize_t)sel_dim1; + start[0] = 1 + ((hsize_t)mpi_rank * count[0]); + start[1] = 0; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, NULL, count, NULL) < 0) + P_TEST_ERROR; + + /* Strided selection in memory */ + block[0] = 1; + block[1] = 1; + stride[0] = 2; + stride[1] = 1; + start[0] = 1 + ((hsize_t)mpi_rank * stride[0] * count[0]); + start[1] = 0; + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 1, &mem_spaces[1], &file_spaces[1], &addrs[1], element_sizes, + (int **)&wbufs[1]) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file buf */ + for (i = 0; i < sel_dim0 / 2; i++) + for (j = 0; j < sel_dim1; j++) { + fbuf2[((i + 1) * sel_dim1) + j] = wbuf2[(((2 * i) + 1) * sel_dim1) + j]; + } + + /* Update expected read buf */ + for (i = 0; i < sel_dim0; i++) + for (j = 0; j < sel_dim1; j++) + erbuf2[(i * sel_dim1) + j] = -1; + for (i = 0; i < sel_dim0 / 2; i++) + for (j = 0; j < sel_dim1; j++) + erbuf2[(((2 * i) + 1) * sel_dim1) + j] = wbuf2[(((2 * i) + 1) * sel_dim1) + j]; + + /* Read and verify */ + verify_start[0] = start[0] * count[1]; + verify_block[0] = (count[0] * count[1] * stride[0]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[1], + &file_spaces[1], &addrs[1], element_sizes, 1, (int **)&erbufs[1], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Reset selections + */ + if (H5Sselect_all(mem_spaces[1]) < 0) + P_TEST_ERROR; + if (H5Sselect_all(file_spaces[1]) < 0) + P_TEST_ERROR; + + block[0] = dims2[0] / (hsize_t)mpi_size; + block[1] = dims2[1]; + count[0] = 1; + count[1] = 1; + stride[0] = block[0]; + stride[1] = block[1]; + start[0] = (hsize_t)mpi_rank * block[0]; + start[1] = 0; + + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Read entire file buffer and verify */ + verify_start[0] = start[0] * block[1]; + verify_block[0] = (block[0] * block[1]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[1], + &file_spaces[1], &addrs[1], element_sizes, 1, (int **)&fbufs[1], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Test 3: Contiguous (memory) <> Strided (file) 2D I/O + */ + + /* Strided selection in file */ + block[0] = 1; + block[1] = 1; + count[0] = (hsize_t)(sel_dim0 / mpi_size); + count[1] = (hsize_t)sel_dim1 / 2; + stride[0] = 1; + stride[1] = 2; + start[0] = (hsize_t)mpi_rank * count[0]; + start[1] = 1; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Contiguous selection in memory */ + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, NULL, count, NULL) < 0) + P_TEST_ERROR; + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 1, &mem_spaces[1], &file_spaces[1], &addrs[1], element_sizes, + (int **)&wbufs[1]) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file buf */ + for (i = 0; i < sel_dim0; i++) + for (j = 0; j < sel_dim1 / 2; j++) + fbuf2[i * sel_dim1 + (2 * j) + 1] = wbuf2[i * sel_dim1 + (j + 1)]; + + /* Update expected read buf */ + for (i = 0; i < sel_dim0; i++) + for (j = 0; j < sel_dim1; j++) + erbuf2[i * sel_dim1 + j] = -1; + for (i = 0; i < sel_dim0; i++) + for (j = 0; j < sel_dim1 / 2; j++) + erbuf2[i * sel_dim1 + (j + 1)] = wbuf2[i * sel_dim1 + (j + 1)]; + + /* Read and verify */ + verify_start[0] = start[0] * count[1] * stride[1]; + verify_block[0] = (count[0] * count[1] * stride[1]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[1], + &file_spaces[1], &addrs[1], element_sizes, 1, (int **)&erbufs[1], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Reset selections + */ + if (H5Sselect_all(mem_spaces[1]) < 0) + P_TEST_ERROR; + if (H5Sselect_all(file_spaces[1]) < 0) + P_TEST_ERROR; + + block[0] = dims2[0] / (hsize_t)mpi_size; + block[1] = dims2[1]; + count[0] = 1; + count[1] = 1; + stride[0] = block[0]; + stride[1] = block[1]; + start[0] = (hsize_t)mpi_rank * block[0]; + start[1] = 0; + + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Read entire file buffer and verify */ + verify_start[0] = start[0] * block[1]; + verify_block[0] = (block[0] * block[1]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[1], + &file_spaces[1], &addrs[1], element_sizes, 1, (int **)&fbufs[1], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Test 4: Strided (memory) <> Strided (file) 2D I/O + */ + /* sel_dim0 and sel_dim1 must be even */ + assert(sel_dim0 / 2 == (sel_dim0 + 1) / 2); + assert(sel_dim1 / 2 == (sel_dim1 + 1) / 2); + + /* Strided selection (across dim 0) in file */ + block[0] = 1; + block[1] = 1; + count[0] = (hsize_t)((sel_dim0 / 2) / mpi_size); + count[1] = (hsize_t)sel_dim1; + stride[0] = 2; + stride[1] = 1; + start[0] = 1 + ((hsize_t)mpi_rank * count[0] * stride[0]); + start[1] = 0; + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Strided selection (across dim 1) in memory */ + block[0] = 1; + block[1] = 1; + count[0] = (hsize_t)(sel_dim0 / mpi_size); + count[1] = (hsize_t)sel_dim1 / 2; + stride[0] = 1; + stride[1] = 2; + start[0] = (hsize_t)mpi_rank * count[0]; + start[1] = 1; + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 1, &mem_spaces[1], &file_spaces[1], &addrs[1], element_sizes, + (int **)&wbufs[1]) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file buf */ + for (i = 0, i2 = 1, j2 = 0; i < sel_dim0; i++) + for (j = 1; j < sel_dim1; j += 2) { + assert(i2 < sel_dim0); + fbuf2[i2 * sel_dim1 + j2] = wbuf2[i * sel_dim1 + j]; + if (++j2 == sel_dim1) { + i2 += 2; + j2 = 0; + } + } + + /* Update expected read buf */ + for (i = 0; i < sel_dim0; i++) + for (j = 0; j < sel_dim1; j++) + erbuf2[i * sel_dim1 + j] = -1; + for (i = 0; i < sel_dim0; i++) + for (j = 1; j < sel_dim1; j += 2) + erbuf2[i * sel_dim1 + j] = wbuf2[i * sel_dim1 + j]; + /* Read and verify */ + verify_start[0] = start[0] * count[1] * stride[1]; + verify_block[0] = (count[0] * count[1] * stride[1]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[1], + &file_spaces[1], &addrs[1], element_sizes, 1, (int **)&erbufs[1], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Reset selections + */ + if (H5Sselect_all(file_spaces[1]) < 0) + P_TEST_ERROR; + if (H5Sselect_all(mem_spaces[1]) < 0) + P_TEST_ERROR; + + block[0] = dims2[0] / (hsize_t)mpi_size; + block[1] = dims2[1]; + count[0] = 1; + count[1] = 1; + stride[0] = block[0]; + stride[1] = block[1]; + start[0] = (hsize_t)mpi_rank * block[0]; + start[1] = 0; + + if (H5Sselect_hyperslab(file_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(mem_spaces[1], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Read entire file buffer and verify */ + verify_start[0] = start[0] * block[1]; + verify_block[0] = (block[0] * block[1]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[1], + &file_spaces[1], &addrs[1], element_sizes, 1, (int **)&fbufs[1], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + return; + +} /* test_selection_io_types_2d() */ + +/* + * Perform the following tests for 1 dimensional spaces: + * --Test 1: Simple 1D contiguous I/O in both file and memory spaces + * --Test 2: Strided (memory) <> Contiguous (file) 1D I/O + * --Reset selections + * --Test 3: Contiguous (memory) <> Strided (file) 1D I/O + * --Reset selections + * --Test 4: Strided (memory) <> Strided 1D (file) I/O + * --Reset selections + */ +static void +test_selection_io_types_1d(int mpi_rank, int mpi_size, H5FD_t *lf, hid_t dxpl, H5FD_mem_t type, + haddr_t addrs[], size_t element_sizes[], hid_t mem_spaces[], hid_t file_spaces[], + hsize_t dims1[]) +{ + hsize_t start[2]; /* start for hyperslab */ + hsize_t stride[2]; /* stride for hyperslab */ + hsize_t count[2]; /* count for hyperslab */ + hsize_t block[2]; /* block for hyperslab */ + hsize_t verify_start[2] = {0, 0}; /* Starting block for verified data */ + hsize_t verify_block[2] = {0, 0}; /* Block size for verified data */ + int i; + + /* + * Test 1: Simple 1D contiguous I/O + */ + + /* Contiguous selection in file and memory */ + block[0] = dims1[0] / (hsize_t)mpi_size; + count[0] = 1; + stride[0] = block[0]; + start[0] = (hsize_t)mpi_rank * block[0]; + + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 1, &mem_spaces[0], &file_spaces[0], &addrs[0], element_sizes, + (int **)&wbufs[0]) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file buf */ + for (i = 0; i < sel_dim0 * sel_dim1; i++) + fbuf1[i] = wbuf1[i]; + + /* Read and verify */ + verify_start[0] = start[0]; + verify_block[0] = block[0]; + + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[0], + &file_spaces[0], &addrs[0], element_sizes, 1, (int **)&fbufs[0], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Test 2: Strided (memory) <> Contiguous (file) 1D I/O + */ + /* sel_dim1 must be even */ + assert(sel_dim1 / 2 == (sel_dim1 + 1) / 2); + + /* Contiguous selection in file */ + count[0] = (hsize_t)(((sel_dim0 * sel_dim1) / 2) / mpi_size); + start[0] = 1 + ((hsize_t)mpi_rank * count[0]); + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, NULL, count, NULL) < 0) + P_TEST_ERROR; + + /* Strided selection in memory */ + block[0] = 1; + stride[0] = 2; + start[0] = 1 + ((hsize_t)mpi_rank * stride[0] * count[0]); + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 1, &mem_spaces[0], &file_spaces[0], &addrs[0], element_sizes, + (int **)&wbufs[0]) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file buf */ + for (i = 0; i < (sel_dim0 * sel_dim1) / 2; i++) + fbuf1[i + 1] = wbuf1[(2 * i) + 1]; + + /* Update expected read buf */ + for (i = 0; i < (sel_dim0 * sel_dim1); i++) + erbuf1[i] = -1; + for (i = 0; i < (sel_dim0 * sel_dim1) / 2; i++) + erbuf1[(2 * i) + 1] = wbuf1[(2 * i) + 1]; + + /* Read and verify */ + verify_start[0] = start[0]; + verify_block[0] = (count[0] * stride[0]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[0], + &file_spaces[0], &addrs[0], element_sizes, 1, (int **)&erbufs[0], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Reset selections + */ + if (H5Sselect_all(mem_spaces[0]) < 0) + P_TEST_ERROR; + if (H5Sselect_all(file_spaces[0]) < 0) + P_TEST_ERROR; + + block[0] = dims1[0] / (hsize_t)mpi_size; + count[0] = 1; + stride[0] = block[0]; + start[0] = (hsize_t)mpi_rank * block[0]; + + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Read entire file buffer and verify */ + verify_start[0] = start[0]; + verify_block[0] = block[0]; + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[0], + &file_spaces[0], &addrs[0], element_sizes, 1, (int **)&fbufs[0], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Test 3: Contiguous (memory) <> Strided (file) 1D I/O + */ + /* sel_dim1 must be even */ + assert(sel_dim1 / 2 == (sel_dim1 + 1) / 2); + + /* Strided selection in file */ + block[0] = 1; + count[0] = (hsize_t)(((sel_dim0 * sel_dim1) / 2) / mpi_size); /* count is this value from twice above */ + stride[0] = 2; /* stride is this value from twice above */ + start[0] = 1 + ((hsize_t)mpi_rank * stride[0] * count[0]); + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Contiguous selection in memory */ + start[0] = 1 + ((hsize_t)mpi_rank * count[0]); + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, NULL, count, NULL) < 0) + P_TEST_ERROR; + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 1, &mem_spaces[0], &file_spaces[0], &addrs[0], element_sizes, + (int **)&wbufs[0]) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file buf */ + for (i = 0; i < (sel_dim0 * sel_dim1) / 2; i++) + fbuf1[(2 * i) + 1] = wbuf1[i + 1]; + + /* Update expected read buf */ + for (i = 0; i < (sel_dim0 * sel_dim1); i++) + erbuf1[i] = -1; + for (i = 0; i < (sel_dim0 * sel_dim1) / 2; i++) + erbuf1[i + 1] = wbuf1[i + 1]; + + /* Read and verify */ + verify_start[0] = start[0]; + verify_block[0] = count[0]; + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[0], + &file_spaces[0], &addrs[0], element_sizes, 1, (int **)&erbufs[0], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Reset selections + */ + if (H5Sselect_all(mem_spaces[0]) < 0) + P_TEST_ERROR; + if (H5Sselect_all(file_spaces[0]) < 0) + P_TEST_ERROR; + + block[0] = dims1[0] / (hsize_t)mpi_size; + count[0] = 1; + stride[0] = block[0]; + start[0] = (hsize_t)mpi_rank * block[0]; + + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Read entire file buffer and verify */ + verify_start[0] = start[0]; + verify_block[0] = block[0]; + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[0], + &file_spaces[0], &addrs[0], element_sizes, 1, (int **)&fbufs[0], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Test 4: Strided (memory) <> Strided 1D (file) I/O + */ + /* sel_dim1 must be even */ + assert(sel_dim1 / 2 == (sel_dim1 + 1) / 2); + + /* Strided selection in file */ + block[0] = 1; + count[0] = (hsize_t)(((sel_dim0 * sel_dim1) / 2) / mpi_size); + stride[0] = 2; + start[0] = 0 + ((hsize_t)mpi_rank * stride[0] * count[0]); + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Strided selection in memory */ + start[0] = 1 + ((hsize_t)mpi_rank * stride[0] * count[0]); + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Issue write call */ + if (test_selection_io_write(dxpl, lf, type, 1, &mem_spaces[0], &file_spaces[0], &addrs[0], element_sizes, + (int **)&wbufs[0]) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* Update file buf */ + for (i = 0; i < (sel_dim0 * sel_dim1) / 2; i++) + fbuf1[2 * i] = wbuf1[(2 * i) + 1]; + + /* Update expected read buf */ + for (i = 0; i < (sel_dim0 * sel_dim1); i++) + erbuf1[i] = -1; + for (i = 0; i < (sel_dim0 * sel_dim1) / 2; i++) + erbuf1[(2 * i) + 1] = wbuf1[(2 * i) + 1]; + + /* Read and verify */ + verify_start[0] = start[0]; + verify_block[0] = (count[0] * stride[0]); + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[0], + &file_spaces[0], &addrs[0], element_sizes, 1, (int **)&erbufs[0], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + /* + * Reset selections + */ + if (H5Sselect_all(mem_spaces[0]) < 0) + P_TEST_ERROR; + if (H5Sselect_all(file_spaces[0]) < 0) + P_TEST_ERROR; + + block[0] = dims1[0] / (hsize_t)mpi_size; + count[0] = 1; + stride[0] = block[0]; + start[0] = (hsize_t)mpi_rank * block[0]; + + if (H5Sselect_hyperslab(mem_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + if (H5Sselect_hyperslab(file_spaces[0], H5S_SELECT_SET, start, stride, count, block) < 0) + P_TEST_ERROR; + + /* Read entire file buffer and verify */ + verify_start[0] = start[0]; + verify_block[0] = block[0]; + if (test_selection_io_read_verify(dxpl, mpi_rank, verify_start, verify_block, lf, type, 1, &mem_spaces[0], + &file_spaces[0], &addrs[0], element_sizes, 1, (int **)&fbufs[0], + FALSE) < 0) + P_TEST_ERROR; + + MPI_Barrier(comm); + + return; + +} /* test_selection_io_types_1d() */ + +/* + * Perform the following tests for selection I/O: + * + * test_selection_io_types_1d(): + * ---Selection I/O tests for 1 dimensional spaces + * test_selection_io_types_2d() + * ---Selection I/O tests for 2 dimensional spaces + * test_selection_io_types_1d_2d() + * ---Selection I/O tests for 1 & 2 dimensional spaces + * test_selection_io_types_shorten() + * --Selection I/O tests that use shortened arrays for wbuf and element sizes + */ +static void +test_selection_io_real(int mpi_rank, int mpi_size, H5FD_t *lf, hid_t dxpl) +{ + hid_t mem_spaces[2] = {H5I_INVALID_HID, H5I_INVALID_HID}; /* memory dataspaces vector */ + hid_t file_spaces[2] = {H5I_INVALID_HID, H5I_INVALID_HID}; /* file dataspaces vector */ + hsize_t dims1[1]; /* 1d dimension sizes */ + hsize_t dims2[2]; /* 2d dimension sizes */ + + H5FD_mem_t type; /* File type */ + haddr_t addrs[2]; /* File allocation address */ + size_t element_sizes[2] = {sizeof(int), sizeof(int)}; /* Element size */ + size_t bufsize; /* Buffer size */ + int i; + int j; + + curr_nerrors = nerrors; + + /* + * Default dimension sizes for mpi_size 1 or 2: + * int sel_dim0 = SELECT_IO_DIM0; + * int sel_dim1 = SELECT_IO_DIM1; + */ + if (mpi_size >= 3) { + sel_dim0 = mpi_size * 2; + sel_dim1 = mpi_size * 4; + } + + dims1[0] = (hsize_t)(sel_dim0 * sel_dim1); + dims2[0] = (hsize_t)sel_dim0, dims2[1] = (hsize_t)sel_dim1; + + /* Create dataspaces - location 0 will be 1D and location 1 will be 2D */ + if ((mem_spaces[0] = H5Screate_simple(1, dims1, NULL)) < 0) + P_TEST_ERROR; + if ((mem_spaces[1] = H5Screate_simple(2, dims2, NULL)) < 0) + P_TEST_ERROR; + if ((file_spaces[0] = H5Screate_simple(1, dims1, NULL)) < 0) + P_TEST_ERROR; + if ((file_spaces[1] = H5Screate_simple(2, dims2, NULL)) < 0) + P_TEST_ERROR; + + /* Initialize global buffers: + * --wbuf1, wbuf2: write buffers + * --fbuf1, fbuf1: expected file buffers + * --erbuf1, erbuf2: expected read buffers + */ + bufsize = (size_t)(sel_dim0 * sel_dim1) * sizeof(int); + + if ((wbuf1 = malloc(bufsize)) == NULL) + P_TEST_ERROR; + + if ((wbuf2 = malloc(bufsize)) == NULL) + P_TEST_ERROR; + + wbufs[0] = wbuf1; + wbufs[1] = wbuf2; + + if ((fbuf1 = malloc(bufsize)) == NULL) + P_TEST_ERROR; + + if ((fbuf2 = malloc(bufsize)) == NULL) + P_TEST_ERROR; + + fbufs[0] = fbuf1; + fbufs[1] = fbuf2; + + if ((erbuf1 = malloc(bufsize)) == NULL) + P_TEST_ERROR; + + if ((erbuf2 = malloc(bufsize)) == NULL) + P_TEST_ERROR; + + erbufs[0] = erbuf1; + erbufs[1] = erbuf2; + + /* Initialize data */ + for (i = 0; i < sel_dim0; i++) + for (j = 0; j < sel_dim1; j++) { + wbuf1[(i * sel_dim1) + j] = (i * sel_dim1) + j; + wbuf2[(i * sel_dim1) + j] = (i * sel_dim1) + j + (sel_dim0 * sel_dim1); + } + + /* Loop over memory types */ + for (type = 1; type < H5FD_MEM_NTYPES; type++) { + + addrs[0] = H5FDalloc(lf, type, H5P_DEFAULT, (sizeof(int) * (hsize_t)sel_dim0 * (hsize_t)sel_dim1)); + addrs[1] = H5FDalloc(lf, type, H5P_DEFAULT, (sizeof(int) * (hsize_t)sel_dim0 * (hsize_t)sel_dim1)); + + test_selection_io_types_1d(mpi_rank, mpi_size, lf, dxpl, type, addrs, element_sizes, mem_spaces, + file_spaces, dims1); + test_selection_io_types_2d(mpi_rank, mpi_size, lf, dxpl, type, addrs, element_sizes, mem_spaces, + file_spaces, dims2); + test_selection_io_types_1d_2d(mpi_rank, mpi_size, lf, dxpl, type, addrs, element_sizes, mem_spaces, + file_spaces, dims1, dims2); + test_selection_io_types_shorten(mpi_rank, mpi_size, lf, dxpl, type, addrs, element_sizes, mem_spaces, + file_spaces, dims1, dims2); + + } /* end for */ + + /* Close dataspaces */ + for (i = 0; i < 2; i++) { + if (H5Sclose(mem_spaces[i]) < 0) + P_TEST_ERROR; + if (H5Sclose(file_spaces[i]) < 0) + P_TEST_ERROR; + } + + /* Free the buffers */ + if (wbuf1) + free(wbuf1); + if (wbuf2) + free(wbuf2); + if (fbuf1) + free(fbuf1); + if (fbuf2) + free(fbuf2); + if (erbuf1) + free(erbuf1); + if (erbuf2) + free(erbuf2); + + CHECK_PASSED(); + + return; + +} /* test_selection_io_real() */ + +/* + * These tests for selection I/O are derived from test_selection_io() in + * test/vfd.c and modified for parallel testing. + */ +static void +test_selection_io(int mpi_rank, int mpi_size) +{ + H5FD_t *lf = NULL; /* VFD struct ptr */ + hid_t fapl = H5I_INVALID_HID; /* File access property list */ + char filename[1024]; /* Test file name */ + unsigned flags = 0; /* File access flags */ + + unsigned collective; /* Types of I/O for testing */ + hid_t dxpl = H5I_INVALID_HID; /* Dataset transfer property list */ + hid_t def_dxpl = H5I_INVALID_HID; /* dxpl: independent access */ + hid_t col_xfer_dxpl = H5I_INVALID_HID; /* dxpl: collective access with collective I/O */ + hid_t ind_io_dxpl = H5I_INVALID_HID; /* dxpl: collective access with individual I/O */ + + /* If I use fapl in this call, I got an environment printout */ + h5_fixname(SELECT_FNAME, H5P_DEFAULT, filename, sizeof(filename)); + + if ((fapl = H5Pcreate(H5P_FILE_ACCESS)) < 0) + P_TEST_ERROR; + + if (H5Pset_fapl_mpio(fapl, comm, info) < 0) + P_TEST_ERROR; + + /* Create file */ + flags = H5F_ACC_RDWR | H5F_ACC_CREAT | H5F_ACC_TRUNC; + + if (NULL == (lf = H5FDopen(filename, flags, fapl, HADDR_UNDEF))) + P_TEST_ERROR; + + /* Default dxpl which will be H5FD_MPIO_INDEPENDENT by default */ + def_dxpl = H5Pcreate(H5P_DATASET_XFER); + + /* Set dxpl for collective access which will have H5FD_MPIO_COLLECTIVE_IO as default */ + if ((col_xfer_dxpl = H5Pcopy(def_dxpl)) < 0) + P_TEST_ERROR; + if (H5Pset_dxpl_mpio(col_xfer_dxpl, H5FD_MPIO_COLLECTIVE) < 0) + P_TEST_ERROR; + + /* Set dxpl for H5FD_MPIO_INDIVIDUAL_IO */ + if ((ind_io_dxpl = H5Pcopy(col_xfer_dxpl)) < 0) + P_TEST_ERROR; + if (H5Pset_dxpl_mpio_collective_opt(ind_io_dxpl, H5FD_MPIO_INDIVIDUAL_IO) < 0) + P_TEST_ERROR; + + for (collective = 0; collective < iotypes; collective++) { + // for (collective = 0; collective < 1; collective++) { + if (collective) + dxpl = collective == 1 ? col_xfer_dxpl : ind_io_dxpl; + else + dxpl = def_dxpl; + + if (MAINPROCESS) { + if (collective) { + if (collective == 1) + printf(" Testing with Collective access: collective I/O "); + else + printf(" Testing with Collective_access: Individual I/O "); + } + else + printf(" Testing with Independent access "); + } + + /* Perform the actual tests */ + test_selection_io_real(mpi_rank, mpi_size, lf, dxpl); + } + + /* Close file */ + if (H5FDclose(lf) < 0) + P_TEST_ERROR; + + /* Close the fapl */ + if (H5Pclose(fapl) < 0) + P_TEST_ERROR; + + if (H5Pclose(def_dxpl) < 0) + P_TEST_ERROR; + if (H5Pclose(col_xfer_dxpl) < 0) + P_TEST_ERROR; + if (H5Pclose(ind_io_dxpl) < 0) + P_TEST_ERROR; + + // if (MAINPROCESS && HDremove(filename) < 0) + // P_TEST_ERROR; + +} /* test_selection_io() */ + +/*------------------------------------------------------------------------- + * Function: main + * + * Purpose: Run parallel VFD tests. + * + * Return: Success: 0 + * + * Failure: 1 + * + *------------------------------------------------------------------------- + */ + +int +main(int argc, char **argv) +{ + +#ifdef H5_HAVE_SUBFILING_VFD + int required = MPI_THREAD_MULTIPLE; + int provided = 0; +#endif + int mpi_size; + int mpi_rank; + int ret; + +#ifdef H5_HAVE_SUBFILING_VFD + if (MPI_SUCCESS != MPI_Init_thread(&argc, &argv, required, &provided)) { + printf(" MPI doesn't support MPI_Init_thread with MPI_THREAD_MULTIPLE. Exiting\n"); + goto finish; + } + + if (provided != required) { + printf(" MPI doesn't support MPI_Init_thread with MPI_THREAD_MULTIPLE. Exiting\n"); + goto finish; + } +#else + if (MPI_SUCCESS != MPI_Init(&argc, &argv)) { + printf(" MPI_Init failed. Exiting\n"); + goto finish; + } +#endif + + MPI_Comm_size(comm, &mpi_size); + MPI_Comm_rank(comm, &mpi_rank); + + /* Attempt to turn off atexit post processing so that in case errors + * occur during the test and the process is aborted, it will not hang + * in the atexit post processing. If it does, it may try to make MPI + * calls which may not work. + */ + if (H5dont_atexit() < 0) + printf("%d:Failed to turn off atexit processing. Continue.\n", mpi_rank); + + H5open(); + + if (mpi_rank == 0) { + printf("=========================================\n"); + printf("Parallel virtual file driver (VFD) tests\n"); + printf(" mpi_size = %d\n", mpi_size); + printf("=========================================\n"); + } + + MPI_Barrier(comm); + + if (mpi_rank == 0) + printf("\n --- TESTING MPIO VFD: selection I/O --- \n"); + + test_selection_io(mpi_rank, mpi_size); + + if (mpi_rank == 0) + printf("\n --- TESTING MPIO VFD: vector I/O --- \n"); + + if (mpi_size < 2) { + if (mpi_rank == 0) { + printf(" Need at least 2 processes to run tests for vector I/O."); + SKIPPED(); + } + printf("\n"); + goto finish; + } + + test_vector_io(mpi_rank, mpi_size); + finish: /* make sure all processes are finished before final report, cleanup * and exit. */ MPI_Barrier(comm); - if (mpi_rank == 0) { /* only process 0 reports */ - printf("===================================\n"); - if (nerrs > 0) - printf("***vfd tests detected %d failures***\n", nerrs); + /* Gather errors from all processes */ + MPI_Allreduce(&nerrors, &ret, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD); + nerrors = ret; + + if (MAINPROCESS) { + printf("\n===================================\n"); + if (nerrors) + printf("***Parallel vfd tests detected %d errors***\n", nerrors); else - printf("vfd tests finished with no failures\n"); + printf("Parallel vfd tests finished with no errors\n"); printf("===================================\n"); } @@ -4337,6 +5992,6 @@ main(int argc, char **argv) MPI_Finalize(); /* cannot just return (nerrs) because exit code is limited to 1byte */ - return (nerrs > 0); + return (nerrors != 0); } /* main() */ diff --git a/tools/lib/h5tools_dump.c b/tools/lib/h5tools_dump.c index c1427d6dea5..e1fab359145 100644 --- a/tools/lib/h5tools_dump.c +++ b/tools/lib/h5tools_dump.c @@ -2571,7 +2571,7 @@ h5tools_print_datatype(FILE *stream, h5tools_str_t *buffer, const h5tool_format_ if (H5Tclose(super) < 0) H5TOOLS_ERROR((-1), "H5Tclose failed"); - h5tools_str_append(buffer, "%s", h5tools_dump_header_format->vlenblockend); + h5tools_str_append(buffer, " %s", h5tools_dump_header_format->vlenblockend); break; diff --git a/tools/testfiles/tarray6.ddl b/tools/testfiles/tarray6.ddl index 5c49b0ff931..343002b7cd5 100644 --- a/tools/testfiles/tarray6.ddl +++ b/tools/testfiles/tarray6.ddl @@ -1,7 +1,7 @@ HDF5 "tarray6.h5" { GROUP "/" { DATASET "Dataset1" { - DATATYPE H5T_ARRAY { [4] H5T_VLEN { H5T_STD_U32LE} } + DATATYPE H5T_ARRAY { [4] H5T_VLEN { H5T_STD_U32LE } } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } DATA { (0): [ (0), (10, 11), (20, 21, 22), (30, 31, 32, 33) ], diff --git a/tools/testfiles/tarray7.ddl b/tools/testfiles/tarray7.ddl index 229d719dc6c..cc537d70c87 100644 --- a/tools/testfiles/tarray7.ddl +++ b/tools/testfiles/tarray7.ddl @@ -1,7 +1,7 @@ HDF5 "tarray7.h5" { GROUP "/" { DATASET "Dataset1" { - DATATYPE H5T_ARRAY { [4] H5T_VLEN { H5T_ARRAY { [4] H5T_STD_U32LE }} } + DATATYPE H5T_ARRAY { [4] H5T_VLEN { H5T_ARRAY { [4] H5T_STD_U32LE } } } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } DATA { (0): [ ([ 0, 1, 2, 3 ]), diff --git a/tools/testfiles/tempty.ddl b/tools/testfiles/tempty.ddl index 0c24334e0c9..5797d48126e 100644 --- a/tools/testfiles/tempty.ddl +++ b/tools/testfiles/tempty.ddl @@ -1,7 +1,7 @@ HDF5 "tempty.h5" { GROUP "/" { DATASET "Dataset1.0" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } DATA { (0): (), (), (), () diff --git a/tools/testfiles/tfill.ddl b/tools/testfiles/tfill.ddl index 556f4f232b1..627e6606155 100644 --- a/tools/testfiles/tfill.ddl +++ b/tools/testfiles/tfill.ddl @@ -124,7 +124,7 @@ GROUP "/" { } } DATASET "fill_vlen" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 2 ) / ( 2 ) } STORAGE_LAYOUT { CONTIGUOUS diff --git a/tools/testfiles/tmultifile.ddl b/tools/testfiles/tmultifile.ddl index cf94f2c061a..ebe1608dd3a 100644 --- a/tools/testfiles/tmultifile.ddl +++ b/tools/testfiles/tmultifile.ddl @@ -30,13 +30,13 @@ DATASET "Dataset1" { } HDF5 "tarray6.h5" { DATASET "Dataset1" { - DATATYPE H5T_ARRAY { [4] H5T_VLEN { H5T_STD_U32LE} } + DATATYPE H5T_ARRAY { [4] H5T_VLEN { H5T_STD_U32LE } } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } } } HDF5 "tarray7.h5" { DATASET "Dataset1" { - DATATYPE H5T_ARRAY { [4] H5T_VLEN { H5T_ARRAY { [4] H5T_STD_U32LE }} } + DATATYPE H5T_ARRAY { [4] H5T_VLEN { H5T_ARRAY { [4] H5T_STD_U32LE } } } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } } } diff --git a/tools/testfiles/treference.ddl b/tools/testfiles/treference.ddl index 6d3849816d1..1145b256cb5 100644 --- a/tools/testfiles/treference.ddl +++ b/tools/testfiles/treference.ddl @@ -427,14 +427,14 @@ GROUP "/" { } } ATTRIBUTE "vlen" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 2 ) / ( 2 ) } DATA { (0): (1), (2, 3) } } ATTRIBUTE "vlen2D" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 3, 2 ) / ( 3, 2 ) } DATA { (0,0): (0), (1), @@ -443,7 +443,7 @@ GROUP "/" { } } ATTRIBUTE "vlen3D" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 4, 3, 2 ) / ( 4, 3, 2 ) } DATA { (0,0,0): (0), (1), @@ -1039,14 +1039,14 @@ GROUP "/" { } } ATTRIBUTE "vlen" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 2 ) / ( 2 ) } DATA { (0): (1), (2, 3) } } ATTRIBUTE "vlen2D" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 3, 2 ) / ( 3, 2 ) } DATA { (0,0): (0), (1), @@ -1055,7 +1055,7 @@ GROUP "/" { } } ATTRIBUTE "vlen3D" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 4, 3, 2 ) / ( 4, 3, 2 ) } DATA { (0,0,0): (0), (1), @@ -1501,14 +1501,14 @@ GROUP "/" { } } ATTRIBUTE "vlen" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 2 ) / ( 2 ) } DATA { (0): (1), (2, 3) } } ATTRIBUTE "vlen2D" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 3, 2 ) / ( 3, 2 ) } DATA { (0,0): (0), (1), @@ -1517,7 +1517,7 @@ GROUP "/" { } } ATTRIBUTE "vlen3D" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 4, 3, 2 ) / ( 4, 3, 2 ) } DATA { (0,0,0): (0), (1), @@ -2109,14 +2109,14 @@ GROUP "/" { } } DATASET "vlen" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 2 ) / ( 2 ) } DATA { (0): (1), (2, 3) } } DATASET "vlen2D" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 3, 2 ) / ( 3, 2 ) } DATA { (0,0): (0), (1), @@ -2125,7 +2125,7 @@ GROUP "/" { } } DATASET "vlen3D" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 4, 3, 2 ) / ( 4, 3, 2 ) } DATA { (0,0,0): (0), (1), diff --git a/tools/testfiles/tvldtypes1.ddl b/tools/testfiles/tvldtypes1.ddl index 1ebb9154c25..bdf93289c5b 100644 --- a/tools/testfiles/tvldtypes1.ddl +++ b/tools/testfiles/tvldtypes1.ddl @@ -1,21 +1,21 @@ HDF5 "tvldtypes1.h5" { GROUP "/" { DATASET "Dataset1.0" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } DATA { (0): (0), (10, 11), (20, 21, 22), (30, 31, 32, 33) } } DATASET "Dataset2.0" { - DATATYPE H5T_VLEN { H5T_IEEE_F32LE} + DATATYPE H5T_VLEN { H5T_IEEE_F32LE } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } DATA { (0): (0), (10, 10.1), (20, 20.1, 20.2), (30, 30.1, 30.2, 30.3) } } DATASET "Dataset3.0" { - DATATYPE H5T_VLEN { H5T_STD_I32LE} + DATATYPE H5T_VLEN { H5T_STD_I32LE } DATASPACE SCALAR DATA { (0): (0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72) diff --git a/tools/testfiles/tvldtypes2.ddl b/tools/testfiles/tvldtypes2.ddl index 93be8627d79..5a91187dc05 100644 --- a/tools/testfiles/tvldtypes2.ddl +++ b/tools/testfiles/tvldtypes2.ddl @@ -1,7 +1,7 @@ HDF5 "tvldtypes2.h5" { GROUP "/" { DATASET "Dataset1" { - DATATYPE H5T_VLEN { H5T_VLEN { H5T_STD_U32LE}} + DATATYPE H5T_VLEN { H5T_VLEN { H5T_STD_U32LE } } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } DATA { (0): ((0)), ((100), (110, 111)), ((200), (210, 211), (220, 221, 222)), diff --git a/tools/testfiles/tvldtypes3.ddl b/tools/testfiles/tvldtypes3.ddl index 3af926839f4..b8f53c96749 100644 --- a/tools/testfiles/tvldtypes3.ddl +++ b/tools/testfiles/tvldtypes3.ddl @@ -4,7 +4,7 @@ GROUP "/" { DATATYPE H5T_COMPOUND { H5T_STD_I32LE "i"; H5T_IEEE_F32LE "f"; - H5T_VLEN { H5T_STD_U32LE} "v"; + H5T_VLEN { H5T_STD_U32LE } "v"; } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } DATA { diff --git a/tools/testfiles/tvldtypes4.ddl b/tools/testfiles/tvldtypes4.ddl index b1ca394ef01..da363fa26cb 100644 --- a/tools/testfiles/tvldtypes4.ddl +++ b/tools/testfiles/tvldtypes4.ddl @@ -4,7 +4,7 @@ GROUP "/" { DATATYPE H5T_VLEN { H5T_COMPOUND { H5T_STD_I32LE "i"; H5T_IEEE_F32LE "f"; - }} + } } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } DATA { (0): ({ diff --git a/tools/testfiles/tvldtypes5.ddl b/tools/testfiles/tvldtypes5.ddl index b4bf3db776e..b0f8a2c9cf1 100644 --- a/tools/testfiles/tvldtypes5.ddl +++ b/tools/testfiles/tvldtypes5.ddl @@ -1,7 +1,7 @@ HDF5 "tvldtypes5.h5" { GROUP "/" { DATASET "Dataset" { - DATATYPE H5T_VLEN { H5T_STD_U32LE} + DATATYPE H5T_VLEN { H5T_STD_U32LE } DATASPACE SIMPLE { ( 4 ) / ( 4 ) } DATA { (0): (0, 2, 4, 6, 8), (), (0, 2, 4, 6, 8, 10, 12), ()