diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/H5Dchunk.c | 32 | ||||
-rw-r--r-- | src/H5Dfarray.c | 1554 | ||||
-rw-r--r-- | src/H5Dint.c | 4 | ||||
-rw-r--r-- | src/H5Dpkg.h | 1 | ||||
-rw-r--r-- | src/H5Dpublic.h | 4 | ||||
-rw-r--r-- | src/H5Olayout.c | 48 | ||||
-rw-r--r-- | src/H5Oprivate.h | 9 | ||||
-rwxr-xr-x | src/Makefile.am | 5 | ||||
-rw-r--r-- | src/Makefile.in | 5 |
9 files changed, 1654 insertions, 8 deletions
diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c index cf61bab..edefd6e 100644 --- a/src/H5Dchunk.c +++ b/src/H5Dchunk.c @@ -461,6 +461,8 @@ H5D_chunk_init(H5F_t *f, hid_t dxpl_id, const H5D_t *dset, hid_t dapl_id) HDassert(dset); HDassert((H5D_CHUNK_IDX_EARRAY == dset->shared->layout.u.chunk.idx_type && H5D_COPS_EARRAY == dset->shared->layout.u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.u.chunk.idx_type && + H5D_COPS_FARRAY == dset->shared->layout.u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == dset->shared->layout.u.chunk.idx_type && H5D_COPS_BTREE == dset->shared->layout.u.chunk.ops)); @@ -537,6 +539,8 @@ H5D_chunk_is_space_alloc(const H5O_layout_t *layout) HDassert(layout); HDassert((H5D_CHUNK_IDX_EARRAY == layout->u.chunk.idx_type && H5D_COPS_EARRAY == layout->u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == layout->u.chunk.idx_type && + H5D_COPS_FARRAY == layout->u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == layout->u.chunk.idx_type && H5D_COPS_BTREE == layout->u.chunk.ops)); @@ -2007,6 +2011,8 @@ H5D_chunk_idx_reset(H5O_layout_t *layout, hbool_t reset_addr) HDassert(layout->u.chunk.ops); HDassert((H5D_CHUNK_IDX_EARRAY == layout->u.chunk.idx_type && H5D_COPS_EARRAY == layout->u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == layout->u.chunk.idx_type && + H5D_COPS_FARRAY == layout->u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == layout->u.chunk.idx_type && H5D_COPS_BTREE == layout->u.chunk.ops)); @@ -2162,6 +2168,8 @@ H5D_chunk_create(H5D_t *dset /*in,out*/, hid_t dxpl_id) HDassert(dset->shared->layout.u.chunk.ndims > 0 && dset->shared->layout.u.chunk.ndims <= H5O_LAYOUT_NDIMS); HDassert((H5D_CHUNK_IDX_EARRAY == dset->shared->layout.u.chunk.idx_type && H5D_COPS_EARRAY == dset->shared->layout.u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.u.chunk.idx_type && + H5D_COPS_FARRAY == dset->shared->layout.u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == dset->shared->layout.u.chunk.idx_type && H5D_COPS_BTREE == dset->shared->layout.u.chunk.ops)); #ifndef NDEBUG @@ -2214,6 +2222,8 @@ H5D_chunk_get_info(const H5D_t *dset, hid_t dxpl_id, const hsize_t *chunk_offset HDassert(dset->shared->layout.u.chunk.ndims > 0); HDassert((H5D_CHUNK_IDX_EARRAY == dset->shared->layout.u.chunk.idx_type && H5D_COPS_EARRAY == dset->shared->layout.u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.u.chunk.idx_type && + H5D_COPS_FARRAY == dset->shared->layout.u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == dset->shared->layout.u.chunk.idx_type && H5D_COPS_BTREE == dset->shared->layout.u.chunk.ops)); HDassert(chunk_offset); @@ -2280,6 +2290,8 @@ H5D_chunk_flush_entry(const H5D_t *dset, hid_t dxpl_id, const H5D_dxpl_cache_t * HDassert(dset->shared); HDassert((H5D_CHUNK_IDX_EARRAY == dset->shared->layout.u.chunk.idx_type && H5D_COPS_EARRAY == dset->shared->layout.u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.u.chunk.idx_type && + H5D_COPS_FARRAY == dset->shared->layout.u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == dset->shared->layout.u.chunk.idx_type && H5D_COPS_BTREE == dset->shared->layout.u.chunk.ops)); HDassert(dxpl_cache); @@ -3079,6 +3091,8 @@ H5D_chunk_allocated(H5D_t *dset, hid_t dxpl_id, hsize_t *nbytes) HDassert(dset->shared); HDassert((H5D_CHUNK_IDX_EARRAY == dset->shared->layout.u.chunk.idx_type && H5D_COPS_EARRAY == dset->shared->layout.u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.u.chunk.idx_type && + H5D_COPS_FARRAY == dset->shared->layout.u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == dset->shared->layout.u.chunk.idx_type && H5D_COPS_BTREE == dset->shared->layout.u.chunk.ops)); @@ -3162,6 +3176,8 @@ H5D_chunk_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite) HDassert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS); HDassert((H5D_CHUNK_IDX_EARRAY == layout->u.chunk.idx_type && H5D_COPS_EARRAY == layout->u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == layout->u.chunk.idx_type && + H5D_COPS_FARRAY == layout->u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == layout->u.chunk.idx_type && H5D_COPS_BTREE == layout->u.chunk.ops)); HDassert(TRUE == H5P_isa_class(dxpl_id, H5P_DATASET_XFER)); @@ -3735,6 +3751,8 @@ H5D_chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id, const hsize_t *old_dims) HDassert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS); HDassert((H5D_CHUNK_IDX_EARRAY == layout->u.chunk.idx_type && H5D_COPS_EARRAY == layout->u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == layout->u.chunk.idx_type && + H5D_COPS_FARRAY == layout->u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == layout->u.chunk.idx_type && H5D_COPS_BTREE == layout->u.chunk.ops)); HDassert(dxpl_cache); @@ -3970,6 +3988,8 @@ H5D_chunk_addrmap(const H5D_io_info_t *io_info, haddr_t chunk_addr[]) HDassert(dset->shared); HDassert((H5D_CHUNK_IDX_EARRAY == dset->shared->layout.u.chunk.idx_type && H5D_COPS_EARRAY == dset->shared->layout.u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.u.chunk.idx_type && + H5D_COPS_FARRAY == dset->shared->layout.u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == dset->shared->layout.u.chunk.idx_type && H5D_COPS_BTREE == dset->shared->layout.u.chunk.ops)); HDassert(chunk_addr); @@ -4023,6 +4043,8 @@ H5D_chunk_delete(H5F_t *f, hid_t dxpl_id, H5O_t *oh, H5O_layout_t *layout) HDassert(layout); HDassert((H5D_CHUNK_IDX_EARRAY == layout->u.chunk.idx_type && H5D_COPS_EARRAY == layout->u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == layout->u.chunk.idx_type && + H5D_COPS_FARRAY == layout->u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == layout->u.chunk.idx_type && H5D_COPS_BTREE == layout->u.chunk.ops)); @@ -4357,11 +4379,15 @@ H5D_chunk_copy(H5F_t *f_src, H5O_layout_t *layout_src, H5F_t *f_dst, HDassert(layout_src && H5D_CHUNKED == layout_src->type); HDassert((H5D_CHUNK_IDX_EARRAY == layout_src->u.chunk.idx_type && H5D_COPS_EARRAY == layout_src->u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == layout_src->u.chunk.idx_type && + H5D_COPS_FARRAY == layout_src->u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == layout_src->u.chunk.idx_type && H5D_COPS_BTREE == layout_src->u.chunk.ops)); HDassert(layout_dst && H5D_CHUNKED == layout_dst->type); HDassert((H5D_CHUNK_IDX_EARRAY == layout_dst->u.chunk.idx_type && H5D_COPS_EARRAY == layout_dst->u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == layout_dst->u.chunk.idx_type && + H5D_COPS_FARRAY == layout_dst->u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == layout_dst->u.chunk.idx_type && H5D_COPS_BTREE == layout_dst->u.chunk.ops)); HDassert(dt_src); @@ -4573,6 +4599,8 @@ H5D_chunk_bh_info(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout, HDassert(layout); HDassert((H5D_CHUNK_IDX_EARRAY == layout->u.chunk.idx_type && H5D_COPS_EARRAY == layout->u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == layout->u.chunk.idx_type && + H5D_COPS_FARRAY == layout->u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == layout->u.chunk.idx_type && H5D_COPS_BTREE == layout->u.chunk.ops)); HDassert(pline); @@ -4664,6 +4692,8 @@ H5D_chunk_dump_index(H5D_t *dset, hid_t dxpl_id, FILE *stream) HDassert(dset); HDassert((H5D_CHUNK_IDX_EARRAY == dset->shared->layout.u.chunk.idx_type && H5D_COPS_EARRAY == dset->shared->layout.u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.u.chunk.idx_type && + H5D_COPS_FARRAY == dset->shared->layout.u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == dset->shared->layout.u.chunk.idx_type && H5D_COPS_BTREE == dset->shared->layout.u.chunk.ops)); @@ -4727,6 +4757,8 @@ H5D_chunk_dest(H5F_t *f, hid_t dxpl_id, H5D_t *dset) HDassert(dset); HDassert((H5D_CHUNK_IDX_EARRAY == dset->shared->layout.u.chunk.idx_type && H5D_COPS_EARRAY == dset->shared->layout.u.chunk.ops) || + (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.u.chunk.idx_type && + H5D_COPS_FARRAY == dset->shared->layout.u.chunk.ops) || (H5D_CHUNK_IDX_BTREE == dset->shared->layout.u.chunk.idx_type && H5D_COPS_BTREE == dset->shared->layout.u.chunk.ops)); diff --git a/src/H5Dfarray.c b/src/H5Dfarray.c new file mode 100644 index 0000000..e5464c6 --- /dev/null +++ b/src/H5Dfarray.c @@ -0,0 +1,1554 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Copyright by The HDF Group. * + * Copyright by the Board of Trustees of the University of Illinois. * + * All rights reserved. * + * * + * This file is part of HDF5. The full HDF5 copyright notice, including * + * terms governing use, modification, and redistribution, is contained in * + * the files COPYING and Copyright.html. COPYING can be found at the root * + * of the source code distribution tree; Copyright.html can be found at the * + * root level of an installed copy of the electronic HDF5 document set and * + * is linked from the top-level documents page. It can also be found at * + * http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have * + * access to either file, you may request a copy from help@hdfgroup.org. * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +/* Programmer: Vailin Choi <vchoi@hdfgroup.org> + * Thursday, April 30, 2009 + * + * Purpose: Fixed array indexed (chunked) I/O functions. + * The chunk coordinate is mapped as an index into an array of + * disk addresses for the chunks. + * + */ + +/****************/ +/* Module Setup */ +/****************/ + +#define H5D_PACKAGE /*suppress error about including H5Dpkg */ + + +/***********/ +/* Headers */ +/***********/ +#include "H5private.h" /* Generic Functions */ +#include "H5Dpkg.h" /* Datasets */ +#include "H5Eprivate.h" /* Error handling */ +#include "H5FAprivate.h" /* Fixed arrays */ +#include "H5FLprivate.h" /* Free Lists */ +#include "H5MFprivate.h" /* File space management */ +#include "H5Vprivate.h" /* Vector functions */ + + +/****************/ +/* Local Macros */ +/****************/ + +/* Value to fill unset array elements with */ +#define H5D_FARRAY_FILL HADDR_UNDEF +#define H5D_FARRAY_FILT_FILL {HADDR_UNDEF, 0, 0} + +/* Fixed array creation values */ +#define H5D_FARRAY_MAX_DBLK_PAGE_NELMTS_BITS 10 /* i.e. 1024 elements per data block page */ + + +/******************/ +/* Local Typedefs */ +/******************/ + +/* Fixed array create/open user data */ +typedef struct H5D_farray_ctx_ud_t { + const H5F_t *f; /* Pointer to file info */ + const H5O_layout_t *layout; /* Pointer to layout info */ +} H5D_farray_ctx_ud_t; + +/* Fixed array callback context */ +typedef struct H5D_farray_ctx_t { + size_t file_addr_len; /* Size of addresses in the file (bytes) */ + size_t chunk_size_len; /* Size of chunk sizes in the file (bytes) */ +} H5D_farray_ctx_t; + +/* User data for chunk deletion callback */ +typedef struct H5D_farray_del_ud_t { + H5F_t *f; /* File pointer for operation */ + hid_t dxpl_id; /* DXPL ID for operation */ + hbool_t filtered; /* Whether the chunks are filtered */ + uint32_t unfilt_size; /* Size of unfiltered chunk in bytes */ +} H5D_farray_del_ud_t; + +/* Fixed Array callback info for iteration over chunks */ +typedef struct H5D_farray_it_ud_t { + H5D_chunk_common_ud_t common; /* Common info for Fixed Array user data (must be first) */ + H5D_chunk_rec_t chunk_rec; /* Generic chunk record for callback */ + hsize_t chunk_offset[H5O_LAYOUT_NDIMS]; /* Chunk offset */ + hbool_t filtered; /* Whether the chunks are filtered */ + H5D_chunk_cb_func_t cb; /* Chunk callback routine */ + void *udata; /* User data for chunk callback routine */ +} H5D_farray_it_ud_t; + +/* Native fixed array element for chunks w/filters */ +typedef struct H5D_farray_filt_elmt_t { + haddr_t addr; /* Address of chunk */ + uint32_t nbytes; /* Size of chunk (in file) */ + uint32_t filter_mask; /* Excluded filters for chunk */ +} H5D_farray_filt_elmt_t; + + +/********************/ +/* Local Prototypes */ +/********************/ + +/* Fixed Array iterator callbacks */ +static int H5D_farray_idx_iterate_cb(hsize_t idx, const void *_elmt, void *_udata); + +/* Fixed array class callbacks for chunks w/o filters */ +static void *H5D_farray_crt_context(void *udata); +static herr_t H5D_farray_dst_context(void *ctx); +static herr_t H5D_farray_fill(void *nat_blk, size_t nelmts); +static herr_t H5D_farray_encode(void *raw, const void *elmt, size_t nelmts, + void *ctx); +static herr_t H5D_farray_decode(const void *raw, void *elmt, size_t nelmts, + void *ctx); +static herr_t H5D_farray_debug(FILE *stream, int indent, int fwidth, + hsize_t idx, const void *elmt); + +/* Fixed array class callbacks for chunks w/filters */ +/* (some shared with callbacks for chunks w/o filters) */ +static herr_t H5D_farray_filt_fill(void *nat_blk, size_t nelmts); +static herr_t H5D_farray_filt_encode(void *raw, const void *elmt, size_t nelmts, + void *ctx); +static herr_t H5D_farray_filt_decode(const void *raw, void *elmt, size_t nelmts, + void *ctx); +static herr_t H5D_farray_filt_debug(FILE *stream, int indent, int fwidth, + hsize_t idx, const void *elmt); + +/* Chunked layout indexing callbacks */ +static herr_t H5D_farray_idx_create(const H5D_chk_idx_info_t *idx_info); +static hbool_t H5D_farray_idx_is_space_alloc(const H5O_layout_t *layout); +static herr_t H5D_farray_idx_insert(const H5D_chk_idx_info_t *idx_info, + H5D_chunk_ud_t *udata); +static herr_t H5D_farray_idx_get_addr(const H5D_chk_idx_info_t *idx_info, + H5D_chunk_ud_t *udata); +static int H5D_farray_idx_iterate(const H5D_chk_idx_info_t *idx_info, + H5D_chunk_cb_func_t chunk_cb, void *chunk_udata); +static herr_t H5D_farray_idx_remove(const H5D_chk_idx_info_t *idx_info, + H5D_chunk_common_ud_t *udata); +static herr_t H5D_farray_idx_delete(const H5D_chk_idx_info_t *idx_info); +static herr_t H5D_farray_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src, + const H5D_chk_idx_info_t *idx_info_dst); +static herr_t H5D_farray_idx_copy_shutdown(H5O_layout_t *layout_src, + H5O_layout_t *layout_dst, hid_t dxpl_id); +static herr_t H5D_farray_idx_size(const H5D_chk_idx_info_t *idx_info, + hsize_t *size); +static herr_t H5D_farray_idx_reset(H5O_layout_t *layout, hbool_t reset_addr); +static herr_t H5D_farray_idx_dump(const H5D_chk_idx_info_t *idx_info, + FILE *stream); +static herr_t H5D_farray_idx_dest(const H5D_chk_idx_info_t *idx_info); + + +/*********************/ +/* Package Variables */ +/*********************/ + +/* Fixed array indexed chunk I/O ops */ +const H5D_chunk_ops_t H5D_COPS_FARRAY[1] = {{ + FALSE, /* Fixed array indices don't current support SWMR access */ + NULL, + H5D_farray_idx_create, + H5D_farray_idx_is_space_alloc, + H5D_farray_idx_insert, + H5D_farray_idx_get_addr, + H5D_farray_idx_iterate, + H5D_farray_idx_remove, + H5D_farray_idx_delete, + H5D_farray_idx_copy_setup, + H5D_farray_idx_copy_shutdown, + H5D_farray_idx_size, + H5D_farray_idx_reset, + NULL, + NULL, + H5D_farray_idx_dump, + H5D_farray_idx_dest +}}; + + +/*****************************/ +/* Library Private Variables */ +/*****************************/ + + +/*******************/ +/* Local Variables */ +/*******************/ + +/* Fixed array class callbacks for dataset chunks w/o filters */ +const H5FA_class_t H5FA_CLS_CHUNK[1]={{ + H5FA_CLS_CHUNK_ID, /* Type of fixed array */ + "Chunk w/o filters", /* Name of fixed array class */ + sizeof(haddr_t), /* Size of native element */ + H5D_farray_crt_context, /* Create context */ + H5D_farray_dst_context, /* Destroy context */ + H5D_farray_fill, /* Fill block of missing elements callback */ + H5D_farray_encode, /* Element encoding callback */ + H5D_farray_decode, /* Element decoding callback */ + H5D_farray_debug /* Element debugging callback */ +}}; + +/* Fixed array class callbacks for dataset chunks w/filters */ +const H5FA_class_t H5FA_CLS_FILT_CHUNK[1]={{ + H5FA_CLS_FILT_CHUNK_ID, /* Type of fixed array */ + "Chunk w/filters", /* Name of fixed array class */ + sizeof(H5D_farray_filt_elmt_t), /* Size of native element */ + H5D_farray_crt_context, /* Create context */ + H5D_farray_dst_context, /* Destroy context */ + H5D_farray_filt_fill, /* Fill block of missing elements callback */ + H5D_farray_filt_encode, /* Element encoding callback */ + H5D_farray_filt_decode, /* Element decoding callback */ + H5D_farray_filt_debug /* Element debugging callback */ +}}; + +/* Declare a free list to manage the H5D_farray_ctx_t struct */ +H5FL_DEFINE_STATIC(H5D_farray_ctx_t); + + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_crt_context + * + * Purpose: Create context for callbacks + * + * Return: Success: non-NULL + * Failure: NULL + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static void * +H5D_farray_crt_context(void *_udata) +{ + H5D_farray_ctx_t *ctx; /* Fixed array callback context */ + H5D_farray_ctx_ud_t *udata = (H5D_farray_ctx_ud_t *)_udata; /* User data for fixed array context */ + void *ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_crt_context) + + /* Sanity checks */ + HDassert(udata); + HDassert(udata->f); + HDassert(udata->layout); + + /* Allocate new context structure */ + if(NULL == (ctx = H5FL_MALLOC(H5D_farray_ctx_t))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, NULL, "can't allocate fixed array client callback context") + + /* Initialize the context */ + ctx->file_addr_len = H5F_SIZEOF_ADDR(udata->f); + + /* Compute the size required for encoding the size of a chunk, allowing + * for an extra byte, in case the filter makes the chunk larger. + */ + ctx->chunk_size_len = 1 + ((H5V_log2_gen(udata->layout->u.chunk.size) + 8) / 8); + if(ctx->chunk_size_len > 8) + ctx->chunk_size_len = 8; + + /* Set return value */ + ret_value = ctx; + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_crt_context() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_dst_context + * + * Purpose: Destroy context for callbacks + * + * Return: Success: non-NULL + * Failure: NULL + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_dst_context(void *_ctx) +{ + H5D_farray_ctx_t *ctx = (H5D_farray_ctx_t *)_ctx; /* Fixed array callback context */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_dst_context) + + /* Sanity checks */ + HDassert(ctx); + + /* Release context structure */ + ctx = H5FL_FREE(H5D_farray_ctx_t, ctx); + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_dst_context() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_fill + * + * Purpose: Fill "missing elements" in block of elements + * + * Return: Success: non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_fill(void *nat_blk, size_t nelmts) +{ + haddr_t fill_val = H5D_FARRAY_FILL; /* Value to fill elements with */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_fill) + + /* Sanity checks */ + HDassert(nat_blk); + HDassert(nelmts); + + H5V_array_fill(nat_blk, &fill_val, H5FA_CLS_CHUNK->nat_elmt_size, nelmts); + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_fill() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_encode + * + * Purpose: Encode an element from "native" to "raw" form + * + * Return: Success: non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_encode(void *raw, const void *_elmt, size_t nelmts, void *_ctx) +{ + H5D_farray_ctx_t *ctx = (H5D_farray_ctx_t *)_ctx; /* Fixed array callback context */ + const haddr_t *elmt = (const haddr_t *)_elmt; /* Convenience pointer to native elements */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_encode) + + /* Sanity checks */ + HDassert(raw); + HDassert(elmt); + HDassert(nelmts); + HDassert(ctx); + + /* Encode native elements into raw elements */ + while(nelmts) { + /* Encode element */ + /* (advances 'raw' pointer) */ + H5F_addr_encode_len(ctx->file_addr_len, (uint8_t **)&raw, *elmt); + + /* Advance native element pointer */ + elmt++; + + /* Decrement # of elements to encode */ + nelmts--; + } /* end while */ + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_encode() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_decode + * + * Purpose: Decode an element from "raw" to "native" form + * + * Return: Success: non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_decode(const void *_raw, void *_elmt, size_t nelmts, void *_ctx) +{ + H5D_farray_ctx_t *ctx = (H5D_farray_ctx_t *)_ctx; /* Fixed array callback context */ + haddr_t *elmt = (haddr_t *)_elmt; /* Convenience pointer to native elements */ + const uint8_t *raw = (const uint8_t *)_raw; /* Convenience pointer to raw elements */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_decode) + + /* Sanity checks */ + HDassert(raw); + HDassert(elmt); + HDassert(nelmts); + + /* Decode raw elements into native elements */ + while(nelmts) { + /* Decode element */ + /* (advances 'raw' pointer) */ + H5F_addr_decode_len(ctx->file_addr_len, &raw, elmt); + + /* Advance native element pointer */ + elmt++; + + /* Decrement # of elements to decode */ + nelmts--; + } /* end while */ + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_decode() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_debug + * + * Purpose: Display an element for debugging + * + * Return: Success: non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_debug(FILE *stream, int indent, int fwidth, hsize_t idx, + const void *elmt) +{ + char temp_str[128]; /* Temporary string, for formatting */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_debug) + + /* Sanity checks */ + HDassert(stream); + HDassert(elmt); + + /* Print element */ + sprintf(temp_str, "Element #%llu:", (unsigned long long)idx); + HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth, temp_str, + *(const haddr_t *)elmt); + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_debug() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_filt_fill + * + * Purpose: Fill "missing elements" in block of elements + * + * Return: Success: non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_filt_fill(void *nat_blk, size_t nelmts) +{ + H5D_farray_filt_elmt_t fill_val = H5D_FARRAY_FILT_FILL; /* Value to fill elements with */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_filt_fill) + + /* Sanity checks */ + HDassert(nat_blk); + HDassert(nelmts); + HDassert(sizeof(fill_val) == H5FA_CLS_FILT_CHUNK->nat_elmt_size); + + H5V_array_fill(nat_blk, &fill_val, H5FA_CLS_FILT_CHUNK->nat_elmt_size, nelmts); + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_filt_fill() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_filt_encode + * + * Purpose: Encode an element from "native" to "raw" form + * + * Return: Success: non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_filt_encode(void *_raw, const void *_elmt, size_t nelmts, void *_ctx) +{ + H5D_farray_ctx_t *ctx = (H5D_farray_ctx_t *)_ctx; /* Fixed array callback context */ + uint8_t *raw = (uint8_t *)_raw; /* Convenience pointer to raw elements */ + const H5D_farray_filt_elmt_t *elmt = (const H5D_farray_filt_elmt_t *)_elmt; /* Convenience pointer to native elements */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_filt_encode) + + /* Sanity checks */ + HDassert(raw); + HDassert(elmt); + HDassert(nelmts); + HDassert(ctx); + + /* Encode native elements into raw elements */ + while(nelmts) { + /* Encode element */ + /* (advances 'raw' pointer) */ + H5F_addr_encode_len(ctx->file_addr_len, &raw, elmt->addr); + UINT64ENCODE_VAR(raw, elmt->nbytes, ctx->chunk_size_len); + UINT32ENCODE(raw, elmt->filter_mask); + + /* Advance native element pointer */ + elmt++; + + /* Decrement # of elements to encode */ + nelmts--; + } /* end while */ + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_filt_encode() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_filt_decode + * + * Purpose: Decode an element from "raw" to "native" form + * + * Return: Success: non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_filt_decode(const void *_raw, void *_elmt, size_t nelmts, void *_ctx) +{ + H5D_farray_ctx_t *ctx = (H5D_farray_ctx_t *)_ctx; /* Fixed array callback context */ + H5D_farray_filt_elmt_t *elmt = (H5D_farray_filt_elmt_t *)_elmt; /* Convenience pointer to native elements */ + const uint8_t *raw = (const uint8_t *)_raw; /* Convenience pointer to raw elements */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_filt_decode) + + /* Sanity checks */ + HDassert(raw); + HDassert(elmt); + HDassert(nelmts); + + /* Decode raw elements into native elements */ + while(nelmts) { + /* Decode element */ + /* (advances 'raw' pointer) */ + H5F_addr_decode_len(ctx->file_addr_len, &raw, &elmt->addr); + UINT64DECODE_VAR(raw, elmt->nbytes, ctx->chunk_size_len); + UINT32DECODE(raw, elmt->filter_mask); + + /* Advance native element pointer */ + elmt++; + + /* Decrement # of elements to decode */ + nelmts--; + } /* end while */ + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_filt_decode() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_filt_debug + * + * Purpose: Display an element for debugging + * + * Return: Success: non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_filt_debug(FILE *stream, int indent, int fwidth, hsize_t idx, + const void *_elmt) +{ + const H5D_farray_filt_elmt_t *elmt = (const H5D_farray_filt_elmt_t *)_elmt; /* Convenience pointer to native elements */ + char temp_str[128]; /* Temporary string, for formatting */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_filt_debug) + + /* Sanity checks */ + HDassert(stream); + HDassert(elmt); + + /* Print element */ + sprintf(temp_str, "Element #%llu:", (unsigned long long)idx); + HDfprintf(stream, "%*s%-*s {%a, %u, %0x}\n", indent, "", fwidth, temp_str, + elmt->addr, elmt->nbytes, elmt->filter_mask); + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_filt_debug() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_open + * + * Purpose: Opens an existing fixed array and initializes + * the layout struct with information about the storage. + * + * Return: Success: non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_open(const H5D_chk_idx_info_t *idx_info) +{ + const H5FA_class_t *cls; /* Fixed array class to use */ + H5D_farray_ctx_ud_t udata; /* User data for fixed array open call */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_open) + + /* Check args */ + HDassert(idx_info); + HDassert(idx_info->f); + HDassert(idx_info->pline); + HDassert(idx_info->layout); + HDassert(H5D_CHUNK_IDX_FARRAY == idx_info->layout->u.chunk.idx_type); + HDassert(H5F_addr_defined(idx_info->layout->u.chunk.u.farray.addr)); + HDassert(NULL == idx_info->layout->u.chunk.u.farray.fa); + + /* Set up the user data */ + udata.f = idx_info->f; + udata.layout = idx_info->layout; + + /* Open the fixed array for the chunk index */ + cls = (idx_info->pline->nused > 0) ? H5FA_CLS_FILT_CHUNK : H5FA_CLS_CHUNK; + if(NULL == (idx_info->layout->u.chunk.u.farray.fa = H5FA_open(idx_info->f, idx_info->dxpl_id, idx_info->layout->u.chunk.u.farray.addr, cls, &udata))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't open fixed array") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_idx_open() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_create + * + * Purpose: Creates a new indexed-storage fixed array and initializes + * the layout struct with information about the storage. The + * struct should be immediately written to the object header. + * + * This function must be called before passing LAYOUT to any of + * the other indexed storage functions! + * + * Return: Non-negative on success (with the LAYOUT argument initialized + * and ready to write to an object header). Negative on failure. + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_create(const H5D_chk_idx_info_t *idx_info) +{ + H5FA_create_t cparam; /* Fixed array creation parameters */ + H5D_farray_ctx_ud_t udata; /* User data for fixed array create call */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_create) + + /* Check args */ + HDassert(idx_info); + HDassert(idx_info->f); + HDassert(idx_info->pline); + HDassert(idx_info->layout); + HDassert(!H5F_addr_defined(idx_info->layout->u.chunk.u.farray.addr)); + HDassert(NULL == idx_info->layout->u.chunk.u.farray.fa); + HDassert(idx_info->layout->u.chunk.nchunks); + + /* General parameters */ + if(idx_info->pline->nused > 0) { + unsigned chunk_size_len; /* Size of encoded chunk size */ + + /* Compute the size required for encoding the size of a chunk, allowing + * for an extra byte, in case the filter makes the chunk larger. + */ + chunk_size_len = 1 + ((H5V_log2_gen(idx_info->layout->u.chunk.size) + 8) / 8); + if(chunk_size_len > 8) + chunk_size_len = 8; + + cparam.cls = H5FA_CLS_FILT_CHUNK; + cparam.raw_elmt_size = (uint8_t)(H5F_SIZEOF_ADDR(idx_info->f) + chunk_size_len + 4); + } /* end if */ + else { + cparam.cls = H5FA_CLS_CHUNK; + cparam.raw_elmt_size = (uint8_t)H5F_SIZEOF_ADDR(idx_info->f); + } /* end else */ + cparam.max_dblk_page_nelmts_bits = H5D_FARRAY_MAX_DBLK_PAGE_NELMTS_BITS; + cparam.nelmts = idx_info->layout->u.chunk.nchunks; + + /* Set up the user data */ + udata.f = idx_info->f; + udata.layout = idx_info->layout; + + /* Create the fixed array for the chunk index */ + if(NULL == (idx_info->layout->u.chunk.u.farray.fa = H5FA_create(idx_info->f, idx_info->dxpl_id, &cparam, &udata))) + HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't create fixed array") + + /* Get the address of the fixed array in file */ + if(H5FA_get_addr(idx_info->layout->u.chunk.u.farray.fa, &(idx_info->layout->u.chunk.u.farray.addr)) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't query fixed array address") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_idx_create() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_is_space_alloc + * + * Purpose: Query if space is allocated for index method + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static hbool_t +H5D_farray_idx_is_space_alloc(const H5O_layout_t *layout) +{ + hbool_t ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_idx_is_space_alloc) + + /* Check args */ + HDassert(layout); + + /* Set return value */ + ret_value = (hbool_t)H5F_addr_defined(layout->u.chunk.u.farray.addr); + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_idx_is_space_alloc() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_insert + * + * Purpose: Create the chunk if it doesn't exist, or reallocate the + * chunk if its size changed. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata) +{ + H5FA_t *fa; /* Pointer to fixed array structure */ + hsize_t idx; /* Array index of chunk */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_insert) + + HDassert(idx_info); + HDassert(idx_info->f); + HDassert(idx_info->pline); + HDassert(idx_info->layout); + HDassert(H5F_addr_defined(idx_info->layout->u.chunk.u.farray.addr)); + HDassert(udata); + + /* Check if the fixed array is open yet */ + if(NULL == idx_info->layout->u.chunk.u.farray.fa) { + /* Open the fixed array in file */ + if(H5D_farray_idx_open(idx_info) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open fixed array") + } /* end if */ + + /* Set convenience pointer to fixed array structure */ + fa = idx_info->layout->u.chunk.u.farray.fa; + + /* Calculate the index of this chunk */ + if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->common.offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index") + + /* Check for filters on chunks */ + if(idx_info->pline->nused > 0) { + H5D_farray_filt_elmt_t elmt; /* Fixed array element */ + unsigned allow_chunk_size_len; /* Allowed size of encoded chunk size */ + unsigned new_chunk_size_len; /* Size of encoded chunk size */ + hbool_t alloc_chunk = FALSE; /* Whether to allocate chunk */ + + /* Compute the size required for encoding the size of a chunk, allowing + * for an extra byte, in case the filter makes the chunk larger. + */ + allow_chunk_size_len = 1 + ((H5V_log2_gen(idx_info->layout->u.chunk.size) + 8) / 8); + if(allow_chunk_size_len > 8) + allow_chunk_size_len = 8; + + /* Compute encoded size of chunk */ + new_chunk_size_len = (H5V_log2_gen(udata->nbytes) + 8) / 8; + if(new_chunk_size_len > 8) + HGOTO_ERROR(H5E_DATASET, H5E_BADRANGE, FAIL, "encoded chunk size is more than 8 bytes?!?") + + /* Check if the chunk became too large to be encoded */ + if(new_chunk_size_len > allow_chunk_size_len) + HGOTO_ERROR(H5E_DATASET, H5E_BADRANGE, FAIL, "chunk size can't be encoded") + + /* Get the information for the chunk */ + if(H5FA_get(fa, idx_info->dxpl_id, idx, &elmt) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk info") + + /* Check for previous chunk */ + if(H5F_addr_defined(elmt.addr)) { + /* Sanity check */ + HDassert(!H5F_addr_defined(udata->addr) || H5F_addr_eq(udata->addr, elmt.addr)); + + /* Check for chunk being same size */ + if(udata->nbytes != elmt.nbytes) { + /* Release previous chunk */ + H5_CHECK_OVERFLOW(elmt.nbytes, uint32_t, hsize_t); + if(H5MF_xfree(idx_info->f, H5FD_MEM_DRAW, idx_info->dxpl_id, elmt.addr, (hsize_t)elmt.nbytes) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to free chunk") + elmt.addr = HADDR_UNDEF; + alloc_chunk = TRUE; + } /* end if */ + else { + /* Don't need to reallocate chunk, but send its address back up */ + if(!H5F_addr_defined(udata->addr)) + udata->addr = elmt.addr; + } /* end else */ + } /* end if */ + else + alloc_chunk = TRUE; + + /* Check if we need to allocate the chunk */ + if(alloc_chunk) { + H5_CHECK_OVERFLOW(udata->nbytes, uint32_t, hsize_t); + udata->addr = H5MF_alloc(idx_info->f, H5FD_MEM_DRAW, idx_info->dxpl_id, (hsize_t)udata->nbytes); + if(!H5F_addr_defined(udata->addr)) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "unable to allocate chunk") + + /* Update the element information */ + elmt.addr = udata->addr; + elmt.nbytes = udata->nbytes; + elmt.filter_mask = udata->filter_mask; + + /* Set the info for the chunk */ + if(H5FA_set(fa, idx_info->dxpl_id, idx, &elmt) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set chunk info") + } /* end if */ + } /* end if */ + else { + HDassert(!H5F_addr_defined(udata->addr)); + HDassert(udata->nbytes == idx_info->layout->u.chunk.size); + +#ifndef NDEBUG +{ + haddr_t addr = HADDR_UNDEF; /* Address of chunk in file */ + + /* Get the address for the chunk */ + if(H5FA_get(fa, idx_info->dxpl_id, idx, &addr) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address") + HDassert(!H5F_addr_defined(addr)); +} +#endif /* NDEBUG */ + + /* + * Allocate storage for the new chunk + */ + H5_CHECK_OVERFLOW(udata->nbytes, /*From: */uint32_t, /*To: */hsize_t); + udata->addr = H5MF_alloc(idx_info->f, H5FD_MEM_DRAW, idx_info->dxpl_id, (hsize_t)udata->nbytes); + if(!H5F_addr_defined(udata->addr)) + HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "file allocation failed") + + /* Set the address for the chunk */ + if(H5FA_set(fa, idx_info->dxpl_id, idx, &udata->addr) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set chunk address") + } /* end else */ + HDassert(H5F_addr_defined(udata->addr)); + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* H5D_farray_idx_insert() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_get_addr + * + * Purpose: Get the file address of a chunk if file space has been + * assigned. Save the retrieved information in the udata + * supplied. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata) +{ + H5FA_t *fa; /* Pointer to fixed array structure */ + hsize_t idx; /* Array index of chunk */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_get_addr) + + HDassert(idx_info); + HDassert(idx_info->f); + HDassert(idx_info->pline); + HDassert(idx_info->layout); + HDassert(H5F_addr_defined(idx_info->layout->u.chunk.u.farray.addr)); + HDassert(udata); + + /* Check if the fixed array is open yet */ + if(NULL == idx_info->layout->u.chunk.u.farray.fa) { + /* Open the fixed array in file */ + if(H5D_farray_idx_open(idx_info) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open fixed array") + } /* end if */ + + /* Set convenience pointer to fixed array structure */ + fa = idx_info->layout->u.chunk.u.farray.fa; + + /* Calculate the index of this chunk */ + if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->common.offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index") + + /* Check for filters on chunks */ + if(idx_info->pline->nused > 0) { + H5D_farray_filt_elmt_t elmt; /* Fixed array element */ + + /* Get the information for the chunk */ + if(H5FA_get(fa, idx_info->dxpl_id, idx, &elmt) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk info") + + /* Set the info for the chunk */ + udata->addr = elmt.addr; + udata->nbytes = elmt.nbytes; + udata->filter_mask = elmt.filter_mask; + } /* end if */ + else { + /* Get the address for the chunk */ + if(H5FA_get(fa, idx_info->dxpl_id, idx, &udata->addr) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address") + + /* Update the other (constant) information for the chunk */ + udata->nbytes = idx_info->layout->u.chunk.size; + udata->filter_mask = 0; + } /* end else */ + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* H5D_farray_idx_get_addr() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_iterate_cb + * + * Purpose: Callback routine for fixed array element iteration. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static int +H5D_farray_idx_iterate_cb(hsize_t UNUSED idx, const void *_elmt, void *_udata) +{ + H5D_farray_it_ud_t *udata = (H5D_farray_it_ud_t *)_udata; /* User data */ + unsigned ndims; /* Rank of chunk */ + int curr_dim; /* Current dimension */ + int ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_iterate_cb) + + /* Compose generic chunk record for callback */ + if(udata->filtered) { + const H5D_farray_filt_elmt_t *filt_elmt = (const H5D_farray_filt_elmt_t *)_elmt; + + udata->chunk_rec.chunk_addr = filt_elmt->addr; + udata->chunk_rec.nbytes = filt_elmt->nbytes; + udata->chunk_rec.filter_mask = filt_elmt->filter_mask; + } /* end if */ + else + udata->chunk_rec.chunk_addr = *(const haddr_t *)_elmt; + + /* Make "generic chunk" callback */ + if((ret_value = (udata->cb)(&udata->chunk_rec, udata->udata)) < 0) + HERROR(H5E_DATASET, H5E_CALLBACK, "failure in generic chunk iterator callback"); + + /* Update coordinates of chunk in dataset */ + ndims = udata->common.mesg->u.chunk.ndims - 1; + HDassert(ndims > 0); + curr_dim = (int)(ndims - 1); + while(curr_dim >= 0) { + /* Increment coordinate in current dimension */ + udata->chunk_offset[curr_dim]++; + udata->chunk_rec.offset[curr_dim] += udata->common.mesg->u.chunk.dim[curr_dim]; + + /* Check if we went off the end of the current dimension */ + if(udata->chunk_offset[curr_dim] >= udata->common.mesg->u.chunk.chunks[curr_dim]) { + /* Reset coordinate & move to next faster dimension */ + udata->chunk_offset[curr_dim] = 0; + udata->chunk_rec.offset[curr_dim] = 0; + curr_dim--; + } /* end if */ + else + break; + } /* end while */ + + FUNC_LEAVE_NOAPI(ret_value) +} /* H5D_farray_idx_iterate_cb() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_iterate + * + * Purpose: Iterate over the chunks in an index, making a callback + * for each one. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static int +H5D_farray_idx_iterate(const H5D_chk_idx_info_t *idx_info, + H5D_chunk_cb_func_t chunk_cb, void *chunk_udata) +{ + H5FA_t *fa; /* Pointer to fixed array structure */ + H5FA_stat_t fa_stat; /* Fixed array statistics */ + int ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_iterate) + + HDassert(idx_info); + HDassert(idx_info->f); + HDassert(idx_info->pline); + HDassert(idx_info->layout); + HDassert(H5F_addr_defined(idx_info->layout->u.chunk.u.farray.addr)); + HDassert(chunk_cb); + HDassert(chunk_udata); + + /* Check if the fixed array is open yet */ + if(NULL == idx_info->layout->u.chunk.u.farray.fa) { + /* Open the fixed array in file */ + if(H5D_farray_idx_open(idx_info) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open fixed array") + } /* end if */ + + /* Set convenience pointer to fixed array structure */ + fa = idx_info->layout->u.chunk.u.farray.fa; + + /* Get the fixed array statistics */ + if(H5FA_get_stats(fa, &fa_stat) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't query fixed array statistics") + + /* Check if there are any array elements */ + if(fa_stat.nelmts > 0) { + H5D_farray_it_ud_t udata; /* User data for iteration callback */ + + /* Initialize userdata */ + HDmemset(&udata, 0, sizeof udata); + udata.common.mesg = idx_info->layout; + HDmemset(&udata.chunk_rec, 0, sizeof(udata.chunk_rec)); + HDmemset(&udata.chunk_offset, 0, sizeof(udata.chunk_offset)); + udata.filtered = (idx_info->pline->nused > 0); + if(!udata.filtered) { + udata.chunk_rec.nbytes = idx_info->layout->u.chunk.size; + udata.chunk_rec.filter_mask = 0; + } /* end if */ + udata.cb = chunk_cb; + udata.udata = chunk_udata; + + /* Iterate over the fixed array elements */ + if((ret_value = H5FA_iterate(fa, idx_info->dxpl_id, H5D_farray_idx_iterate_cb, &udata)) < 0) + HERROR(H5E_DATASET, H5E_BADITER, "unable to iterate over fixed array chunk index"); + } /* end if */ + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_idx_iterate() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_remove + * + * Purpose: Remove chunk from index. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t *udata) +{ + H5FA_t *fa; /* Pointer to fixed array structure */ + hsize_t idx; /* Array index of chunk */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_remove) + + HDassert(idx_info); + HDassert(idx_info->f); + HDassert(idx_info->pline); + HDassert(idx_info->layout); + HDassert(H5F_addr_defined(idx_info->layout->u.chunk.u.farray.addr)); + HDassert(udata); + + /* Check if the fixed array is open yet */ + if(NULL == idx_info->layout->u.chunk.u.farray.fa) { + /* Open the fixed array in file */ + if(H5D_farray_idx_open(idx_info) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open fixed array") + } /* end if */ + + /* Set convenience pointer to fixed array structure */ + fa = idx_info->layout->u.chunk.u.farray.fa; + + /* Calculate the index of this chunk */ + if(H5V_chunk_index((idx_info->layout->u.chunk.ndims - 1), udata->offset, idx_info->layout->u.chunk.dim, idx_info->layout->u.chunk.down_chunks, &idx) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index") + + /* Check for filters on chunks */ + if(idx_info->pline->nused > 0) { + H5D_farray_filt_elmt_t elmt; /* Fixed array element */ + + /* Get the info about the chunk for the index */ + if(H5FA_get(fa, idx_info->dxpl_id, idx, &elmt) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk info") + + /* Remove raw data chunk from file */ + HDassert(H5F_addr_defined(elmt.addr)); + H5_CHECK_OVERFLOW(elmt.nbytes, /*From: */uint32_t, /*To: */hsize_t); + if(H5MF_xfree(idx_info->f, H5FD_MEM_DRAW, idx_info->dxpl_id, elmt.addr, (hsize_t)elmt.nbytes) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to free chunk") + + /* Reset the info about the chunk for the index */ + elmt.addr = HADDR_UNDEF; + elmt.nbytes = 0; + elmt.filter_mask = 0; + if(H5FA_set(fa, idx_info->dxpl_id, idx, &elmt) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "unable to reset chunk info") + } /* end if */ + else { + haddr_t addr = HADDR_UNDEF; /* Chunk address */ + + /* Get the address of the chunk for the index */ + if(H5FA_get(fa, idx_info->dxpl_id, idx, &addr) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address") + + /* Remove raw data chunk from file */ + HDassert(H5F_addr_defined(addr)); + H5_CHECK_OVERFLOW(idx_info->layout->u.chunk.size, /*From: */uint32_t, /*To: */hsize_t); + if(H5MF_xfree(idx_info->f, H5FD_MEM_DRAW, idx_info->dxpl_id, addr, (hsize_t)idx_info->layout->u.chunk.size) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to free chunk") + + /* Reset the address of the chunk for the index */ + addr = HADDR_UNDEF; + if(H5FA_set(fa, idx_info->dxpl_id, idx, &addr) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "unable to reset chunk address") + } /* end else */ + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* H5D_farray_idx_remove() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_delete_cb + * + * Purpose: Delete space for chunk in file + * + * Return: Success: Non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static int +H5D_farray_idx_delete_cb(hsize_t UNUSED idx, const void *_elmt, void *_udata) +{ + H5D_farray_del_ud_t *udata = (H5D_farray_del_ud_t *)_udata; /* User data for callback */ + haddr_t chunk_addr; /* Address of chunk */ + uint32_t nbytes; /* Size of chunk */ + int ret_value = H5_ITER_CONT; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_delete_cb) + + /* Sanity checks */ + HDassert(_elmt); + HDassert(udata); + HDassert(udata->f); + + /* Check for filtered elements */ + if(udata->filtered) { + const H5D_farray_filt_elmt_t *filt_elmt = (const H5D_farray_filt_elmt_t *)_elmt; + + chunk_addr = filt_elmt->addr; + nbytes = filt_elmt->nbytes; + } /* end if */ + else { + chunk_addr = *(const haddr_t *)_elmt; + nbytes = udata->unfilt_size; + } /* end else */ + + /* Remove raw data chunk from file */ + H5_CHECK_OVERFLOW(nbytes, /*From: */uint32_t, /*To: */hsize_t); + if(H5MF_xfree(udata->f, H5FD_MEM_DRAW, udata->dxpl_id, chunk_addr, (hsize_t)nbytes) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, H5_ITER_ERROR, "unable to free chunk") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_idx_delete_cb() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_delete + * + * Purpose: Delete index and raw data storage for entire dataset + * (i.e. all chunks) + * + * Return: Success: Non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_delete(const H5D_chk_idx_info_t *idx_info) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_delete) + + /* Sanity checks */ + HDassert(idx_info); + HDassert(idx_info->f); + HDassert(idx_info->pline); + HDassert(idx_info->layout); + + /* Check if the index data structure has been allocated */ + if(H5F_addr_defined(idx_info->layout->u.chunk.u.farray.addr)) { + H5FA_t *fa; /* Pointer to fixed array structure */ + H5FA_stat_t fa_stat; /* Fixed array statistics */ + + /* Check if the fixed array is open yet */ + if(NULL == idx_info->layout->u.chunk.u.farray.fa) { + /* Open the fixed array in file */ + if(H5D_farray_idx_open(idx_info) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open fixed array") + } /* end if */ + + /* Set convenience pointer to fixed array structure */ + fa = idx_info->layout->u.chunk.u.farray.fa; + + /* Get the fixed array statistics */ + if(H5FA_get_stats(fa, &fa_stat) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't query fixed array statistics") + + /* Check if there are any array elements */ + if(fa_stat.nelmts > 0) { + H5D_farray_del_ud_t udata; /* User data for callback */ + + /* Initialize user data for callback */ + udata.f = idx_info->f; + udata.dxpl_id = idx_info->dxpl_id; + udata.filtered = (idx_info->pline->nused > 0); + udata.unfilt_size = idx_info->layout->u.chunk.size; + + /* Iterate over the chunk addresses in the fixed array, deleting each chunk */ + if(H5FA_iterate(fa, idx_info->dxpl_id, H5D_farray_idx_delete_cb, &udata) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_BADITER, FAIL, "unable to iterate over chunk addresses") + } /* end if */ + + /* Close fixed array */ + if(H5FA_close(idx_info->layout->u.chunk.u.farray.fa, idx_info->dxpl_id) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to close fixed array") + idx_info->layout->u.chunk.u.farray.fa = NULL; + + /* Delete fixed array */ + if(H5FA_delete(idx_info->f, idx_info->dxpl_id, idx_info->layout->u.chunk.u.farray.addr) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTDELETE, FAIL, "unable to delete chunk fixed array") + idx_info->layout->u.chunk.u.farray.addr = HADDR_UNDEF; + } /* end if */ + else + HDassert(NULL == idx_info->layout->u.chunk.u.farray.fa); + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_idx_delete() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_copy_setup + * + * Purpose: Set up any necessary information for copying chunks + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src, + const H5D_chk_idx_info_t *idx_info_dst) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_copy_setup) + + /* Check args */ + HDassert(idx_info_src); + HDassert(idx_info_src->f); + HDassert(idx_info_src->pline); + HDassert(idx_info_src->layout); + HDassert(idx_info_dst); + HDassert(idx_info_dst->f); + HDassert(idx_info_dst->pline); + HDassert(idx_info_dst->layout); + HDassert(!H5F_addr_defined(idx_info_dst->layout->u.chunk.u.farray.addr)); + + /* Check if the source fixed array is open yet */ + if(NULL == idx_info_src->layout->u.chunk.u.farray.fa) { + /* Open the fixed array in file */ + if(H5D_farray_idx_open(idx_info_src) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open fixed array") + } /* end if */ + + /* Create the fixed array that describes chunked storage in the dest. file */ + if(H5D_farray_idx_create(idx_info_dst) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize chunked storage") + HDassert(H5F_addr_defined(idx_info_dst->layout->u.chunk.u.farray.addr)); + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_idx_copy_setup() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_copy_shutdown + * + * Purpose: Shutdown any information from copying chunks + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_copy_shutdown(H5O_layout_t *layout_src, H5O_layout_t *layout_dst, + hid_t dxpl_id) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_copy_shutdown) + + /* Check args */ + HDassert(layout_src); + HDassert(layout_src->u.chunk.u.farray.fa); + HDassert(layout_dst); + HDassert(layout_dst->u.chunk.u.farray.fa); + + /* Close fixed arrays */ + if(H5FA_close(layout_src->u.chunk.u.farray.fa, dxpl_id) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to close fixed array") + layout_src->u.chunk.u.farray.fa = NULL; + if(H5FA_close(layout_dst->u.chunk.u.farray.fa, dxpl_id) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to close fixed array") + layout_dst->u.chunk.u.farray.fa = NULL; + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_idx_copy_shutdown() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_size + * + * Purpose: Retrieve the amount of index storage for chunked dataset + * + * Return: Success: Non-negative + * Failure: negative + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_size(const H5D_chk_idx_info_t *idx_info, hsize_t *index_size) +{ + H5FA_t *fa; /* Pointer to fixed array structure */ + H5FA_stat_t fa_stat; /* Fixed array statistics */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(H5D_farray_idx_size, FAIL) + + /* Check args */ + HDassert(idx_info); + HDassert(idx_info->f); + HDassert(idx_info->pline); + HDassert(idx_info->layout); + HDassert(H5F_addr_defined(idx_info->layout->u.chunk.u.farray.addr)); + HDassert(index_size); + + /* Open the fixed array in file */ + if(H5D_farray_idx_open(idx_info) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open fixed array") + + /* Set convenience pointer to fixed array structure */ + fa = idx_info->layout->u.chunk.u.farray.fa; + + /* Get the fixed array statistics */ + if(H5FA_get_stats(fa, &fa_stat) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't query fixed array statistics") + + *index_size = fa_stat.hdr_size; + *index_size += fa_stat.dblk_size; + +done: + if(idx_info->layout->u.chunk.u.farray.fa) { + if(H5FA_close(idx_info->layout->u.chunk.u.farray.fa, idx_info->dxpl_id) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to close fixed array") + idx_info->layout->u.chunk.u.farray.fa = NULL; + } /* end if */ + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_idx_size() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_reset + * + * Purpose: Reset indexing information. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_reset(H5O_layout_t *layout, hbool_t reset_addr) +{ + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_idx_reset) + + /* Check args */ + HDassert(layout); + + /* Reset index info */ + if(reset_addr) + layout->u.chunk.u.farray.addr = HADDR_UNDEF; + layout->u.chunk.u.farray.fa = NULL; + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_idx_reset() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_dump + * + * Purpose: Dump indexing information to a stream. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_dump(const H5D_chk_idx_info_t *idx_info, FILE *stream) +{ + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_farray_idx_dump) + + /* Check args */ + HDassert(idx_info); + HDassert(idx_info->f); + HDassert(idx_info->layout); + HDassert(stream); + + HDfprintf(stream, " Address: %a\n", idx_info->layout->u.chunk.u.farray.addr); + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5D_farray_idx_dump() */ + + +/*------------------------------------------------------------------------- + * Function: H5D_farray_idx_dest + * + * Purpose: Release indexing information in memory. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Vailin Choi + * Thursday, April 30, 2009 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5D_farray_idx_dest(const H5D_chk_idx_info_t *idx_info) +{ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_farray_idx_dest) + + /* Check args */ + HDassert(idx_info); + HDassert(idx_info->f); + HDassert(idx_info->layout); + + /* Check if the fixed array is open */ + if(idx_info->layout->u.chunk.u.farray.fa) { + if(H5FA_close(idx_info->layout->u.chunk.u.farray.fa, idx_info->dxpl_id) < 0) + HGOTO_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to close fixed array") + idx_info->layout->u.chunk.u.farray.fa = NULL; + } /* end if */ + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_farray_idx_dest() */ + diff --git a/src/H5Dint.c b/src/H5Dint.c index 001b48a..1fddd01 100644 --- a/src/H5Dint.c +++ b/src/H5Dint.c @@ -735,6 +735,10 @@ H5D_set_io_ops(H5D_t *dataset) dataset->shared->layout.u.chunk.ops = H5D_COPS_EARRAY; break; + case H5D_CHUNK_IDX_FARRAY: + dataset->shared->layout.u.chunk.ops = H5D_COPS_FARRAY; + break; + default: HDassert(0 && "Unknown chunk index method!"); HGOTO_ERROR(H5E_DATASET, H5E_UNSUPPORTED, FAIL, "unknown chunk index method") diff --git a/src/H5Dpkg.h b/src/H5Dpkg.h index cc26afb..1188d36 100644 --- a/src/H5Dpkg.h +++ b/src/H5Dpkg.h @@ -524,6 +524,7 @@ H5_DLLVAR const H5D_layout_ops_t H5D_LOPS_CHUNK[1]; /* Chunked layout operations */ H5_DLLVAR const H5D_chunk_ops_t H5D_COPS_BTREE[1]; H5_DLLVAR const H5D_chunk_ops_t H5D_COPS_EARRAY[1]; +H5_DLLVAR const H5D_chunk_ops_t H5D_COPS_FARRAY[1]; /******************************/ diff --git a/src/H5Dpublic.h b/src/H5Dpublic.h index 79f0bc4..1eaa705 100644 --- a/src/H5Dpublic.h +++ b/src/H5Dpublic.h @@ -51,7 +51,9 @@ typedef enum H5D_layout_t { /* Types of chunk index data structures */ typedef enum H5D_chunk_index_t { H5D_CHUNK_IDX_BTREE = 0, /* v1 B-tree index (default) */ - H5D_CHUNK_IDX_EARRAY /* Extensible array (for 1 unlimited dim) */ + H5D_CHUNK_IDX_EARRAY = 1, /* Extensible array (for 1 unlimited dim) */ + H5D_CHUNK_IDX_FARRAY = 2, /* Fixed array (for 0 unlimited dims) */ + H5D_CHUNK_IDX_NTYPES /*this one must be last! */ } H5D_chunk_index_t; /* Values for the space allocation time property */ diff --git a/src/H5Olayout.c b/src/H5Olayout.c index 718e63b..83b8469 100644 --- a/src/H5Olayout.c +++ b/src/H5Olayout.c @@ -257,7 +257,7 @@ H5O_layout_decode(H5F_t *f, hid_t UNUSED dxpl_id, H5O_t UNUSED *open_oh, /* Chunk index type */ mesg->u.chunk.idx_type = *p++; - if(mesg->u.chunk.idx_type > H5D_CHUNK_IDX_EARRAY) + if(mesg->u.chunk.idx_type >= H5D_CHUNK_IDX_NTYPES) HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "unknown chunk index type") switch(mesg->u.chunk.idx_type) { @@ -277,6 +277,14 @@ H5O_layout_decode(H5F_t *f, hid_t UNUSED dxpl_id, H5O_t UNUSED *open_oh, mesg->u.chunk.ops = H5D_COPS_EARRAY; break; + case H5D_CHUNK_IDX_FARRAY: + /* Fixed Array Header address */ + H5F_addr_decode(f, &p, &(mesg->u.chunk.u.farray.addr)); + + /* Set the chunk operations */ + mesg->u.chunk.ops = H5D_COPS_FARRAY; + break; + default: HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "Invalid chunk index type") } /* end switch */ @@ -419,6 +427,11 @@ H5O_layout_encode(H5F_t *f, hbool_t UNUSED disable_shared, uint8_t *p, const voi H5F_addr_encode(f, &p, mesg->u.chunk.u.earray.addr); break; + case H5D_CHUNK_IDX_FARRAY: + /* Fixed Array Header address */ + H5F_addr_encode(f, &p, mesg->u.chunk.u.farray.addr); + break; + default: HGOTO_ERROR(H5E_OHDR, H5E_CANTENCODE, FAIL, "Invalid chunk index type") } /* end switch */ @@ -833,6 +846,13 @@ H5O_layout_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *_mesg, "Extensible Array address:", mesg->u.chunk.u.earray.addr); break; + case H5D_CHUNK_IDX_FARRAY: + HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth, + "Index Type:", "Fixed Array"); + HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth, + "Fixed Array address:", mesg->u.chunk.u.farray.addr); + break; + default: HDfprintf(stream, "%*s%-*s %s (%u)\n", indent, "", fwidth, "Index Type:", "Unknown", (unsigned)mesg->u.chunk.idx_type); @@ -946,6 +966,11 @@ H5O_layout_meta_size(const H5F_t *f, const void *_mesg) ret_value += H5F_SIZEOF_ADDR(f); /* Address of data */ break; + case H5D_CHUNK_IDX_FARRAY: + /* Fixed Array address */ + ret_value += H5F_SIZEOF_ADDR(f); /* Address of data */ + break; + default: HGOTO_ERROR(H5E_OHDR, H5E_CANTENCODE, 0, "Invalid chunk index type") } /* end switch */ @@ -995,12 +1020,14 @@ H5O_layout_set_latest_version(H5O_layout_t *layout, const H5S_t *space) /* Avoid scalar/null dataspace */ if(ndims > 0) { - hsize_t max_dims[H5O_LAYOUT_NDIMS]; /* Current dimension sizes */ + hsize_t max_dims[H5O_LAYOUT_NDIMS]; /* Maximum dimension sizes */ + hsize_t curr_dims[H5O_LAYOUT_NDIMS]; /* Current dimension sizes */ unsigned unlim_count; /* Count of unlimited max. dimensions */ + hbool_t fixed = FALSE; /* Fixed dimension or not */ unsigned u; /* Local index variable */ /* Query the dataspace's dimensions */ - if(H5S_get_simple_extent_dims(space, NULL, max_dims) < 0) + if(H5S_get_simple_extent_dims(space, curr_dims, max_dims) < 0) HGOTO_ERROR(H5E_OHDR, H5E_CANTGET, FAIL, "can't get dataspace max. dimensions") /* Spin through the max. dimensions, looking for unlimited dimensions */ @@ -1009,6 +1036,16 @@ H5O_layout_set_latest_version(H5O_layout_t *layout, const H5S_t *space) if(max_dims[u] == H5S_UNLIMITED) unlim_count++; + /* Check if it is fixed dimension */ + if(0 == unlim_count) { + fixed = TRUE; + for(u = 0; u < ndims; u++) + if(curr_dims[u] != max_dims[u]) { + fixed = FALSE; + break; + } /* end if */ + } /* end if */ + /* If we have only 1 unlimited dimension, we can use extensible array index */ if(1 == unlim_count) { /* Check for rank == 1 (>1 unsupported currently) */ @@ -1017,6 +1054,11 @@ H5O_layout_set_latest_version(H5O_layout_t *layout, const H5S_t *space) layout->u.chunk.idx_type = H5D_CHUNK_IDX_EARRAY; } /* end if */ } /* end if */ + /* Chunked datasets with fixed dimensions */ + else if(layout->type == H5D_CHUNKED && fixed) { + /* Set the chunk index type */ + layout->u.chunk.idx_type = H5D_CHUNK_IDX_FARRAY; + } /* end if */ } /* end if */ done: diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h index 4adb2f4..c2b7cca 100644 --- a/src/H5Oprivate.h +++ b/src/H5Oprivate.h @@ -371,6 +371,14 @@ typedef struct H5O_layout_chunk_earray_t { struct H5EA_t *ea; /* Pointer to extensible array struct */ } H5O_layout_chunk_earray_t; +/* Forward declaration of structs used below */ +struct H5FA_t; /* Defined in H5FAprivate.h */ + +typedef struct H5O_layout_chunk_farray_t { + haddr_t addr; /* File address of fixed index array */ + struct H5FA_t *fa; /* Pointer to fixed index array struct */ +} H5O_layout_chunk_farray_t; + typedef struct H5O_layout_chunk_t { H5D_chunk_index_t idx_type; /* Type of chunk index */ unsigned ndims; /* Num dimensions in chunk */ @@ -384,6 +392,7 @@ typedef struct H5O_layout_chunk_t { union { H5O_layout_chunk_btree_t btree; /* Information for v1 B-tree index */ H5O_layout_chunk_earray_t earray; /* Information for extensible array index */ + H5O_layout_chunk_farray_t farray; /* Information for fixed array index */ } u; } H5O_layout_chunk_t; diff --git a/src/Makefile.am b/src/Makefile.am index 8678e8b..e83fba6 100755 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -47,8 +47,9 @@ libhdf5_la_SOURCES= H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \ H5B2.c H5B2cache.c H5B2dbg.c H5B2int.c H5B2stat.c H5B2test.c \ H5C.c H5CS.c \ H5D.c H5Dbtree.c H5Dchunk.c H5Dcompact.c H5Dcontig.c H5Ddbg.c \ - H5Ddeprec.c H5Dearray.c H5Defl.c H5Dfill.c H5Dint.c H5Dio.c \ - H5Dmpio.c H5Doh.c H5Dproxy.c H5Dscatgath.c H5Dselect.c H5Dtest.c \ + H5Ddeprec.c H5Dearray.c H5Defl.c H5Dfarray.c H5Dfill.c H5Dint.c \ + H5Dio.c H5Dmpio.c H5Doh.c H5Dproxy.c H5Dscatgath.c H5Dselect.c \ + H5Dtest.c \ H5E.c H5Edeprec.c H5Eint.c \ H5EA.c H5EAcache.c H5EAdbg.c H5EAdblkpage.c H5EAdblock.c H5EAhdr.c \ H5EAiblock.c H5EAint.c H5EAsblock.c H5EAstat.c H5EAtest.c \ diff --git a/src/Makefile.in b/src/Makefile.in index 727902c..93559bb 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -84,7 +84,7 @@ am_libhdf5_la_OBJECTS = H5.lo H5checksum.lo H5dbg.lo H5system.lo \ H5Bdbg.lo H5B2.lo H5B2cache.lo H5B2dbg.lo H5B2int.lo \ H5B2stat.lo H5B2test.lo H5C.lo H5CS.lo H5D.lo H5Dbtree.lo \ H5Dchunk.lo H5Dcompact.lo H5Dcontig.lo H5Ddbg.lo H5Ddeprec.lo \ - H5Dearray.lo H5Defl.lo H5Dfill.lo H5Dint.lo \ + H5Dearray.lo H5Dfarray.lo H5Defl.lo H5Dfill.lo H5Dint.lo \ H5Dio.lo H5Dmpio.lo H5Doh.lo H5Dproxy.lo H5Dscatgath.lo H5Dselect.lo \ H5Dtest.lo H5E.lo H5Edeprec.lo H5Eint.lo H5EA.lo H5EAcache.lo \ H5EAdbg.lo H5EAdblkpage.lo H5EAdblock.lo H5EAhdr.lo \ @@ -433,7 +433,7 @@ libhdf5_la_SOURCES = H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \ H5B2.c H5B2cache.c H5B2dbg.c H5B2int.c H5B2stat.c H5B2test.c \ H5C.c H5CS.c \ H5D.c H5Dbtree.c H5Dchunk.c H5Dcompact.c H5Dcontig.c H5Ddbg.c \ - H5Ddeprec.c H5Dearray.c H5Defl.c H5Dfill.c H5Dint.c H5Dio.c \ + H5Ddeprec.c H5Dearray.c H5Dfarray.c H5Defl.c H5Dfill.c H5Dint.c H5Dio.c \ H5Dmpio.c H5Doh.c H5Dproxy.c H5Dscatgath.c H5Dselect.c H5Dtest.c \ H5E.c H5Edeprec.c H5Eint.c \ H5EA.c H5EAcache.c H5EAdbg.c H5EAdblkpage.c H5EAdblock.c H5EAhdr.c \ @@ -647,6 +647,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Ddeprec.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dearray.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Defl.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dfarray.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dfill.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dint.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dio.Plo@am__quote@ |