mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-03-07 16:37:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r17281] Description:

Browse Source 
Further refactoring of the dataset layout information, to separate the
storage information from the layout info.

Tested on:
    FreeBSD/32 6.3 (duty) in debug mode
    FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
    Linux/32 2.6 (jam) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
        in debug mode
    Linux/64-amd64 2.6 (smirom) w/Intel compilers w/default API=1.6.x,
        w/C++ & FORTRAN, in production mode
    Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
        w/szip filter, in production mode
    Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
        in production mode
    Linux/64-ia64 2.4 (tg-login3) w/parallel, w/FORTRAN, in debug mode
    Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode
    Mac OS X/32 10.5.7 (amazon) in debug mode
    Mac OS X/32 10.5.7 (amazon) w/C++ & FORTRAN, w/threadsafe,
        in production mode
This commit is contained in:
Quincey Koziol 2009-07-30 22:08:12 -05:00
parent 361586a90e
commit 0eb775f358
14 changed files with 122 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
src/H5Dchunk.c
View File

@ -191,7 +191,7 @@ H5D_nonexistent_readvv(const H5D_io_info_t *io_info,
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[]);
/* Helper routines */
static herr_t H5D_chunk_set_info_real(H5O_layout_t *layout, unsigned ndims,
static herr_t H5D_chunk_set_info_real(H5O_layout_chunk_t *layout, unsigned ndims,
const hsize_t *curr_dims);
static void *H5D_chunk_alloc(size_t size, const H5O_pline_t *pline);
static void *H5D_chunk_xfree(void *chk, const H5O_pline_t *pline);
@ -287,8 +287,8 @@ H5FL_DEFINE_STATIC(H5D_chunk_prune_stack_t);
*
*-------------------------------------------------------------------------
*/
herr_t
H5D_chunk_set_info_real(H5O_layout_t *layout, unsigned ndims, const hsize_t *curr_dims)
static herr_t
H5D_chunk_set_info_real(H5O_layout_chunk_t *layout, unsigned ndims, const hsize_t *curr_dims)
{
unsigned u; /* Local index variable */
herr_t ret_value = SUCCEED; /* Return value */
@ -301,16 +301,16 @@ H5D_chunk_set_info_real(H5O_layout_t *layout, unsigned ndims, const hsize_t *cur
HDassert(curr_dims);
/* Compute the # of chunks in dataset dimensions */
for(u = 0, layout->u.chunk.nchunks = 1; u < ndims; u++) {
for(u = 0, layout->nchunks = 1; u < ndims; u++) {
/* Round up to the next integer # of chunks, to accomodate partial chunks */
layout->u.chunk.chunks[u] = ((curr_dims[u] + layout->u.chunk.dim[u]) - 1) / layout->u.chunk.dim[u];
layout->chunks[u] = ((curr_dims[u] + layout->dim[u]) - 1) / layout->dim[u];
/* Accumulate the # of chunks */
layout->u.chunk.nchunks *= layout->u.chunk.chunks[u];
layout->nchunks *= layout->chunks[u];
} /* end for */
/* Get the "down" sizes for each dimension */
if(H5V_array_down(ndims, layout->u.chunk.chunks, layout->u.chunk.down_chunks) < 0)
if(H5V_array_down(ndims, layout->chunks, layout->down_chunks) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't compute 'down' chunk size value")
done:
@ -349,7 +349,7 @@ H5D_chunk_set_info(const H5D_t *dset)
H5_ASSIGN_OVERFLOW(ndims, sndims, int, unsigned);
/* Set the base layout information */
if(H5D_chunk_set_info_real(&dset->shared->layout, ndims, curr_dims) < 0)
if(H5D_chunk_set_info_real(&dset->shared->layout.u.chunk, ndims, curr_dims) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set layout's chunk info")
/* Call the index's "resize" callback */
@ -532,17 +532,17 @@ done:
*-------------------------------------------------------------------------
*/
hbool_t
H5D_chunk_is_space_alloc(const H5O_layout_t *layout)
H5D_chunk_is_space_alloc(const H5O_storage_t *storage)
{
hbool_t ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOFUNC(H5D_chunk_is_space_alloc)
/* Sanity checks */
HDassert(layout);
HDassert(storage);
/* Query index layer */
ret_value = (layout->storage.u.chunk.ops->is_space_alloc)(&layout->storage.u.chunk);
ret_value = (storage->u.chunk.ops->is_space_alloc)(&storage->u.chunk);
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D_chunk_is_space_alloc() */
@ -4288,8 +4288,9 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
H5D_chunk_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
H5O_layout_t *layout_dst, const H5S_extent_t *ds_extent_src,
H5D_chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src,
H5O_layout_chunk_t *layout_src, H5F_t *f_dst, H5O_storage_chunk_t *storage_dst,
H5O_layout_chunk_t *layout_dst, const H5S_extent_t *ds_extent_src,
const H5T_t *dt_src, const H5O_pline_t *pline_src,
H5O_copy_t *cpy_info, hid_t dxpl_id)
{
@ -4318,9 +4319,11 @@ H5D_chunk_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
/* Check args */
HDassert(f_src);
HDassert(layout_src);
HDassert(storage_src);
HDassert(f_dst);
HDassert(layout_src && H5D_CHUNKED == layout_src->type);
HDassert(layout_dst && H5D_CHUNKED == layout_dst->type);
HDassert(layout_dst);
HDassert(storage_dst);
HDassert(ds_extent_src);
HDassert(dt_src);
@ -4333,7 +4336,7 @@ H5D_chunk_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
pline = pline_src;
/* Layout is not created in the destination file, reset index address */
if(H5D_chunk_idx_reset(&layout_dst->storage.u.chunk, TRUE) < 0)
if(H5D_chunk_idx_reset(storage_dst, TRUE) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to reset chunked storage index in dest")
/* Initialize layout information */
@ -4360,17 +4363,17 @@ H5D_chunk_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
idx_info_src.f = f_src;
idx_info_src.dxpl_id = dxpl_id;
idx_info_src.pline = pline;
idx_info_src.layout = &layout_src->u.chunk;
idx_info_src.storage = &layout_src->storage.u.chunk;
idx_info_src.layout = layout_src;
idx_info_src.storage = storage_src;
idx_info_dst.f = f_dst;
idx_info_dst.dxpl_id = dxpl_id;
idx_info_dst.pline = pline; /* Use same I/O filter pipeline for dest. */
idx_info_dst.layout = &layout_dst->u.chunk;
idx_info_dst.storage = &layout_dst->storage.u.chunk;
idx_info_dst.layout = layout_dst;
idx_info_dst.storage = storage_dst;
/* Call the index-specific "copy setup" routine */
if((layout_src->storage.u.chunk.ops->copy_setup)(&idx_info_src, &idx_info_dst) < 0)
if((storage_src->ops->copy_setup)(&idx_info_src, &idx_info_dst) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to set up index-specific chunk copying information")
copy_setup_done = TRUE;
@ -4420,8 +4423,8 @@ H5D_chunk_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
/* Compute the number of elements per chunk */
nelmts = 1;
for(u = 0; u < (layout_src->u.chunk.ndims - 1); u++)
nelmts *= layout_src->u.chunk.dim[u];
for(u = 0; u < (layout_src->ndims - 1); u++)
nelmts *= layout_src->dim[u];
/* Create the space and set the initial extent */
buf_dim = nelmts;
@ -4451,7 +4454,7 @@ H5D_chunk_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
do_convert = TRUE;
} /* end if */
H5_ASSIGN_OVERFLOW(buf_size, layout_src->u.chunk.size, uint32_t, size_t);
H5_ASSIGN_OVERFLOW(buf_size, layout_src->size, uint32_t, size_t);
reclaim_buf_size = 0;
} /* end else */
@ -4474,8 +4477,8 @@ H5D_chunk_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
/* Initialize the callback structure for the source */
HDmemset(&udata, 0, sizeof udata);
udata.common.layout = &layout_src->u.chunk;
udata.common.storage = &layout_src->storage.u.chunk;
udata.common.layout = layout_src;
udata.common.storage = storage_src;
udata.file_src = f_src;
udata.idx_info_dst = &idx_info_dst;
udata.buf = buf;
@ -4496,7 +4499,7 @@ H5D_chunk_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
udata.cpy_info = cpy_info;
/* Iterate over chunks to copy data */
if((layout_src->storage.u.chunk.ops->iterate)(&idx_info_src, H5D_chunk_copy_cb, &udata) < 0)
if((storage_src->ops->iterate)(&idx_info_src, H5D_chunk_copy_cb, &udata) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_BADITER, FAIL, "unable to iterate over chunk index to copy data")
/* I/O buffers may have been re-allocated */
@ -4524,7 +4527,7 @@ done:
/* Clean up any index information */
if(copy_setup_done)
if((layout_src->storage.u.chunk.ops->copy_shutdown)(&layout_src->storage.u.chunk, &layout_dst->storage.u.chunk, dxpl_id) < 0)
if((storage_src->ops->copy_shutdown)(storage_src, storage_dst, dxpl_id) < 0)
HDONE_ERROR(H5E_DATASET, H5E_CANTRELEASE, FAIL, "unable to shut down index copying info")
FUNC_LEAVE_NOAPI(ret_value)

43
src/H5Dcompact.c
View File

@ -38,6 +38,7 @@
#include "H5FDprivate.h" /* File drivers */
#include "H5FLprivate.h" /* Free Lists */
#include "H5Iprivate.h" /* IDs */
#include "H5MMprivate.h" /* Memory management */
#include "H5Oprivate.h" /* Object headers */
#include "H5Vprivate.h" /* Vector and array functions */
@ -58,7 +59,7 @@
/* Layout operation callbacks */
static herr_t H5D_compact_construct(H5F_t *f, H5D_t *dset);
static hbool_t H5D_compact_is_space_alloc(const H5O_layout_t *layout);
static hbool_t H5D_compact_is_space_alloc(const H5O_storage_t *storage);
static herr_t H5D_compact_io_init(const H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
hsize_t nelmts, const H5S_t *file_space, const H5S_t *mem_space,
H5D_chunk_map_t *cm);
@ -213,12 +214,12 @@ done:
*-------------------------------------------------------------------------
*/
static hbool_t
H5D_compact_is_space_alloc(const H5O_layout_t UNUSED *layout)
H5D_compact_is_space_alloc(const H5O_storage_t UNUSED *storage)
{
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_compact_is_space_alloc)
/* Sanity checks */
HDassert(layout);
HDassert(storage);
/* Compact storage is currently always allocated */
FUNC_LEAVE_NOAPI(TRUE)
@ -380,8 +381,9 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
H5D_compact_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
H5O_layout_t *layout_dst, H5T_t *dt_src, H5O_copy_t *cpy_info, hid_t dxpl_id)
H5D_compact_copy(H5F_t *f_src, H5O_storage_compact_t *storage_src, H5F_t *f_dst,
H5O_storage_compact_t *storage_dst, H5T_t *dt_src, H5O_copy_t *cpy_info,
hid_t dxpl_id)
{
hid_t tid_src = -1; /* Datatype ID for source datatype */
hid_t tid_dst = -1; /* Datatype ID for destination datatype */
@ -395,15 +397,19 @@ H5D_compact_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
FUNC_ENTER_NOAPI(H5D_compact_copy, FAIL)
/* Check args */
HDassert(layout_src && H5D_COMPACT == layout_src->type);
HDassert(f_src);
HDassert(storage_src);
HDassert(f_dst);
HDassert(layout_dst && H5D_COMPACT == layout_dst->type);
HDassert(storage_dst);
HDassert(dt_src);
/* Allocate space for destination data */
if(NULL == (storage_dst->buf = H5MM_malloc(storage_src->size)))
HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "unable to allocate memory for compact dataset")
/* Create datatype ID for src datatype, so it gets freed */
if((tid_src = H5I_register(H5I_DATATYPE, dt_src, FALSE)) < 0)
HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to register source file datatype")
HGOTO_ERROR(H5E_DATASET, H5E_CANTREGISTER, FAIL, "unable to register source file datatype")
/* If there's a VLEN source datatype, do type conversion information */
if(H5T_detect_class(dt_src, H5T_VLEN) > 0) {
@ -449,7 +455,7 @@ H5D_compact_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
max_dt_size = MAX(max_dt_size, tmp_dt_size);
/* Set number of whole elements that fit in buffer */
if(0 == (nelmts = layout_src->storage.u.compact.size / src_dt_size))
if(0 == (nelmts = storage_src->size / src_dt_size))
HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "element size too large")
/* Set up number of bytes to copy, and initial buffer size */
@ -476,7 +482,7 @@ H5D_compact_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
if(NULL == (buf = H5FL_BLK_MALLOC(type_conv, buf_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
HDmemcpy(buf, layout_src->storage.u.compact.buf, layout_src->storage.u.compact.size);
HDmemcpy(buf, storage_src->buf, storage_src->size);
/* Convert from source file to memory */
if(H5T_convert(tpath_src_mem, tid_src, tid_mem, nelmts, (size_t)0, (size_t)0, buf, NULL, dxpl_id) < 0)
@ -492,7 +498,7 @@ H5D_compact_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
if(H5T_convert(tpath_mem_dst, tid_mem, tid_dst, nelmts, (size_t)0, (size_t)0, buf, bkg, dxpl_id) < 0)
HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "datatype conversion failed")
HDmemcpy(layout_dst->storage.u.compact.buf, buf, layout_dst->storage.u.compact.size);
HDmemcpy(storage_dst->buf, buf, storage_dst->size);
if(H5D_vlen_reclaim(tid_mem, buf_space, H5P_DATASET_XFER_DEFAULT, reclaim_buf) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_BADITER, FAIL, "unable to reclaim variable-length data")
@ -504,24 +510,27 @@ H5D_compact_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst,
size_t ref_count;
/* Determine # of reference elements to copy */
ref_count = layout_src->storage.u.compact.size / H5T_get_size(dt_src);
ref_count = storage_src->size / H5T_get_size(dt_src);
/* Copy objects referenced in source buffer to destination file and set destination elements */
if(H5O_copy_expand_ref(f_src, layout_src->storage.u.compact.buf, dxpl_id, f_dst,
layout_dst->storage.u.compact.buf, ref_count, H5T_get_ref_type(dt_src), cpy_info) < 0)
if(H5O_copy_expand_ref(f_src, storage_src->buf, dxpl_id, f_dst,
storage_dst->buf, ref_count, H5T_get_ref_type(dt_src), cpy_info) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTCOPY, FAIL, "unable to copy reference attribute")
} /* end if */
else
/* Reset value to zero */
HDmemset(layout_dst->storage.u.compact.buf, 0, layout_src->storage.u.compact.size);
HDmemset(storage_dst->buf, 0, storage_src->size);
} /* end if */
else
/* Type conversion not necessary */
HDmemcpy(layout_dst->storage.u.compact.buf, layout_src->storage.u.compact.buf, layout_src->storage.u.compact.size);
HDmemcpy(storage_dst->buf, storage_src->buf, storage_src->size);
} /* end if */
else
/* Type conversion not necessary */
HDmemcpy(layout_dst->storage.u.compact.buf, layout_src->storage.u.compact.buf, layout_src->storage.u.compact.size);
HDmemcpy(storage_dst->buf, storage_src->buf, storage_src->size);
/* Mark destination buffer as dirty */
storage_dst->dirty = TRUE;
done:
if(buf_sid > 0 && H5I_dec_ref(buf_sid, FALSE) < 0)

35
src/H5Dcontig.c
View File

@ -62,7 +62,6 @@
/* Layout operation callbacks */
static herr_t H5D_contig_construct(H5F_t *f, H5D_t *dset);
static hbool_t H5D_contig_is_space_alloc(const H5O_layout_t *layout);
static herr_t H5D_contig_io_init(const H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
hsize_t nelmts, const H5S_t *file_space, const H5S_t *mem_space,
H5D_chunk_map_t *cm);
@ -121,7 +120,7 @@ H5FL_BLK_EXTERN(type_conv);
*-------------------------------------------------------------------------
*/
herr_t
H5D_contig_alloc(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout /*out */ )
H5D_contig_alloc(H5F_t *f, hid_t dxpl_id, H5O_storage_contig_t *storage /*out */ )
{
herr_t ret_value = SUCCEED; /* Return value */
@ -129,10 +128,10 @@ H5D_contig_alloc(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout /*out */ )
/* check args */
HDassert(f);
HDassert(layout);
HDassert(storage);
/* Allocate space for the contiguous data */
if(HADDR_UNDEF == (layout->storage.u.contig.addr = H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, layout->storage.u.contig.size)))
if(HADDR_UNDEF == (storage->addr = H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, storage->size)))
HGOTO_ERROR(H5E_IO, H5E_NOSPACE, FAIL, "unable to reserve file space")
done:
@ -445,18 +444,18 @@ done:
*
*-------------------------------------------------------------------------
*/
static hbool_t
H5D_contig_is_space_alloc(const H5O_layout_t *layout)
hbool_t
H5D_contig_is_space_alloc(const H5O_storage_t *storage)
{
hbool_t ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_contig_is_space_alloc)
/* Sanity checks */
HDassert(layout);
HDassert(storage);
/* Set return value */
ret_value = (hbool_t)H5F_addr_defined(layout->storage.u.contig.addr);
ret_value = (hbool_t)H5F_addr_defined(storage->u.contig.addr);
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5D_contig_is_space_alloc() */
@ -1215,14 +1214,12 @@ done:
* Programmer: Quincey Koziol
* Monday, November 21, 2005
*
* Modifier: Peter Cao
* Saturday, January 07, 2006
* Add case to deal with compressed variable length datasets
*-------------------------------------------------------------------------
*/
herr_t
H5D_contig_copy(H5F_t *f_src, const H5O_layout_t *layout_src, H5F_t *f_dst,
H5O_layout_t *layout_dst, H5T_t *dt_src, H5O_copy_t *cpy_info, hid_t dxpl_id)
H5D_contig_copy(H5F_t *f_src, const H5O_storage_contig_t *storage_src,
H5F_t *f_dst, H5O_storage_contig_t *storage_dst, H5T_t *dt_src,
H5O_copy_t *cpy_info, hid_t dxpl_id)
{
haddr_t addr_src; /* File offset in source dataset */
haddr_t addr_dst; /* File offset in destination dataset */
@ -1256,18 +1253,18 @@ H5D_contig_copy(H5F_t *f_src, const H5O_layout_t *layout_src, H5F_t *f_dst,
/* Check args */
HDassert(f_src);
HDassert(layout_src && H5D_CONTIGUOUS == layout_src->type);
HDassert(storage_src);
HDassert(f_dst);
HDassert(layout_dst && H5D_CONTIGUOUS == layout_dst->type);
HDassert(storage_dst);
HDassert(dt_src);
/* Allocate space for destination raw data */
if(H5D_contig_alloc(f_dst, dxpl_id, layout_dst) < 0)
if(H5D_contig_alloc(f_dst, dxpl_id, storage_dst) < 0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, FAIL, "unable to allocate contiguous storage")
/* Set up number of bytes to copy, and initial buffer size */
/* (actually use the destination size, which has been fixed up, if necessary) */
total_src_nbytes = layout_dst->storage.u.contig.size;
total_src_nbytes = storage_dst->size;
H5_CHECK_OVERFLOW(total_src_nbytes, hsize_t, size_t);
buf_size = MIN(H5D_TEMP_BUF_SIZE, (size_t)total_src_nbytes);
@ -1365,8 +1362,8 @@ H5D_contig_copy(H5F_t *f_src, const H5O_layout_t *layout_src, H5F_t *f_dst,
} /* end if */
/* Loop over copying data */
addr_src = layout_src->storage.u.contig.addr;
addr_dst = layout_dst->storage.u.contig.addr;
addr_src = storage_src->addr;
addr_dst = storage_dst->addr;
while(total_src_nbytes > 0) {
/* Check if we should reduce the number of bytes to transfer */
if(total_src_nbytes < src_nbytes) {

14
src/H5Dint.c
View File

@ -1299,7 +1299,7 @@ H5D_open_oid(H5D_t *dataset, hid_t dapl_id, hid_t dxpl_id)
* be fully allocated before I/O can happen.
*/
if((H5F_INTENT(dataset->oloc.file) & H5F_ACC_RDWR)
&& !(*dataset->shared->layout.ops->is_space_alloc)(&dataset->shared->layout)
&& !(*dataset->shared->layout.ops->is_space_alloc)(&dataset->shared->layout.storage)
&& IS_H5FD_MPI(dataset->oloc.file)) {
if(H5D_alloc_storage(dataset, dxpl_id, H5D_ALLOC_OPEN, FALSE) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize file storage")
@ -1580,9 +1580,9 @@ H5D_alloc_storage(H5D_t *dset/*in,out*/, hid_t dxpl_id, H5D_time_alloc_t time_al
switch(layout->type) {
case H5D_CONTIGUOUS:
if(!(*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout)) {
if(!(*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout.storage)) {
/* Reserve space in the file for the entire array */
if(H5D_contig_alloc(f, dxpl_id, layout/*out*/) < 0)
if(H5D_contig_alloc(f, dxpl_id, &layout->storage.u.contig/*out*/) < 0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, FAIL, "unable to initialize contiguous storage")
/* Indicate that we set the storage addr */
@ -1594,7 +1594,7 @@ H5D_alloc_storage(H5D_t *dset/*in,out*/, hid_t dxpl_id, H5D_time_alloc_t time_al
break;
case H5D_CHUNKED:
if(!(*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout)) {
if(!(*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout.storage)) {
/* Create the root of the B-tree that describes chunked storage */
if(H5D_chunk_create(dset /*in,out*/, dxpl_id) < 0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, FAIL, "unable to initialize chunked storage")
@ -1773,7 +1773,7 @@ H5D_get_storage_size(H5D_t *dset, hid_t dxpl_id)
switch(dset->shared->layout.type) {
case H5D_CHUNKED:
if((*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout)) {
if((*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout.storage)) {
if(H5D_chunk_allocated(dset, dxpl_id, &ret_value) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't retrieve chunked dataset allocated size")
} /* end if */
@ -1783,7 +1783,7 @@ H5D_get_storage_size(H5D_t *dset, hid_t dxpl_id)
case H5D_CONTIGUOUS:
/* Datasets which are not allocated yet are using no space on disk */
if((*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout))
if((*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout.storage))
ret_value = dset->shared->layout.storage.u.contig.size;
else
ret_value = 0;
@ -2164,7 +2164,7 @@ H5D_set_extent(H5D_t *dset, const hsize_t *size, hid_t dxpl_id)
*-------------------------------------------------------------------------
*/
if(shrink && H5D_CHUNKED == dset->shared->layout.type &&
(*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout)) {
(*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout.storage)) {
/* Remove excess chunks */
if(H5D_chunk_prune_by_extent(dset, dxpl_id, curr_dims) < 0)
HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to remove chunks ")

6
src/H5Dio.c
View File

@ -350,7 +350,7 @@ H5D_read(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
* has been overwritten. So just proceed in reading.
*/
if(nelmts > 0 && dataset->shared->dcpl_cache.efl.nused == 0 &&
!(*dataset->shared->layout.ops->is_space_alloc)(&dataset->shared->layout)) {
!(*dataset->shared->layout.ops->is_space_alloc)(&dataset->shared->layout.storage)) {
H5D_fill_value_t fill_status; /* Whether/How the fill value is defined */
/* Retrieve dataset's fill-value properties */
@ -384,7 +384,7 @@ H5D_read(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
/* Sanity check that space is allocated, if there are elements */
if(nelmts > 0)
HDassert((*dataset->shared->layout.ops->is_space_alloc)(&dataset->shared->layout)
HDassert((*dataset->shared->layout.ops->is_space_alloc)(&dataset->shared->layout.storage)
|| dataset->shared->dcpl_cache.efl.nused > 0
|| dataset->shared->layout.type == H5D_COMPACT);
@ -534,7 +534,7 @@ H5D_write(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
/* Allocate data space and initialize it if it hasn't been. */
if(nelmts > 0 && dataset->shared->dcpl_cache.efl.nused == 0 &&
!(*dataset->shared->layout.ops->is_space_alloc)(&dataset->shared->layout)) {
!(*dataset->shared->layout.ops->is_space_alloc)(&dataset->shared->layout.storage)) {
hssize_t file_nelmts; /* Number of elements in file dataset's dataspace */
hbool_t full_overwrite; /* Whether we are over-writing all the elements */

2
src/H5Doh.c
View File

@ -376,7 +376,7 @@ H5O_dset_bh_info(H5F_t *f, hid_t dxpl_id, H5O_t *oh, H5_ih_info_t *bh_info)
HGOTO_ERROR(H5E_OHDR, H5E_CANTGET, FAIL, "can't find layout message")
/* Check for chunked dataset storage */
if(layout.type == H5D_CHUNKED && H5D_chunk_is_space_alloc(&layout)) {
if(layout.type == H5D_CHUNKED && H5D_chunk_is_space_alloc(&layout.storage)) {
H5O_pline_t pline; /* I/O pipeline message */
htri_t exists; /* Flag if header message of interest exists */

23
src/H5Dpkg.h
View File

@ -101,7 +101,7 @@ struct H5D_chunk_map_t;
typedef herr_t (*H5D_layout_construct_func_t)(H5F_t *f, H5D_t *dset);
typedef herr_t (*H5D_layout_init_func_t)(H5F_t *f, hid_t dxpl_id, const H5D_t *dset,
hid_t dapl_id);
typedef hbool_t (*H5D_layout_is_space_alloc_func_t)(const H5O_layout_t *layout);
typedef hbool_t (*H5D_layout_is_space_alloc_func_t)(const H5O_storage_t *storage);
typedef herr_t (*H5D_layout_io_init_func_t)(const struct H5D_io_info_t *io_info,
const H5D_type_info_t *type_info,
hsize_t nelmts, const H5S_t *file_space, const H5S_t *mem_space,
@ -571,7 +571,9 @@ H5_DLL herr_t H5D_layout_oh_write(H5D_t *dataset, hid_t dxpl_id, H5O_t *oh,
unsigned update_flags);
/* Functions that operate on contiguous storage */
H5_DLL herr_t H5D_contig_alloc(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout);
H5_DLL herr_t H5D_contig_alloc(H5F_t *f, hid_t dxpl_id,
H5O_storage_contig_t *storage);
H5_DLL hbool_t H5D_contig_is_space_alloc(const H5O_storage_t *storage);
H5_DLL herr_t H5D_contig_fill(H5D_t *dset, hid_t dxpl_id);
H5_DLL haddr_t H5D_contig_get_addr(const H5D_t *dset);
H5_DLL herr_t H5D_contig_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
@ -586,8 +588,9 @@ H5_DLL ssize_t H5D_contig_readvv(const H5D_io_info_t *io_info,
H5_DLL ssize_t H5D_contig_writevv(const H5D_io_info_t *io_info,
size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_offset_arr[],
size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_offset_arr[]);
H5_DLL herr_t H5D_contig_copy(H5F_t *f_src, const H5O_layout_t *layout_src, H5F_t *f_dst,
H5O_layout_t *layout_dst, H5T_t *src_dtype, H5O_copy_t *cpy_info, hid_t dxpl_id);
H5_DLL herr_t H5D_contig_copy(H5F_t *f_src, const H5O_storage_contig_t *storage_src,
H5F_t *f_dst, H5O_storage_contig_t *storage_dst, H5T_t *src_dtype,
H5O_copy_t *cpy_info, hid_t dxpl_id);
/* Functions that operate on chunked dataset storage */
H5_DLL htri_t H5D_chunk_cacheable(const H5D_io_info_t *io_info, haddr_t caddr,
@ -597,7 +600,7 @@ H5_DLL herr_t H5D_chunk_create(H5D_t *dset /*in,out*/, hid_t dxpl_id);
H5_DLL herr_t H5D_chunk_set_info(const H5D_t *dset);
H5_DLL herr_t H5D_chunk_init(H5F_t *f, hid_t dxpl_id, const H5D_t *dset,
hid_t dapl_id);
H5_DLL hbool_t H5D_chunk_is_space_alloc(const H5O_layout_t *layout);
H5_DLL hbool_t H5D_chunk_is_space_alloc(const H5O_storage_t *storage);
H5_DLL herr_t H5D_chunk_get_info(const H5D_t *dset, hid_t dxpl_id,
const hsize_t *chunk_offset, H5D_chunk_ud_t *udata);
H5_DLL void *H5D_chunk_lock(const H5D_io_info_t *io_info,
@ -613,8 +616,9 @@ H5_DLL herr_t H5D_chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id,
H5_DLL herr_t H5D_chunk_addrmap(const H5D_io_info_t *io_info, haddr_t chunk_addr[]);
#endif /* H5_HAVE_PARALLEL */
H5_DLL herr_t H5D_chunk_update_cache(H5D_t *dset, hid_t dxpl_id);
H5_DLL herr_t H5D_chunk_copy(H5F_t *f_src, H5O_layout_t *layout_src,
H5F_t *f_dst, H5O_layout_t *layout_dst, const H5S_extent_t *ds_extent_src,
H5_DLL herr_t H5D_chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src,
H5O_layout_chunk_t *layout_src, H5F_t *f_dst, H5O_storage_chunk_t *storage_dst,
H5O_layout_chunk_t *layout_dst, const H5S_extent_t *ds_extent_src,
const H5T_t *dt_src, const H5O_pline_t *pline_src,
H5O_copy_t *cpy_info, hid_t dxpl_id);
H5_DLL herr_t H5D_chunk_bh_info(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout,
@ -627,8 +631,9 @@ H5_DLL herr_t H5D_chunk_stats(const H5D_t *dset, hbool_t headers);
/* Functions that operate on compact dataset storage */
H5_DLL herr_t H5D_compact_fill(H5D_t *dset, hid_t dxpl_id);
H5_DLL herr_t H5D_compact_copy(H5F_t *f_src, H5O_layout_t *layout_src,
H5F_t *f_dst, H5O_layout_t *layout_dst, H5T_t *src_dtype, H5O_copy_t *cpy_info, hid_t dxpl_id);
H5_DLL herr_t H5D_compact_copy(H5F_t *f_src, H5O_storage_compact_t *storage_src,
H5F_t *f_dst, H5O_storage_compact_t *storage_dst, H5T_t *src_dtype,
H5O_copy_t *cpy_info, hid_t dxpl_id);
/* Functions that perform fill value operations on datasets */
H5_DLL herr_t H5D_fill(const void *fill, const H5T_t *fill_type, void *buf,

7
src/H5Dprivate.h
View File

@ -139,6 +139,13 @@ typedef struct H5D_dcpl_cache_t {
H5O_efl_t efl; /* External file list info (H5D_CRT_EXT_FILE_LIST_NAME) */
} H5D_dcpl_cache_t;
/* Callback information for copying dataset */
typedef struct H5D_copy_file_ud_t {
struct H5S_extent_t *src_space_extent; /* Copy of dataspace extent for dataset */
H5T_t *src_dtype; /* Copy of datatype for dataset */
H5O_pline_t *src_pline; /* Copy of filter pipeline for dataet */
} H5D_copy_file_ud_t;
/*****************************/
/* Library Private Variables */

1
src/H5Odtype.c
View File

@ -17,6 +17,7 @@
#define H5T_PACKAGE /*prevent warning from including H5Tpkg */
#include "H5private.h" /* Generic Functions */
#include "H5Dprivate.h" /* Datasets */
#include "H5Eprivate.h" /* Error handling */
#include "H5Fprivate.h" /* Files */
#include "H5FLprivate.h" /* Free Lists */

31
src/H5Olayout.c
View File

@ -375,7 +375,7 @@ H5O_layout_copy(const void *_mesg, void *_dest)
/* check args */
HDassert(mesg);
if(!dest && NULL == (dest = H5FL_MALLOC(H5O_layout_t)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
HGOTO_ERROR(H5E_OHDR, H5E_NOSPACE, NULL, "memory allocation failed")
/* copy */
*dest = *mesg;
@ -384,7 +384,7 @@ H5O_layout_copy(const void *_mesg, void *_dest)
if(mesg->type == H5D_COMPACT && mesg->storage.u.compact.size > 0) {
/* Allocate memory for the raw data */
if(NULL == (dest->storage.u.compact.buf = H5MM_malloc(dest->storage.u.compact.size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "unable to allocate memory for compact dataset")
HGOTO_ERROR(H5E_OHDR, H5E_NOSPACE, NULL, "unable to allocate memory for compact dataset")
/* Copy over the raw data */
HDmemcpy(dest->storage.u.compact.buf, mesg->storage.u.compact.buf, dest->storage.u.compact.size);
@ -588,23 +588,18 @@ H5O_layout_copy_file(H5F_t *file_src, void *mesg_src, H5F_t *file_dst,
/* Allocate space for the destination layout */
if(NULL == (layout_dst = H5FL_MALLOC(H5O_layout_t)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
HGOTO_ERROR(H5E_OHDR, H5E_CANTALLOC, NULL, "memory allocation failed")
/* Copy the "top level" information */
HDmemcpy(layout_dst, layout_src, sizeof(H5O_layout_t));
*layout_dst = *layout_src;
/* Copy the layout type specific information */
switch(layout_src->type) {
case H5D_COMPACT:
if(layout_src->storage.u.compact.buf) {
if(NULL == (layout_dst->storage.u.compact.buf = H5MM_malloc(layout_src->storage.u.compact.size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "unable to allocate memory for compact dataset")
/* copy compact raw data */
if(H5D_compact_copy(file_src, layout_src, file_dst, layout_dst, udata->src_dtype, cpy_info, dxpl_id) < 0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, NULL, "unable to copy chunked storage")
layout_dst->storage.u.compact.dirty = TRUE;
if(H5D_compact_copy(file_src, &layout_src->storage.u.compact, file_dst, &layout_dst->storage.u.compact, udata->src_dtype, cpy_info, dxpl_id) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy chunked storage")
} /* end if */
break;
@ -617,18 +612,18 @@ H5O_layout_copy_file(H5F_t *file_src, void *mesg_src, H5F_t *file_dst,
layout_dst->storage.u.contig.size = H5S_extent_nelem(udata->src_space_extent) *
H5T_get_size(udata->src_dtype);
if(H5F_addr_defined(layout_src->storage.u.contig.addr)) {
/* create contig layout */
if(H5D_contig_copy(file_src, layout_src, file_dst, layout_dst, udata->src_dtype, cpy_info, dxpl_id) < 0)
HGOTO_ERROR(H5E_IO, H5E_CANTINIT, NULL, "unable to copy contiguous storage")
if(H5D_contig_is_space_alloc(&layout_src->storage)) {
/* copy contiguous raw data */
if(H5D_contig_copy(file_src, &layout_src->storage.u.contig, file_dst, &layout_dst->storage.u.contig, udata->src_dtype, cpy_info, dxpl_id) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy contiguous storage")
} /* end if */
break;
case H5D_CHUNKED:
if(H5D_chunk_is_space_alloc(layout_src)) {
if(H5D_chunk_is_space_alloc(&layout_src->storage)) {
/* Create chunked layout */
if(H5D_chunk_copy(file_src, layout_src, file_dst, layout_dst, udata->src_space_extent, udata->src_dtype, udata->src_pline, cpy_info, dxpl_id) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "unable to copy chunked storage")
if(H5D_chunk_copy(file_src, &layout_src->storage.u.chunk, &layout_src->u.chunk, file_dst, &layout_dst->storage.u.chunk, &layout_dst->u.chunk, udata->src_space_extent, udata->src_dtype, udata->src_pline, cpy_info, dxpl_id) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy chunked storage")
} /* end if */
break;

7
src/H5Opkg.h
View File

@ -310,13 +310,6 @@ struct H5O_t {
H5O_chunk_t *chunk; /*array of chunks */
};
/* Callback information for copying dataset */
typedef struct H5D_copy_file_ud_t {
struct H5S_extent_t *src_space_extent; /* Copy of dataspace extent for dataset */
H5T_t *src_dtype; /* Copy of datatype for dataset */
H5O_pline_t *src_pline; /* Copy of filter pipeline for dataet */
} H5D_copy_file_ud_t;
/* Class for types of objects in file */
typedef struct H5O_obj_class_t {
H5O_type_t type; /*object type on disk */

1
src/H5Opline.c
View File

@ -24,6 +24,7 @@
#define H5Z_PACKAGE /*suppress error about including H5Zpkg */
#include "H5private.h" /* Generic Functions */
#include "H5Dprivate.h" /* Datasets */
#include "H5Eprivate.h" /* Error handling */
#include "H5FLprivate.h" /* Free Lists */
#include "H5MMprivate.h" /* Memory management */

1
src/H5Osdspace.c
View File

@ -17,6 +17,7 @@
#define H5S_PACKAGE /*prevent warning from including H5Spkg.h */
#include "H5private.h" /* Generic Functions */
#include "H5Dprivate.h" /* Datasets */
#include "H5Eprivate.h" /* Error handling */
#include "H5FLprivate.h" /* Free lists */
#include "H5Gprivate.h" /* Groups */

2
src/H5Pdcpl.c
View File

@ -777,7 +777,7 @@ H5P_init_def_layout(void)
H5D_def_layout_compact_g.u.compact = def_layout_compact;
H5D_def_layout_compact_g.storage.u.compact = def_store_compact;
H5D_def_layout_chunk_g.u.chunk = def_chunk;
H5D_def_layout_compact_g.storage.u.chunk = def_store_chunk;
H5D_def_layout_chunk_g.storage.u.chunk = def_store_chunk;
/* Note that we've initialized the default values */
H5P_dcrt_def_layout_init_g = TRUE;