diff options
Diffstat (limited to 'src/H5Dmpio.c')
| -rw-r--r-- | src/H5Dmpio.c | 2658 |
1 files changed, 1317 insertions, 1341 deletions
diff --git a/src/H5Dmpio.c b/src/H5Dmpio.c index 22f32ab..889fbce 100644 --- a/src/H5Dmpio.c +++ b/src/H5Dmpio.c @@ -34,12 +34,12 @@ /* Headers */ /***********/ #include "H5private.h" /* Generic Functions */ -#include "H5Iprivate.h" #include "H5Dpkg.h" /* Datasets */ #include "H5Eprivate.h" /* Error handling */ #include "H5Fprivate.h" /* File access */ #include "H5FDprivate.h" /* File drivers */ -#include "H5MMprivate.h" +#include "H5Iprivate.h" /* IDs */ +#include "H5MMprivate.h" /* Memory management */ #include "H5Oprivate.h" /* Object headers */ #include "H5Pprivate.h" /* Property lists */ #include "H5Sprivate.h" /* Dataspaces */ @@ -86,6 +86,7 @@ #define H5D_CHUNK_SELECT_IRREG 2 #define H5D_CHUNK_SELECT_NONE 0 + /******************/ /* Local Typedefs */ /******************/ @@ -95,66 +96,47 @@ typedef struct H5D_chunk_addr_info_t { H5D_chunk_info_t chunk_info; } H5D_chunk_addr_info_t; -/* Combine all information that needs to know for collective MPI-IO of this selection. */ -typedef struct H5D_common_coll_info_t { - hbool_t mbt_is_derived; - hbool_t mft_is_derived; - size_t mpi_buf_count; - haddr_t chunk_addr; -} H5D_common_coll_info_t; - /********************/ /* Local Prototypes */ /********************/ - -static herr_t -H5D_multi_chunk_collective_io(H5D_io_info_t *io_info,H5D_chunk_map_t *fm,const void *buf, - hbool_t do_write); -static herr_t -H5D_multi_chunk_collective_io_no_opt(H5D_io_info_t *io_info,H5D_chunk_map_t *fm,const void *buf, - hbool_t do_write); - -static herr_t -H5D_link_chunk_collective_io(H5D_io_info_t *io_info,H5D_chunk_map_t *fm,const void *buf, - hbool_t do_write,int sum_chunk); - -static herr_t -H5D_inter_collective_io(H5D_io_info_t *io_info,const H5S_t *file_space, - const H5S_t *mem_space,haddr_t addr, - const void *buf, hbool_t do_write ); - -static herr_t -H5D_final_collective_io(H5D_io_info_t *io_info,MPI_Datatype*mpi_file_type, - MPI_Datatype *mpi_buf_type, - H5D_common_coll_info_t* coll_info, - const void *buf, hbool_t do_write); -static herr_t -H5D_sort_chunk(H5D_io_info_t * io_info, - H5D_chunk_map_t *fm, - H5D_chunk_addr_info_t chunk_addr_info_array[], - int many_chunk_opt); - -static herr_t -H5D_obtain_mpio_mode(H5D_io_info_t* io_info, - H5D_chunk_map_t *fm, - uint8_t assign_io_mode[], - haddr_t chunk_addr[]); - -static herr_t H5D_ioinfo_make_ind(H5D_io_info_t *io_info); -static herr_t H5D_ioinfo_make_coll_opt(H5D_io_info_t *io_info); -static herr_t H5D_ioinfo_make_coll(H5D_io_info_t *io_info); +static herr_t H5D_chunk_collective_io(H5D_io_info_t *io_info, + const H5D_type_info_t *type_info, H5D_chunk_map_t *fm); +static herr_t H5D_multi_chunk_collective_io(H5D_io_info_t *io_info, + const H5D_type_info_t *type_info, H5D_chunk_map_t *fm, + H5P_genplist_t *dx_plist); +static herr_t H5D_multi_chunk_collective_io_no_opt(H5D_io_info_t *io_info, + const H5D_type_info_t *type_info, H5D_chunk_map_t *fm, H5P_genplist_t *dx_plist); +#ifdef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS +static herr_t H5D_link_chunk_collective_io(H5D_io_info_t *io_info, + const H5D_type_info_t *type_info, H5D_chunk_map_t *fm, int sum_chunk); +#endif /* H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS */ +static herr_t H5D_inter_collective_io(H5D_io_info_t *io_info, + const H5D_type_info_t *type_info, const H5S_t *file_space, + const H5S_t *mem_space); +static herr_t H5D_final_collective_io(H5D_io_info_t *io_info, + const H5D_type_info_t *type_info, size_t nelmts, MPI_Datatype *mpi_file_type, + MPI_Datatype *mpi_buf_type); +static herr_t H5D_sort_chunk(H5D_io_info_t *io_info, const H5D_chunk_map_t *fm, + H5D_chunk_addr_info_t chunk_addr_info_array[], int many_chunk_opt); +static herr_t H5D_obtain_mpio_mode(H5D_io_info_t *io_info, H5D_chunk_map_t *fm, + H5P_genplist_t *dx_plist, uint8_t assign_io_mode[], haddr_t chunk_addr[]); +static herr_t H5D_ioinfo_xfer_mode(H5D_io_info_t *io_info, H5P_genplist_t *dx_plist, + H5FD_mpio_xfer_t xfer_mode); +static herr_t H5D_ioinfo_coll_opt_mode(H5D_io_info_t *io_info, H5P_genplist_t *dx_plist, + H5FD_mpio_collective_opt_t coll_opt_mode); static herr_t H5D_mpio_get_min_chunk(const H5D_io_info_t *io_info, const H5D_chunk_map_t *fm, int *min_chunkf); static int H5D_cmp_chunk_addr(const void *addr1, const void *addr2); static herr_t H5D_mpio_get_sum_chunk(const H5D_io_info_t *io_info, - const H5D_chunk_map_t *fm, int *sum_chunkf); + const H5D_chunk_map_t *fm, int *sum_chunkf); /*********************/ /* Package Variables */ /*********************/ + /*******************/ /* Local Variables */ /*******************/ @@ -175,64 +157,77 @@ static herr_t H5D_mpio_get_sum_chunk(const H5D_io_info_t *io_info, *------------------------------------------------------------------------- */ htri_t -H5D_mpio_opt_possible( const H5D_io_info_t *io_info, - const H5S_t *mem_space, const H5S_t *file_space, const H5T_path_t *tpath) +H5D_mpio_opt_possible(const H5D_io_info_t *io_info, const H5S_t *file_space, + const H5S_t *mem_space, const H5D_type_info_t *type_info, + const H5D_chunk_map_t *fm) { - int local_opinion = TRUE; /* This process's idea of whether to perform collective I/O or not */ - int consensus; /* Consensus opinion of all processes */ - int mpi_code; /* MPI error code */ - htri_t ret_value=TRUE; + int local_opinion = TRUE; /* This process's idea of whether to perform collective I/O or not */ + int consensus; /* Consensus opinion of all processes */ + int mpi_code; /* MPI error code */ + htri_t ret_value = TRUE; - FUNC_ENTER_NOAPI(H5D_mpio_opt_possible, FAIL); + FUNC_ENTER_NOAPI(H5D_mpio_opt_possible, FAIL) /* Check args */ - assert(io_info); - assert(mem_space); - assert(file_space); + HDassert(io_info); + HDassert(mem_space); + HDassert(file_space); + HDassert(type_info); /* For independent I/O, get out quickly and don't try to form consensus */ - if (io_info->dxpl_cache->xfer_mode==H5FD_MPIO_INDEPENDENT) + if(io_info->dxpl_cache->xfer_mode == H5FD_MPIO_INDEPENDENT) HGOTO_DONE(FALSE); + /* Don't allow collective operations if datatype conversions need to happen */ + if(!type_info->is_conv_noop) { + local_opinion = FALSE; + goto broadcast; + } /* end if */ + + /* Don't allow collective operations if data transform operations should occur */ + if(!type_info->is_xform_noop) { + local_opinion = FALSE; + goto broadcast; + } /* end if */ + /* Optimized MPI types flag must be set and it must be collective IO */ /* (Don't allow parallel I/O for the MPI-posix driver, since it doesn't do real collective I/O) */ - if (!(H5S_mpi_opt_types_g && io_info->dxpl_cache->xfer_mode==H5FD_MPIO_COLLECTIVE && !IS_H5FD_MPIPOSIX(io_info->dset->oloc.file))) { + if(!(H5S_mpi_opt_types_g && io_info->dxpl_cache->xfer_mode == H5FD_MPIO_COLLECTIVE + && !IS_H5FD_MPIPOSIX(io_info->dset->oloc.file))) { local_opinion = FALSE; goto broadcast; } /* end if */ /* Check whether these are both simple or scalar dataspaces */ - if (!((H5S_SIMPLE==H5S_GET_EXTENT_TYPE(mem_space) || H5S_SCALAR==H5S_GET_EXTENT_TYPE(mem_space)) - && (H5S_SIMPLE==H5S_GET_EXTENT_TYPE(file_space) || H5S_SCALAR==H5S_GET_EXTENT_TYPE(file_space)))) { + if(!((H5S_SIMPLE == H5S_GET_EXTENT_TYPE(mem_space) || H5S_SCALAR == H5S_GET_EXTENT_TYPE(mem_space)) + && (H5S_SIMPLE == H5S_GET_EXTENT_TYPE(file_space) || H5S_SCALAR == H5S_GET_EXTENT_TYPE(file_space)))) { local_opinion = FALSE; goto broadcast; } /* end if */ /* Can't currently handle point selections */ - if (H5S_SEL_POINTS==H5S_GET_SELECT_TYPE(mem_space) || H5S_SEL_POINTS==H5S_GET_SELECT_TYPE(file_space)) { + if(H5S_SEL_POINTS == H5S_GET_SELECT_TYPE(mem_space) + || H5S_SEL_POINTS == H5S_GET_SELECT_TYPE(file_space)) { local_opinion = FALSE; goto broadcast; } /* end if */ /* Dataset storage must be contiguous or chunked */ - if (!(io_info->dset->shared->layout.type == H5D_CONTIGUOUS || + if(!(io_info->dset->shared->layout.type == H5D_CONTIGUOUS || io_info->dset->shared->layout.type == H5D_CHUNKED)) { local_opinion = FALSE; goto broadcast; } /* end if */ - /* The handling of memory space is different for chunking - and contiguous storage, - For contigous storage, mem_space and file_space won't - change when it it is doing disk IO. - For chunking storage, mem_space will change for different - chunks. So for chunking storage, whether we can use - collective IO will defer until each chunk IO is reached. - For contiguous storage, if we find MPI-IO cannot - support complicated MPI derived data type and the shape - of data space is not regular, we will - set use_par_opt_io = FALSE. - */ + /* The handling of memory space is different for chunking and contiguous + * storage. For contiguous storage, mem_space and file_space won't change + * when it it is doing disk IO. For chunking storage, mem_space will + * change for different chunks. So for chunking storage, whether we can + * use collective IO will defer until each chunk IO is reached. For + * contiguous storage, if we find MPI-IO cannot support complicated MPI + * derived data type and the shape of data space is not regular, we will + * set use_par_opt_io = FALSE. + */ #ifndef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS if(io_info->dset->shared->layout.type == H5D_CONTIGUOUS) if((H5S_SELECT_IS_REGULAR(file_space) != TRUE) || @@ -243,81 +238,43 @@ H5D_mpio_opt_possible( const H5D_io_info_t *io_info, #endif /* Don't allow collective operations if filters need to be applied */ - if(io_info->dset->shared->layout.type == H5D_CHUNKED) - if(io_info->dset->shared->dcpl_cache.pline.nused>0) { + if(io_info->dset->shared->layout.type == H5D_CHUNKED) { + if(io_info->dset->shared->dcpl_cache.pline.nused > 0) { local_opinion = FALSE; goto broadcast; } /* end if */ - /* Don't allow collective operations if datatype conversions need to happen */ - if(!H5T_path_noop(tpath)) { - local_opinion = FALSE; - goto broadcast; - } /* end if */ - - /* Don't allow collective operations if data transform operations should occur */ - if(!H5Z_xform_noop(io_info->dxpl_cache->data_xform_prop)) { - local_opinion = FALSE; - goto broadcast; +/* If H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS and H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS + * are defined, the HDF5 library will do collective IO if the application + * asks for it. + * + * If H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS is not defined and one or more + * processes are not participating in the IO, then collective IO is not + * assured. The library will check each process for the number of chunks + * it involves. If any process involves zero chunks, the library will use + * independent IO mode instead. + */ +#ifndef H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS + /* Check the number of chunks to perform I/O on */ + if(0 == H5SL_count(fm->sel_chunks)) { + local_opinion = FALSE; + goto broadcast; + } /* end if */ +#endif /* H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS */ } /* end if */ broadcast: /* Form consensus opinion among all processes about whether to perform - * collective I/O */ - if (MPI_SUCCESS != (mpi_code = MPI_Allreduce(&local_opinion, &consensus, 1, MPI_INT, MPI_LAND, io_info->comm))) + * collective I/O + */ + if(MPI_SUCCESS != (mpi_code = MPI_Allreduce(&local_opinion, &consensus, 1, MPI_INT, MPI_LAND, io_info->comm))) HMPI_GOTO_ERROR(FAIL, "MPI_Allreduce failed", mpi_code) ret_value = consensus > 0 ? TRUE : FALSE; done: - FUNC_LEAVE_NOAPI(ret_value); -} /* H5D_mpio_opt_possible() */ - - -/*------------------------------------------------------------------------- - * Function: H5D_mpio_chunk_adjust_iomode - * - * Decription: If H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS and - H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS are defined, - the HDF5 library will do collective IO if the application asks for it. - - If H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS is not defined - and one or more processes are not participating in the IO, - then collective IO is not assured. The library will check - each process for the - number of chunks it involves. If any process involves zero chunks, - the library will use independent IO mode instead. - This function is only used for linked chunk IO. - * Purpose: Checks if it is possible to do collective IO - * - * Return: Success: Non-negative: TRUE or FALSE - * Failure: Negative - * - * Programmer: Muqun Yang - * Monday, Feb. 13th, 2006 - * - *------------------------------------------------------------------------- - */ -#ifndef H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS -herr_t -H5D_mpio_chunk_adjust_iomode(H5D_io_info_t *io_info, const H5D_chunk_map_t *fm) -{ - int min_chunk; - herr_t ret_value = SUCCEED; - - FUNC_ENTER_NOAPI_NOINIT(H5D_mpio_chunk_adjust_iomode) - - if(H5D_mpio_get_min_chunk(io_info,fm,&min_chunk) < 0) - HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSWAP, FAIL, "unable to obtain the min chunk number of all processes"); - if(min_chunk == 0) { - /* Switch to independent I/O */ - if(H5D_ioinfo_make_ind(io_info) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to independent I/O") - } /* end if */ -done: FUNC_LEAVE_NOAPI(ret_value) -} -#endif +} /* H5D_mpio_opt_possible() */ /*------------------------------------------------------------------------- @@ -332,23 +289,20 @@ done: *------------------------------------------------------------------------- */ herr_t -H5D_mpio_select_read(H5D_io_info_t *io_info, - size_t mpi_buf_count, - const size_t UNUSED elmt_size, - const H5S_t UNUSED *file_space, - const H5S_t UNUSED *mem_space, - haddr_t addr, - void UNUSED *pointer, - void *buf/*out*/) +H5D_mpio_select_read(const H5D_io_info_t *io_info, const H5D_type_info_t UNUSED *type_info, + hsize_t mpi_buf_count, const H5S_t UNUSED *file_space, const H5S_t UNUSED *mem_space) { + const H5D_contig_storage_t *store_contig = &(io_info->store->contig); /* Contiguous storage info for this I/O operation */ herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI(H5D_mpio_select_read,FAIL); + FUNC_ENTER_NOAPI(H5D_mpio_select_read, FAIL) + + H5_CHECK_OVERFLOW(mpi_buf_count, hsize_t, size_t); + if(H5F_block_read(io_info->dset->oloc.file, H5FD_MEM_DRAW, store_contig->dset_addr, (size_t)mpi_buf_count, io_info->dxpl_id, io_info->u.rbuf) < 0) + HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "can't finish collective parallel read") - if(H5F_block_read (io_info->dset->oloc.file, H5FD_MEM_DRAW, addr, mpi_buf_count, io_info->dxpl_id, buf) < 0) - HGOTO_ERROR(H5E_IO,H5E_READERROR,FAIL,"can't finish collective parallel read"); done: - FUNC_LEAVE_NOAPI(ret_value); + FUNC_LEAVE_NOAPI(ret_value) } /* end H5D_mpio_select_read() */ @@ -364,32 +318,28 @@ done: *------------------------------------------------------------------------- */ herr_t -H5D_mpio_select_write(H5D_io_info_t *io_info, - size_t mpi_buf_count, - const size_t UNUSED elmt_size, - const H5S_t UNUSED *file_space, - const H5S_t UNUSED *mem_space, - haddr_t addr, - void UNUSED *pointer, - const void *buf) +H5D_mpio_select_write(const H5D_io_info_t *io_info, const H5D_type_info_t UNUSED *type_info, + hsize_t mpi_buf_count, const H5S_t UNUSED *file_space, const H5S_t UNUSED *mem_space) { + const H5D_contig_storage_t *store_contig = &(io_info->store->contig); /* Contiguous storage info for this I/O operation */ herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI(H5D_mpio_select_write,FAIL); + FUNC_ENTER_NOAPI(H5D_mpio_select_write, FAIL) /*OKAY: CAST DISCARDS CONST QUALIFIER*/ - if(H5F_block_write (io_info->dset->oloc.file, H5FD_MEM_DRAW, addr, mpi_buf_count, io_info->dxpl_id, buf)<0) - HGOTO_ERROR(H5E_IO,H5E_WRITEERROR,FAIL,"can't finish collective parallel write"); + H5_CHECK_OVERFLOW(mpi_buf_count, hsize_t, size_t); + if(H5F_block_write(io_info->dset->oloc.file, H5FD_MEM_DRAW, store_contig->dset_addr, (size_t)mpi_buf_count, io_info->dxpl_id, io_info->u.wbuf) < 0) + HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "can't finish collective parallel write") done: - FUNC_LEAVE_NOAPI(ret_value); + FUNC_LEAVE_NOAPI(ret_value) } /* end H5D_mpio_select_write() */ /*------------------------------------------------------------------------- - * Function: H5D_ioinfo_make_ind + * Function: H5D_ioinfo_xfer_mode * - * Purpose: Switch to MPI independent I/O + * Purpose: Switch to between collective & independent MPI I/O * * Return: Non-negative on success/Negative on failure * @@ -399,42 +349,42 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5D_ioinfo_make_ind(H5D_io_info_t *io_info) +H5D_ioinfo_xfer_mode(H5D_io_info_t *io_info, H5P_genplist_t *dx_plist, + H5FD_mpio_xfer_t xfer_mode) { - H5P_genplist_t *dx_plist; /* Data transer property list */ herr_t ret_value = SUCCEED; /*return value */ - FUNC_ENTER_NOAPI_NOINIT(H5D_ioinfo_make_ind) - - /* Get the dataset transfer property list */ - if (NULL == (dx_plist = H5I_object(io_info->dxpl_id))) - HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset transfer property list") + FUNC_ENTER_NOAPI_NOINIT(H5D_ioinfo_xfer_mode) - /* Change the xfer_mode to independent, handle the request, - * then set xfer_mode before return. - */ - io_info->dxpl_cache->xfer_mode = H5FD_MPIO_INDEPENDENT; - if(H5P_set (dx_plist, H5D_XFER_IO_XFER_MODE_NAME, &io_info->dxpl_cache->xfer_mode) < 0) + /* Change the xfer_mode */ + io_info->dxpl_cache->xfer_mode = xfer_mode; + if(H5P_set(dx_plist, H5D_XFER_IO_XFER_MODE_NAME, &io_info->dxpl_cache->xfer_mode) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set transfer mode") - /* Set the pointers to the non-MPI-specific routines */ - io_info->ops.read = H5D_select_read; - io_info->ops.write = H5D_select_write; + /* Change the "single I/O" function pointers */ + if(xfer_mode == H5FD_MPIO_INDEPENDENT) { + /* Set the pointers to the original, non-MPI-specific routines */ + io_info->io_ops.single_read = io_info->orig.io_ops.single_read; + io_info->io_ops.single_write = io_info->orig.io_ops.single_write; + } /* end if */ + else { + HDassert(xfer_mode == H5FD_MPIO_COLLECTIVE); - /* Indicate that the transfer mode should be restored before returning - * to user. - */ - io_info->xfer_mode_changed=TRUE; + /* Set the pointers to the MPI-specific routines */ + io_info->io_ops.single_read = H5D_mpio_select_read; + io_info->io_ops.single_write = H5D_mpio_select_write; + } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) -} /* end H5D_ioinfo_make_ind() */ +} /* end H5D_ioinfo_xfer_mode() */ /*------------------------------------------------------------------------- - * Function: H5D_ioinfo_make_coll_opt + * Function: H5D_ioinfo_coll_opt_mode * - * Purpose: Switch to MPI independent I/O with file set view + * Purpose: Switch between using collective & independent MPI I/O w/file + * set view * * Return: Non-negative on success/Negative on failure * @@ -444,87 +394,21 @@ done: *------------------------------------------------------------------------- */ static herr_t -H5D_ioinfo_make_coll_opt(H5D_io_info_t *io_info) +H5D_ioinfo_coll_opt_mode(H5D_io_info_t *io_info, H5P_genplist_t *dx_plist, + H5FD_mpio_collective_opt_t coll_opt_mode) { - H5P_genplist_t *dx_plist; /* Data transer property list */ herr_t ret_value = SUCCEED; /*return value */ - FUNC_ENTER_NOAPI_NOINIT(H5D_ioinfo_make_coll_opt) + FUNC_ENTER_NOAPI_NOINIT(H5D_ioinfo_coll_opt_mode) - /* Get the dataset transfer property list */ - if (NULL == (dx_plist = H5I_object(io_info->dxpl_id))) - HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset transfer property list") - - /* Change the optimial xfer_mode to independent, handle the request, - * then set xfer_mode before return. - */ - io_info->dxpl_cache->xfer_opt_mode = H5FD_MPIO_INDIVIDUAL_IO; - if(H5P_set (dx_plist, H5D_XFER_IO_XFER_OPT_MODE_NAME, &io_info->dxpl_cache->xfer_opt_mode) < 0) + /* Change the optimal xfer_mode */ + io_info->dxpl_cache->coll_opt_mode = coll_opt_mode; + if(H5P_set(dx_plist, H5D_XFER_MPIO_COLLECTIVE_OPT_NAME, &io_info->dxpl_cache->coll_opt_mode) < 0) HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set transfer mode") - /* Set the pointers to the non-MPI-specific routines */ - io_info->ops.read = H5D_mpio_select_read; - io_info->ops.write = H5D_mpio_select_write; - - /* Indicate that the transfer mode should be restored before returning - * to user. - */ - io_info->xfer_opt_mode_changed = TRUE; - done: FUNC_LEAVE_NOAPI(ret_value) -} /* end H5D_ioinfo_make_coll_opt() */ - - -/*------------------------------------------------------------------------- - * Function: H5D_ioinfo_make_coll - * - * Purpose: Switch to MPI collective I/O - * - * Return: Non-negative on success/Negative on failure - * - * Programmer: Quincey Koziol - * Friday, August 12, 2005 - * - *------------------------------------------------------------------------- - */ -static herr_t -H5D_ioinfo_make_coll(H5D_io_info_t *io_info) -{ - H5P_genplist_t *dx_plist; /* Data transer property list */ - herr_t ret_value = SUCCEED; /*return value */ - - FUNC_ENTER_NOAPI_NOINIT(H5D_ioinfo_make_coll) - - /* Get the dataset transfer property list */ - if (NULL == (dx_plist = H5I_object(io_info->dxpl_id))) - HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset transfer property list") - - /* Change the xfer_mode to independent, handle the request, - * then set xfer_mode before return. - */ - io_info->dxpl_cache->xfer_mode = H5FD_MPIO_COLLECTIVE; - if(H5P_set (dx_plist, H5D_XFER_IO_XFER_MODE_NAME, &io_info->dxpl_cache->xfer_mode) < 0) - HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set transfer mode") - - io_info->dxpl_cache->xfer_opt_mode = H5FD_MPIO_COLLECTIVE_IO; - if(H5P_set (dx_plist, H5D_XFER_IO_XFER_OPT_MODE_NAME, &io_info->dxpl_cache->xfer_opt_mode) < 0) - HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set transfer mode") - - - /* Set the pointers to the MPI-specific routines */ - io_info->ops.read = H5D_mpio_select_read; - io_info->ops.write = H5D_mpio_select_write; - - /* Indicate that the transfer mode should _NOT_ be restored before returning - * to user. - */ - io_info->xfer_mode_changed=FALSE; - io_info->xfer_opt_mode_changed=FALSE; - -done: - FUNC_LEAVE_NOAPI(ret_value) -} /* end H5D_ioinfo_make_coll() */ +} /* end H5D_ioinfo_coll_opt_mode() */ /*------------------------------------------------------------------------- @@ -535,29 +419,30 @@ done: * * Return: Non-negative on success/Negative on failure * - * Programmer: + * Programmer: Muqun Yang + * Monday, Feb. 13th, 2006 * *------------------------------------------------------------------------- */ static herr_t -H5D_mpio_get_min_chunk(const H5D_io_info_t *io_info, - const H5D_chunk_map_t *fm, int *min_chunkf) +H5D_mpio_get_min_chunk(const H5D_io_info_t *io_info, const H5D_chunk_map_t *fm, + int *min_chunkf) { int num_chunkf; /* Number of chunks to iterate over */ int mpi_code; /* MPI return code */ herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI_NOINIT(H5D_mpio_get_min_chunk); + FUNC_ENTER_NOAPI_NOINIT(H5D_mpio_get_min_chunk) /* Get the number of chunks to perform I/O on */ num_chunkf = H5SL_count(fm->sel_chunks); /* Determine the minimum # of chunks for all processes */ - if (MPI_SUCCESS != (mpi_code = MPI_Allreduce(&num_chunkf, min_chunkf, 1, MPI_INT, MPI_MIN, io_info->comm))) + if(MPI_SUCCESS != (mpi_code = MPI_Allreduce(&num_chunkf, min_chunkf, 1, MPI_INT, MPI_MIN, io_info->comm))) HMPI_GOTO_ERROR(FAIL, "MPI_Allreduce failed", mpi_code) done: - FUNC_LEAVE_NOAPI(ret_value); + FUNC_LEAVE_NOAPI(ret_value) } /* end H5D_mpio_get_min_chunk() */ @@ -569,221 +454,252 @@ done: * * Return: Non-negative on success/Negative on failure * - * Programmer: + * Programmer: Muqun Yang + * Monday, Feb. 13th, 2006 * *------------------------------------------------------------------------- */ static herr_t -H5D_mpio_get_sum_chunk(const H5D_io_info_t *io_info, - const H5D_chunk_map_t *fm, int *sum_chunkf) +H5D_mpio_get_sum_chunk(const H5D_io_info_t *io_info, const H5D_chunk_map_t *fm, + int *sum_chunkf) { int num_chunkf; /* Number of chunks to iterate over */ size_t ori_num_chunkf; int mpi_code; /* MPI return code */ herr_t ret_value = SUCCEED; - FUNC_ENTER_NOAPI_NOINIT(H5D_mpio_get_sum_chunk); + FUNC_ENTER_NOAPI_NOINIT(H5D_mpio_get_sum_chunk) /* Get the number of chunks to perform I/O on */ num_chunkf = 0; ori_num_chunkf = H5SL_count(fm->sel_chunks); - H5_ASSIGN_OVERFLOW(num_chunkf,ori_num_chunkf,size_t,int); + H5_ASSIGN_OVERFLOW(num_chunkf, ori_num_chunkf, size_t, int); /* Determine the summation of number of chunks for all processes */ - if (MPI_SUCCESS != (mpi_code = MPI_Allreduce(&num_chunkf, sum_chunkf, 1, MPI_INT, MPI_SUM, io_info->comm))) + if(MPI_SUCCESS != (mpi_code = MPI_Allreduce(&num_chunkf, sum_chunkf, 1, MPI_INT, MPI_SUM, io_info->comm))) HMPI_GOTO_ERROR(FAIL, "MPI_Allreduce failed", mpi_code) done: - FUNC_LEAVE_NOAPI(ret_value); + FUNC_LEAVE_NOAPI(ret_value) } /* end H5D_mpio_get_sum_chunk() */ /*------------------------------------------------------------------------- - * Function: H5D_contig_collective_io + * Function: H5D_contig_collective_read * - * Purpose: Wrapper Routine for H5D_inter_collective_io - The starting file address of contiguous layout - will be calculated and passed to H5D_inter_collective_io routine. - * + * Purpose: Reads directly from contiguous data in file into application + * memory using collective I/O. * * Return: Non-negative on success/Negative on failure * - * Programmer: - * - * Modifications: + * Programmer: Quincey Koziol + * Tuesday, March 4, 2008 * *------------------------------------------------------------------------- */ herr_t -H5D_contig_collective_io(H5D_io_info_t *io_info, - const H5S_t *file_space, - const H5S_t *mem_space, - const void *buf, - hbool_t do_write) +H5D_contig_collective_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, + hsize_t UNUSED nelmts, const H5S_t *file_space, const H5S_t *mem_space, + H5D_chunk_map_t UNUSED *fm) { + herr_t ret_value = SUCCEED; /* Return value */ + FUNC_ENTER_NOAPI(H5D_contig_collective_read, FAIL) - haddr_t addr = HADDR_UNDEF; /* Address of dataset (or selection) within file */ - herr_t ret_value = SUCCEED; /* return value */ + /* Sanity check */ + HDassert(IS_H5FD_MPIO(io_info->dset->oloc.file)); + HDassert(TRUE == H5P_isa_class(io_info->dxpl_id, H5P_DATASET_XFER)); + + /* Call generic internal collective I/O routine */ + if(H5D_inter_collective_io(io_info, type_info, file_space, mem_space) < 0) + HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "couldn't finish shared collective MPI-IO") - FUNC_ENTER_NOAPI_NOINIT(H5D_contig_collective_io) - assert (IS_H5FD_MPIO(io_info->dset->oloc.file)); +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_contig_collective_read() */ - /* Make certain we have the correct type of property list */ - assert(TRUE==H5P_isa_class(io_info->dxpl_id,H5P_DATASET_XFER)); + +/*------------------------------------------------------------------------- + * Function: H5D_contig_collective_write + * + * Purpose: Write directly to contiguous data in file from application + * memory using collective I/O. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Quincey Koziol + * Tuesday, March 4, 2008 + * + *------------------------------------------------------------------------- + */ +herr_t +H5D_contig_collective_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, + hsize_t UNUSED nelmts, const H5S_t *file_space, const H5S_t *mem_space, + H5D_chunk_map_t UNUSED *fm) +{ + herr_t ret_value = SUCCEED; /* Return value */ - /* Get the base address of the contiguous dataset */ - if(io_info->dset->shared->layout.type == H5D_CONTIGUOUS) - addr = H5D_contig_get_addr(io_info->dset); + FUNC_ENTER_NOAPI(H5D_contig_collective_write, FAIL) - if(H5D_inter_collective_io(io_info,file_space,mem_space,addr,buf,do_write)<0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish shared collective MPI-IO"); - - done: + /* Sanity check */ + HDassert(IS_H5FD_MPIO(io_info->dset->oloc.file)); + HDassert(TRUE == H5P_isa_class(io_info->dxpl_id, H5P_DATASET_XFER)); + /* Call generic internal collective I/O routine */ + if(H5D_inter_collective_io(io_info, type_info, file_space, mem_space) < 0) + HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "couldn't finish shared collective MPI-IO") + +done: FUNC_LEAVE_NOAPI(ret_value) -} /* end H5D_contig_collective_io */ +} /* end H5D_contig_collective_write() */ /*------------------------------------------------------------------------- * Function: H5D_chunk_collective_io * * Purpose: Routine for - 1) choose an IO option: - a) One collective IO defined by one MPI derived datatype to link through all chunks - or b) multiple chunk IOs,to do MPI-IO for each chunk, the IO mode may be adjusted - due to the selection pattern for each chunk. + * 1) choose an IO option: + * a) One collective IO defined by one MPI derived datatype to link through all chunks + * or b) multiple chunk IOs,to do MPI-IO for each chunk, the IO mode may be adjusted + * due to the selection pattern for each chunk. * For option a) - 1. Sort the chunk address, obtain chunk info according to the sorted chunk address - 2. Build up MPI derived datatype for each chunk - 3. Build up the final MPI derived datatype - 4. Set up collective IO property list - 5. Do IO + * 1. Sort the chunk address, obtain chunk info according to the sorted chunk address + * 2. Build up MPI derived datatype for each chunk + * 3. Build up the final MPI derived datatype + * 4. Set up collective IO property list + * 5. Do IO * For option b) - 1. Use MPI_gather and MPI_Bcast to obtain information of *collective/independent/none* - IO mode for each chunk of the selection - 2. Depending on whether the IO mode is collective or independent or none, - Create either MPI derived datatype for each chunk to do collective IO or - just do independent IO or independent IO with file set view - 3. Set up collective IO property list for collective mode - 4. DO IO + * 1. Use MPI_gather and MPI_Bcast to obtain information of *collective/independent/none* + * IO mode for each chunk of the selection + * 2. Depending on whether the IO mode is collective or independent or none, + * Create either MPI derived datatype for each chunk to do collective IO or + * just do independent IO or independent IO with file set view + * 3. Set up collective IO property list for collective mode + * 4. DO IO * * Return: Non-negative on success/Negative on failure * - * Programmer: - * - * Modifications: + * Programmer: Muqun Yang + * Monday, Feb. 13th, 2006 * *------------------------------------------------------------------------- */ -herr_t -H5D_chunk_collective_io(H5D_io_info_t *io_info,H5D_chunk_map_t *fm,const void *buf, hbool_t do_write) +static herr_t +H5D_chunk_collective_io(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, + H5D_chunk_map_t *fm) { - - int io_option = H5D_MULTI_CHUNK_IO_MORE_OPT; - int sum_chunk = 0,mpi_size; - unsigned one_link_chunk_io_threshold; - H5P_genplist_t *plist; + H5P_genplist_t *dx_plist; /* Pointer to DXPL */ H5FD_mpio_chunk_opt_t chunk_opt_mode; - + int io_option = H5D_MULTI_CHUNK_IO_MORE_OPT; + int sum_chunk = -1; #ifdef H5_HAVE_INSTRUMENTED_LIBRARY - htri_t check_prop,temp_not_link_io = FALSE; - int new_value; + htri_t temp_not_link_io = FALSE; #endif - herr_t ret_value = SUCCEED; + herr_t ret_value = SUCCEED; FUNC_ENTER_NOAPI_NOINIT(H5D_chunk_collective_io) - assert (IS_H5FD_MPIO(io_info->dset->oloc.file)); + /* Sanity checks */ + HDassert(io_info); + HDassert(io_info->using_mpi_vfd); + HDassert(type_info); + HDassert(fm); /* Obtain the data transfer properties */ - if(NULL == (plist = H5I_object(io_info->dxpl_id))) + if(NULL == (dx_plist = H5I_object(io_info->dxpl_id))) HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list") - + /* Check the optional property list on what to do with collective chunk IO. */ - chunk_opt_mode=(H5FD_mpio_chunk_opt_t)H5P_peek_unsigned(plist,H5D_XFER_MPIO_CHUNK_OPT_HARD_NAME); - + chunk_opt_mode = (H5FD_mpio_chunk_opt_t)H5P_peek_unsigned(dx_plist, H5D_XFER_MPIO_CHUNK_OPT_HARD_NAME); if(chunk_opt_mode == H5FD_MPIO_CHUNK_ONE_IO) - io_option = H5D_ONE_LINK_CHUNK_IO;/*no opt*/ + io_option = H5D_ONE_LINK_CHUNK_IO; /*no opt*/ else if(chunk_opt_mode == H5FD_MPIO_CHUNK_MULTI_IO) - io_option = H5D_MULTI_CHUNK_IO;/*no opt */ + io_option = H5D_MULTI_CHUNK_IO; /*no opt */ else { - if(H5D_mpio_get_sum_chunk(io_info,fm,&sum_chunk)<0) + unsigned one_link_chunk_io_threshold; /* Threshhold to use single collective I/O for all chunks */ + int mpi_size; /* Number of processes in MPI job */ + + if(H5D_mpio_get_sum_chunk(io_info, fm, &sum_chunk) < 0) HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSWAP, FAIL, "unable to obtain the total chunk number of all processes"); - if((mpi_size = H5F_mpi_get_size(io_info->dset->oloc.file))<0) - HGOTO_ERROR (H5E_IO, H5E_MPI, FAIL, "unable to obtain mpi size"); + if((mpi_size = H5F_mpi_get_size(io_info->dset->oloc.file)) < 0) + HGOTO_ERROR(H5E_IO, H5E_MPI, FAIL, "unable to obtain mpi size") - if(NULL == (plist = H5I_object(io_info->dxpl_id))) - HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list") - - one_link_chunk_io_threshold =H5P_peek_unsigned(plist,H5D_XFER_MPIO_CHUNK_OPT_NUM_NAME); + one_link_chunk_io_threshold = H5P_peek_unsigned(dx_plist, H5D_XFER_MPIO_CHUNK_OPT_NUM_NAME); - /* step 1: choose an IO option */ - /* If the average number of chunk per process is greater than a threshold, we will do one link chunked IO. */ - if((unsigned)sum_chunk/mpi_size >= one_link_chunk_io_threshold) + /* step 1: choose an IO option */ + /* If the average number of chunk per process is greater than a threshold, we will do one link chunked IO. */ + if((unsigned)sum_chunk / mpi_size >= one_link_chunk_io_threshold) io_option = H5D_ONE_LINK_CHUNK_IO_MORE_OPT; #ifdef H5_HAVE_INSTRUMENTED_LIBRARY - else - temp_not_link_io = TRUE; + else + temp_not_link_io = TRUE; +#endif + } /* end else */ + +#ifndef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS + if(io_option == H5D_ONE_LINK_CHUNK_IO) + io_option = H5D_MULTI_CHUNK_IO; /* We can not do this with one chunk IO. */ + if(io_option == H5D_ONE_LINK_CHUNK_IO_MORE_OPT) + io_option = H5D_MULTI_CHUNK_IO_MORE_OPT; #endif - } #ifdef H5_HAVE_INSTRUMENTED_LIBRARY +{ + htri_t check_prop; + int new_value; + /*** Test collective chunk user-input optimization APIs. ***/ - check_prop = H5Pexist(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_LINK_HARD_NAME); + check_prop = H5Pexist(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_LINK_HARD_NAME); if(check_prop > 0) { if(io_option == H5D_ONE_LINK_CHUNK_IO) { - new_value = 0; - if(H5Pset(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_LINK_HARD_NAME,&new_value)<0) - HGOTO_ERROR(H5E_PLIST, H5E_UNSUPPORTED, FAIL, "unable to get property value"); - } - } - check_prop = H5Pexist(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_MULTI_HARD_NAME); + new_value = 0; + if(H5Pset(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_LINK_HARD_NAME, &new_value) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTSET, FAIL, "unable to set property value") + } /* end if */ + } /* end if */ + check_prop = H5Pexist(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_MULTI_HARD_NAME); if(check_prop > 0) { - if(io_option == H5D_MULTI_CHUNK_IO) { - new_value = 0; - if(H5Pset(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_MULTI_HARD_NAME,&new_value)<0) - HGOTO_ERROR(H5E_PLIST, H5E_UNSUPPORTED, FAIL, "unable to get property value"); - } - } - check_prop = H5Pexist(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_LINK_NUM_TRUE_NAME); + if(io_option == H5D_MULTI_CHUNK_IO) { + new_value = 0; + if(H5Pset(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_MULTI_HARD_NAME, &new_value) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTSET, FAIL, "unable to set property value") + } /* end if */ + } /* end if */ + check_prop = H5Pexist(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_LINK_NUM_TRUE_NAME); if(check_prop > 0) { - if(io_option == H5D_ONE_LINK_CHUNK_IO_MORE_OPT) { - new_value = 0; - if(H5Pset(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_LINK_NUM_TRUE_NAME,&new_value)<0) - HGOTO_ERROR(H5E_PLIST, H5E_UNSUPPORTED, FAIL, "unable to get property value"); - } - } - check_prop = H5Pexist(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_LINK_NUM_FALSE_NAME); + if(io_option == H5D_ONE_LINK_CHUNK_IO_MORE_OPT) { + new_value = 0; + if(H5Pset(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_LINK_NUM_TRUE_NAME, &new_value) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTSET, FAIL, "unable to set property value") + } /* end if */ + } /* end if */ + check_prop = H5Pexist(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_LINK_NUM_FALSE_NAME); if(check_prop > 0) { - if(temp_not_link_io){ - new_value = 0; - if(H5Pset(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_LINK_NUM_FALSE_NAME,&new_value)<0) - HGOTO_ERROR(H5E_PLIST, H5E_UNSUPPORTED, FAIL, "unable to get property value"); - } - } -#endif - -#ifndef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS - if(io_option == H5D_ONE_LINK_CHUNK_IO ) - io_option = H5D_MULTI_CHUNK_IO ;/* We can not do this with one chunk IO. */ - if(io_option == H5D_ONE_LINK_CHUNK_IO_MORE_OPT) - io_option = H5D_MULTI_CHUNK_IO_MORE_OPT; + if(temp_not_link_io) { + new_value = 0; + if(H5Pset(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_LINK_NUM_FALSE_NAME, &new_value) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTSET, FAIL, "unable to set property value") + } /* end if */ + } /* end if */ +} #endif /* step 2: Go ahead to do IO.*/ +#ifdef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS if(io_option == H5D_ONE_LINK_CHUNK_IO || io_option == H5D_ONE_LINK_CHUNK_IO_MORE_OPT) { - if(H5D_link_chunk_collective_io(io_info,fm,buf,do_write,sum_chunk)<0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish linked chunk MPI-IO"); - } - else if(io_option == H5D_MULTI_CHUNK_IO) { - if(H5D_multi_chunk_collective_io_no_opt(io_info,fm,buf,do_write)<0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish multiple chunk MPI-IO"); - } + if(H5D_link_chunk_collective_io(io_info, type_info, fm, sum_chunk) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL, "couldn't finish linked chunk MPI-IO") + } /* end if */ + else +#endif /* H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS */ + if(io_option == H5D_MULTI_CHUNK_IO) { + if(H5D_multi_chunk_collective_io_no_opt(io_info, type_info, fm, dx_plist) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL, "couldn't finish multiple chunk MPI-IO") + } /* end if */ else { /*multiple chunk IOs with opt */ - if(H5D_multi_chunk_collective_io(io_info,fm,buf,do_write)<0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish multiple chunk MPI-IO"); - } + if(H5D_multi_chunk_collective_io(io_info, type_info, fm, dx_plist) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL, "couldn't finish optimized multiple chunk MPI-IO") + } /* end else */ done: FUNC_LEAVE_NOAPI(ret_value) @@ -791,459 +707,583 @@ done: /*------------------------------------------------------------------------- - * Function: H5D_link_chunk_collective_io + * Function: H5D_chunk_collective_read * - * Purpose: Routine for one collective IO with one MPI derived datatype to link with all chunks + * Purpose: Reads directly from chunks in file into application memory + * using collective I/O. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Quincey Koziol + * Tuesday, March 4, 2008 + * + *------------------------------------------------------------------------- + */ +herr_t +H5D_chunk_collective_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, + hsize_t UNUSED nelmts, const H5S_t UNUSED *file_space, const H5S_t UNUSED *mem_space, + H5D_chunk_map_t *fm) +{ + herr_t ret_value = SUCCEED; /* Return value */ - 1. Sort the chunk address and chunk info - 2. Build up MPI derived datatype for each chunk - 3. Build up the final MPI derived datatype - 4. Use common collective IO routine to do MPI-IO + FUNC_ENTER_NOAPI(H5D_chunk_collective_read, FAIL) + /* Call generic selection operation */ + if(H5D_chunk_collective_io(io_info, type_info, fm) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_READERROR, FAIL, "read error") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_chunk_collective_read() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_chunk_collective_write * - * Return: Non-negative on success/Negative on failure + * Purpose: Write directly to chunks in file from application memory + * using collective I/O. * - * Programmer: + * Return: Non-negative on success/Negative on failure * - * Modifications: + * Programmer: Quincey Koziol + * Tuesday, March 4, 2008 * *------------------------------------------------------------------------- */ +herr_t +H5D_chunk_collective_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, + hsize_t UNUSED nelmts, const H5S_t UNUSED *file_space, const H5S_t UNUSED *mem_space, + H5D_chunk_map_t *fm) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(H5D_chunk_collective_write, FAIL) + + /* Call generic selection operation */ + if(H5D_chunk_collective_io(io_info, type_info, fm) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_WRITEERROR, FAIL, "write error") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_chunk_collective_write() */ +#ifdef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS + +/*------------------------------------------------------------------------- + * Function: H5D_link_chunk_collective_io + * + * Purpose: Routine for one collective IO with one MPI derived datatype to link with all chunks + * + * 1. Sort the chunk address and chunk info + * 2. Build up MPI derived datatype for each chunk + * 3. Build up the final MPI derived datatype + * 4. Use common collective IO routine to do MPI-IO + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Muqun Yang + * Monday, Feb. 13th, 2006 + * + *------------------------------------------------------------------------- + */ static herr_t -H5D_link_chunk_collective_io(H5D_io_info_t *io_info,H5D_chunk_map_t *fm,const void *buf, hbool_t do_write,int sum_chunk) +H5D_link_chunk_collective_io(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, + H5D_chunk_map_t *fm, int sum_chunk) { - size_t src_type_size; /*size of source type */ - size_t dst_type_size; /*size of destination type*/ - hsize_t mpi_buf_extra_offset; - hsize_t mpi_file_extra_offset; - size_t mpi_buf_count; - size_t mpi_file_count; - hbool_t mbt_is_derived=0, /* Whether the buffer (memory) type is derived and needs to be free'd */ - mft_is_derived=0; /* Whether the file type is derived and needs to be free'd */ - - int mpi_size,mpi_code; /* MPI return code */ - - int i,num_chunk=0,total_chunks; - size_t ori_num_chunk; - hsize_t ori_total_chunks; - haddr_t chunk_base_addr; - haddr_t* total_chunk_addr_array=NULL; - MPI_Datatype *chunk_mtype=NULL; - MPI_Datatype *chunk_ftype=NULL; - MPI_Datatype chunk_final_mtype; - MPI_Datatype chunk_final_ftype; - MPI_Aint *chunk_disp_array=NULL; - MPI_Aint *chunk_mem_disp_array=NULL; - int *blocklen=NULL; - int blocklen_value; - int actual_bsearch_coll_chunk_threshold; - int bsearch_coll_chunk_threshold; - int many_chunk_opt = 0; - - H5D_common_coll_info_t coll_info; - H5D_chunk_addr_info_t* chunk_addr_info_array=NULL; - - herr_t ret_value = SUCCEED; - - FUNC_ENTER_NOAPI_NOINIT(H5D_link_chunk_collective_io) - ori_total_chunks = fm->total_chunks; - H5_ASSIGN_OVERFLOW(total_chunks,ori_total_chunks,hsize_t,int); - - /* Handle with a special case when only one chunk is covered by all processes */ - if(total_chunks == 1){ - H5SL_node_t *chunk_node; - H5D_chunk_info_t *chunk_info; - H5D_storage_t store; + H5D_chunk_addr_info_t *chunk_addr_info_array = NULL; + hbool_t mbt_is_derived = FALSE; + hbool_t mft_is_derived = FALSE; + MPI_Datatype chunk_final_mtype; /* Final memory MPI datatype for all chunks with seletion */ + MPI_Datatype chunk_final_ftype; /* Final file MPI datatype for all chunks with seletion */ + H5D_storage_t ctg_store; /* Storage info for "fake" contiguous dataset */ + size_t total_chunks; + haddr_t *total_chunk_addr_array = NULL; + MPI_Datatype *chunk_mtype = NULL; + MPI_Datatype *chunk_ftype = NULL; + MPI_Aint *chunk_disp_array = NULL; + MPI_Aint *chunk_mem_disp_array = NULL; + int *blocklen = NULL; + int mpi_code; /* MPI return code */ + herr_t ret_value = SUCCEED; + + FUNC_ENTER_NOAPI_NOINIT(H5D_link_chunk_collective_io) + + /* Get the sum # of chunks, if not already available */ + if(sum_chunk < 0) { + if(H5D_mpio_get_sum_chunk(io_info, fm, &sum_chunk) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSWAP, FAIL, "unable to obtain the total chunk number of all processes"); + } /* end if */ + + /* Retrieve total # of chunks in dataset */ + H5_ASSIGN_OVERFLOW(total_chunks, fm->total_chunks, hsize_t, size_t); + + /* Handle special case when dataspace dimensions only allow one chunk in + * the dataset. [This sometimes is used by developers who want the + * equivalent of compressed contiguous datasets - QAK] + */ + if(total_chunks == 1) { + H5D_storage_t chk_store; /* Temporary storage info for chunk address lookup */ + hsize_t coords[H5O_LAYOUT_NDIMS]; /* Coordinates of chunk in file dataset's dataspace */ + H5SL_node_t *chunk_node; /* Pointer to chunk node for selection */ + H5S_t *fspace; /* Dataspace describing chunk & selection in it */ + H5S_t *mspace; /* Dataspace describing selection in memory corresponding to this chunk */ + + /* Initialize the chunk coordinates */ + /* (must be all zero, since there's only one chunk) */ + HDmemset(coords, 0, sizeof(coords)); + + /* Look up address of chunk */ + io_info->store = &chk_store; + chk_store.chunk.offset = coords; + chk_store.chunk.index = 0; + if(HADDR_UNDEF == (ctg_store.contig.dset_addr = H5D_istore_get_addr(io_info, NULL))) + HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL, "couldn't get chunk info from skipped list") + /* Check for this process having selection in this chunk */ chunk_node = H5SL_first(fm->sel_chunks); if(chunk_node == NULL) { - if(H5D_istore_chunkmap(io_info, &chunk_base_addr, fm->down_chunks) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address"); - if(H5D_inter_collective_io(io_info,NULL,NULL,chunk_base_addr,buf,do_write)<0) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't finish shared collective MPI-IO"); - } + /* Set the dataspace info for I/O to NULL, this process doesn't have any I/O to perform */ + fspace = mspace = NULL; + } /* end if */ else { - if(NULL ==(chunk_info = H5SL_item(chunk_node))) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk info from skipped list"); - io_info->store = &store; - store.chunk.offset = chunk_info->coords; - store.chunk.index = chunk_info->index; + H5D_chunk_info_t *chunk_info; + + /* Get the chunk info, for the selection in the chunk */ + if(NULL == (chunk_info = H5SL_item(chunk_node))) + HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL, "couldn't get chunk info from skipped list") + + /* Set the dataspace info for I/O */ + fspace = chunk_info->fspace; + mspace = chunk_info->mspace; + } /* end else */ + + /* Set up the base storage address for this chunk */ + io_info->store = &ctg_store; - if(HADDR_UNDEF==(chunk_base_addr = H5D_istore_get_addr(io_info,NULL))) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk info from skipped list"); - #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"before inter_collective_io for total chunk = 1 \n"); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D),"before inter_collective_io for total chunk = 1 \n"); #endif - if(H5D_inter_collective_io(io_info,chunk_info->fspace,chunk_info->mspace,chunk_base_addr,buf,do_write)<0) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't finish shared collective MPI-IO"); - } - goto done; - } - /* Allocate chunking information */ - ori_num_chunk = H5SL_count(fm->sel_chunks); - H5_ASSIGN_OVERFLOW(num_chunk,ori_num_chunk,size_t,int); + /* Perform I/O */ + if(H5D_inter_collective_io(io_info, type_info, fspace, mspace) < 0) + HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL, "couldn't finish shared collective MPI-IO") + } /* end if */ + else { + size_t mpi_buf_count; /* Number of MPI types */ + size_t num_chunk; /* Number of chunks for this process */ + size_t u; /* Local index variable */ + + /* Get the number of chunks with a selection */ + num_chunk = H5SL_count(fm->sel_chunks); + H5_CHECK_OVERFLOW(num_chunk, size_t, int); #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"total_chunks = %d\n",(int)total_chunks); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D),"total_chunks = %Zu, num_chunk = %Zu\n", total_chunks, num_chunk); #endif - - if(num_chunk == 0) - total_chunk_addr_array = H5MM_malloc(sizeof(haddr_t)*total_chunks); - else - { - chunk_addr_info_array= H5MM_malloc(num_chunk*sizeof(H5D_chunk_addr_info_t)); - chunk_mtype = H5MM_malloc(num_chunk*sizeof(MPI_Datatype)); - chunk_ftype = H5MM_malloc(num_chunk*sizeof(MPI_Datatype)); - chunk_disp_array = H5MM_malloc(num_chunk*sizeof(MPI_Aint)); - chunk_mem_disp_array = H5MM_calloc(num_chunk*sizeof(MPI_Aint)); - blocklen = H5MM_malloc(num_chunk*sizeof(int)); - } - - /* Obtain information to do collective IO, - in order to do collective IO, no datatype conversion should happen. */ - if((src_type_size = H5T_get_size(io_info->dset->shared->type))==0) - HGOTO_ERROR(H5E_DATATYPE, H5E_BADSIZE, FAIL, "datatype size invalid"); - dst_type_size = src_type_size; - - bsearch_coll_chunk_threshold = H5D_ALL_CHUNK_ADDR_THRES_COL; - - if((mpi_size = H5F_mpi_get_size(io_info->dset->oloc.file))<0) - HGOTO_ERROR (H5E_IO, H5E_MPI, FAIL, "unable to obtain mpi size"); - - /* Calculate the actual threshold to obtain all chunk addresses collectively - The bigger this number is, the more possible the use of obtaining chunk address collectively. */ - /* For non-optimization one-link IO, - actual bsearch threshold is always 0, - we would always want to obtain the chunk addresses individually - for each process. */ - actual_bsearch_coll_chunk_threshold = sum_chunk*100/(total_chunks*mpi_size); - - if((actual_bsearch_coll_chunk_threshold > bsearch_coll_chunk_threshold) - &&(sum_chunk/mpi_size >= H5D_ALL_CHUNK_ADDR_THRES_COL_NUM)) - many_chunk_opt = H5D_OBTAIN_ALL_CHUNK_ADDR_COL; + + /* Set up MPI datatype for chunks selected */ + if(num_chunk) { + hsize_t mpi_mem_extra_offset; /* Extra offset for memory MPI datatype */ + hsize_t mpi_file_extra_offset; /* Extra offset for file MPI datatype */ + size_t mpi_mem_count; /* Memory MPI datatype count */ + size_t mpi_file_count; /* File MPI datatype count */ + hbool_t locl_mbt_is_derived = FALSE, /* Whether the buffer (memory) type is derived and needs to be free'd */ + local_mft_is_derived = FALSE; /* Whether the file type is derived and needs to be free'd */ + int blocklen_value; /* Placeholder for array fill */ + + /* Allocate chunking information */ + chunk_addr_info_array= H5MM_malloc(num_chunk * sizeof(H5D_chunk_addr_info_t)); + chunk_mtype = H5MM_malloc(num_chunk * sizeof(MPI_Datatype)); + chunk_ftype = H5MM_malloc(num_chunk * sizeof(MPI_Datatype)); + chunk_disp_array = H5MM_malloc(num_chunk * sizeof(MPI_Aint)); + chunk_mem_disp_array = H5MM_calloc(num_chunk * sizeof(MPI_Aint)); + blocklen = H5MM_malloc(num_chunk * sizeof(int)); #ifdef H5D_DEBUG - if(H5DEBUG(D)) +if(H5DEBUG(D)) HDfprintf(H5DEBUG(D),"before sorting the chunk address \n"); #endif - - /* Sort the chunk address - when chunk optimization selection is either H5D_OBTAIN_*/ - - if(num_chunk == 0){ /* special case: this process doesn't select anything */ - if(H5D_istore_chunkmap(io_info, total_chunk_addr_array, fm->down_chunks)<0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address"); - chunk_base_addr = total_chunk_addr_array[0]; - } - - else { - if(H5D_sort_chunk(io_info,fm,chunk_addr_info_array,many_chunk_opt)<0) - HGOTO_ERROR (H5E_DATASPACE, H5E_CANTSWAP, FAIL, "unable to sort chunk address"); - chunk_base_addr = chunk_addr_info_array[0].chunk_addr; - } + /* Sort the chunk address */ + if(H5D_sort_chunk(io_info, fm, chunk_addr_info_array, sum_chunk) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSWAP, FAIL, "unable to sort chunk address") + ctg_store.contig.dset_addr = chunk_addr_info_array[0].chunk_addr; #ifdef H5D_DEBUG - if(H5DEBUG(D)) +if(H5DEBUG(D)) HDfprintf(H5DEBUG(D),"after sorting the chunk address \n"); #endif - - /* Obtain MPI derived datatype from all individual chunks */ - for ( i = 0; i < num_chunk; i++) { - /* Disk MPI derived datatype */ - if(H5S_mpio_space_type(chunk_addr_info_array[i].chunk_info.fspace,src_type_size,&chunk_ftype[i], - &mpi_file_count,&mpi_file_extra_offset,&mft_is_derived)<0) - HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL,"couldn't create MPI file type"); - - /* Buffer MPI derived datatype */ - if(H5S_mpio_space_type(chunk_addr_info_array[i].chunk_info.mspace,dst_type_size,&chunk_mtype[i], - &mpi_buf_count,&mpi_buf_extra_offset,&mbt_is_derived)<0) - HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL,"couldn't create MPI buf type"); - - /* Chunk address relative to the first chunk */ - chunk_addr_info_array[i].chunk_addr -= chunk_base_addr; - H5_ASSIGN_OVERFLOW(chunk_disp_array[i],chunk_addr_info_array[i].chunk_addr,haddr_t,MPI_Aint); - } - - blocklen_value = 1; - if(num_chunk){ - - /* initialize the buffer with the constant value 1; this algo. is very fast. */ - H5V_array_fill(blocklen,&blocklen_value,sizeof(int),(size_t)num_chunk); - - /* Create final MPI derived datatype */ - if(MPI_SUCCESS != (mpi_code = MPI_Type_struct(num_chunk,blocklen,chunk_disp_array,chunk_ftype,&chunk_final_ftype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_struct failed", mpi_code); - if(MPI_SUCCESS != (mpi_code = MPI_Type_commit(&chunk_final_ftype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code); - - if(MPI_SUCCESS != (mpi_code = MPI_Type_struct(num_chunk,blocklen,chunk_mem_disp_array,chunk_mtype,&chunk_final_mtype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_struct failed", mpi_code); - if(MPI_SUCCESS != (mpi_code = MPI_Type_commit(&chunk_final_mtype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code); - - for ( i = 0; i< num_chunk;i++){ - if (MPI_SUCCESS != (mpi_code= MPI_Type_free( chunk_mtype+i ))) - HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); - - if (MPI_SUCCESS != (mpi_code= MPI_Type_free( chunk_ftype+i ))) - HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); - } - - /* buffer, file derived datatypes should be true */ - coll_info.mbt_is_derived = 1; - coll_info.mft_is_derived = 1; - coll_info.mpi_buf_count = 1; - coll_info.chunk_addr = chunk_base_addr; - - } - - else {/* no selection at all for this process */ - chunk_final_ftype = MPI_BYTE; - chunk_final_mtype = MPI_BYTE; - - /* buffer, file derived datatypes should be true */ - coll_info.mbt_is_derived = 0; - coll_info.mft_is_derived = 0; - coll_info.mpi_buf_count = 0; - coll_info.chunk_addr = chunk_base_addr; - } + + /* Obtain MPI derived datatype from all individual chunks */ + for(u = 0; u < num_chunk; u++) { + /* Disk MPI derived datatype */ + if(H5S_mpio_space_type(chunk_addr_info_array[u].chunk_info.fspace, + type_info->src_type_size, &chunk_ftype[u], &mpi_file_count, + &mpi_file_extra_offset, &local_mft_is_derived) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "couldn't create MPI file type") + + /* Buffer MPI derived datatype */ + if(H5S_mpio_space_type(chunk_addr_info_array[u].chunk_info.mspace, + type_info->dst_type_size, &chunk_mtype[u], &mpi_mem_count, + &mpi_mem_extra_offset, &locl_mbt_is_derived) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "couldn't create MPI buf type") + + /* Chunk address relative to the first chunk */ + chunk_addr_info_array[u].chunk_addr -= ctg_store.contig.dset_addr; + H5_ASSIGN_OVERFLOW(chunk_disp_array[u], chunk_addr_info_array[u].chunk_addr, haddr_t, MPI_Aint); + } /* end for */ + + /* Initialize the buffer with the constant value 1 */ + blocklen_value = 1; + H5V_array_fill(blocklen, &blocklen_value, sizeof(int), num_chunk); + + /* Create final MPI derived datatype for the file */ + if(MPI_SUCCESS != (mpi_code = MPI_Type_struct((int)num_chunk, blocklen, chunk_disp_array, chunk_ftype, &chunk_final_ftype))) + HMPI_GOTO_ERROR(FAIL, "MPI_Type_struct failed", mpi_code) + if(MPI_SUCCESS != (mpi_code = MPI_Type_commit(&chunk_final_ftype))) + HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code) + + /* Create final MPI derived datatype for memory */ + if(MPI_SUCCESS != (mpi_code = MPI_Type_struct(num_chunk, blocklen, chunk_mem_disp_array, chunk_mtype, &chunk_final_mtype))) + HMPI_GOTO_ERROR(FAIL, "MPI_Type_struct failed", mpi_code) + if(MPI_SUCCESS != (mpi_code = MPI_Type_commit(&chunk_final_mtype))) + HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code) + + /* Free the file & memory MPI datatypes for each chunk */ + for(u = 0; u < num_chunk; u++) { + if(MPI_SUCCESS != (mpi_code = MPI_Type_free(chunk_mtype + u))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code) + + if(MPI_SUCCESS != (mpi_code = MPI_Type_free(chunk_ftype + u))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code) + } /* end for */ + + /* buffer, file derived datatypes should be true */ + mbt_is_derived = TRUE; + mft_is_derived = TRUE; + mpi_buf_count = (size_t)1; + } /* end if */ + else { /* no selection at all for this process */ + /* Allocate chunking information */ + total_chunk_addr_array = H5MM_malloc(sizeof(haddr_t) * total_chunks); + + /* Retrieve chunk address map */ + if(H5D_istore_chunkmap(io_info, total_chunk_addr_array, fm->down_chunks) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address") + + /* Get chunk with lowest address */ + ctg_store.contig.dset_addr = HADDR_MAX; + for(u = 0; u < total_chunks; u++) + if(total_chunk_addr_array[u] < ctg_store.contig.dset_addr) + ctg_store.contig.dset_addr = total_chunk_addr_array[u]; + HDassert(ctg_store.contig.dset_addr != HADDR_MAX); + + /* Set the MPI datatype */ + chunk_final_ftype = MPI_BYTE; + chunk_final_mtype = MPI_BYTE; + + /* buffer, file derived datatypes should be true */ + mpi_buf_count = (size_t)0; + } /* end else */ #ifdef H5D_DEBUG - if(H5DEBUG(D)) +if(H5DEBUG(D)) HDfprintf(H5DEBUG(D),"before coming to final collective IO\n"); #endif - if(H5D_final_collective_io(io_info,&chunk_final_ftype,&chunk_final_mtype,&coll_info,buf,do_write)<0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish MPI-IO"); + /* Set up the base storage address for this chunk */ + io_info->store = &ctg_store; + + /* Perform final collective I/O operation */ + if(H5D_final_collective_io(io_info, type_info, mpi_buf_count, &chunk_final_ftype, &chunk_final_mtype) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL, "couldn't finish MPI-IO") + } /* end else */ done: #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"before freeing memory inside H5D_link_collective_io ret_value = %d\n",ret_value); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D),"before freeing memory inside H5D_link_collective_io ret_value = %d\n", ret_value); #endif - if (fm->total_chunks != 1) { - if(num_chunk == 0) HDfree(total_chunk_addr_array); - else { - HDfree(chunk_addr_info_array); - HDfree(chunk_mtype); - HDfree(chunk_ftype); - HDfree(chunk_disp_array); - HDfree(chunk_mem_disp_array); - HDfree(blocklen); - } - } - FUNC_LEAVE_NOAPI(ret_value) + if(total_chunk_addr_array) + H5MM_xfree(total_chunk_addr_array); + if(chunk_addr_info_array) + H5MM_xfree(chunk_addr_info_array); + if(chunk_mtype) + H5MM_xfree(chunk_mtype); + if(chunk_ftype) + H5MM_xfree(chunk_ftype); + if(chunk_disp_array) + H5MM_xfree(chunk_disp_array); + if(chunk_mem_disp_array) + H5MM_xfree(chunk_mem_disp_array); + if(blocklen) + H5MM_xfree(blocklen); + + /* Free the MPI buf and file types, if they were derived */ + if(mbt_is_derived && MPI_SUCCESS != (mpi_code = MPI_Type_free(&chunk_final_mtype))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code) + if(mft_is_derived && MPI_SUCCESS != (mpi_code = MPI_Type_free(&chunk_final_ftype))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code) + + FUNC_LEAVE_NOAPI(ret_value) } /* end H5D_link_chunk_collective_io */ +#endif /* H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS */ /*------------------------------------------------------------------------- * Function: H5D_multi_chunk_collective_io * * Purpose: To do IO per chunk according to IO mode(collective/independent/none) - - 1. Use MPI_gather and MPI_Bcast to obtain IO mode in each chunk(collective/independent/none) - 2. Depending on whether the IO mode is collective or independent or none, - Create either MPI derived datatype for each chunk or just do independent IO - 3. Use common collective IO routine to do MPI-IO * - * Return: Non-negative on success/Negative on failure + * 1. Use MPI_gather and MPI_Bcast to obtain IO mode in each chunk(collective/independent/none) + * 2. Depending on whether the IO mode is collective or independent or none, + * Create either MPI derived datatype for each chunk or just do independent IO + * 3. Use common collective IO routine to do MPI-IO * - * Programmer: + * Return: Non-negative on success/Negative on failure * - * Modifications: + * Programmer: Muqun Yang + * Monday, Feb. 13th, 2006 * *------------------------------------------------------------------------- */ static herr_t -H5D_multi_chunk_collective_io(H5D_io_info_t *io_info,H5D_chunk_map_t *fm,const void *buf, hbool_t do_write) +H5D_multi_chunk_collective_io(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, + H5D_chunk_map_t *fm, H5P_genplist_t *dx_plist) { - unsigned i, total_chunk; - hsize_t ori_total_chunk; - uint8_t *chunk_io_option; - - H5SL_node_t *chunk_node; /* Current node in chunk skip list */ - H5D_chunk_info_t *chunk_info=NULL; - haddr_t *chunk_addr; - H5D_storage_t store; /* union of EFL and chunk pointer in file space */ - hbool_t select_chunk; - hbool_t last_io_mode_coll = TRUE; - - void *chunk = NULL; /* Pointer to the data chunk in cache */ - H5D_t *dataset=io_info->dset;/* Local pointer to dataset info */ - H5D_istore_ud1_t udata; /*B-tree pass-through */ - haddr_t caddr; /* Address of the cached chunk */ - size_t accessed_bytes; /*total accessed size in a chunk */ - unsigned idx_hint=0; /* Cache index hint */ - hbool_t dirty = TRUE; /* Flag for cache flushing */ - hbool_t relax=TRUE; /* Whether whole chunk is selected */ - - herr_t ret_value = SUCCEED; + H5D_t *dataset = io_info->dset;/* Local pointer to dataset info */ + H5D_io_info_t ctg_io_info; /* Contiguous I/O info object */ + H5D_storage_t ctg_store; /* Chunk storage information as contiguous dataset */ + H5D_io_info_t cpt_io_info; /* Compact I/O info object */ + H5D_storage_t cpt_store; /* Chunk storage information as compact dataset */ + hbool_t cpt_dirty; /* Temporary placeholder for compact storage "dirty" flag */ + uint8_t *chunk_io_option = NULL; + haddr_t *chunk_addr = NULL; + H5D_storage_t store; /* union of EFL and chunk pointer in file space */ + H5FD_mpio_xfer_t last_xfer_mode = H5FD_MPIO_COLLECTIVE; /* Last parallel transfer for this request (H5D_XFER_IO_XFER_MODE_NAME) */ + H5FD_mpio_collective_opt_t last_coll_opt_mode = H5FD_MPIO_COLLECTIVE_IO; /* Last parallel transfer with independent IO or collective IO with this mode */ + size_t total_chunk; /* Total # of chunks in dataset */ #ifdef H5Dmpio_DEBUG - int mpi_rank; + int mpi_rank; #endif + size_t u; /* Local index variable */ + herr_t ret_value = SUCCEED; - - FUNC_ENTER_NOAPI_NOINIT(H5D_multi_chunk_collective_io) + FUNC_ENTER_NOAPI_NOINIT(H5D_multi_chunk_collective_io) #ifdef H5Dmpio_DEBUG - mpi_rank = H5F_mpi_get_rank(io_info->dset->oloc.file); + mpi_rank = H5F_mpi_get_rank(io_info->dset->oloc.file); #endif - /* Allocate memories */ - ori_total_chunk = fm->total_chunks; - H5_ASSIGN_OVERFLOW(total_chunk,ori_total_chunk,hsize_t,unsigned); - HDassert(total_chunk!=0); - chunk_io_option = (uint8_t *)H5MM_calloc(total_chunk*sizeof(MPI_BYTE)); - chunk_addr = (haddr_t *)H5MM_calloc(total_chunk*sizeof(haddr_t)); + /* Retrieve total # of chunks in dataset */ + H5_ASSIGN_OVERFLOW(total_chunk, fm->total_chunks, hsize_t, size_t); + HDassert(total_chunk != 0); + + /* Allocate memories */ + chunk_io_option = (uint8_t *)H5MM_calloc(total_chunk); + chunk_addr = (haddr_t *)H5MM_calloc(total_chunk * sizeof(haddr_t)); #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"total_chunk %u\n",total_chunk); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D), "total_chunk %Zu\n", total_chunk); #endif - /* obtain IO option for each chunk */ - if(H5D_obtain_mpio_mode(io_info,fm,chunk_io_option,chunk_addr)<0) - HGOTO_ERROR (H5E_DATASET, H5E_CANTRECV, FAIL, "unable to obtain MPIO mode"); + /* Obtain IO option for each chunk */ + if(H5D_obtain_mpio_mode(io_info, fm, dx_plist, chunk_io_option, chunk_addr) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTRECV, FAIL, "unable to obtain MPIO mode") + + /* Set up contiguous I/O info object */ + HDmemcpy(&ctg_io_info, io_info, sizeof(ctg_io_info)); + ctg_io_info.store = &ctg_store; + ctg_io_info.layout_ops = *H5D_LOPS_CONTIG; + + /* Initialize temporary contiguous storage info */ + ctg_store.contig.dset_size = (hsize_t)io_info->dset->shared->layout.u.chunk.size; + + /* Set up compact I/O info object */ + HDmemcpy(&cpt_io_info, io_info, sizeof(cpt_io_info)); + cpt_io_info.store = &cpt_store; + cpt_io_info.layout_ops = *H5D_LOPS_COMPACT; + + /* Initialize temporary compact storage info */ + cpt_store.compact.dirty = &cpt_dirty; + + /* Set dataset storage for I/O info */ + io_info->store = &store; + + /* Loop over _all_ the chunks */ + for(u = 0; u < total_chunk; u++) { + H5D_chunk_info_t *chunk_info; /* Chunk info for current chunk */ + H5S_t *fspace; /* Dataspace describing chunk & selection in it */ + H5S_t *mspace; /* Dataspace describing selection in memory corresponding to this chunk */ - for(i = 0; i < total_chunk; i++) { #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"mpi_rank = %d, chunk index = %u\n",mpi_rank,i); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D),"mpi_rank = %d, chunk index = %Zu\n", mpi_rank, u); #endif - select_chunk = fm->select_chunk[i]; - if(select_chunk == 1){/* Have selection elements in this chunk. Find the chunk info. */ - if(NULL ==(chunk_node = H5SL_first(fm->sel_chunks))) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk node from skipped list"); - - while(chunk_node){ - if(NULL ==(chunk_info = H5SL_item(chunk_node))) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk info from skipped list"); - if(chunk_info->index == i) { - /* Set dataset storage for I/O info */ - io_info->store=&store; - /* Pass in chunk's coordinates in a union. */ - store.chunk.offset = chunk_info->coords; - store.chunk.index = chunk_info->index; - break; - } - - chunk_node = H5SL_next(chunk_node); - } - } - - if(chunk_io_option[i] == 1){ /*collective IO for this chunk, - note: even there is no selection for this process, - the process still needs to contribute MPI NONE TYPE.*/ + /* Get the chunk info for this chunk, if there are elements selected */ + chunk_info = fm->select_chunk[u]; + + /* Set the storage information for chunks with selections */ + if(chunk_info) { + HDassert(chunk_info->index == u); + + /* Pass in chunk's coordinates in a union. */ + store.chunk.offset = chunk_info->coords; + store.chunk.index = chunk_info->index; + } /* end if */ + + /* Collective IO for this chunk, + * Note: even there is no selection for this process, the process still + * needs to contribute MPI NONE TYPE. + */ + if(chunk_io_option[u] == 1) { #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"inside collective chunk IO mpi_rank = %d, chunk index = %u\n",mpi_rank,i); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D),"inside collective chunk IO mpi_rank = %d, chunk index = %Zu\n", mpi_rank, u); #endif - if(!last_io_mode_coll) - /* Switch back to collective I/O */ - if(H5D_ioinfo_make_coll(io_info) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to collective I/O") + /* Set the file & memory dataspaces */ + if(chunk_info) { + fspace = chunk_info->fspace; + mspace = chunk_info->mspace; + } /* end if */ + else { + fspace = mspace = NULL; + } /* end else */ + + /* Switch back to collective I/O */ + if(last_xfer_mode != H5FD_MPIO_COLLECTIVE) { + if(H5D_ioinfo_xfer_mode(io_info, dx_plist, H5FD_MPIO_COLLECTIVE) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to collective I/O") + last_xfer_mode = H5FD_MPIO_COLLECTIVE; + } /* end if */ + if(last_coll_opt_mode != H5FD_MPIO_COLLECTIVE_IO) { + if(H5D_ioinfo_coll_opt_mode(io_info, dx_plist, H5FD_MPIO_COLLECTIVE_IO) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to collective I/O") + last_coll_opt_mode = H5FD_MPIO_COLLECTIVE_IO; + } /* end if */ - if(select_chunk){ - if(H5D_inter_collective_io(io_info,chunk_info->fspace,chunk_info->mspace, - chunk_addr[i],buf,do_write )<0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish shared collective MPI-IO"); - - } - else{ - if(H5D_inter_collective_io(io_info,NULL,NULL, - chunk_addr[i],buf,do_write )<0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish shared collective MPI-IO"); - - } - last_io_mode_coll = TRUE; - - } - else {/*possible independent IO for this chunk*/ + /* Initialize temporary contiguous storage address */ + ctg_store.contig.dset_addr = chunk_addr[u]; + + /* Perform the I/O */ + if(H5D_inter_collective_io(&ctg_io_info, type_info, fspace, mspace) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL, "couldn't finish shared collective MPI-IO") + } /* end if */ + else { /* possible independent IO for this chunk */ #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"inside independent IO mpi_rank = %d, chunk index = %u\n",mpi_rank,i); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D),"inside independent IO mpi_rank = %d, chunk index = %Zu\n", mpi_rank, u); #endif - HDassert(chunk_io_option[i] == 0); + HDassert(chunk_io_option[u] == 0); #if !defined(H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS) || !defined(H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS) - if(!select_chunk) - continue; /* this process has nothing to do with this chunk, continue! */ - if(last_io_mode_coll) + /* Check if this process has somethign to do with this chunk */ + if(chunk_info) { + H5D_io_info_t *chk_io_info; /* Pointer to I/O info object for this chunk */ + H5D_istore_ud1_t udata; /* B-tree pass-through */ + void *chunk; /* Pointer to the data chunk in cache */ + size_t accessed_bytes; /* Total accessed size in a chunk */ + unsigned idx_hint = 0; /* Cache index hint */ + haddr_t caddr; /* Address of the cached chunk */ + /* Switch to independent I/O */ - if(H5D_ioinfo_make_ind(io_info) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to independent I/O") - - /* Load the chunk into cache. But if the whole chunk is written, - * simply allocate space instead of load the chunk. */ - if(HADDR_UNDEF==(caddr = H5D_istore_get_addr(io_info, &udata))) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk info from skipped list"); - - if(H5D_istore_if_load(io_info, caddr)) { - accessed_bytes = chunk_info->chunk_points * H5T_get_size(dataset->shared->type); - if((do_write && (accessed_bytes != dataset->shared->layout.u.chunk.size)) || !do_write) - relax=FALSE; - - if(NULL == (chunk = H5D_istore_lock(io_info, &udata, relax, &idx_hint))) - HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to read raw data chunk") - } else - chunk = NULL; - - if(do_write) { - if((io_info->ops.write)(io_info, - chunk_info->chunk_points,H5T_get_size(io_info->dset->shared->type), - chunk_info->fspace,chunk_info->mspace,caddr,chunk, buf) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "optimized write failed") - } - else { - if((io_info->ops.read)(io_info, - chunk_info->chunk_points,H5T_get_size(io_info->dset->shared->type), - chunk_info->fspace,chunk_info->mspace,caddr,chunk, buf) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "optimized read failed") - } + if(last_xfer_mode != H5FD_MPIO_INDEPENDENT) { + if(H5D_ioinfo_xfer_mode(io_info, dx_plist, H5FD_MPIO_INDEPENDENT) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to independent I/O") + last_xfer_mode = H5FD_MPIO_INDEPENDENT; + } /* end if */ - /* Release the cache lock on the chunk. */ - if(chunk) { - if(!do_write) - dirty = FALSE; + /* Load the chunk into cache. But if the whole chunk is written, + * simply allocate space instead of load the chunk. + */ + if(HADDR_UNDEF == (caddr = H5D_istore_get_addr(io_info, &udata))) + HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL, "couldn't get chunk info from skipped list") - if(H5D_istore_unlock(io_info, dirty, idx_hint, chunk, accessed_bytes) < 0) - HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to unlock raw data chunk") - } /* end if */ -#else - if(!last_io_mode_coll) - /* using independent I/O with file setview.*/ - if(H5D_ioinfo_make_coll_opt(io_info) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to collective I/O") - if(select_chunk){ - if(H5D_inter_collective_io(io_info,chunk_info->fspace,chunk_info->mspace, - chunk_addr[i],buf,do_write )<0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish shared collective MPI-IO"); - } + /* Load the chunk into cache and lock it. */ + if(H5D_chunk_cacheable(io_info, caddr)) { + hbool_t entire_chunk = TRUE; /* Whether whole chunk is selected */ + + /* Compute # of bytes accessed in chunk */ + accessed_bytes = chunk_info->chunk_points * type_info->src_type_size; + + /* Determine if we will access all the data in the chunk */ + if(((io_info->op_type == H5D_IO_OP_WRITE) && (accessed_bytes != ctg_store.contig.dset_size)) + || (io_info->op_type != H5D_IO_OP_WRITE)) + entire_chunk = FALSE; + + /* Lock the chunk into the cache */ + if(NULL == (chunk = H5D_istore_lock(io_info, &udata, entire_chunk, &idx_hint))) + HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to read raw data chunk") + + /* Set up the storage buffer information for this chunk */ + cpt_store.compact.buf = chunk; + + /* Point I/O info at contiguous I/O info for this chunk */ + chk_io_info = &cpt_io_info; + } /* end if */ + else { + /* Set up the storage address information for this chunk */ + ctg_store.contig.dset_addr = caddr; + + /* No chunk cached */ + chunk = NULL; + + /* Point I/O info at temporary I/O info for this chunk */ + chk_io_info = &ctg_io_info; + } /* end else */ + + if(io_info->op_type == H5D_IO_OP_WRITE) { + if((io_info->io_ops.single_write)(chk_io_info, type_info, + (hsize_t)chunk_info->chunk_points, chunk_info->fspace, chunk_info->mspace) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "optimized write failed") + } /* end if */ + else { + if((io_info->io_ops.single_read)(chk_io_info, type_info, + (hsize_t)chunk_info->chunk_points, chunk_info->fspace, chunk_info->mspace) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "optimized read failed") + } /* end else */ + + /* Release the cache lock on the chunk. */ + if(chunk && H5D_istore_unlock(io_info, (io_info->op_type == H5D_IO_OP_WRITE), idx_hint, chunk, accessed_bytes) < 0) + HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to unlock raw data chunk") + } /* end if */ +#else /* !defined(H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS) || !defined(H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS) */ + /* Set the file & memory dataspaces */ + if(chunk_info) { + fspace = chunk_info->fspace; + mspace = chunk_info->mspace; + } /* end if */ else { - if(H5D_inter_collective_io(io_info,NULL,NULL, - chunk_addr[i],buf,do_write )<0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish shared collective MPI-IO"); - } + fspace = mspace = NULL; + } /* end else */ + + /* Using independent I/O with file setview.*/ + if(last_coll_opt_mode != H5FD_MPIO_INDIVIDUAL_IO) { + if(H5D_ioinfo_coll_opt_mode(io_info, dx_plist, H5FD_MPIO_INDIVIDUAL_IO) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to individual I/O") + last_coll_opt_mode = H5FD_MPIO_INDIVIDUAL_IO; + } /* end if */ + /* Initialize temporary contiguous storage address */ + ctg_store.contig.dset_addr = chunk_addr[u]; + + /* Perform the I/O */ + if(H5D_inter_collective_io(&ctg_io_info, type_info, fspace, mspace) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL, "couldn't finish shared collective MPI-IO") #ifdef H5D_DEBUG if(H5DEBUG(D)) HDfprintf(H5DEBUG(D),"after inter collective IO\n"); #endif -#endif - last_io_mode_coll = FALSE; - } - } - if(!last_io_mode_coll) - /* Switch back to collective I/O */ - if(H5D_ioinfo_make_coll(io_info) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to collective I/O") +#endif /* !defined(H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS) || !defined(H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS) */ + } /* end else */ + } /* end for */ + done: - HDfree(chunk_io_option); - HDfree(chunk_addr); + if(chunk_io_option) + H5MM_xfree(chunk_io_option); + if(chunk_addr) + H5MM_xfree(chunk_addr); FUNC_LEAVE_NOAPI(ret_value) } /* end H5D_multi_chunk_collective_io */ @@ -1257,90 +1297,105 @@ done: * non-contiguous(or with holes) storage efficiently. * Under this case, the one independent IO call may consist of * many small disk IOs. So we may use independent IO with derived datatype - to replace the independent IO when we find this chunk is not good to - do collective IO. However, according to our performance study, - this approach may not overcome the overhead caused by MPI gather/scatter. - So we decide to leave the original collective IO per chunk approach as - an option for users. NO MPI gather/scatter calls are used. - HDF5 will try to collective IO if possible. - If users choose to use - H5Pset_dxpl_mpio_chunk_opt(dxpl_id,H5FD_MPIO_OPT_MULTI_IO), - this function will be called. - The HDF5 library won't do any IO management but leave it to MPI-IO to figure - out. + * to replace the independent IO when we find this chunk is not good to + * do collective IO. However, according to our performance study, + * this approach may not overcome the overhead caused by MPI gather/scatter. + * So we decide to leave the original collective IO per chunk approach as + * an option for users. NO MPI gather/scatter calls are used. + * HDF5 will try to collective IO if possible. + * If users choose to use + * H5Pset_dxpl_mpio_chunk_opt(dxpl_id,H5FD_MPIO_OPT_MULTI_IO), + * this function will be called. + * The HDF5 library won't do any IO management but leave it to MPI-IO to figure + * out. * * Return: Non-negative on success/Negative on failure * - * Programmer: - * - * Modifications: + * Programmer: Muqun Yang + * Monday, Feb. 13th, 2006 * *------------------------------------------------------------------------- */ static herr_t -H5D_multi_chunk_collective_io_no_opt(H5D_io_info_t *io_info,H5D_chunk_map_t *fm,const void *buf, hbool_t do_write) +H5D_multi_chunk_collective_io_no_opt(H5D_io_info_t *io_info, + const H5D_type_info_t *type_info, H5D_chunk_map_t *fm, H5P_genplist_t *dx_plist) { - int count_chunk,min_num_chunk; - haddr_t chunk_addr; - H5SL_node_t *chunk_node; /* Current node in chunk skip list */ - H5D_storage_t store; /* union of EFL and chunk pointer in file space */ - H5D_chunk_info_t *chunk_info; /* chunk information */ - hbool_t make_ind, make_coll; /* Flags to indicate that the MPI mode should change */ - - void *chunk = NULL; /* Pointer to the data chunk in cache */ - H5D_t *dataset=io_info->dset;/* Local pointer to dataset info */ - H5D_istore_ud1_t udata; /*B-tree pass-through */ - size_t accessed_bytes; /*total accessed size in a chunk */ - unsigned idx_hint=0; /* Cache index hint */ - hbool_t dirty = TRUE; /* Flag for cache flushing */ - hbool_t relax=TRUE; /* Whether whole chunk is selected */ - herr_t ret_value = SUCCEED; - -#ifdef H5Dmpio_DEBUG - int mpi_rank; -#endif + H5D_t *dataset = io_info->dset;/* Local pointer to dataset info */ + H5SL_node_t *chunk_node; /* Current node in chunk skip list */ + H5D_io_info_t ctg_io_info; /* Contiguous I/O info object */ + H5D_storage_t ctg_store; /* Chunk storage information as contiguous dataset */ + H5D_io_info_t cpt_io_info; /* Compact I/O info object */ + H5D_storage_t cpt_store; /* Chunk storage information as compact dataset */ + hbool_t cpt_dirty; /* Temporary placeholder for compact storage "dirty" flag */ + int min_chunk = -1; /* Minimum # of chunks all processes will operate on */ + int count_chunk; /* How many chunks have we operated on? */ + H5D_storage_t store; /* union of EFL and chunk pointer in file space */ + herr_t ret_value = SUCCEED; + + FUNC_ENTER_NOAPI_NOINIT(H5D_multi_chunk_collective_io_no_opt) - FUNC_ENTER_NOAPI_NOINIT(H5D_multi_chunk_collective_io_no_opt) #ifdef H5D_DEBUG - if(H5DEBUG(D)){ +if(H5DEBUG(D)) { + int mpi_rank; + mpi_rank = H5F_mpi_get_rank(io_info->dset->oloc.file); - HDfprintf(H5DEBUG(D),"coming to multi_chunk_collective_io_no_opt\n"); - } + HDfprintf(H5DEBUG(D), "coming to multi_chunk_collective_io_no_opt\n"); +} #endif - if(H5D_mpio_get_min_chunk(io_info,fm,&min_num_chunk)<0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get minimum number of chunk"); - count_chunk = 0; - - /* Get first node in chunk skip list */ - chunk_node=H5SL_first(fm->sel_chunks); - - /* Iterate through chunks to be operated on */ - while(chunk_node) { - H5D_chunk_info_t *chunk_info; /* chunk information */ - hbool_t make_ind, make_coll; /* Flags to indicate that the MPI mode should change */ - - /* Get the actual chunk information from the skip list node */ - chunk_info=H5SL_item(chunk_node); - - /* Set dataset storage for I/O info */ - io_info->store=&store; - - /* Pass in chunk's coordinates in a union. */ - store.chunk.offset = chunk_info->coords; - store.chunk.index = chunk_info->index; - - /* Reset flags for changing parallel I/O mode */ - make_ind = make_coll = FALSE; - - count_chunk++; - /* If the number of chunk is greater than minimum number of chunk, - Do independent read */ - if(count_chunk > min_num_chunk) { - /* Switch to independent I/O (permanently) */ - make_ind = TRUE; - } + /* Set up contiguous I/O info object */ + HDmemcpy(&ctg_io_info, io_info, sizeof(ctg_io_info)); + ctg_io_info.store = &ctg_store; + ctg_io_info.layout_ops = *H5D_LOPS_CONTIG; + + /* Initialize temporary contiguous storage info */ + ctg_store.contig.dset_size = (hsize_t)io_info->dset->shared->layout.u.chunk.size; + + /* Set up compact I/O info object */ + HDmemcpy(&cpt_io_info, io_info, sizeof(cpt_io_info)); + cpt_io_info.store = &cpt_store; + cpt_io_info.layout_ops = *H5D_LOPS_COMPACT; + + /* Initialize temporary compact storage info */ + cpt_store.compact.dirty = &cpt_dirty; + + /* Set dataset storage for I/O info */ + io_info->store = &store; + + /* Get the min. # of chunks */ + if(H5D_mpio_get_min_chunk(io_info, fm, &min_chunk) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get minimum number of chunk") + HDassert(min_chunk >= 0); + + /* Get first node in chunk skip list */ + chunk_node = H5SL_first(fm->sel_chunks); + count_chunk = 0; + + /* Iterate through chunks to be operated on */ + while(chunk_node) { + H5D_chunk_info_t *chunk_info; /* chunk information */ + haddr_t chunk_addr; /* Address of chunk in file */ + H5D_istore_ud1_t udata; /* B-tree pass-through */ + hbool_t make_ind, make_coll; /* Flags to indicate that the MPI mode should change */ + /* Get the actual chunk information from the skip list node */ + chunk_info = H5SL_item(chunk_node); + + /* Pass in chunk's coordinates in a union. */ + store.chunk.offset = chunk_info->coords; + store.chunk.index = chunk_info->index; + + /* Reset flags for changing parallel I/O mode */ + make_ind = make_coll = FALSE; + + count_chunk++; + + /* If the number of chunk is greater than minimum number of chunk, + * Do independent read. + */ + if(count_chunk > min_chunk) + /* Switch to independent I/O (permanently) */ + make_ind = TRUE; #ifndef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS /* This case needs to be improved to check if the selected space is regular. If all selections are regular, collective IO can still be done. @@ -1349,67 +1404,92 @@ H5D_multi_chunk_collective_io_no_opt(H5D_io_info_t *io_info,H5D_chunk_map_t *fm, we turn off this optimization but leave the following code for future optimization. Otherwise, the following else {} doesn't make sense. KY 2006/8/4/ */ - else { - /* Switch to independent I/O (temporarily) */ - make_ind = TRUE; - make_coll = TRUE; - } /* end else */ + else { + /* Switch to independent I/O (temporarily) */ + make_ind = TRUE; + make_coll = TRUE; + } /* end else */ #endif /* H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS */ + /* Retrieve the chunk's address */ + if(HADDR_UNDEF == (chunk_addr = H5D_istore_get_addr(io_info, &udata))) + HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk info from skipped list") + + /* Independent I/O */ + if(make_ind) { + void *chunk; /* Pointer to the data chunk in cache */ + H5D_io_info_t *chk_io_info; /* Pointer to I/O info object for this chunk */ + size_t accessed_bytes = 0; /* Total accessed size in a chunk */ + unsigned idx_hint = 0; /* Cache index hint */ + /* Switch to independent I/O */ - if(make_ind) - if(H5D_ioinfo_make_ind(io_info) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to independent I/O") + if(H5D_ioinfo_xfer_mode(io_info, dx_plist, H5FD_MPIO_INDEPENDENT) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to independent I/O") - if(HADDR_UNDEF==(chunk_addr = H5D_istore_get_addr(io_info, &udata))) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk info from skipped list"); + /* Load the chunk into cache and lock it. */ + if(H5D_chunk_cacheable(io_info, chunk_addr)) { + hbool_t entire_chunk = TRUE; /* Whether whole chunk is selected */ - if(make_ind) {/*independent I/O */ - /* Load the chunk into cache. But if the whole chunk is written, - * simply allocate space instead of load the chunk. */ - if(H5D_istore_if_load(io_info, chunk_addr)) { - accessed_bytes = chunk_info->chunk_points * H5T_get_size(dataset->shared->type); - if((do_write && (accessed_bytes != dataset->shared->layout.u.chunk.size)) || !do_write) - relax=FALSE; - - if(NULL == (chunk = H5D_istore_lock(io_info, &udata, relax, &idx_hint))) - HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to read raw data chunk") - } else - chunk = NULL; - - if(do_write) { - if((io_info->ops.write)(io_info, - chunk_info->chunk_points,H5T_get_size(io_info->dset->shared->type), - chunk_info->fspace,chunk_info->mspace, chunk_addr, chunk, buf) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "optimized write failed") - } else { - if((io_info->ops.read)(io_info, - chunk_info->chunk_points,H5T_get_size(io_info->dset->shared->type), - chunk_info->fspace,chunk_info->mspace, chunk_addr, chunk, buf) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "optimized read failed") - } + /* Compute # of bytes accessed in chunk */ + accessed_bytes = chunk_info->chunk_points * type_info->src_type_size; - /* Release the cache lock on the chunk. */ - if(chunk) { - if(!do_write) - dirty = FALSE; + /* Determine if we will access all the data in the chunk */ + if(((io_info->op_type == H5D_IO_OP_WRITE) && (accessed_bytes != ctg_store.contig.dset_size)) + || (io_info->op_type != H5D_IO_OP_WRITE)) + entire_chunk = FALSE; + + /* Lock the chunk into the cache */ + if(NULL == (chunk = H5D_istore_lock(io_info, &udata, entire_chunk, &idx_hint))) + HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to read raw data chunk") - if(H5D_istore_unlock(io_info, dirty, idx_hint, chunk, accessed_bytes) < 0) - HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to unlock raw data chunk") - } /* end if */ + /* Set up the storage buffer information for this chunk */ + cpt_store.compact.buf = chunk; + + /* Point I/O info at contiguous I/O info for this chunk */ + chk_io_info = &cpt_io_info; } /* end if */ - else { /*collective I/O */ - if(H5D_inter_collective_io(io_info,chunk_info->fspace,chunk_info->mspace, - chunk_addr,buf,do_write ) < 0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish shared collective MPI-IO"); - } - - if(make_coll) - if(H5D_ioinfo_make_coll(io_info) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to independent I/O") - /* Get the next chunk node in the skip list */ - chunk_node=H5SL_next(chunk_node); - } /* end while */ + else { + /* Set up the storage address information for this chunk */ + ctg_store.contig.dset_addr = chunk_addr; + + /* No chunk cached */ + chunk = NULL; + + /* Point I/O info at temporary I/O info for this chunk */ + chk_io_info = &ctg_io_info; + } /* end else */ + + if(io_info->op_type == H5D_IO_OP_WRITE) { + if((io_info->io_ops.single_write)(chk_io_info, type_info, + (hsize_t)chunk_info->chunk_points, chunk_info->fspace, chunk_info->mspace) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "optimized write failed") + } /* end if */ + else { + if((io_info->io_ops.single_read)(chk_io_info, type_info, + (hsize_t)chunk_info->chunk_points, chunk_info->fspace, chunk_info->mspace) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "optimized read failed") + } /* end ese */ + + /* Release the cache lock on the chunk. */ + if(chunk) + if(H5D_istore_unlock(io_info, (io_info->op_type == H5D_IO_OP_WRITE), idx_hint, chunk, accessed_bytes) < 0) + HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to unlock raw data chunk") + } /* end if */ + else { /*collective I/O */ + /* Set up the storage address information for this chunk */ + ctg_store.contig.dset_addr = chunk_addr; + + if(H5D_inter_collective_io(&ctg_io_info, type_info, chunk_info->fspace, chunk_info->mspace) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish shared collective MPI-IO") + } /* end else */ + + if(make_coll) + if(H5D_ioinfo_xfer_mode(io_info, dx_plist, H5FD_MPIO_COLLECTIVE) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't switch to independent I/O") + + /* Get the next chunk node in the skip list */ + chunk_node = H5SL_next(chunk_node); + } /* end while */ done: FUNC_LEAVE_NOAPI(ret_value) @@ -1420,303 +1500,266 @@ done: * Function: H5D_inter_collective_io * * Purpose: Routine for the shared part of collective IO between multiple chunk - collective IO and contiguous collective IO - + * collective IO and contiguous collective IO * * Return: Non-negative on success/Negative on failure * - * Programmer: - * - * Modifications: + * Programmer: Muqun Yang + * Monday, Feb. 13th, 2006 * *------------------------------------------------------------------------- */ static herr_t -H5D_inter_collective_io(H5D_io_info_t *io_info,const H5S_t *file_space,const H5S_t *mem_space, - haddr_t addr, const void *buf, hbool_t do_write ) +H5D_inter_collective_io(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, + const H5S_t *file_space, const H5S_t *mem_space) { + size_t mpi_buf_count; /* # of MPI types */ + hbool_t mbt_is_derived = FALSE; + hbool_t mft_is_derived = FALSE; + MPI_Datatype mpi_file_type, mpi_buf_type; + int mpi_code; /* MPI return code */ + herr_t ret_value = SUCCEED; /* return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_inter_collective_io) + + if((file_space != NULL) && (mem_space != NULL)) { + hsize_t mpi_buf_offset, mpi_file_offset; /* Offset within dataset where selection (ie. MPI type) begins */ + size_t mpi_file_count; /* Number of file "objects" to transfer */ - size_t mpi_buf_count, mpi_file_count; /* Number of "objects" to transfer */ - MPI_Datatype mpi_file_type,mpi_buf_type; - hsize_t mpi_buf_offset, mpi_file_offset; /* Offset within dataset where selection (ie. MPI type) begins */ - hbool_t mbt_is_derived=0, /* Whether the buffer (memory) type is derived and needs to be free'd */ - mft_is_derived=0; /* Whether the file type is derived and needs to be free'd */ - H5D_common_coll_info_t coll_info; - herr_t ret_value = SUCCEED; /* return value */ - - FUNC_ENTER_NOAPI_NOINIT(H5D_inter_collective_io) - if((file_space!=NULL) && (mem_space != NULL)) { - /*Obtain disk and memory MPI derived datatype */ - if(H5S_mpio_space_type(file_space,H5T_get_size(io_info->dset->shared->type), - &mpi_file_type,&mpi_file_count,&mpi_file_offset,&mft_is_derived)<0) - HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL,"couldn't create MPI file type"); - - if(H5S_mpio_space_type(mem_space,H5T_get_size(io_info->dset->shared->type), - &mpi_buf_type,&mpi_buf_count,&mpi_buf_offset,&mbt_is_derived)<0) - HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL,"couldn't create MPI buffer type"); - - } - else { - /* For non-selection, participate with a none MPI derived datatype, the count is 0. */ - mpi_buf_type = MPI_BYTE; - mpi_file_type = MPI_BYTE; - mpi_file_count = 0; - mpi_buf_count = 0; - } - - coll_info.mbt_is_derived = mbt_is_derived; - coll_info.mft_is_derived = mft_is_derived; - coll_info.mpi_buf_count = mpi_buf_count; - coll_info.chunk_addr = addr; + /* Obtain disk and memory MPI derived datatype */ + if(H5S_mpio_space_type(file_space, type_info->src_type_size, + &mpi_file_type, &mpi_file_count, &mpi_file_offset, &mft_is_derived) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "couldn't create MPI file type") + if(H5S_mpio_space_type(mem_space, type_info->src_type_size, + &mpi_buf_type, &mpi_buf_count, &mpi_buf_offset, &mbt_is_derived) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "couldn't create MPI buffer type") + } /* end if */ + else { + /* For non-selection, participate with a none MPI derived datatype, the count is 0. */ + mpi_buf_type = MPI_BYTE; + mpi_file_type = MPI_BYTE; + mpi_buf_count = (size_t)0; + mbt_is_derived = FALSE; + mft_is_derived = FALSE; + } /* end else */ #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"before final collective IO \n"); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D),"before final collective IO \n"); #endif - if(H5D_final_collective_io(io_info,&mpi_file_type,&mpi_buf_type,&coll_info,buf,do_write)<0) - HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL,"couldn't finish collective MPI-IO"); - done: + /* Perform final collective I/O operation */ + if(H5D_final_collective_io(io_info, type_info, mpi_buf_count, &mpi_file_type, &mpi_buf_type) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTGET, FAIL, "couldn't finish collective MPI-IO") + +done: + /* Free the MPI buf and file types, if they were derived */ + if(mbt_is_derived && MPI_SUCCESS != (mpi_code = MPI_Type_free(&mpi_buf_type))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code) + if(mft_is_derived && MPI_SUCCESS != (mpi_code = MPI_Type_free(&mpi_file_type))) + HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code) + #ifdef H5D_DEBUG - if(H5DEBUG(D)) +if(H5DEBUG(D)) HDfprintf(H5DEBUG(D),"before leaving inter_collective_io ret_value = %d\n",ret_value); #endif - FUNC_LEAVE_NOAPI(ret_value) -} /* end H5D_inter_collective_io */ + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_inter_collective_io() */ /*------------------------------------------------------------------------- * Function: H5D_final_collective_io * * Purpose: Routine for the common part of collective IO with different storages. - * * Return: Non-negative on success/Negative on failure * - * Programmer: - * - * Modifications: + * Programmer: Muqun Yang + * Monday, Feb. 13th, 2006 * *------------------------------------------------------------------------- */ static herr_t -H5D_final_collective_io(H5D_io_info_t *io_info,MPI_Datatype*mpi_file_type,MPI_Datatype *mpi_buf_type, - H5D_common_coll_info_t* coll_info, const void *buf, hbool_t do_write) +H5D_final_collective_io(H5D_io_info_t *io_info, const H5D_type_info_t *type_info, + size_t mpi_buf_count, MPI_Datatype *mpi_file_type, MPI_Datatype *mpi_buf_type) { - - - int mpi_code; /* MPI return code */ - hbool_t plist_is_setup=0; /* Whether the dxpl has been customized */ - herr_t ret_value = SUCCEED; - + int mpi_code; /* MPI return code */ + hbool_t plist_is_setup = FALSE; /* Whether the dxpl has been customized */ + herr_t ret_value = SUCCEED; FUNC_ENTER_NOAPI_NOINIT(H5D_final_collective_io) - /* - * Pass buf type, file type to the file driver. - */ - - if(H5FD_mpi_setup_collective(io_info->dxpl_id, *mpi_buf_type, *mpi_file_type)<0) - HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set MPI-I/O properties"); + /* Pass buf type, file type to the file driver. */ + if(H5FD_mpi_setup_collective(io_info->dxpl_id, *mpi_buf_type, *mpi_file_type) < 0) + HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set MPI-I/O properties") + plist_is_setup = TRUE; - plist_is_setup=1; -#ifdef H5D_DEBUG - if(H5DEBUG(D)){ - HDfprintf(H5DEBUG(D),"chunk addr %Hu\n",coll_info->chunk_addr); - HDfprintf(H5DEBUG(D),"mpi_buf_count %d\n",coll_info->mpi_buf_count); - } - -#endif - - if(do_write) { - if((io_info->ops.write)(io_info, - coll_info->mpi_buf_count,0,NULL,NULL,coll_info->chunk_addr, - NULL, buf) < 0) + if(io_info->op_type == H5D_IO_OP_WRITE) { + if((io_info->io_ops.single_write)(io_info, type_info, + (hsize_t)mpi_buf_count, NULL, NULL) < 0) HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "optimized write failed") - } + } /* end if */ else { - if((io_info->ops.read)(io_info, - coll_info->mpi_buf_count,0,NULL,NULL,coll_info->chunk_addr, - NULL, buf) < 0) + if((io_info->io_ops.single_read)(io_info, type_info, + (hsize_t)mpi_buf_count, NULL, NULL) < 0) HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "optimized read failed") - } + } /* end else */ done: - /* Reset the dxpl settings */ - if(plist_is_setup) { - if(H5FD_mpi_teardown_collective(io_info->dxpl_id)<0) - HDONE_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "unable to reset dxpl values"); - } /* end if */ - - /* free the MPI buf and file types */ - if (coll_info->mbt_is_derived) { - if (MPI_SUCCESS != (mpi_code= MPI_Type_free( mpi_buf_type ))) - HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); - } - if (coll_info->mft_is_derived) { - if (MPI_SUCCESS != (mpi_code= MPI_Type_free( mpi_file_type ))) - HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); - } + /* Reset the dxpl settings */ + if(plist_is_setup) + if(H5FD_mpi_teardown_collective(io_info->dxpl_id) < 0) + HDONE_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "unable to reset dxpl values") + #ifdef H5D_DEBUG - if(H5DEBUG(D)) +if(H5DEBUG(D)) HDfprintf(H5DEBUG(D),"ret_value before leaving final_collective_io=%d\n",ret_value); #endif - FUNC_LEAVE_NOAPI(ret_value) -}/* end H5D_final_collective_io */ +} /* end H5D_final_collective_io */ /*------------------------------------------------------------------------- * Function: H5D_sort_chunk * * Purpose: Routine to sort chunks in increasing order of chunk address - Each chunk address is also obtained. - - Description: - For most cases, the chunk address has already been sorted in increasing order. - The special sorting flag is used to optimize this common case. - quick sort is used for necessary sorting. - - Parameters: - Input: H5D_io_info_t* io_info, - H5D_chunk_map_t *fm(global chunk map struct) - Input/Output: H5D_chunk_addr_info_t chunk_addr_info_array[] : array to store chunk address and information - many_chunk_opt : flag to optimize the way to obtain chunk addresses - for many chunks + * Each chunk address is also obtained. * - * Return: Non-negative on success/Negative on failure + * Description: + * For most cases, the chunk address has already been sorted in increasing order. + * The special sorting flag is used to optimize this common case. + * quick sort is used for necessary sorting. * - * Programmer: + * Parameters: + * Input: H5D_io_info_t* io_info, + * H5D_chunk_map_t *fm(global chunk map struct) + * Input/Output: H5D_chunk_addr_info_t chunk_addr_info_array[] : array to store chunk address and information + * many_chunk_opt : flag to optimize the way to obtain chunk addresses + * for many chunks * - * Modifications: + * Return: Non-negative on success/Negative on failure + * + * Programmer: Muqun Yang + * Monday, Feb. 13th, 2006 * *------------------------------------------------------------------------- */ - static herr_t -H5D_sort_chunk(H5D_io_info_t * io_info, - H5D_chunk_map_t *fm, - H5D_chunk_addr_info_t chunk_addr_info_array[], - int many_chunk_opt) +H5D_sort_chunk(H5D_io_info_t *io_info, const H5D_chunk_map_t *fm, + H5D_chunk_addr_info_t chunk_addr_info_array[], int sum_chunk) { - - - H5SL_node_t *chunk_node; /* Current node in chunk skip list */ + H5SL_node_t *chunk_node; /* Current node in chunk skip list */ H5D_chunk_info_t *chunk_info; /* Current chunking info. of this node. */ - haddr_t chunk_addr; /* Current chunking address of this node */ - haddr_t *total_chunk_addr_array=NULL; /* The array of chunk address for the total number of chunk */ - int i,mpi_code; - int total_chunks; - size_t num_chunks; - int mpi_type_cleanup = 0; - int tchunk_addr_cleanup = 0; - MPI_Datatype chunk_addrtype; - H5D_storage_t store; /*union of EFL and chunk pointer in file space */ - hbool_t do_sort = FALSE; - herr_t ret_value = SUCCEED; /*return value */ + haddr_t chunk_addr; /* Current chunking address of this node */ + haddr_t *total_chunk_addr_array = NULL; /* The array of chunk address for the total number of chunk */ + H5D_storage_t store; /*union of EFL and chunk pointer in file space */ + hbool_t do_sort = FALSE; /* Whether the addresses need to be sorted */ + int bsearch_coll_chunk_threshold; + int many_chunk_opt = H5D_OBTAIN_ONE_CHUNK_ADDR_IND; + int mpi_size; /* Number of MPI processes */ + int mpi_code; /* MPI return code */ + int i; /* Local index variable */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5D_sort_chunk) - num_chunks = H5SL_count(fm->sel_chunks); + /* Retrieve # of MPI processes */ + if((mpi_size = H5F_mpi_get_size(io_info->dset->oloc.file)) < 0) + HGOTO_ERROR(H5E_IO, H5E_MPI, FAIL, "unable to obtain mpi size") + + /* Calculate the actual threshold to obtain all chunk addresses collectively + * The bigger this number is, the more possible the use of obtaining chunk + * address collectively. + */ + /* For non-optimization one-link IO, actual bsearch threshold is always + * 0, we would always want to obtain the chunk addresses individually + * for each process. + */ + bsearch_coll_chunk_threshold = (sum_chunk * 100) / ((int)fm->total_chunks * mpi_size); + if((bsearch_coll_chunk_threshold > H5D_ALL_CHUNK_ADDR_THRES_COL) + && ((sum_chunk / mpi_size) >= H5D_ALL_CHUNK_ADDR_THRES_COL_NUM)) + many_chunk_opt = H5D_OBTAIN_ALL_CHUNK_ADDR_COL; + #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"many_chunk_opt= %d\n",many_chunk_opt); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D), "many_chunk_opt= %d\n", many_chunk_opt); #endif /* If we need to optimize the way to obtain the chunk address */ - if(many_chunk_opt != H5D_OBTAIN_ONE_CHUNK_ADDR_IND){ + if(many_chunk_opt != H5D_OBTAIN_ONE_CHUNK_ADDR_IND) { + int mpi_rank; - int mpi_rank, root; - total_chunks = (int)fm->total_chunks; - total_chunk_addr_array = H5MM_malloc(sizeof(haddr_t)*total_chunks); - tchunk_addr_cleanup = 1; #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"Coming inside H5D_OBTAIN_ALL_CHUNK_ADDR_COL\n"); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D), "Coming inside H5D_OBTAIN_ALL_CHUNK_ADDR_COL\n"); #endif - root = 0; - if((mpi_rank = H5F_mpi_get_rank(io_info->dset->oloc.file))<0) - HGOTO_ERROR (H5E_IO, H5E_MPI, FAIL, "unable to obtain mpi rank"); - - /*Create received MPI derived datatype */ - if(MPI_SUCCESS !=(mpi_code = MPI_Type_contiguous((int)(sizeof(haddr_t)*total_chunks), MPI_BYTE, &chunk_addrtype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_contiguous failed", mpi_code); - if(MPI_SUCCESS !=(mpi_code = MPI_Type_commit(&chunk_addrtype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code); - - mpi_type_cleanup = 1; - - if(mpi_rank == root) { - if(H5D_istore_chunkmap(io_info, total_chunk_addr_array, fm->down_chunks)<0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address"); - } + /* Allocate array for chunk addresses */ + if(NULL == (total_chunk_addr_array = H5MM_malloc(sizeof(haddr_t) * (size_t)fm->total_chunks))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate memory chunk address array") + + /* Retrieve all the chunk addresses with process 0 */ + if((mpi_rank = H5F_mpi_get_rank(io_info->dset->oloc.file)) < 0) + HGOTO_ERROR(H5E_IO, H5E_MPI, FAIL, "unable to obtain mpi rank") + if(mpi_rank == 0) { + if(H5D_istore_chunkmap(io_info, total_chunk_addr_array, fm->down_chunks) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address") + } /* end if */ + /* Broadcasting the MPI_IO option info. and chunk address info. */ - if(MPI_SUCCESS !=(mpi_code = MPI_Bcast(total_chunk_addr_array,1,chunk_addrtype,root,io_info->comm))) - HMPI_GOTO_ERROR(FAIL, "MPI_BCast failed", mpi_code); + if(MPI_SUCCESS != (mpi_code = MPI_Bcast(total_chunk_addr_array, (int)(sizeof(haddr_t) * fm->total_chunks), MPI_BYTE, (int)0, io_info->comm))) + HMPI_GOTO_ERROR(FAIL, "MPI_BCast failed", mpi_code) } /* end if */ - /* Get first node in chunk skip list */ - if(NULL ==(chunk_node = H5SL_first(fm->sel_chunks))) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk node from skipped list"); /* Set dataset storage for I/O info */ io_info->store = &store; - if(NULL ==(chunk_info = H5SL_item(chunk_node))) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk info from skipped list"); - store.chunk.offset = chunk_info->coords; - store.chunk.index = chunk_info->index; + + /* Start at first node in chunk skip list */ i = 0; - if(many_chunk_opt == H5D_OBTAIN_ONE_CHUNK_ADDR_IND){ - if(HADDR_UNDEF==(chunk_addr = H5D_istore_get_addr(io_info,NULL))) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk info from skipped list"); + if(NULL == (chunk_node = H5SL_first(fm->sel_chunks))) + HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk node from skipped list") -#ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"coming to obtain each chunk address individually \n"); -#endif - } - else - chunk_addr = total_chunk_addr_array[chunk_info->index]; + /* Iterate over all chunks for this process */ + while(chunk_node) { + if(NULL == (chunk_info = H5SL_item(chunk_node))) + HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk info from skipped list") + + if(many_chunk_opt == H5D_OBTAIN_ONE_CHUNK_ADDR_IND) { + store.chunk.offset = chunk_info->coords; + store.chunk.index = chunk_info->index; + if(HADDR_UNDEF == (chunk_addr = H5D_istore_get_addr(io_info, NULL))) + HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL, "couldn't get chunk info from skipped list") + } /* end if */ + else + chunk_addr = total_chunk_addr_array[chunk_info->index]; - chunk_addr_info_array[i].chunk_addr = chunk_addr; - chunk_addr_info_array[i].chunk_info = *chunk_info; + /* Check if chunk addresses are not in increasing order in the file */ + if(i > 0 && chunk_addr < chunk_addr_info_array[i - 1].chunk_addr) + do_sort = TRUE; - chunk_node = H5SL_next(chunk_node); + /* Set the address & info for this chunk */ + chunk_addr_info_array[i].chunk_addr = chunk_addr; + chunk_addr_info_array[i].chunk_info = *chunk_info; - while(chunk_node) { + /* Advance to next chunk in list */ + i++; + chunk_node = H5SL_next(chunk_node); + } /* end while */ - chunk_info = H5SL_item(chunk_node); - store.chunk.offset = chunk_info->coords; - store.chunk.index = chunk_info->index; - - if(many_chunk_opt == H5D_OBTAIN_ONE_CHUNK_ADDR_IND){ - if(HADDR_UNDEF==(chunk_addr = H5D_istore_get_addr(io_info,NULL))) - HGOTO_ERROR(H5E_STORAGE, H5E_CANTGET, FAIL,"couldn't get chunk info from skipped list"); - } - else - chunk_addr = total_chunk_addr_array[chunk_info->index]; - - if(chunk_addr < chunk_addr_info_array[i].chunk_addr) do_sort = TRUE; - chunk_addr_info_array[i+1].chunk_addr = chunk_addr; - chunk_addr_info_array[i+1].chunk_info =*chunk_info; - i++; - chunk_node = H5SL_next(chunk_node); - } #ifdef H5D_DEBUG - if(H5DEBUG(D)) - HDfprintf(H5DEBUG(D),"before Qsort\n"); +if(H5DEBUG(D)) + HDfprintf(H5DEBUG(D), "before Qsort\n"); #endif - if(do_sort) - HDqsort(chunk_addr_info_array,num_chunks,sizeof(chunk_addr_info_array),H5D_cmp_chunk_addr); + if(do_sort) { + size_t num_chunks = H5SL_count(fm->sel_chunks); + + HDqsort(chunk_addr_info_array, num_chunks, sizeof(chunk_addr_info_array[0]), H5D_cmp_chunk_addr); + } /* end if */ done: + if(total_chunk_addr_array) + H5MM_xfree(total_chunk_addr_array); - if(tchunk_addr_cleanup) - HDfree(total_chunk_addr_array); - if(mpi_type_cleanup) { - if (MPI_SUCCESS != (mpi_code= MPI_Type_free( &chunk_addrtype ))) - HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); - } FUNC_LEAVE_NOAPI(ret_value) } /* end H5D_sort_chunk() */ @@ -1725,310 +1768,244 @@ done: * Function: H5D_obtain_mpio_mode * * Purpose: Routine to obtain each io mode(collective,independent or none) for each chunk; - Each chunk address is also obtained. - - Description: - - 1) Each process provides two piece of information for all chunks having selection - a) chunk index - b) wheather this chunk is regular(for MPI derived datatype not working case) - - 2) Gather all the information to the root process - - 3) Root process will do the following: - a) Obtain chunk addresses for all chunks in this data space - b) With the consideration of the user option, calculate IO mode for each chunk - c) Build MPI derived datatype to combine "chunk address" and "assign_io" information - in order to do MPI Bcast only once - d) MPI Bcast the IO mode and chunk address information for each chunk. - 4) Each process then retrieves IO mode and chunk address information to assign_io_mode and chunk_addr. - - Parameters: - - Input: H5D_io_info_t* io_info, - H5D_chunk_map_t *fm,(global chunk map struct) - Output: uint8_t assign_io_mode[], : IO mode, collective, independent or none - haddr_t chunk_addr[], : chunk address array for each chunk + * Each chunk address is also obtained. * - * Return: Non-negative on success/Negative on failure + * Description: * - * Programmer: + * 1) Each process provides two piece of information for all chunks having selection + * a) chunk index + * b) wheather this chunk is regular(for MPI derived datatype not working case) + * + * 2) Gather all the information to the root process * - * Modifications: + * 3) Root process will do the following: + * a) Obtain chunk addresses for all chunks in this data space + * b) With the consideration of the user option, calculate IO mode for each chunk + * c) Build MPI derived datatype to combine "chunk address" and "assign_io" information + * in order to do MPI Bcast only once + * d) MPI Bcast the IO mode and chunk address information for each chunk. + * 4) Each process then retrieves IO mode and chunk address information to assign_io_mode and chunk_addr. + * + * Parameters: + * + * Input: H5D_io_info_t* io_info, + * H5D_chunk_map_t *fm,(global chunk map struct) + * Output: uint8_t assign_io_mode[], : IO mode, collective, independent or none + * haddr_t chunk_addr[], : chunk address array for each chunk + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Muqun Yang + * Monday, Feb. 13th, 2006 * *------------------------------------------------------------------------- */ - static herr_t -H5D_obtain_mpio_mode(H5D_io_info_t* io_info, - H5D_chunk_map_t *fm, - uint8_t assign_io_mode[], - haddr_t chunk_addr[]) +H5D_obtain_mpio_mode(H5D_io_info_t* io_info, H5D_chunk_map_t *fm, + H5P_genplist_t *dx_plist, uint8_t assign_io_mode[], haddr_t chunk_addr[]) { - - int total_chunks; - hsize_t ori_total_chunks; - unsigned percent_nproc_per_chunk,threshold_nproc_per_chunk; - H5FD_mpio_chunk_opt_t chunk_opt_mode; - uint8_t* io_mode_info=NULL; - uint8_t* recv_io_mode_info=NULL; - uint8_t* mergebuf=NULL; - uint8_t* tempbuf; - - H5SL_node_t* chunk_node; - H5D_chunk_info_t* chunk_info; - - MPI_Datatype bastype[2]; - MPI_Datatype chunk_addrtype; - int bascount; - int basblock[2]; - MPI_Aint basdisp[2]; - MPI_Datatype rtype; - MPI_Datatype stype; - int mpi_size,mpi_rank; - MPI_Comm comm; - int ic,root; - int mpi_code; - H5P_genplist_t *plist; - int mem_cleanup = 0, - mpi_type_cleanup = 0; - + int total_chunks; + unsigned percent_nproc_per_chunk,threshold_nproc_per_chunk; + H5FD_mpio_chunk_opt_t chunk_opt_mode; + uint8_t* io_mode_info=NULL; + uint8_t* recv_io_mode_info=NULL; + uint8_t* mergebuf=NULL; + uint8_t* tempbuf; + H5SL_node_t* chunk_node; + H5D_chunk_info_t* chunk_info; + int mpi_size,mpi_rank; + MPI_Comm comm; + int ic,root; + int mpi_code; + int mem_cleanup = 0; #ifdef H5_HAVE_INSTRUMENTED_LIBRARY - int new_value; - htri_t check_prop; + int new_value; + htri_t check_prop; #endif + herr_t ret_value = SUCCEED; - herr_t ret_value = SUCCEED; - - FUNC_ENTER_NOAPI_NOINIT(H5D_obtain_mpio_mode) + FUNC_ENTER_NOAPI_NOINIT(H5D_obtain_mpio_mode) - /* Assign the rank 0 to the root */ - root = 0; - comm = io_info->comm; + /* Assign the rank 0 to the root */ + root = 0; + comm = io_info->comm; - /* Obtain the number of process and the current rank of the process */ - if((mpi_rank = H5F_mpi_get_rank(io_info->dset->oloc.file))<0) - HGOTO_ERROR (H5E_IO, H5E_MPI, FAIL, "unable to obtain mpi rank"); - if((mpi_size = H5F_mpi_get_size(io_info->dset->oloc.file))<0) - HGOTO_ERROR (H5E_IO, H5E_MPI, FAIL, "unable to obtain mpi size"); + /* Obtain the number of process and the current rank of the process */ + if((mpi_rank = H5F_mpi_get_rank(io_info->dset->oloc.file)) < 0) + HGOTO_ERROR(H5E_IO, H5E_MPI, FAIL, "unable to obtain mpi rank") + if((mpi_size = H5F_mpi_get_size(io_info->dset->oloc.file)) < 0) + HGOTO_ERROR(H5E_IO, H5E_MPI, FAIL, "unable to obtain mpi size") - /* Allocate memory */ - ori_total_chunks = fm->total_chunks; - H5_ASSIGN_OVERFLOW(total_chunks,ori_total_chunks,hsize_t,int); - - /* Obtain the data transfer properties */ - if(NULL == (plist = H5I_object(io_info->dxpl_id))) - HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list") - - percent_nproc_per_chunk=H5P_peek_unsigned(plist,H5D_XFER_MPIO_CHUNK_OPT_RATIO_NAME); + /* Setup parameters */ + H5_ASSIGN_OVERFLOW(total_chunks, fm->total_chunks, hsize_t, int); + percent_nproc_per_chunk = H5P_peek_unsigned(dx_plist, H5D_XFER_MPIO_CHUNK_OPT_RATIO_NAME); #if defined(H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS) && defined(H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS) - - chunk_opt_mode=(H5FD_mpio_chunk_opt_t)H5P_peek_unsigned(plist,H5D_XFER_MPIO_CHUNK_OPT_HARD_NAME); - - if((chunk_opt_mode == H5FD_MPIO_CHUNK_MULTI_IO) || (percent_nproc_per_chunk == 0)){ - if(H5D_istore_chunkmap(io_info, chunk_addr, fm->down_chunks) < 0) - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address"); - for(ic = 0; ic<total_chunks;ic++) - assign_io_mode[ic] = H5D_CHUNK_IO_MODE_COL; - goto done; - } + chunk_opt_mode = (H5FD_mpio_chunk_opt_t)H5P_peek_unsigned(dx_plist, H5D_XFER_MPIO_CHUNK_OPT_HARD_NAME); + if((chunk_opt_mode == H5FD_MPIO_CHUNK_MULTI_IO) || (percent_nproc_per_chunk == 0)) { + if(H5D_istore_chunkmap(io_info, chunk_addr, fm->down_chunks) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address"); + for(ic = 0; ic < total_chunks; ic++) + assign_io_mode[ic] = H5D_CHUNK_IO_MODE_COL; + + HGOTO_DONE(SUCCEED) + } /* end if */ #endif - threshold_nproc_per_chunk = mpi_size * percent_nproc_per_chunk/100; - - io_mode_info = (uint8_t *)H5MM_calloc(total_chunks*sizeof(MPI_BYTE)); - mergebuf = H5MM_malloc((sizeof(haddr_t)+sizeof(MPI_BYTE))*total_chunks); - tempbuf = mergebuf + sizeof(MPI_BYTE)*total_chunks; - if(mpi_rank == root) - recv_io_mode_info = (uint8_t *)H5MM_malloc(total_chunks*sizeof(MPI_BYTE)*mpi_size); + threshold_nproc_per_chunk = mpi_size * percent_nproc_per_chunk/100; + + /* Allocate memory */ + io_mode_info = (uint8_t *)H5MM_calloc(total_chunks); + mergebuf = H5MM_malloc((sizeof(haddr_t) + 1) * total_chunks); + tempbuf = mergebuf + total_chunks; + if(mpi_rank == root) + recv_io_mode_info = (uint8_t *)H5MM_malloc(total_chunks * mpi_size); - mem_cleanup = 1; + mem_cleanup = 1; - chunk_node = H5SL_first(fm->sel_chunks); - - /*Obtain the regularity and selection information for all chunks in this process. */ - while(chunk_node){ - - chunk_info = H5SL_item(chunk_node); + /* Obtain the regularity and selection information for all chunks in this process. */ + chunk_node = H5SL_first(fm->sel_chunks); + while(chunk_node) { + chunk_info = H5SL_item(chunk_node); #ifndef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS - /* regularity information: 1, selection information: 2 */ - if(H5S_SELECT_IS_REGULAR(chunk_info->fspace) == TRUE && - H5S_SELECT_IS_REGULAR(chunk_info->mspace) == TRUE) + /* regularity information: 1, selection information: 2 */ + if(H5S_SELECT_IS_REGULAR(chunk_info->fspace) == TRUE && + H5S_SELECT_IS_REGULAR(chunk_info->mspace) == TRUE) #endif - io_mode_info[chunk_info->index] = H5D_CHUNK_SELECT_REG; /* this chunk is selected and is "regular" without defining H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS. */ + io_mode_info[chunk_info->index] = H5D_CHUNK_SELECT_REG; /* this chunk is selected and is "regular" without defining H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS. */ #ifndef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS - else - io_mode_info[chunk_info->index] = H5D_CHUNK_SELECT_IRREG; /* this chunk is selected and is irregular*/ + else + io_mode_info[chunk_info->index] = H5D_CHUNK_SELECT_IRREG; /* this chunk is selected and is irregular*/ #endif - - chunk_node = H5SL_next(chunk_node); - } + chunk_node = H5SL_next(chunk_node); + } /* end while */ - /*Create sent MPI derived datatype */ - if(MPI_SUCCESS !=(mpi_code = MPI_Type_contiguous(total_chunks,MPI_BYTE,&stype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Comm_rank failed", mpi_code); - if(MPI_SUCCESS != (mpi_code = MPI_Type_commit(&stype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code); - - /*Create received basic MPI derived datatype */ - bascount = 2; - basblock[0] = total_chunks; - basblock[1] = total_chunks; - basdisp[0] = 0; - basdisp[1] = (MPI_Aint)(sizeof(MPI_BYTE)*total_chunks);/* may need to check overflow */ - bastype[0] = MPI_BYTE; - - if(MPI_SUCCESS !=(mpi_code = MPI_Type_contiguous(sizeof(haddr_t),MPI_BYTE,&chunk_addrtype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_contiguous failed", mpi_code); - if(MPI_SUCCESS != (mpi_code = MPI_Type_commit(&chunk_addrtype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code); - bastype[1] = chunk_addrtype; - - if(MPI_SUCCESS !=(mpi_code = MPI_Type_struct(bascount,basblock,basdisp,bastype,&rtype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_struct failed", mpi_code); - if(MPI_SUCCESS !=(mpi_code = MPI_Type_commit(&rtype))) - HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code); - - /* Set up a flag to clean up the MPI derived datatype later */ - mpi_type_cleanup = 1; - - /*Gather all the information */ - if(MPI_SUCCESS !=(mpi_code = MPI_Gather(io_mode_info,1,stype,recv_io_mode_info,1,stype,root,comm))) - HMPI_GOTO_ERROR(FAIL, "MPI_Gather failed", mpi_code); - - /* Calculate the mode for IO(collective, independent or none) at root process */ - if(mpi_rank == root) { - - int nproc; - int* nproc_per_chunk; + /*Gather all the information */ + if(MPI_SUCCESS != (mpi_code = MPI_Gather(io_mode_info, total_chunks, MPI_BYTE, recv_io_mode_info, total_chunks, MPI_BYTE, root, comm))) + HMPI_GOTO_ERROR(FAIL, "MPI_Gather failed", mpi_code) + + /* Calculate the mode for IO(collective, independent or none) at root process */ + if(mpi_rank == root) { + int nproc; + int* nproc_per_chunk; #if !defined(H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS) || !defined(H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS) - int* ind_this_chunk; + int* ind_this_chunk; #endif - /* pre-computing: calculate number of processes and - regularity of the selection occupied in each chunk */ - nproc_per_chunk = (int*)H5MM_calloc(total_chunks*sizeof(int)); + /* pre-computing: calculate number of processes and + regularity of the selection occupied in each chunk */ + nproc_per_chunk = (int*)H5MM_calloc(total_chunks * sizeof(int)); #if !defined(H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS) || !defined(H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS) - ind_this_chunk = (int*)H5MM_calloc(total_chunks*sizeof(int)); + ind_this_chunk = (int*)H5MM_calloc(total_chunks * sizeof(int)); #endif - /* calculating the chunk address */ - if(H5D_istore_chunkmap(io_info, chunk_addr, fm->down_chunks)<0){ - HDfree(nproc_per_chunk); + /* calculating the chunk address */ + if(H5D_istore_chunkmap(io_info, chunk_addr, fm->down_chunks) < 0) { + HDfree(nproc_per_chunk); #if !defined(H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS) || !defined(H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS) - HDfree(ind_this_chunk); + HDfree(ind_this_chunk); #endif - HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address"); - } - - /* checking for number of process per chunk and regularity of the selection*/ - for (nproc = 0;nproc <mpi_size;nproc++){ - uint8_t *tmp_recv_io_mode_info = recv_io_mode_info + nproc*total_chunks; - /* calculate the number of process per chunk and adding irregular selection option */ - for(ic = 0; ic < total_chunks; ic++, tmp_recv_io_mode_info++){ - if(*tmp_recv_io_mode_info != 0) { - nproc_per_chunk[ic]++; + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address") + } /* end if */ + + /* checking for number of process per chunk and regularity of the selection*/ + for(nproc = 0; nproc < mpi_size; nproc++) { + uint8_t *tmp_recv_io_mode_info = recv_io_mode_info + (nproc * total_chunks); + + /* Calculate the number of process per chunk and adding irregular selection option */ + for(ic = 0; ic < total_chunks; ic++, tmp_recv_io_mode_info++) { + if(*tmp_recv_io_mode_info != 0) { + nproc_per_chunk[ic]++; #ifndef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS - if(*tmp_recv_io_mode_info == H5D_CHUNK_SELECT_IRREG) - ind_this_chunk[ic] = 1; + if(*tmp_recv_io_mode_info == H5D_CHUNK_SELECT_IRREG) + ind_this_chunk[ic] = 1; #endif - } + } /* end if */ #ifndef H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS else { - /*checking whether we have a selection in this chunk */ - ind_this_chunk[ic] = 1; - } + /*checking whether we have a selection in this chunk */ + ind_this_chunk[ic] = 1; + } /* end else */ #endif - } + } /* end for */ + } /* end for */ - } - - /* Calculating MPIO mode for each chunk (collective, independent, none) */ - for(ic = 0; ic < total_chunks; ic++){ - if(nproc_per_chunk[ic]>MAX(1,threshold_nproc_per_chunk)){ + /* Calculating MPIO mode for each chunk (collective, independent, none) */ + for(ic = 0; ic < total_chunks; ic++) { + if(nproc_per_chunk[ic] > MAX(1, threshold_nproc_per_chunk)) { #if !defined(H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS) || !defined(H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS) - if(!ind_this_chunk[ic]) assign_io_mode[ic] = H5D_CHUNK_IO_MODE_COL; + if(!ind_this_chunk[ic]) + assign_io_mode[ic] = H5D_CHUNK_IO_MODE_COL; #else - assign_io_mode[ic] = H5D_CHUNK_IO_MODE_COL; + assign_io_mode[ic] = H5D_CHUNK_IO_MODE_COL; #endif - } - } + } /* end if */ + } /* end for */ - /* merge buffer io_mode info and chunk addr into one */ - HDmemcpy(mergebuf,assign_io_mode,sizeof(MPI_BYTE)*total_chunks); - HDmemcpy(tempbuf,chunk_addr,sizeof(haddr_t)*total_chunks); + /* merge buffer io_mode info and chunk addr into one */ + HDmemcpy(mergebuf, assign_io_mode, total_chunks); + HDmemcpy(tempbuf, chunk_addr, sizeof(haddr_t) * total_chunks); - HDfree(nproc_per_chunk); + HDfree(nproc_per_chunk); #if !defined(H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS) || !defined(H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS) - HDfree(ind_this_chunk); + HDfree(ind_this_chunk); #endif - } + } /* end if */ - /* Broadcasting the MPI_IO option info. and chunk address info. */ - if(MPI_SUCCESS !=(mpi_code = MPI_Bcast(mergebuf,1,rtype,root,comm))) - HMPI_GOTO_ERROR(FAIL, "MPI_BCast failed", mpi_code); + /* Broadcasting the MPI_IO option info. and chunk address info. */ + if(MPI_SUCCESS != (mpi_code = MPI_Bcast(mergebuf, ((sizeof(haddr_t) + 1) * total_chunks), MPI_BYTE, root, comm))) + HMPI_GOTO_ERROR(FAIL, "MPI_BCast failed", mpi_code) - HDmemcpy(assign_io_mode,mergebuf,sizeof(MPI_BYTE)*total_chunks); - HDmemcpy(chunk_addr,tempbuf,sizeof(haddr_t)*total_chunks); + HDmemcpy(assign_io_mode, mergebuf, total_chunks); + HDmemcpy(chunk_addr, tempbuf, sizeof(haddr_t) * total_chunks); #ifdef H5_HAVE_INSTRUMENTED_LIBRARY - check_prop = H5Pexist(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_MULTI_RATIO_COLL_NAME); + check_prop = H5Pexist(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_MULTI_RATIO_COLL_NAME); if(check_prop > 0) { #if !defined(H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS) || !defined(H5_MPI_SPECIAL_COLLECTIVE_IO_WORKS) - new_value = 0; - if(H5Pset(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_MULTI_RATIO_COLL_NAME,&new_value)<0) - HGOTO_ERROR(H5E_PLIST, H5E_UNSUPPORTED, FAIL, "unable to set property value"); + new_value = 0; + if(H5Pset(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_MULTI_RATIO_COLL_NAME, &new_value) < 0) + HGOTO_ERROR(H5E_PLIST, H5E_UNSUPPORTED, FAIL, "unable to set property value") #else - for(ic = 0; ic < total_chunks; ic++){ - if(assign_io_mode[ic] == H5D_CHUNK_IO_MODE_COL) { - new_value = 0; - if(H5Pset(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_MULTI_RATIO_COLL_NAME,&new_value)<0) - HGOTO_ERROR(H5E_PLIST, H5E_UNSUPPORTED, FAIL, "unable to set property value"); - break; - } - } + for(ic = 0; ic < total_chunks; ic++) { + if(assign_io_mode[ic] == H5D_CHUNK_IO_MODE_COL) { + new_value = 0; + if(H5Pset(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_MULTI_RATIO_COLL_NAME,&new_value) < 0) + HGOTO_ERROR(H5E_PLIST, H5E_UNSUPPORTED, FAIL, "unable to set property value") + break; + } /* end if */ + } /* end for */ #endif - } - check_prop = H5Pexist(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_MULTI_RATIO_IND_NAME); - if(check_prop > 0) { - int temp_count = 0; - for(ic = 0; ic < total_chunks; ic++){ - if(assign_io_mode[ic] == H5D_CHUNK_IO_MODE_COL) { - temp_count++; - break; - } - } - if(temp_count==0){ - new_value = 0; - if(H5Pset(io_info->dxpl_id,H5D_XFER_COLL_CHUNK_MULTI_RATIO_IND_NAME,&new_value)<0) - HGOTO_ERROR(H5E_PLIST, H5E_UNSUPPORTED, FAIL, "unable to set property value"); - } - } + } /* end if */ + + check_prop = H5Pexist(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_MULTI_RATIO_IND_NAME); + if(check_prop > 0) { + int temp_count = 0; + + for(ic = 0; ic < total_chunks; ic++) { + if(assign_io_mode[ic] == H5D_CHUNK_IO_MODE_COL) { + temp_count++; + break; + } /* end if */ + } /* end for */ + if(temp_count == 0) { + new_value = 0; + if(H5Pset(io_info->dxpl_id, H5D_XFER_COLL_CHUNK_MULTI_RATIO_IND_NAME, &new_value) < 0) + HGOTO_ERROR(H5E_PLIST, H5E_UNSUPPORTED, FAIL, "unable to set property value") + } /* end if */ + } /* end if */ #endif done: - - if(mpi_type_cleanup) { - if (MPI_SUCCESS != (mpi_code= MPI_Type_free( &chunk_addrtype ))) - HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); - - if (MPI_SUCCESS != (mpi_code= MPI_Type_free( &stype ))) - HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); - - if (MPI_SUCCESS != (mpi_code= MPI_Type_free( &rtype ))) - HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code); - } - - if(mem_cleanup){ - HDfree(io_mode_info); - HDfree(mergebuf); - if(mpi_rank == root) - HDfree(recv_io_mode_info); - } + if(mem_cleanup) { + HDfree(io_mode_info); + HDfree(mergebuf); + if(mpi_rank == root) + HDfree(recv_io_mode_info); + } /* end if */ FUNC_LEAVE_NOAPI(ret_value) -}/* end H5D_obtain_mpio_mode*/ +} /* end H5D_obtain_mpio_mode() */ static int H5D_cmp_chunk_addr(const void *chunk_addr_info1, const void *chunk_addr_info2) @@ -2041,7 +2018,6 @@ H5D_cmp_chunk_addr(const void *chunk_addr_info1, const void *chunk_addr_info2) addr2 = ((const H5D_chunk_addr_info_t *)chunk_addr_info2)->chunk_addr; FUNC_LEAVE_NOAPI(H5F_addr_cmp(addr1, addr2)) - } #endif /* H5_HAVE_PARALLEL */ |