diff options
Diffstat (limited to 'src')
40 files changed, 2354 insertions, 853 deletions
diff --git a/src/H5Apkg.h b/src/H5Apkg.h index 976340d..753ad64 100644 --- a/src/H5Apkg.h +++ b/src/H5Apkg.h @@ -38,6 +38,7 @@ #include "H5Aprivate.h" /* Other private headers needed by this file */ +#include "H5FLprivate.h" /* Free Lists */ #include "H5Sprivate.h" /* Dataspace */ #include "H5Tprivate.h" /* Datatype functions */ @@ -54,6 +55,12 @@ struct H5A_t { size_t data_size; /* Size of data on disk */ }; +/* Declare extern the free list for H5A_t's */ +H5FL_EXTERN(H5A_t); + +/* Declare extern a free list to manage blocks of type conversion data */ +H5FL_BLK_EXTERN(attr_buf); + /* Function prototypes for H5A package scope */ H5_DLL H5A_t *H5A_copy(H5A_t *new_attr, const H5A_t *old_attr, unsigned update_flags); H5_DLL herr_t H5A_free(H5A_t *attr); @@ -14,7 +14,7 @@ /*------------------------------------------------------------------------- * - * Created: hdf5btree.c + * Created: H5B.c * Jul 10 1997 * Robb Matzke <matzke@llnl.gov> * @@ -89,41 +89,47 @@ * that type of B-tree. * * - * Modifications: - * - * Robb Matzke, 4 Aug 1997 - * Added calls to H5E. - * *------------------------------------------------------------------------- */ +/****************/ +/* Module Setup */ +/****************/ + #define H5B_PACKAGE /*suppress error about including H5Bpkg */ #define H5F_PACKAGE /*suppress error about including H5Fpkg */ -/* private headers */ +/***********/ +/* Headers */ +/***********/ #include "H5private.h" /* Generic Functions */ #include "H5ACprivate.h" /* Metadata cache */ #include "H5Bpkg.h" /* B-link trees */ #include "H5Dprivate.h" /* Datasets */ #include "H5Eprivate.h" /* Error handling */ #include "H5Fpkg.h" /* File access */ -#include "H5FLprivate.h" /* Free Lists */ #include "H5Iprivate.h" /* IDs */ #include "H5MFprivate.h" /* File memory management */ #include "H5MMprivate.h" /* Memory management */ #include "H5Pprivate.h" /* Property lists */ -/* Local macros */ +/****************/ +/* Local Macros */ +/****************/ #define H5B_SIZEOF_HDR(F) \ (H5B_SIZEOF_MAGIC + /*magic number */ \ 4 + /*type, level, num entries */ \ 2*H5F_SIZEOF_ADDR(F)) /*left and right sibling addresses */ #define H5B_NKEY(b,shared,idx) ((b)->native+(shared)->nkey[(idx)]) -/* Local typedefs */ +/******************/ +/* Local Typedefs */ +/******************/ -/* PRIVATE PROTOTYPES */ +/********************/ +/* Local Prototypes */ +/********************/ static H5B_ins_t H5B_insert_helper(H5F_t *f, hid_t dxpl_id, haddr_t addr, const H5B_class_t *type, uint8_t *lt_key, @@ -139,40 +145,34 @@ static herr_t H5B_split(H5F_t *f, hid_t dxpl_id, H5B_t *old_bt, unsigned *old_bt_flags, haddr_t old_addr, unsigned idx, void *udata, haddr_t *new_addr/*out*/); static H5B_t * H5B_copy(const H5B_t *old_bt); -static herr_t H5B_serialize(const H5F_t *f, const H5B_t *bt); #ifdef H5B_DEBUG static herr_t H5B_assert(H5F_t *f, hid_t dxpl_id, haddr_t addr, const H5B_class_t *type, void *udata); #endif -/* Metadata cache callbacks */ -static H5B_t *H5B_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_type, void *udata); -static herr_t H5B_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5B_t *b); -static herr_t H5B_dest(H5F_t *f, H5B_t *b); -static herr_t H5B_clear(H5F_t *f, H5B_t *b, hbool_t destroy); -static herr_t H5B_compute_size(const H5F_t *f, const H5B_t *bt, size_t *size_ptr); - -/* H5B inherits cache-like properties from H5AC */ -static const H5AC_class_t H5AC_BT[1] = {{ - H5AC_BT_ID, - (H5AC_load_func_t)H5B_load, - (H5AC_flush_func_t)H5B_flush, - (H5AC_dest_func_t)H5B_dest, - (H5AC_clear_func_t)H5B_clear, - (H5AC_size_func_t)H5B_compute_size, -}}; +/*********************/ +/* Package Variables */ +/*********************/ + +/* Declare a free list to manage the haddr_t sequence information */ +H5FL_SEQ_DEFINE(haddr_t); /* Declare a PQ free list to manage the native block information */ -H5FL_BLK_DEFINE_STATIC(native_block); +H5FL_BLK_DEFINE(native_block); -/* Declare a free list to manage the haddr_t sequence information */ -H5FL_SEQ_DEFINE_STATIC(haddr_t); +/* Declare a free list to manage the H5B_t struct */ +H5FL_DEFINE(H5B_t); + +/*****************************/ +/* Library Private Variables */ +/*****************************/ /* Declare a free list to manage the H5B_shared_t struct */ H5FL_DEFINE(H5B_shared_t); -/* Declare a free list to manage the H5B_t struct */ -H5FL_DEFINE_STATIC(H5B_t); +/*******************/ +/* Local Variables */ +/*******************/ /*------------------------------------------------------------------------- @@ -263,377 +263,7 @@ done: } FUNC_LEAVE_NOAPI(ret_value) -} /*lint !e818 Can't make udata a pointer to const */ - - -/*------------------------------------------------------------------------- - * Function: H5B_load - * - * Purpose: Loads a B-tree node from the disk. - * - * Return: Success: Pointer to a new B-tree node. - * - * Failure: NULL - * - * Programmer: Robb Matzke - * matzke@llnl.gov - * Jun 23 1997 - * - * Modifications: - * Robb Matzke, 1999-07-28 - * The ADDR argument is passed by value. - * - * Quincey Koziol, 2002-7-180 - * Added dxpl parameter to allow more control over I/O from metadata - * cache. - *------------------------------------------------------------------------- - */ -static H5B_t * -H5B_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_type, void *udata) -{ - const H5B_class_t *type = (const H5B_class_t *) _type; - H5B_t *bt = NULL; - H5B_shared_t *shared; /* Pointer to shared B-tree info */ - uint8_t *p; /* Pointer into raw data buffer */ - uint8_t *native; /* Pointer to native keys */ - unsigned u; /* Local index variable */ - H5B_t *ret_value; - - FUNC_ENTER_NOAPI(H5B_load, NULL) - - /* Check arguments */ - assert(f); - assert(H5F_addr_defined(addr)); - assert(type); - assert(type->get_shared); - - if (NULL==(bt = H5FL_MALLOC(H5B_t))) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") - HDmemset(&bt->cache_info,0,sizeof(H5AC_info_t)); - if((bt->rc_shared=(type->get_shared)(f, udata))==NULL) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "can't retrieve B-tree node buffer") - shared=H5RC_GET_OBJ(bt->rc_shared); - HDassert(shared); - if (NULL==(bt->native=H5FL_BLK_MALLOC(native_block,shared->sizeof_keys)) || - NULL==(bt->child=H5FL_SEQ_MALLOC(haddr_t,(size_t)shared->two_k))) - HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") - - if (H5F_block_read(f, H5FD_MEM_BTREE, addr, shared->sizeof_rnode, dxpl_id, shared->page)<0) - HGOTO_ERROR(H5E_BTREE, H5E_READERROR, NULL, "can't read B-tree node") - - p = shared->page; - - /* magic number */ - if (HDmemcmp(p, H5B_MAGIC, (size_t)H5B_SIZEOF_MAGIC)) - HGOTO_ERROR(H5E_BTREE, H5E_CANTLOAD, NULL, "wrong B-tree signature") - p += 4; - - /* node type and level */ - if (*p++ != (uint8_t)type->id) - HGOTO_ERROR(H5E_BTREE, H5E_CANTLOAD, NULL, "incorrect B-tree node type") - bt->level = *p++; - - /* entries used */ - UINT16DECODE(p, bt->nchildren); - - /* sibling pointers */ - H5F_addr_decode(f, (const uint8_t **) &p, &(bt->left)); - H5F_addr_decode(f, (const uint8_t **) &p, &(bt->right)); - - /* the child/key pairs */ - native=bt->native; - for (u = 0; u < bt->nchildren; u++) { - /* Decode native key value */ - if ((type->decode) (f, bt, p, native) < 0) - HGOTO_ERROR(H5E_BTREE, H5E_CANTDECODE, NULL, "unable to decode key") - p += shared->sizeof_rkey; - native += type->sizeof_nkey; - - /* Decode address value */ - H5F_addr_decode(f, (const uint8_t **) &p, bt->child + u); - } - - /* Decode final key */ - if(bt->nchildren>0) { - /* Decode native key value */ - if ((type->decode) (f, bt, p, native) < 0) - HGOTO_ERROR(H5E_BTREE, H5E_CANTDECODE, NULL, "unable to decode key") - } /* end if */ - - /* Set return value */ - ret_value = bt; - -done: - if (!ret_value && bt) - (void)H5B_dest(f,bt); - FUNC_LEAVE_NOAPI(ret_value) -} /*lint !e818 Can't make udata a pointer to const */ - - -/*------------------------------------------------------------------------- - * Function: H5B_serialize - * - * Purpose: Serialize the data structure for writing to disk or - * storing on the SAP (for FPHDF5). - * - * Return: Success: SUCCEED - * Failure: FAIL - * - * Programmer: Bill Wendling - * wendling@ncsa.uiuc.edu - * Sept. 15, 2003 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -static herr_t -H5B_serialize(const H5F_t *f, const H5B_t *bt) -{ - H5B_shared_t *shared=NULL; /* Pointer to shared B-tree info */ - unsigned u; - uint8_t *p; /* Pointer into raw data buffer */ - uint8_t *native; /* Pointer to native keys */ - herr_t ret_value = SUCCEED; /* Return value */ - - FUNC_ENTER_NOAPI(H5B_serialize, FAIL) - - /* check arguments */ - assert(f); - assert(bt); - assert(bt->rc_shared); - shared=H5RC_GET_OBJ(bt->rc_shared); - HDassert(shared); - - p = shared->page; - - /* magic number */ - HDmemcpy(p, H5B_MAGIC, (size_t)H5B_SIZEOF_MAGIC); - p += 4; - - /* node type and level */ - *p++ = (uint8_t)shared->type->id; - H5_CHECK_OVERFLOW(bt->level, unsigned, uint8_t); - *p++ = (uint8_t)bt->level; - - /* entries used */ - UINT16ENCODE(p, bt->nchildren); - - /* sibling pointers */ - H5F_addr_encode(f, &p, bt->left); - H5F_addr_encode(f, &p, bt->right); - - /* child keys and pointers */ - native=bt->native; - for (u = 0; u < bt->nchildren; ++u) { - /* encode the key */ - if (shared->type->encode(f, bt, p, native) < 0) - HGOTO_ERROR(H5E_BTREE, H5E_CANTENCODE, FAIL, "unable to encode B-tree key") - p += shared->sizeof_rkey; - native += shared->type->sizeof_nkey; - - /* encode the child address */ - H5F_addr_encode(f, &p, bt->child[u]); - } /* end for */ - if(bt->nchildren>0) { - /* Encode the final key */ - if (shared->type->encode(f, bt, p, native) < 0) - HGOTO_ERROR(H5E_BTREE, H5E_CANTENCODE, FAIL, "unable to encode B-tree key") - } /* end if */ - -done: - FUNC_LEAVE_NOAPI(ret_value) -} - - -/*------------------------------------------------------------------------- - * Function: H5B_flush - * - * Purpose: Flushes a dirty B-tree node to disk. - * - * Return: Non-negative on success/Negative on failure - * - * Programmer: Robb Matzke - * matzke@llnl.gov - * Jun 23 1997 - * - * Modifications: - * rky 980828 - * Only p0 writes metadata to disk. - * - * Robb Matzke, 1999-07-28 - * The ADDR argument is passed by value. - * - * Quincey Koziol, 2002-7-180 - * Added dxpl parameter to allow more control over I/O from metadata - * cache. - * - * Bill Wendling, 2003-09-15 - * Separated out the bit of code that serializes the B-Tree - * structure. - * - *------------------------------------------------------------------------- - */ -static herr_t -H5B_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5B_t *bt) -{ - H5B_shared_t *shared; /* Pointer to shared B-tree info */ - herr_t ret_value = SUCCEED; /* Return value */ - - FUNC_ENTER_NOAPI(H5B_flush, FAIL) - - /* check arguments */ - assert(f); - assert(H5F_addr_defined(addr)); - assert(bt); - shared=H5RC_GET_OBJ(bt->rc_shared); - HDassert(shared); - assert(shared->type); - assert(shared->type->encode); - - if (bt->cache_info.is_dirty) { - if (H5B_serialize(f, bt) < 0) - HGOTO_ERROR(H5E_BTREE, H5E_CANTSERIALIZE, FAIL, "unable to serialize B-tree") - - /* - * Write the disk page. We always write the header, but we don't - * bother writing data for the child entries that don't exist or - * for the final unchanged children. - */ - if (H5F_block_write(f, H5FD_MEM_BTREE, addr, shared->sizeof_rnode, dxpl_id, shared->page) < 0) - HGOTO_ERROR(H5E_BTREE, H5E_CANTFLUSH, FAIL, "unable to save B-tree node to disk") - - bt->cache_info.is_dirty = FALSE; - } /* end if */ - - if (destroy) - if (H5B_dest(f,bt) < 0) - HGOTO_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to destroy B-tree node") - -done: - FUNC_LEAVE_NOAPI(ret_value) -} - - -/*------------------------------------------------------------------------- - * Function: H5B_dest - * - * Purpose: Destroys a B-tree node in memory. - * - * Return: Non-negative on success/Negative on failure - * - * Programmer: Quincey Koziol - * koziol@ncsa.uiuc.edu - * Jan 15 2003 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -/* ARGSUSED */ -static herr_t -H5B_dest(H5F_t UNUSED *f, H5B_t *bt) -{ - FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5B_dest) - - /* - * Check arguments. - */ - assert(bt); - assert(bt->rc_shared); - - H5FL_SEQ_FREE(haddr_t,bt->child); - H5FL_BLK_FREE(native_block,bt->native); - H5RC_DEC(bt->rc_shared); - H5FL_FREE(H5B_t,bt); - - FUNC_LEAVE_NOAPI(SUCCEED) -} /* end H5B_dest() */ - - -/*------------------------------------------------------------------------- - * Function: H5B_clear - * - * Purpose: Mark a B-tree node in memory as non-dirty. - * - * Return: Non-negative on success/Negative on failure - * - * Programmer: Quincey Koziol - * koziol@ncsa.uiuc.edu - * Mar 20 2003 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -static herr_t -H5B_clear(H5F_t *f, H5B_t *bt, hbool_t destroy) -{ - herr_t ret_value = SUCCEED; - - FUNC_ENTER_NOAPI_NOINIT(H5B_clear) - - /* - * Check arguments. - */ - assert(bt); - - /* Reset the dirty flag. */ - bt->cache_info.is_dirty = FALSE; - - if (destroy) - if (H5B_dest(f, bt) < 0) - HGOTO_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to destroy B-tree node") - -done: - FUNC_LEAVE_NOAPI(ret_value) -} /* end H5B_clear() */ - - -/*------------------------------------------------------------------------- - * Function: H5B_compute_size - * - * Purpose: Compute the size in bytes of the specified instance of - * H5B_t on disk, and return it in *len_ptr. On failure, - * the value of *len_ptr is undefined. - * - * Return: Non-negative on success/Negative on failure - * - * Programmer: John Mainzer - * 5/13/04 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -static herr_t -H5B_compute_size(const H5F_t *f, const H5B_t *bt, size_t *size_ptr) -{ - H5B_shared_t *shared; /* Pointer to shared B-tree info */ - size_t size; - herr_t ret_value = SUCCEED; /* Return value */ - - FUNC_ENTER_NOAPI_NOINIT(H5B_compute_size) - - /* check arguments */ - HDassert(f); - HDassert(bt); - HDassert(bt->rc_shared); - shared=H5RC_GET_OBJ(bt->rc_shared); - HDassert(shared); - HDassert(shared->type); - HDassert(size_ptr); - - /* Check node's size */ - if ((size = H5B_nodesize(f, shared, NULL)) == 0) - HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGETSIZE, FAIL, "H5B_nodesize() failed") - - /* Set size value */ - *size_ptr = size; - -done: - FUNC_LEAVE_NOAPI(ret_value) -} /* H5B_H5B_compute_size() */ +} /* end H5B_create() */ /*lint !e818 Can't make udata a pointer to const */ /*------------------------------------------------------------------------- @@ -749,7 +379,7 @@ done: HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release node") FUNC_LEAVE_NOAPI(ret_value) -} +} /* end H5B_find() */ /*------------------------------------------------------------------------- @@ -934,7 +564,7 @@ done: HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree node") FUNC_LEAVE_NOAPI(ret_value) -} +} /* end H5B_split() */ /*------------------------------------------------------------------------- @@ -1106,7 +736,7 @@ H5B_insert(H5F_t *f, hid_t dxpl_id, const H5B_class_t *type, haddr_t addr, done: FUNC_LEAVE_NOAPI(ret_value) -} +} /* end H5B_insert() */ /*------------------------------------------------------------------------- @@ -28,15 +28,23 @@ *------------------------------------------------------------------------- */ +/****************/ +/* Module Setup */ +/****************/ + #define H5B2_PACKAGE /*suppress error about including H5B2pkg */ -/* Private headers */ +/***********/ +/* Headers */ +/***********/ #include "H5private.h" /* Generic Functions */ #include "H5B2pkg.h" /* v2 B-trees */ #include "H5Eprivate.h" /* Error handling */ #include "H5MFprivate.h" /* File memory management */ -/* Local macros */ +/****************/ +/* Local Macros */ +/****************/ /* Format overhead for each node (on disk) */ #define H5B2_OVERHEAD_SIZE (H5B2_SIZEOF_MAGIC+1) /* Signature + version # */ @@ -51,9 +59,13 @@ /* #define H5B2_DEBUG */ -/* Local typedefs */ +/******************/ +/* Local Typedefs */ +/******************/ -/* Local prototypes */ +/********************/ +/* Local Prototypes */ +/********************/ /* Helper functions */ static herr_t H5B2_create_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, @@ -113,7 +125,9 @@ static herr_t H5B2_assert_internal2(hsize_t parent_all_nrec, H5B2_shared_t *shar #endif /* H5B2_DEBUG */ -/* Package variables */ +/*********************/ +/* Package Variables */ +/*********************/ /* Declare a free list to manage the H5B2_t struct */ H5FL_DEFINE(H5B2_t); @@ -124,8 +138,13 @@ H5FL_DEFINE(H5B2_internal_t); /* Declare a free list to manage the H5B2_leaf_t struct */ H5FL_DEFINE(H5B2_leaf_t); +/*****************************/ +/* Library Private Variables */ +/*****************************/ -/* Static variables */ +/*******************/ +/* Local Variables */ +/*******************/ /* Declare a free list to manage B-tree node pages to/from disk */ H5FL_BLK_DEFINE_STATIC(node_page); diff --git a/src/H5B2private.h b/src/H5B2private.h index 3be4413..850eb50 100644 --- a/src/H5B2private.h +++ b/src/H5B2private.h @@ -96,6 +96,10 @@ typedef struct H5B2_class_t { } H5B2_class_t; +/*****************************/ +/* Library-private Variables */ +/*****************************/ + /***************************************/ /* Library-private Function Prototypes */ /***************************************/ diff --git a/src/H5BPcache.c b/src/H5BPcache.c index 57e1677..4580c38 100644 --- a/src/H5BPcache.c +++ b/src/H5BPcache.c @@ -551,7 +551,7 @@ H5BP_cache_leaf_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5 /* Encode the record */ if((shared->type->encode)(f, leaf->rec_ptr[u], p, &rec_len) < 0) - HGOTO_ERROR(H5E_BTREE, H5E_CANTENCODE, NULL, "can't encode B+ tree record") + HGOTO_ERROR(H5E_BTREE, H5E_CANTENCODE, FAIL, "can't encode B+ tree record") assert(rec_len > 0); p += rec_len; @@ -561,7 +561,7 @@ H5BP_cache_leaf_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5 } /* end if */ else { HDfprintf(stderr,"%s: attempting to decode fixed-size records from leaf node\n",FUNC); -HGOTO_ERROR(H5E_BTREE, H5E_UNSUPPORTED, NULL, "Can't decode records yet!") +HGOTO_ERROR(H5E_BTREE, H5E_UNSUPPORTED, FAIL, "Can't decode records yet!") } /* end else */ #ifdef LATER diff --git a/src/H5Bcache.c b/src/H5Bcache.c new file mode 100644 index 0000000..443b482 --- /dev/null +++ b/src/H5Bcache.c @@ -0,0 +1,417 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * 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://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have * + * access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +/*------------------------------------------------------------------------- + * + * Created: H5Bcache.c + * Oct 31 2005 + * Quincey Koziol <koziol@ncsa.uiuc.edu> + * + * Purpose: Implement B-tree metadata cache methods. + * + *------------------------------------------------------------------------- + */ + +/****************/ +/* Module Setup */ +/****************/ + +#define H5B_PACKAGE /*suppress error about including H5Bpkg */ + + +/***********/ +/* Headers */ +/***********/ +#include "H5private.h" /* Generic Functions */ +#include "H5Bpkg.h" /* B-link trees */ +#include "H5Eprivate.h" /* Error handling */ + +/****************/ +/* Local Macros */ +/****************/ + +/******************/ +/* Local Typedefs */ +/******************/ + +/********************/ +/* Local Prototypes */ +/********************/ + +/* General routines */ +static herr_t H5B_serialize(const H5F_t *f, const H5B_t *bt); + +/* Metadata cache callbacks */ +static H5B_t *H5B_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_type, void *udata); +static herr_t H5B_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5B_t *b); +static herr_t H5B_clear(H5F_t *f, H5B_t *b, hbool_t destroy); +static herr_t H5B_compute_size(const H5F_t *f, const H5B_t *bt, size_t *size_ptr); + +/*********************/ +/* Package Variables */ +/*********************/ + +/* H5B inherits cache-like properties from H5AC */ +const H5AC_class_t H5AC_BT[1] = {{ + H5AC_BT_ID, + (H5AC_load_func_t)H5B_load, + (H5AC_flush_func_t)H5B_flush, + (H5AC_dest_func_t)H5B_dest, + (H5AC_clear_func_t)H5B_clear, + (H5AC_size_func_t)H5B_compute_size, +}}; + +/*******************/ +/* Local Variables */ +/*******************/ + + +/*------------------------------------------------------------------------- + * Function: H5B_serialize + * + * Purpose: Serialize the data structure for writing to disk or + * storing on the SAP (for FPHDF5). + * + * Return: Success: SUCCEED + * Failure: FAIL + * + * Programmer: Bill Wendling + * wendling@ncsa.uiuc.edu + * Sept. 15, 2003 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5B_serialize(const H5F_t *f, const H5B_t *bt) +{ + H5B_shared_t *shared=NULL; /* Pointer to shared B-tree info */ + unsigned u; + uint8_t *p; /* Pointer into raw data buffer */ + uint8_t *native; /* Pointer to native keys */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(H5B_serialize, FAIL) + + /* check arguments */ + HDassert(f); + HDassert(bt); + HDassert(bt->rc_shared); + shared=H5RC_GET_OBJ(bt->rc_shared); + HDassert(shared); + + p = shared->page; + + /* magic number */ + HDmemcpy(p, H5B_MAGIC, (size_t)H5B_SIZEOF_MAGIC); + p += 4; + + /* node type and level */ + *p++ = (uint8_t)shared->type->id; + H5_CHECK_OVERFLOW(bt->level, unsigned, uint8_t); + *p++ = (uint8_t)bt->level; + + /* entries used */ + UINT16ENCODE(p, bt->nchildren); + + /* sibling pointers */ + H5F_addr_encode(f, &p, bt->left); + H5F_addr_encode(f, &p, bt->right); + + /* child keys and pointers */ + native=bt->native; + for (u = 0; u < bt->nchildren; ++u) { + /* encode the key */ + if (shared->type->encode(f, bt, p, native) < 0) + HGOTO_ERROR(H5E_BTREE, H5E_CANTENCODE, FAIL, "unable to encode B-tree key") + p += shared->sizeof_rkey; + native += shared->type->sizeof_nkey; + + /* encode the child address */ + H5F_addr_encode(f, &p, bt->child[u]); + } /* end for */ + if(bt->nchildren>0) { + /* Encode the final key */ + if (shared->type->encode(f, bt, p, native) < 0) + HGOTO_ERROR(H5E_BTREE, H5E_CANTENCODE, FAIL, "unable to encode B-tree key") + } /* end if */ + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5B_serialize() */ + + +/*------------------------------------------------------------------------- + * Function: H5B_load + * + * Purpose: Loads a B-tree node from the disk. + * + * Return: Success: Pointer to a new B-tree node. + * + * Failure: NULL + * + * Programmer: Robb Matzke + * matzke@llnl.gov + * Jun 23 1997 + * + *------------------------------------------------------------------------- + */ +static H5B_t * +H5B_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_type, void *udata) +{ + const H5B_class_t *type = (const H5B_class_t *) _type; + H5B_t *bt = NULL; + H5B_shared_t *shared; /* Pointer to shared B-tree info */ + uint8_t *p; /* Pointer into raw data buffer */ + uint8_t *native; /* Pointer to native keys */ + unsigned u; /* Local index variable */ + H5B_t *ret_value; + + FUNC_ENTER_NOAPI(H5B_load, NULL) + + /* Check arguments */ + HDassert(f); + HDassert(H5F_addr_defined(addr)); + HDassert(type); + HDassert(type->get_shared); + + if (NULL==(bt = H5FL_MALLOC(H5B_t))) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + HDmemset(&bt->cache_info,0,sizeof(H5AC_info_t)); + if((bt->rc_shared=(type->get_shared)(f, udata))==NULL) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "can't retrieve B-tree node buffer") + shared=H5RC_GET_OBJ(bt->rc_shared); + HDassert(shared); + if (NULL==(bt->native=H5FL_BLK_MALLOC(native_block,shared->sizeof_keys)) || + NULL==(bt->child=H5FL_SEQ_MALLOC(haddr_t,(size_t)shared->two_k))) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + if (H5F_block_read(f, H5FD_MEM_BTREE, addr, shared->sizeof_rnode, dxpl_id, shared->page)<0) + HGOTO_ERROR(H5E_BTREE, H5E_READERROR, NULL, "can't read B-tree node") + + p = shared->page; + + /* magic number */ + if (HDmemcmp(p, H5B_MAGIC, (size_t)H5B_SIZEOF_MAGIC)) + HGOTO_ERROR(H5E_BTREE, H5E_CANTLOAD, NULL, "wrong B-tree signature") + p += 4; + + /* node type and level */ + if (*p++ != (uint8_t)type->id) + HGOTO_ERROR(H5E_BTREE, H5E_CANTLOAD, NULL, "incorrect B-tree node type") + bt->level = *p++; + + /* entries used */ + UINT16DECODE(p, bt->nchildren); + + /* sibling pointers */ + H5F_addr_decode(f, (const uint8_t **) &p, &(bt->left)); + H5F_addr_decode(f, (const uint8_t **) &p, &(bt->right)); + + /* the child/key pairs */ + native=bt->native; + for (u = 0; u < bt->nchildren; u++) { + /* Decode native key value */ + if ((type->decode) (f, bt, p, native) < 0) + HGOTO_ERROR(H5E_BTREE, H5E_CANTDECODE, NULL, "unable to decode key") + p += shared->sizeof_rkey; + native += type->sizeof_nkey; + + /* Decode address value */ + H5F_addr_decode(f, (const uint8_t **) &p, bt->child + u); + } + + /* Decode final key */ + if(bt->nchildren>0) { + /* Decode native key value */ + if ((type->decode) (f, bt, p, native) < 0) + HGOTO_ERROR(H5E_BTREE, H5E_CANTDECODE, NULL, "unable to decode key") + } /* end if */ + + /* Set return value */ + ret_value = bt; + +done: + if (!ret_value && bt) + (void)H5B_dest(f,bt); + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5B_load() */ /*lint !e818 Can't make udata a pointer to const */ + + +/*------------------------------------------------------------------------- + * Function: H5B_flush + * + * Purpose: Flushes a dirty B-tree node to disk. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Robb Matzke + * matzke@llnl.gov + * Jun 23 1997 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5B_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5B_t *bt) +{ + H5B_shared_t *shared; /* Pointer to shared B-tree info */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(H5B_flush, FAIL) + + /* check arguments */ + HDassert(f); + HDassert(H5F_addr_defined(addr)); + HDassert(bt); + shared=H5RC_GET_OBJ(bt->rc_shared); + HDassert(shared); + HDassert(shared->type); + HDassert(shared->type->encode); + + if (bt->cache_info.is_dirty) { + if (H5B_serialize(f, bt) < 0) + HGOTO_ERROR(H5E_BTREE, H5E_CANTSERIALIZE, FAIL, "unable to serialize B-tree") + + /* + * Write the disk page. We always write the header, but we don't + * bother writing data for the child entries that don't exist or + * for the final unchanged children. + */ + if (H5F_block_write(f, H5FD_MEM_BTREE, addr, shared->sizeof_rnode, dxpl_id, shared->page) < 0) + HGOTO_ERROR(H5E_BTREE, H5E_CANTFLUSH, FAIL, "unable to save B-tree node to disk") + + bt->cache_info.is_dirty = FALSE; + } /* end if */ + + if (destroy) + if (H5B_dest(f,bt) < 0) + HGOTO_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to destroy B-tree node") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5B_flush() */ + + +/*------------------------------------------------------------------------- + * Function: H5B_dest + * + * Purpose: Destroys a B-tree node in memory. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Quincey Koziol + * koziol@ncsa.uiuc.edu + * Jan 15 2003 + * + *------------------------------------------------------------------------- + */ +/* ARGSUSED */ +herr_t +H5B_dest(H5F_t UNUSED *f, H5B_t *bt) +{ + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5B_dest) + + /* + * Check arguments. + */ + HDassert(bt); + HDassert(bt->rc_shared); + + H5FL_SEQ_FREE(haddr_t,bt->child); + H5FL_BLK_FREE(native_block,bt->native); + H5RC_DEC(bt->rc_shared); + H5FL_FREE(H5B_t,bt); + + FUNC_LEAVE_NOAPI(SUCCEED) +} /* end H5B_dest() */ + + +/*------------------------------------------------------------------------- + * Function: H5B_clear + * + * Purpose: Mark a B-tree node in memory as non-dirty. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Quincey Koziol + * koziol@ncsa.uiuc.edu + * Mar 20 2003 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5B_clear(H5F_t *f, H5B_t *bt, hbool_t destroy) +{ + herr_t ret_value = SUCCEED; + + FUNC_ENTER_NOAPI_NOINIT(H5B_clear) + + /* + * Check arguments. + */ + HDassert(bt); + + /* Reset the dirty flag. */ + bt->cache_info.is_dirty = FALSE; + + if (destroy) + if (H5B_dest(f, bt) < 0) + HGOTO_ERROR(H5E_BTREE, H5E_CANTFREE, FAIL, "unable to destroy B-tree node") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5B_clear() */ + + +/*------------------------------------------------------------------------- + * Function: H5B_compute_size + * + * Purpose: Compute the size in bytes of the specified instance of + * H5B_t on disk, and return it in *len_ptr. On failure, + * the value of *len_ptr is undefined. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: John Mainzer + * 5/13/04 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5B_compute_size(const H5F_t *f, const H5B_t *bt, size_t *size_ptr) +{ + H5B_shared_t *shared; /* Pointer to shared B-tree info */ + size_t size; + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5B_compute_size) + + /* check arguments */ + HDassert(f); + HDassert(bt); + HDassert(bt->rc_shared); + shared=H5RC_GET_OBJ(bt->rc_shared); + HDassert(shared); + HDassert(shared->type); + HDassert(size_ptr); + + /* Check node's size */ + if ((size = H5B_nodesize(f, shared, NULL)) == 0) + HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGETSIZE, FAIL, "H5B_nodesize() failed") + + /* Set size value */ + *size_ptr = size; + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* H5B_compute_size() */ diff --git a/src/H5Bpkg.h b/src/H5Bpkg.h index 74fa393..e96161d 100644 --- a/src/H5Bpkg.h +++ b/src/H5Bpkg.h @@ -31,7 +31,7 @@ #include "H5Bprivate.h" /* Other private headers needed by this file */ -#include "H5RCprivate.h" /* Reference counted object functions */ +#include "H5RCprivate.h" /* Reference counted objects */ /**************************/ /* Package Private Macros */ @@ -41,9 +41,7 @@ /* Package Private Typedefs */ /****************************/ -/* - * The B-tree node as stored in memory... - */ +/* The B-tree node as stored in memory... */ struct H5B_t { H5AC_info_t cache_info; /* Information for H5AC cache functions, _must_ be */ /* first field in structure */ @@ -56,8 +54,25 @@ struct H5B_t { haddr_t *child; /*2k child pointers */ }; +/*****************************/ +/* Package Private Variables */ +/*****************************/ + +/* H5B header inherits cache-like properties from H5AC */ +H5_DLLVAR const H5AC_class_t H5AC_BT[1]; + +/* Declare a free list to manage the haddr_t sequence information */ +H5FL_SEQ_EXTERN(haddr_t); + +/* Declare a PQ free list to manage the native block information */ +H5FL_BLK_EXTERN(native_block); + +/* Declare a free list to manage the H5B_t struct */ +H5FL_EXTERN(H5B_t); + /******************************/ /* Package Private Prototypes */ /******************************/ +herr_t H5B_dest(H5F_t *f, H5B_t *b); #endif /*_H5Bpkg_H*/ diff --git a/src/H5Bprivate.h b/src/H5Bprivate.h index 28494f7..246d0c5 100644 --- a/src/H5Bprivate.h +++ b/src/H5Bprivate.h @@ -34,8 +34,13 @@ #include "H5private.h" /* Generic Functions */ #include "H5ACprivate.h" /* Metadata cache */ #include "H5Fprivate.h" /* File access */ +#include "H5FLprivate.h" /* Free Lists */ #include "H5RCprivate.h" /* Reference counted object functions */ +/**************************/ +/* Library Private Macros */ +/**************************/ + /* * Feature: Define this constant if you want to check B-tree consistency * after each B-tree operation. Note that this slows down the @@ -48,6 +53,19 @@ #define H5B_MAGIC "TREE" /*tree node magic number */ #define H5B_SIZEOF_MAGIC 4 /*size of magic number */ +/* Define return values from operator callback function for H5B_iterate */ +/* (Actually, any postive value will cause the iterator to stop and pass back + * that positive value to the function that called the iterator) + */ +#define H5B_ITER_ERROR (-1) +#define H5B_ITER_CONT (0) +#define H5B_ITER_STOP (1) + +/****************************/ +/* Library Private Typedefs */ +/****************************/ + +/* Define return values from B-tree insertion callbacks */ typedef enum H5B_ins_t { H5B_INS_ERROR = -1, /*error return value */ H5B_INS_NOOP = 0, /*insert made no changes */ @@ -58,14 +76,6 @@ typedef enum H5B_ins_t { H5B_INS_REMOVE = 5 /*remove current node */ } H5B_ins_t; -/* Define return values from operator callback function for H5B_iterate */ -/* (Actually, any postive value will cause the iterator to stop and pass back - * that positive value to the function that called the iterator) - */ -#define H5B_ITER_ERROR (-1) -#define H5B_ITER_CONT (0) -#define H5B_ITER_STOP (1) - /* Define the operator callback function pointer for H5B_iterate() */ typedef int (*H5B_operator_t)(H5F_t *f, hid_t dxpl_id, const void *_lt_key, haddr_t addr, const void *_rt_key, void *_udata); @@ -97,7 +107,6 @@ typedef struct H5B_shared_t { typedef struct H5B_class_t { H5B_subid_t id; /*id as found in file*/ size_t sizeof_nkey; /*size of native (memory) key*/ - size_t (*get_sizeof_rkey)(const H5F_t*, const void*); /*raw key size */ H5RC_t * (*get_shared)(const H5F_t*, const void*); /*shared info for node */ herr_t (*new_node)(H5F_t*, hid_t, H5B_ins_t, void*, void*, void*, haddr_t*); int (*cmp2)(H5F_t*, hid_t, void*, void*, void*); /*compare 2 keys */ @@ -120,12 +129,19 @@ typedef struct H5B_class_t { herr_t (*decode)(const H5F_t*, const struct H5B_t*, const uint8_t*, void*); herr_t (*encode)(const H5F_t*, const struct H5B_t*, uint8_t*, void*); herr_t (*debug_key)(FILE*, H5F_t*, hid_t, int, int, const void*, const void*); - } H5B_class_t; -/* - * Library prototypes. - */ +/*****************************/ +/* Library-private Variables */ +/*****************************/ + +/* Declare a free list to manage the H5B_shared_t struct */ +H5FL_EXTERN(H5B_shared_t); + + +/***************************************/ +/* Library-private Function Prototypes */ +/***************************************/ H5_DLL size_t H5B_nodesize(const H5F_t *f, const H5B_shared_t *shared, size_t *total_nkey_size); H5_DLL herr_t H5B_create (H5F_t *f, hid_t dxpl_id, const H5B_class_t *type, void *udata, @@ -87,6 +87,10 @@ static herr_t H5D_xfer_xform_close(const char* name, size_t size, void* value); /* Define a "default" dataset transfer property list cache structure to use for default DXPLs */ H5D_dxpl_cache_t H5D_def_dxpl_cache; +/*****************************/ +/* Library Private Variables */ +/*****************************/ + /*******************/ /* Local Variables */ /*******************/ diff --git a/src/H5Distore.c b/src/H5Distore.c index bf0c92e..b0d60d6 100644 --- a/src/H5Distore.c +++ b/src/H5Distore.c @@ -144,14 +144,57 @@ typedef struct H5D_istore_key_t { unsigned filter_mask; /*excluded filters */ } H5D_istore_key_t; -typedef struct H5D_istore_ud1_t { +/* + * Common data exchange structure for indexed storage nodes. This structure is + * passed through the B-link tree layer to the methods for the objects + * to which the B-link tree points. + */ +typedef struct H5D_istore_bt_ud_common_t { + /* downward */ H5D_istore_key_t key; /*key values */ - haddr_t addr; /*file address of chunk */ const H5O_layout_t *mesg; /*layout message */ +} H5D_istore_bt_ud_common_t; + +/* + * Data exchange structure for indexed storage nodes. This structure is + * passed through the B-link tree layer to the methods for the objects + * to which the B-link tree points for operations which require no + * additional information. + * + * (Just an alias for the "common" info). + */ +typedef H5D_istore_bt_ud_common_t H5D_istore_ud0_t; + +typedef struct H5D_istore_ud1_t { + H5D_istore_bt_ud_common_t common; /* Common info for B-tree user data (must be first) */ + haddr_t addr; /*file address of chunk */ +} H5D_istore_ud1_t; + +/* B-tree callback info for iteration to total allocated space */ +typedef struct H5D_istore_it_ud1_t { + H5D_istore_bt_ud_common_t common; /* Common info for B-tree user data (must be first) */ hsize_t total_storage; /*output from iterator */ +} H5D_istore_it_ud1_t; + +/* B-tree callback info for iteration to dump node's info */ +typedef struct H5D_istore_it_ud2_t { + H5D_istore_bt_ud_common_t common; /* Common info for B-tree user data (must be first) */ FILE *stream; /*debug output stream */ + hbool_t header_displayed; /* Node's header is displayed? */ +} H5D_istore_it_ud2_t; + +/* B-tree callback info for iteration to prune chunks */ +typedef struct H5D_istore_it_ud3_t { + H5D_istore_bt_ud_common_t common; /* Common info for B-tree user data (must be first) */ hsize_t *dims; /*dataset dimensions */ -} H5D_istore_ud1_t; +} H5D_istore_it_ud3_t; + +/* B-tree callback info for iteration to copy data */ +typedef struct H5D_istore_it_ud4_t { + H5D_istore_bt_ud_common_t common; /* Common info for B-tree user data (must be first) */ + H5F_t *file_dst; /* Destination file for copy */ + haddr_t addr_dst; /* Address of dest. B-tree */ +} H5D_istore_it_ud4_t; /********************/ /* Local Prototypes */ @@ -169,9 +212,10 @@ static int H5D_istore_iter_dump(H5F_t *f, hid_t dxpl_id, const void *left_key, h const void *right_key, void *_udata); static int H5D_istore_prune_extent(H5F_t *f, hid_t dxpl_id, const void *_lt_key, haddr_t addr, const void *_rt_key, void *_udata); +static int H5D_istore_iter_copy(H5F_t *f, hid_t dxpl_id, const void *_lt_key, haddr_t addr, + const void *_rt_key, void *_udata); /* B-tree callbacks */ -static size_t H5D_istore_sizeof_rkey(const H5F_t *f, const void *_udata); static H5RC_t *H5D_istore_get_shared(const H5F_t *f, const void *_udata); static herr_t H5D_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t, void *_lt_key, void *_udata, void *_rt_key, @@ -202,7 +246,6 @@ static herr_t H5D_istore_debug_key(FILE *stream, H5F_t *f, hid_t dxpl_id, H5B_class_t H5B_ISTORE[1] = {{ H5B_ISTORE_ID, /*id */ sizeof(H5D_istore_key_t), /*sizeof_nkey */ - H5D_istore_sizeof_rkey, /*get_sizeof_rkey */ H5D_istore_get_shared, /*get_shared */ H5D_istore_new_node, /*new */ H5D_istore_cmp2, /*cmp2 */ @@ -221,13 +264,14 @@ H5B_class_t H5B_ISTORE[1] = {{ /* Package Variables */ /*********************/ +/*****************************/ +/* Library Private Variables */ +/*****************************/ + /*******************/ /* Local Variables */ /*******************/ -/* Declare a free list to manage the H5B_shared_t struct */ -H5FL_EXTERN(H5B_shared_t); - /* Declare a free list to manage H5F_rdcc_ent_t objects */ H5FL_DEFINE_STATIC(H5D_rdcc_ent_t); @@ -245,43 +289,6 @@ H5FL_BLK_DEFINE_STATIC(chunk_page); /*------------------------------------------------------------------------- - * Function: H5D_istore_sizeof_rkey - * - * Purpose: Returns the size of a raw key for the specified UDATA. The - * size of the key is dependent on the number of dimensions for - * the object to which this B-tree points. The dimensionality - * of the UDATA is the only portion that's referenced here. - * - * Return: Success: Size of raw key in bytes. - * - * Failure: abort() - * - * Programmer: Robb Matzke - * Wednesday, October 8, 1997 - * - *------------------------------------------------------------------------- - */ -/* ARGSUSED */ -static size_t -H5D_istore_sizeof_rkey(const H5F_t UNUSED *f, const void *_udata) -{ - const H5D_istore_ud1_t *udata = (const H5D_istore_ud1_t *) _udata; - size_t nbytes; - - FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_sizeof_rkey) - - assert(udata); - assert(udata->mesg->u.chunk.ndims > 0 && udata->mesg->u.chunk.ndims <= H5O_LAYOUT_NDIMS); - - nbytes = 4 + /*storage size */ - 4 + /*filter mask */ - udata->mesg->u.chunk.ndims*8; /*dimension indices */ - - FUNC_LEAVE_NOAPI(nbytes) -} /* end H5D_istore_sizeof_rkey() */ - - -/*------------------------------------------------------------------------- * Function: H5D_istore_get_shared * * Purpose: Returns the shared B-tree info for the specified UDATA. @@ -299,13 +306,13 @@ H5D_istore_sizeof_rkey(const H5F_t UNUSED *f, const void *_udata) static H5RC_t * H5D_istore_get_shared(const H5F_t UNUSED *f, const void *_udata) { - const H5D_istore_ud1_t *udata = (const H5D_istore_ud1_t *) _udata; + const H5D_istore_ud0_t *udata = (const H5D_istore_ud0_t *) _udata; FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_get_shared) - assert(udata); - assert(udata->mesg); - assert(udata->mesg->u.chunk.btree_shared); + HDassert(udata); + HDassert(udata->mesg); + HDassert(udata->mesg->u.chunk.btree_shared); /* Increment reference count on B-tree info */ H5RC_INC(udata->mesg->u.chunk.btree_shared); @@ -413,26 +420,23 @@ H5D_istore_encode_key(const H5F_t UNUSED *f, const H5B_t *bt, uint8_t *raw, void */ /* ARGSUSED */ static herr_t -H5D_istore_debug_key (FILE *stream, H5F_t UNUSED *f, hid_t UNUSED dxpl_id, int indent, int fwidth, +H5D_istore_debug_key(FILE *stream, H5F_t UNUSED *f, hid_t UNUSED dxpl_id, int indent, int fwidth, const void *_key, const void *_udata) { const H5D_istore_key_t *key = (const H5D_istore_key_t *)_key; - const H5D_istore_ud1_t *udata = (const H5D_istore_ud1_t *)_udata; + const H5D_istore_ud0_t *udata = (const H5D_istore_ud0_t *)_udata; unsigned u; FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_debug_key) - assert (key); + HDassert(key); - HDfprintf(stream, "%*s%-*s %Zd bytes\n", indent, "", fwidth, - "Chunk size:", key->nbytes); - HDfprintf(stream, "%*s%-*s 0x%08x\n", indent, "", fwidth, - "Filter mask:", key->filter_mask); - HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, - "Logical offset:"); - for (u=0; u<udata->mesg->u.chunk.ndims; u++) - HDfprintf (stream, "%s%Hd", u?", ":"", key->offset[u]); - HDfputs ("}\n", stream); + HDfprintf(stream, "%*s%-*s %Zd bytes\n", indent, "", fwidth, "Chunk size:", key->nbytes); + HDfprintf(stream, "%*s%-*s 0x%08x\n", indent, "", fwidth, "Filter mask:", key->filter_mask); + HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, "Logical offset:"); + for(u = 0; u < udata->mesg->u.chunk.ndims; u++) + HDfprintf(stream, "%s%Hd", u?", ":"", key->offset[u]); + HDfputs("}\n", stream); FUNC_LEAVE_NOAPI(SUCCEED) } /* end H5D_istore_debug_key() */ @@ -464,15 +468,15 @@ H5D_istore_cmp2(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_uda { H5D_istore_key_t *lt_key = (H5D_istore_key_t *) _lt_key; H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key; - H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata; + H5D_istore_ud0_t *udata = (H5D_istore_ud0_t *) _udata; int ret_value; FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_cmp2) - assert(lt_key); - assert(rt_key); - assert(udata); - assert(udata->mesg->u.chunk.ndims > 0 && udata->mesg->u.chunk.ndims <= H5O_LAYOUT_NDIMS); + HDassert(lt_key); + HDassert(rt_key); + HDassert(udata); + HDassert(udata->mesg->u.chunk.ndims > 0 && udata->mesg->u.chunk.ndims <= H5O_LAYOUT_NDIMS); /* Compare the offsets but ignore the other fields */ ret_value = H5V_vector_cmp_u(udata->mesg->u.chunk.ndims, lt_key->offset, rt_key->offset); @@ -515,15 +519,15 @@ H5D_istore_cmp3(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, void *_lt_key, void *_uda { H5D_istore_key_t *lt_key = (H5D_istore_key_t *) _lt_key; H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key; - H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata; + H5D_istore_ud0_t *udata = (H5D_istore_ud0_t *) _udata; int ret_value = 0; FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_cmp3) - assert(lt_key); - assert(rt_key); - assert(udata); - assert(udata->mesg->u.chunk.ndims > 0 && udata->mesg->u.chunk.ndims <= H5O_LAYOUT_NDIMS); + HDassert(lt_key); + HDassert(rt_key); + HDassert(udata); + HDassert(udata->mesg->u.chunk.ndims > 0 && udata->mesg->u.chunk.ndims <= H5O_LAYOUT_NDIMS); /* Special case for faster checks on 1-D chunks */ /* (Checking for ndims==2 because last dimension is the datatype size) */ @@ -580,22 +584,22 @@ H5D_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t op, H5D_istore_key_t *rt_key = (H5D_istore_key_t *) _rt_key; H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata; unsigned u; - herr_t ret_value=SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_new_node) /* check args */ - assert(f); - assert(lt_key); - assert(rt_key); - assert(udata); - assert(udata->mesg->u.chunk.ndims > 0 && udata->mesg->u.chunk.ndims < H5O_LAYOUT_NDIMS); - assert(addr_p); + HDassert(f); + HDassert(lt_key); + HDassert(rt_key); + HDassert(udata); + HDassert(udata->common.mesg->u.chunk.ndims > 0 && udata->common.mesg->u.chunk.ndims < H5O_LAYOUT_NDIMS); + HDassert(addr_p); /* Allocate new storage */ - assert (udata->key.nbytes > 0); - H5_CHECK_OVERFLOW( udata->key.nbytes ,size_t, hsize_t); - if (HADDR_UNDEF==(*addr_p=H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, (hsize_t)udata->key.nbytes))) + HDassert(udata->common.key.nbytes > 0); + H5_CHECK_OVERFLOW(udata->common.key.nbytes ,size_t, hsize_t); + if(HADDR_UNDEF == (*addr_p = H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, (hsize_t)udata->common.key.nbytes))) HGOTO_ERROR(H5E_IO, H5E_CANTINIT, FAIL, "couldn't allocate new file storage") udata->addr = *addr_p; @@ -603,10 +607,10 @@ H5D_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t op, * The left key describes the storage of the UDATA chunk being * inserted into the tree. */ - lt_key->nbytes = udata->key.nbytes; - lt_key->filter_mask = udata->key.filter_mask; - for (u=0; u<udata->mesg->u.chunk.ndims; u++) - lt_key->offset[u] = udata->key.offset[u]; + lt_key->nbytes = udata->common.key.nbytes; + lt_key->filter_mask = udata->common.key.filter_mask; + for (u=0; u<udata->common.mesg->u.chunk.ndims; u++) + lt_key->offset[u] = udata->common.key.offset[u]; /* * The right key might already be present. If not, then add a zero-width @@ -615,10 +619,10 @@ H5D_istore_new_node(H5F_t *f, hid_t dxpl_id, H5B_ins_t op, if (H5B_INS_LEFT != op) { rt_key->nbytes = 0; rt_key->filter_mask = 0; - for (u=0; u<udata->mesg->u.chunk.ndims; u++) { - assert (udata->key.offset[u]+udata->mesg->u.chunk.dim[u] > - udata->key.offset[u]); - rt_key->offset[u] = udata->key.offset[u] + udata->mesg->u.chunk.dim[u]; + for (u=0; u<udata->common.mesg->u.chunk.ndims; u++) { + HDassert(udata->common.key.offset[u]+udata->common.mesg->u.chunk.dim[u] > + udata->common.key.offset[u]); + rt_key->offset[u] = udata->common.key.offset[u] + udata->common.mesg->u.chunk.dim[u]; } } @@ -659,28 +663,28 @@ H5D_istore_found(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, haddr_t addr, const void H5D_istore_ud1_t *udata = (H5D_istore_ud1_t *) _udata; const H5D_istore_key_t *lt_key = (const H5D_istore_key_t *) _lt_key; unsigned u; - herr_t ret_value=SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_found) /* Check arguments */ - assert(f); - assert(H5F_addr_defined(addr)); - assert(udata); - assert(lt_key); + HDassert(f); + HDassert(H5F_addr_defined(addr)); + HDassert(udata); + HDassert(lt_key); /* Is this *really* the requested chunk? */ - for (u=0; u<udata->mesg->u.chunk.ndims; u++) - if (udata->key.offset[u] >= lt_key->offset[u]+udata->mesg->u.chunk.dim[u]) + for(u = 0; u < udata->common.mesg->u.chunk.ndims; u++) + if(udata->common.key.offset[u] >= lt_key->offset[u] + udata->common.mesg->u.chunk.dim[u]) HGOTO_DONE(FAIL) /* Initialize return values */ udata->addr = addr; - udata->key.nbytes = lt_key->nbytes; - udata->key.filter_mask = lt_key->filter_mask; - assert (lt_key->nbytes>0); - for (u = 0; u < udata->mesg->u.chunk.ndims; u++) - udata->key.offset[u] = lt_key->offset[u]; + udata->common.key.nbytes = lt_key->nbytes; + udata->common.key.filter_mask = lt_key->filter_mask; + HDassert(lt_key->nbytes>0); + for(u = 0; u < udata->common.mesg->u.chunk.ndims; u++) + udata->common.key.offset[u] = lt_key->offset[u]; done: FUNC_LEAVE_NOAPI(ret_value) @@ -734,30 +738,30 @@ H5D_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key, FUNC_ENTER_NOAPI_NOINIT(H5D_istore_insert) /* check args */ - assert(f); - assert(H5F_addr_defined(addr)); - assert(lt_key); - assert(lt_key_changed); - assert(md_key); - assert(udata); - assert(rt_key); - assert(new_node_p); + HDassert(f); + HDassert(H5F_addr_defined(addr)); + HDassert(lt_key); + HDassert(lt_key_changed); + HDassert(md_key); + HDassert(udata); + HDassert(rt_key); + HDassert(new_node_p); cmp = H5D_istore_cmp3(f, dxpl_id, lt_key, udata, rt_key); - assert(cmp <= 0); + HDassert(cmp <= 0); if (cmp < 0) { /* Negative indices not supported yet */ HGOTO_ERROR(H5E_STORAGE, H5E_UNSUPPORTED, H5B_INS_ERROR, "internal error") - } else if (H5V_vector_eq_u (udata->mesg->u.chunk.ndims, - udata->key.offset, lt_key->offset) && + } else if (H5V_vector_eq_u (udata->common.mesg->u.chunk.ndims, + udata->common.key.offset, lt_key->offset) && lt_key->nbytes>0) { /* * Already exists. If the new size is not the same as the old size * then we should reallocate storage. */ - if (lt_key->nbytes != udata->key.nbytes) { + if (lt_key->nbytes != udata->common.key.nbytes) { /* Currently, the old chunk data is "thrown away" after the space is reallocated, * so avoid data copy in H5MF_realloc() call by just free'ing the space and * allocating new space. @@ -768,19 +772,19 @@ H5D_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key, * QAK - 11/19/2002 */ #ifdef OLD_WAY - if (HADDR_UNDEF==(*new_node_p=H5MF_realloc(f, H5FD_MEM_DRAW, addr, - (hsize_t)lt_key->nbytes, (hsize_t)udata->key.nbytes))) - HGOTO_ERROR (H5E_STORAGE, H5E_NOSPACE, H5B_INS_ERROR, "unable to reallocate chunk storage") + if(HADDR_UNDEF == (*new_node_p = H5MF_realloc(f, H5FD_MEM_DRAW, addr, + (hsize_t)lt_key->nbytes, (hsize_t)udata->common.key.nbytes))) + HGOTO_ERROR(H5E_STORAGE, H5E_NOSPACE, H5B_INS_ERROR, "unable to reallocate chunk storage") #else /* OLD_WAY */ H5_CHECK_OVERFLOW( lt_key->nbytes ,size_t, hsize_t); - if (H5MF_xfree(f, H5FD_MEM_DRAW, dxpl_id, addr, (hsize_t)lt_key->nbytes)<0) + if(H5MF_xfree(f, H5FD_MEM_DRAW, dxpl_id, addr, (hsize_t)lt_key->nbytes)<0) HGOTO_ERROR(H5E_STORAGE, H5E_CANTFREE, H5B_INS_ERROR, "unable to free chunk") - H5_CHECK_OVERFLOW( udata->key.nbytes ,size_t, hsize_t); - if (HADDR_UNDEF==(*new_node_p=H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, (hsize_t)udata->key.nbytes))) + H5_CHECK_OVERFLOW(udata->common.key.nbytes ,size_t, hsize_t); + if(HADDR_UNDEF == (*new_node_p = H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, (hsize_t)udata->common.key.nbytes))) HGOTO_ERROR(H5E_STORAGE, H5E_NOSPACE, H5B_INS_ERROR, "unable to reallocate chunk") #endif /* OLD_WAY */ - lt_key->nbytes = udata->key.nbytes; - lt_key->filter_mask = udata->key.filter_mask; + lt_key->nbytes = udata->common.key.nbytes; + lt_key->filter_mask = udata->common.key.filter_mask; *lt_key_changed = TRUE; udata->addr = *new_node_p; ret_value = H5B_INS_CHANGE; @@ -789,28 +793,28 @@ H5D_istore_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key, ret_value = H5B_INS_NOOP; } - } else if (H5V_hyper_disjointp(udata->mesg->u.chunk.ndims, - lt_key->offset, udata->mesg->u.chunk.dim, - udata->key.offset, udata->mesg->u.chunk.dim)) { - assert(H5V_hyper_disjointp(udata->mesg->u.chunk.ndims, - rt_key->offset, udata->mesg->u.chunk.dim, - udata->key.offset, udata->mesg->u.chunk.dim)); + } else if (H5V_hyper_disjointp(udata->common.mesg->u.chunk.ndims, + lt_key->offset, udata->common.mesg->u.chunk.dim, + udata->common.key.offset, udata->common.mesg->u.chunk.dim)) { + HDassert(H5V_hyper_disjointp(udata->common.mesg->u.chunk.ndims, + rt_key->offset, udata->common.mesg->u.chunk.dim, + udata->common.key.offset, udata->common.mesg->u.chunk.dim)); /* * Split this node, inserting the new new node to the right of the * current node. The MD_KEY is where the split occurs. */ - md_key->nbytes = udata->key.nbytes; - md_key->filter_mask = udata->key.filter_mask; - for (u=0; u<udata->mesg->u.chunk.ndims; u++) { - assert(0 == udata->key.offset[u] % udata->mesg->u.chunk.dim[u]); - md_key->offset[u] = udata->key.offset[u]; + md_key->nbytes = udata->common.key.nbytes; + md_key->filter_mask = udata->common.key.filter_mask; + for(u = 0; u < udata->common.mesg->u.chunk.ndims; u++) { + HDassert(0 == udata->common.key.offset[u] % udata->common.mesg->u.chunk.dim[u]); + md_key->offset[u] = udata->common.key.offset[u]; } /* * Allocate storage for the new chunk */ - H5_CHECK_OVERFLOW( udata->key.nbytes ,size_t, hsize_t); - if (HADDR_UNDEF==(*new_node_p=H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, (hsize_t)udata->key.nbytes))) + H5_CHECK_OVERFLOW(udata->common.key.nbytes ,size_t, hsize_t); + if(HADDR_UNDEF == (*new_node_p = H5MF_alloc(f, H5FD_MEM_DRAW, dxpl_id, (hsize_t)udata->common.key.nbytes))) HGOTO_ERROR(H5E_STORAGE, H5E_NOSPACE, H5B_INS_ERROR, "file allocation failed") udata->addr = *new_node_p; ret_value = H5B_INS_RIGHT; @@ -843,12 +847,12 @@ static int H5D_istore_iter_allocated (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *_lt_key, haddr_t UNUSED addr, const void UNUSED *_rt_key, void *_udata) { - H5D_istore_ud1_t *bt_udata = (H5D_istore_ud1_t *)_udata; + H5D_istore_it_ud1_t *udata = (H5D_istore_it_ud1_t *)_udata; const H5D_istore_key_t *lt_key = (const H5D_istore_key_t *)_lt_key; FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_iter_allocated) - bt_udata->total_storage += lt_key->nbytes; + udata->total_storage += lt_key->nbytes; FUNC_LEAVE_NOAPI(H5B_ITER_CONT) } /* H5D_istore_iter_allocated() */ @@ -874,35 +878,86 @@ static int H5D_istore_iter_dump (H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *_lt_key, haddr_t UNUSED addr, const void UNUSED *_rt_key, void *_udata) { - H5D_istore_ud1_t *bt_udata = (H5D_istore_ud1_t *)_udata; + H5D_istore_it_ud2_t *udata = (H5D_istore_it_ud2_t *)_udata; const H5D_istore_key_t *lt_key = (const H5D_istore_key_t *)_lt_key; unsigned u; FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_iter_dump) - if (bt_udata->stream) { - if (0==bt_udata->total_storage) { - fprintf(bt_udata->stream, - " Flags Bytes Address Logical Offset\n"); - fprintf(bt_udata->stream, - " ========== ======== ========== " - "==============================\n"); - } - HDfprintf(bt_udata->stream, " 0x%08x %8Zu %10a [", - lt_key->filter_mask, lt_key->nbytes, addr); - for (u=0; u<bt_udata->mesg->u.chunk.ndims; u++) - HDfprintf(bt_udata->stream, "%s%Hd", u?", ":"", lt_key->offset[u]); - HDfputs("]\n", bt_udata->stream); - - /* Use "total storage" information as flag for printing headers */ - bt_udata->total_storage++; - } + if(udata->stream) { + if(!udata->header_displayed) { + HDfprintf(udata->stream, " Flags Bytes Address Logical Offset\n"); + HDfprintf(udata->stream, " ========== ======== ========== ==============================\n"); + + /* Set flag that the headers has been printed */ + udata->header_displayed = TRUE; + } /* end if */ + HDfprintf(udata->stream, " 0x%08x %8Zu %10a [", lt_key->filter_mask, lt_key->nbytes, addr); + for(u = 0; u < udata->common.mesg->u.chunk.ndims; u++) + HDfprintf(udata->stream, "%s%Hd", (u ? ", " : ""), lt_key->offset[u]); + HDfputs("]\n", udata->stream); + } /* end if */ FUNC_LEAVE_NOAPI(H5B_ITER_CONT) } /* H5D_istore_iter_dump() */ /*------------------------------------------------------------------------- + * Function: H5D_istore_iter_copy + * + * Purpose: copy chunked raw data from source file and insert to the + * B-tree node in the destination file + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Peter Cao + * August 20, 2005 + * + *------------------------------------------------------------------------- + */ +static int +H5D_istore_iter_copy(H5F_t *f_src, hid_t dxpl_id, const void *_lt_key, haddr_t addr_src, + const void UNUSED *_rt_key, void *_udata) +{ + H5D_istore_it_ud4_t *udata = (H5D_istore_it_ud4_t *)_udata; + const H5D_istore_key_t *lt_key = (const H5D_istore_key_t *)_lt_key; + void *chunk = NULL; /*the chunk data */ + H5D_istore_ud1_t udata_dst; + int ret_value = H5B_ITER_CONT; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5D_istore_iter_copy) + + /* Allocate memory for copying the chunk */ + if(NULL == (chunk = H5MM_malloc(lt_key->nbytes))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, H5B_ITER_ERROR, "memory allocation failed for raw data chunk") + + /* read chunk data from the source file */ + if(H5F_block_read(f_src, H5FD_MEM_DRAW, addr_src, lt_key->nbytes, dxpl_id, chunk) < 0) + HGOTO_ERROR(H5E_IO, H5E_READERROR, H5B_ITER_ERROR, "unable to read raw data chunk") + + /* Copy source chunk callback information for insertion */ + HDmemset(&udata_dst, 0, sizeof(udata_dst)); + HDmemcpy(&(udata_dst.common.key), lt_key, sizeof(H5D_istore_key_t)); + udata_dst.common.mesg = udata->common.mesg; /* Share this pointer for a short while */ + + /* Insert chunk into the destination Btree */ + if(H5B_insert(udata->file_dst, dxpl_id, H5B_ISTORE, udata->addr_dst, &udata_dst) < 0) + HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, H5B_ITER_ERROR, "unable to allocate chunk") + + /* Write chunk data to destination file */ + HDassert(H5F_addr_defined(udata_dst.addr)); + if(H5F_block_write(udata->file_dst, H5FD_MEM_DRAW, udata_dst.addr, udata_dst.common.key.nbytes, dxpl_id, chunk) < 0) + HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, H5B_ITER_ERROR, "unable to write raw data to file") + +done: + if(chunk) + H5MM_xfree(chunk); + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_istore_iter_copy() */ + + +/*------------------------------------------------------------------------- * Function: H5D_istore_init * * Purpose: Initialize the raw data chunk cache for a dataset. This is @@ -974,12 +1029,12 @@ H5D_istore_flush_entry(const H5D_io_info_t *io_info, H5D_rdcc_ent_t *ent, hbool_ if (ent->dirty) { H5D_istore_ud1_t udata; /*pass through B-tree */ - udata.mesg = &io_info->dset->shared->layout; - udata.key.filter_mask = 0; + udata.common.mesg = &io_info->dset->shared->layout; + udata.common.key.filter_mask = 0; udata.addr = HADDR_UNDEF; - udata.key.nbytes = ent->chunk_size; + udata.common.key.nbytes = ent->chunk_size; for (u=0; u<io_info->dset->shared->layout.u.chunk.ndims; u++) - udata.key.offset[u] = ent->offset[u]; + udata.common.key.offset[u] = ent->offset[u]; alloc = ent->alloc_size; /* Should the chunk be filtered before writing it to disk? */ @@ -1005,8 +1060,8 @@ H5D_istore_flush_entry(const H5D_io_info_t *io_info, H5D_rdcc_ent_t *ent, hbool_ point_of_no_return = TRUE; ent->chunk = NULL; } - if (H5Z_pipeline(&(io_info->dset->shared->dcpl_cache.pline), 0, &(udata.key.filter_mask), io_info->dxpl_cache->err_detect, - io_info->dxpl_cache->filter_cb, &(udata.key.nbytes), &alloc, &buf)<0) + if (H5Z_pipeline(&(io_info->dset->shared->dcpl_cache.pline), 0, &(udata.common.key.filter_mask), io_info->dxpl_cache->err_detect, + io_info->dxpl_cache->filter_cb, &(udata.common.key.nbytes), &alloc, &buf)<0) HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL, "output pipeline failed") } @@ -1016,7 +1071,7 @@ H5D_istore_flush_entry(const H5D_io_info_t *io_info, H5D_rdcc_ent_t *ent, hbool_ */ if (H5B_insert(io_info->dset->ent.file, io_info->dxpl_id, H5B_ISTORE, io_info->dset->shared->layout.u.chunk.addr, &udata)<0) HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to allocate chunk") - if (H5F_block_write(io_info->dset->ent.file, H5FD_MEM_DRAW, udata.addr, udata.key.nbytes, io_info->dxpl_id, buf)<0) + if (H5F_block_write(io_info->dset->ent.file, H5FD_MEM_DRAW, udata.addr, udata.common.key.nbytes, io_info->dxpl_id, buf)<0) HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file") /* Mark cache entry as clean */ @@ -1251,16 +1306,12 @@ done: static herr_t H5D_istore_shared_create (const H5F_t *f, H5O_layout_t *layout) { - H5D_istore_ud1_t udata; H5B_shared_t *shared; /* Shared B-tree node info */ size_t u; /* Local index variable */ herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI_NOINIT(H5D_istore_shared_create) - /* Initialize "user" data for B-tree callbacks, etc. */ - udata.mesg = layout; - /* Allocate space for the shared structure */ if(NULL==(shared=H5FL_MALLOC(H5B_shared_t))) HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for shared B-tree info") @@ -1268,7 +1319,9 @@ H5D_istore_shared_create (const H5F_t *f, H5O_layout_t *layout) /* Set up the "global" information for this file's groups */ shared->type= H5B_ISTORE; shared->two_k=2*H5F_KVALUE(f,H5B_ISTORE); - shared->sizeof_rkey = H5D_istore_sizeof_rkey(f, &udata); + shared->sizeof_rkey = 4 + /*storage size */ + 4 + /*filter mask */ + layout->u.chunk.ndims*8; /*dimension indices */ assert(shared->sizeof_rkey); shared->sizeof_rnode = H5B_nodesize(f, shared, &shared->sizeof_keys); assert(shared->sizeof_rnode); @@ -1539,10 +1592,10 @@ H5D_istore_lock(const H5D_io_info_t *io_info, haddr_t chunk_addr; /* Address of chunk on disk */ if(udata!=NULL) - chunk_addr=udata->addr; + chunk_addr = udata->addr; else { /* Point at temporary storage for B-tree pass through */ - udata=&tmp_udata; + udata = &tmp_udata; /* * Not in the cache. Read it from the file and count this as a miss @@ -1552,22 +1605,22 @@ H5D_istore_lock(const H5D_io_info_t *io_info, } /* end else */ if (H5F_addr_defined(chunk_addr)) { - size_t chunk_alloc=0; /*allocated chunk size */ + size_t chunk_alloc = 0; /*allocated chunk size */ /* * The chunk exists on disk. */ /* Chunk size on disk isn't [likely] the same size as the final chunk * size in memory, so allocate memory big enough. */ - chunk_alloc = udata->key.nbytes; + chunk_alloc = udata->common.key.nbytes; if (NULL==(chunk = H5D_istore_chunk_alloc (chunk_alloc,pline))) HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for raw data chunk") - if (H5F_block_read(dset->ent.file, H5FD_MEM_DRAW, chunk_addr, udata->key.nbytes, io_info->dxpl_id, chunk)<0) + if (H5F_block_read(dset->ent.file, H5FD_MEM_DRAW, chunk_addr, udata->common.key.nbytes, io_info->dxpl_id, chunk)<0) HGOTO_ERROR (H5E_IO, H5E_READERROR, NULL, "unable to read raw data chunk") if (pline->nused) - if (H5Z_pipeline(pline, H5Z_FLAG_REVERSE, &(udata->key.filter_mask), io_info->dxpl_cache->err_detect, - io_info->dxpl_cache->filter_cb, &(udata->key.nbytes), &chunk_alloc, &chunk)<0) { + if (H5Z_pipeline(pline, H5Z_FLAG_REVERSE, &(udata->common.key.filter_mask), io_info->dxpl_cache->err_detect, + io_info->dxpl_cache->filter_cb, &(udata->common.key.nbytes), &chunk_alloc, &chunk)<0) { HGOTO_ERROR(H5E_PLINE, H5E_READERROR, NULL, "data pipeline read failed") } #ifdef H5D_ISTORE_DEBUG @@ -1831,16 +1884,16 @@ H5D_istore_readvv(const H5D_io_info_t *io_info, FUNC_ENTER_NOAPI(H5D_istore_readvv, FAIL) /* Check args */ - assert(io_info); - assert(dset && H5D_CHUNKED==dset->shared->layout.type); - assert(dset->shared->layout.u.chunk.ndims>0 && dset->shared->layout.u.chunk.ndims<=H5O_LAYOUT_NDIMS); - assert(io_info->dxpl_cache); - assert(io_info->store); - assert(chunk_len_arr); - assert(chunk_offset_arr); - assert(mem_len_arr); - assert(mem_offset_arr); - assert(buf); + HDassert(io_info); + HDassert(dset && H5D_CHUNKED==dset->shared->layout.type); + HDassert(dset->shared->layout.u.chunk.ndims>0 && dset->shared->layout.u.chunk.ndims<=H5O_LAYOUT_NDIMS); + HDassert(io_info->dxpl_cache); + HDassert(io_info->store); + HDassert(chunk_len_arr); + HDassert(chunk_offset_arr); + HDassert(mem_len_arr); + HDassert(mem_offset_arr); + HDassert(buf); /* Get the address of this chunk on disk */ #ifdef QAK @@ -1848,7 +1901,7 @@ HDfprintf(stderr,"%s: io_info->store->chunk.offset={",FUNC); for(u=0; u<dset->shared->layout.u.chunk.ndims; u++) HDfprintf(stderr,"%Hd%s",io_info->store->chunk.offset[u],(u<(dset->shared->layout.u.chunk.ndims-1) ? ", " : "}\n")); #endif /* QAK */ - chunk_addr=H5D_istore_get_addr(io_info, &udata); + chunk_addr = H5D_istore_get_addr(io_info, &udata); #ifdef QAK HDfprintf(stderr,"%s: chunk_addr=%a, chunk_size=%Zu\n",FUNC,chunk_addr,dset->shared->layout.u.chunk.size); HDfprintf(stderr,"%s: chunk_len_arr[%Zu]=%Zu\n",FUNC,*chunk_curr_seq,chunk_len_arr[*chunk_curr_seq]); @@ -2013,7 +2066,7 @@ H5D_istore_writevv(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[], const void *buf) { - H5D_t *dset=io_info->dset; /* Local pointer to the dataset info */ + H5D_t *dset = io_info->dset; /* Local pointer to the dataset info */ H5D_istore_ud1_t udata; /*B-tree pass-through */ haddr_t chunk_addr; /* Chunk address on disk */ size_t u; /* Local index variables */ @@ -2022,16 +2075,16 @@ H5D_istore_writevv(const H5D_io_info_t *io_info, FUNC_ENTER_NOAPI(H5D_istore_writevv, FAIL) /* Check args */ - assert(io_info); - assert(dset && H5D_CHUNKED==dset->shared->layout.type); - assert(dset->shared->layout.u.chunk.ndims>0 && dset->shared->layout.u.chunk.ndims<=H5O_LAYOUT_NDIMS); - assert(io_info->dxpl_cache); - assert(io_info->store); - assert(chunk_len_arr); - assert(chunk_offset_arr); - assert(mem_len_arr); - assert(mem_offset_arr); - assert(buf); + HDassert(io_info); + HDassert(dset && H5D_CHUNKED==dset->shared->layout.type); + HDassert(dset->shared->layout.u.chunk.ndims>0 && dset->shared->layout.u.chunk.ndims<=H5O_LAYOUT_NDIMS); + HDassert(io_info->dxpl_cache); + HDassert(io_info->store); + HDassert(chunk_len_arr); + HDassert(chunk_offset_arr); + HDassert(mem_len_arr); + HDassert(mem_offset_arr); + HDassert(buf); /* Get the address of this chunk on disk */ #ifdef QAK @@ -2039,7 +2092,7 @@ HDfprintf(stderr,"%s: io_info->store->chunk.offset={",FUNC); for(u=0; u<dset->shared->layout.u.chunk.ndims; u++) HDfprintf(stderr,"%Hd%s",io_info->store->chunk.offset[u],(u<(dset->shared->layout.u.chunk.ndims-1) ? ", " : "}\n")); #endif /* QAK */ - chunk_addr=H5D_istore_get_addr(io_info, &udata); + chunk_addr = H5D_istore_get_addr(io_info, &udata); #ifdef QAK HDfprintf(stderr,"%s: chunk_addr=%a, chunk_size=%Zu\n",FUNC,chunk_addr,dset->shared->layout.u.chunk.size); HDfprintf(stderr,"%s: chunk_len_arr[%Zu]=%Zu\n",FUNC,*chunk_curr_seq,chunk_len_arr[*chunk_curr_seq]); @@ -2161,29 +2214,29 @@ done: *------------------------------------------------------------------------- */ herr_t -H5D_istore_create(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout /*out */ ) +H5D_istore_create(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout /*out */) { - H5D_istore_ud1_t udata; + H5D_istore_ud0_t udata; #ifndef NDEBUG unsigned u; #endif - herr_t ret_value=SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5D_istore_create, FAIL) /* Check args */ - assert(f); - assert(layout && H5D_CHUNKED == layout->type); - assert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS); + HDassert(f); + HDassert(layout && H5D_CHUNKED == layout->type); + HDassert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS); #ifndef NDEBUG - for (u = 0; u < layout->u.chunk.ndims; u++) - assert(layout->u.chunk.dim[u] > 0); + for(u = 0; u < layout->u.chunk.ndims; u++) + HDassert(layout->u.chunk.dim[u] > 0); #endif /* Initialize "user" data for B-tree callbacks, etc. */ udata.mesg = layout; - if (H5B_create(f, dxpl_id, H5B_ISTORE, &udata, &(layout->u.chunk.addr)/*out*/) < 0) + if(H5B_create(f, dxpl_id, H5B_ISTORE, &udata, &(layout->u.chunk.addr)/*out*/) < 0) HGOTO_ERROR(H5E_IO, H5E_CANTINIT, FAIL, "can't create B-tree") done: @@ -2215,12 +2268,12 @@ H5D_istore_allocated(H5D_t *dset, hid_t dxpl_id) H5D_rdcc_ent_t *ent; /*cache entry */ H5D_dxpl_cache_t _dxpl_cache; /* Data transfer property cache buffer */ H5D_dxpl_cache_t *dxpl_cache=&_dxpl_cache; /* Data transfer property cache */ - H5D_istore_ud1_t udata; + H5D_istore_it_ud1_t udata; hsize_t ret_value; /* Return value */ FUNC_ENTER_NOAPI(H5D_istore_allocated, 0) - assert(dset); + HDassert(dset); /* Fill the DXPL cache values for later use */ if (H5D_get_dxpl_cache(dxpl_id,&dxpl_cache)<0) @@ -2237,12 +2290,12 @@ H5D_istore_allocated(H5D_t *dset, hid_t dxpl_id) } /* end for */ HDmemset(&udata, 0, sizeof udata); - udata.mesg = &dset->shared->layout; + udata.common.mesg = &dset->shared->layout; if (H5B_iterate(dset->ent.file, dxpl_id, H5B_ISTORE, H5D_istore_iter_allocated, dset->shared->layout.u.chunk.addr, &udata)<0) HGOTO_ERROR(H5E_IO, H5E_CANTINIT, 0, "unable to iterate over chunk B-tree") /* Set return value */ - ret_value=udata.total_storage; + ret_value = udata.total_storage; done: FUNC_LEAVE_NOAPI(ret_value) @@ -2273,18 +2326,18 @@ H5D_istore_get_addr(const H5D_io_info_t *io_info, H5D_istore_ud1_t *_udata) FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_istore_get_addr) - assert(io_info); - assert(io_info->dset); - assert(io_info->dset->shared->layout.u.chunk.ndims > 0); - assert(io_info->store->chunk.offset); + HDassert(io_info); + HDassert(io_info->dset); + HDassert(io_info->dset->shared->layout.u.chunk.ndims > 0); + HDassert(io_info->store->chunk.offset); /* Check for udata struct to return */ - udata = (_udata!=NULL ? _udata : &tmp_udata); + udata = (_udata != NULL ? _udata : &tmp_udata); /* Initialize the information about the chunk we are looking for */ - for (u=0; u<io_info->dset->shared->layout.u.chunk.ndims; u++) - udata->key.offset[u] = io_info->store->chunk.offset[u]; - udata->mesg = &(io_info->dset->shared->layout); + for(u = 0; u < io_info->dset->shared->layout.u.chunk.ndims; u++) + udata->common.key.offset[u] = io_info->store->chunk.offset[u]; + udata->common.mesg = &(io_info->dset->shared->layout); udata->addr = HADDR_UNDEF; /* Go get the chunk information */ @@ -2328,6 +2381,7 @@ static void * H5D_istore_chunk_alloc(size_t size, const H5O_pline_t *pline) { void *ret_value=NULL; /* Return value */ + FUNC_ENTER_NOAPI_NOINIT(H5D_istore_chunk_alloc) assert(size); @@ -2411,7 +2465,6 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite) H5D_fill_time_t fill_time; /* When to write fill values */ H5D_fill_value_t fill_status; /* The fill value status */ unsigned should_fill=0; /* Whether fill values should be written */ - H5D_istore_ud1_t udata; /* B-tree pass-through for creating chunk */ void *chunk=NULL; /* Chunk buffer for writing fill values */ H5D_dxpl_cache_t _dxpl_cache; /* Data transfer property cache buffer */ H5D_dxpl_cache_t *dxpl_cache=&_dxpl_cache; /* Data transfer property cache */ @@ -2562,14 +2615,16 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite) } /* end if */ if(!chunk_exists) { + H5D_istore_ud1_t udata; /* B-tree pass-through for creating chunk */ + /* Initialize the chunk information */ - udata.mesg = &dset->shared->layout; - udata.key.filter_mask = filter_mask; + udata.common.mesg = &dset->shared->layout; + udata.common.key.filter_mask = filter_mask; udata.addr = HADDR_UNDEF; H5_CHECK_OVERFLOW(chunk_size,hsize_t,size_t); - udata.key.nbytes = (size_t)chunk_size; - for (u=0; u<dset->shared->layout.u.chunk.ndims; u++) - udata.key.offset[u] = chunk_offset[u]; + udata.common.key.nbytes = (size_t)chunk_size; + for(u = 0; u < dset->shared->layout.u.chunk.ndims; u++) + udata.common.key.offset[u] = chunk_offset[u]; /* Allocate the chunk with all processes */ if (H5B_insert(dset->ent.file, dxpl_id, H5B_ISTORE, dset->shared->layout.u.chunk.addr, &udata)<0) @@ -2583,7 +2638,7 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite) /* Write the chunks out from only one process */ /* !! Use the internal "independent" DXPL!! -QAK */ if(H5_PAR_META_WRITE==mpi_rank) { - if (H5F_block_write(dset->ent.file, H5FD_MEM_DRAW, udata.addr, udata.key.nbytes, H5AC_ind_dxpl_id, chunk)<0) + if (H5F_block_write(dset->ent.file, H5FD_MEM_DRAW, udata.addr, udata.common.key.nbytes, H5AC_ind_dxpl_id, chunk)<0) HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file") } /* end if */ @@ -2592,7 +2647,7 @@ H5D_istore_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite) } /* end if */ else { #endif /* H5_HAVE_PARALLEL */ - if (H5F_block_write(dset->ent.file, H5FD_MEM_DRAW, udata.addr, udata.key.nbytes, dxpl_id, chunk)<0) + if (H5F_block_write(dset->ent.file, H5FD_MEM_DRAW, udata.addr, udata.common.key.nbytes, dxpl_id, chunk)<0) HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "unable to write raw data to file") #ifdef H5_HAVE_PARALLEL } /* end else */ @@ -2735,14 +2790,14 @@ done: herr_t H5D_istore_prune_by_extent(const H5D_io_info_t *io_info) { - H5D_t *dset=io_info->dset; /* Local pointer to the dataset info */ + H5D_t *dset = io_info->dset; /* Local pointer to the dataset info */ const H5D_rdcc_t *rdcc = &(dset->shared->cache.chunk); /*raw data chunk cache */ H5D_rdcc_ent_t *ent = NULL, *next = NULL; /*cache entry */ unsigned u; /*counters */ int found; /*remove this entry */ - H5D_istore_ud1_t udata; /*B-tree pass-through */ + H5D_istore_it_ud3_t udata; /*B-tree pass-through */ hsize_t curr_dims[H5O_LAYOUT_NDIMS]; /*current dataspace dimensions */ - herr_t ret_value=SUCCEED; /* Return value */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5D_istore_prune_by_extent, FAIL) @@ -2794,8 +2849,7 @@ H5D_istore_prune_by_extent(const H5D_io_info_t *io_info) */ HDmemset(&udata, 0, sizeof udata); - udata.stream = stdout; - udata.mesg = &dset->shared->layout; + udata.common.mesg = &dset->shared->layout; udata.dims = curr_dims; if(H5B_iterate(dset->ent.file, io_info->dxpl_id, H5B_ISTORE, H5D_istore_prune_extent, dset->shared->layout.u.chunk.addr, &udata) < 0) @@ -2826,11 +2880,10 @@ static int H5D_istore_prune_extent(H5F_t *f, hid_t dxpl_id, const void *_lt_key, haddr_t UNUSED addr, const void UNUSED *_rt_key, void *_udata) { - H5D_istore_ud1_t *bt_udata = (H5D_istore_ud1_t *)_udata; + H5D_istore_it_ud3_t *udata = (H5D_istore_it_ud3_t *)_udata; const H5D_istore_key_t *lt_key = (const H5D_istore_key_t *)_lt_key; unsigned u; - H5D_istore_ud1_t udata; - int ret_value=H5B_ITER_CONT; /* Return value */ + int ret_value = H5B_ITER_CONT; /* Return value */ /* The LT_KEY is the left key (the one that describes the chunk). It points to a chunk of * storage that contains the beginning of the logical address space represented by UDATA. @@ -2839,21 +2892,16 @@ H5D_istore_prune_extent(H5F_t *f, hid_t dxpl_id, const void *_lt_key, haddr_t UN FUNC_ENTER_NOAPI_NOINIT(H5D_istore_prune_extent) /* Figure out what chunks are no longer in use for the specified extent and release them */ - for(u = 0; u < bt_udata->mesg->u.chunk.ndims - 1; u++) - if((hsize_t)lt_key->offset[u] > bt_udata->dims[u]) { -#ifdef H5D_ISTORE_DEBUG - HDfputs("b-tree:remove:[", bt_udata->stream); - for(u = 0; u < bt_udata->mesg->u.chunk.ndims - 1; u++) - HDfprintf(bt_udata->stream, "%s%Hd", u ? ", " : "", lt_key->offset[u]); - HDfputs("]\n", bt_udata->stream); -#endif + for(u = 0; u < udata->common.mesg->u.chunk.ndims - 1; u++) + if((hsize_t)lt_key->offset[u] > udata->dims[u]) { + H5D_istore_ud0_t bt_udata; - HDmemset(&udata, 0, sizeof udata); - udata.key = *lt_key; - udata.mesg = bt_udata->mesg; + HDmemset(&bt_udata, 0, sizeof bt_udata); + bt_udata.key = *lt_key; + bt_udata.mesg = udata->common.mesg; /* Remove */ - if(H5B_remove(f, dxpl_id, H5B_ISTORE, bt_udata->mesg->u.chunk.addr, &udata) < 0) + if(H5B_remove(f, dxpl_id, H5B_ISTORE, udata->common.mesg->u.chunk.addr, &bt_udata) < 0) HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, H5B_ITER_ERROR, "unable to remove entry") break; } /* end if */ @@ -3128,7 +3176,7 @@ H5D_istore_delete(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout) /* Check if the B-tree has been created in the file */ if(H5F_addr_defined(layout->u.chunk.addr)) { H5O_layout_t tmp_layout=*layout;/* Local copy of layout info */ - H5D_istore_ud1_t udata; /* User data for B-tree iterator call */ + H5D_istore_ud0_t udata; /* User data for B-tree iterator call */ /* Set up user data for B-tree deletion */ HDmemset(&udata, 0, sizeof udata); @@ -3253,6 +3301,67 @@ done: /*------------------------------------------------------------------------- + * Function: H5D_istore_copy + * + * Purpose: copy an indexed storage B-tree from SRC file to DST file. + * + * Return: Non-negative on success (with the ISTORE argument initialized + * and ready to write to an object header). Negative on failure. + * + * Programmer: Peter Cao + * August 20, 2005 + * + *------------------------------------------------------------------------- + */ +herr_t +H5D_istore_copy(H5F_t *f_src, H5O_layout_t *layout_src, + H5F_t *f_dst, H5O_layout_t *layout_dst, hid_t dxpl_id) +{ + H5D_istore_it_ud4_t udata; + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(H5D_istore_copy, FAIL) + + /* Check args */ + HDassert(f_src); + HDassert(f_dst); + HDassert(layout_src && H5D_CHUNKED == layout_src->type); + HDassert(layout_dst && H5D_CHUNKED == layout_dst->type); + + /* Create shared B-tree info for each file */ + if(H5D_istore_shared_create(f_src, layout_src) < 0) + HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't create wrapper for shared B-tree info") + if(H5D_istore_shared_create(f_dst, layout_dst) < 0) + HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't create wrapper for shared B-tree info") + + /* Check if we need to create the B-tree in the dest. file */ + if(layout_dst->u.chunk.addr == HADDR_UNDEF) { + /* Create the root of the B-tree that describes chunked storage */ + if(H5D_istore_create(f_dst, dxpl_id, layout_dst) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTINIT, FAIL, "unable to initialize chunked storage") + } /* end if */ + + /* Initialize the callback structure for the source */ + HDmemset(&udata, 0, sizeof udata); + udata.common.mesg = layout_src; + udata.file_dst = f_dst; + udata.addr_dst = layout_dst->u.chunk.addr; + + /* copy the chunked data by iteration */ + if(H5B_iterate(f_src, dxpl_id, H5B_ISTORE, H5D_istore_iter_copy, layout_src->u.chunk.addr, &udata) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTINIT, FAIL, "unable to iterate over chunk B-tree") + +done: + if(H5RC_DEC(layout_src->u.chunk.btree_shared) < 0) + HDONE_ERROR(H5E_IO, H5E_CANTFREE, FAIL, "unable to decrement ref-counted page") + if(H5RC_DEC(layout_dst->u.chunk.btree_shared) < 0) + HDONE_ERROR(H5E_IO, H5E_CANTFREE, FAIL, "unable to decrement ref-counted page") + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5D_istore_copy() */ + + +/*------------------------------------------------------------------------- * Function: H5D_istore_dump_btree * * Purpose: Prints information about the storage B-tree to the specified @@ -3271,17 +3380,17 @@ herr_t H5D_istore_dump_btree(H5F_t *f, hid_t dxpl_id, FILE *stream, unsigned ndims, haddr_t addr) { H5O_layout_t layout; - H5D_istore_ud1_t udata; + H5D_istore_it_ud2_t udata; herr_t ret_value=SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5D_istore_dump_btree, FAIL) HDmemset(&udata, 0, sizeof udata); layout.u.chunk.ndims = ndims; - udata.mesg = &layout; + udata.common.mesg = &layout; udata.stream = stream; if(stream) - HDfprintf(stream, " Address: %a\n",addr); + HDfprintf(stream, " Address: %a\n", addr); if(H5B_iterate(f, dxpl_id, H5B_ISTORE, H5D_istore_iter_dump, addr, &udata)<0) HGOTO_ERROR(H5E_IO, H5E_CANTINIT, 0, "unable to iterate over chunk B-tree") @@ -3371,20 +3480,22 @@ H5D_istore_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int inden int fwidth, unsigned ndims) { H5O_layout_t layout; - H5D_istore_ud1_t udata; - herr_t ret_value=SUCCEED; /* Return value */ + H5D_istore_ud0_t udata; /* B-tree user data */ + herr_t ret_value = SUCCEED; /* Return value */ FUNC_ENTER_NOAPI(H5D_istore_debug,FAIL) layout.u.chunk.ndims = ndims; - HDmemset (&udata, 0, sizeof udata); - udata.mesg = &layout; /* Allocate the shared structure */ if(H5D_istore_shared_create(f, &layout)<0) HGOTO_ERROR (H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't create wrapper for shared B-tree info") - (void)H5B_debug (f, dxpl_id, addr, stream, indent, fwidth, H5B_ISTORE, &udata); + /* Set up B-tree user data */ + HDmemset(&udata, 0, sizeof udata); + udata.mesg = &layout; + + (void)H5B_debug(f, dxpl_id, addr, stream, indent, fwidth, H5B_ISTORE, &udata); /* Free the raw B-tree node buffer */ if(layout.u.chunk.btree_shared==NULL) diff --git a/src/H5Dpkg.h b/src/H5Dpkg.h index 04fce35..651f2b8 100644 --- a/src/H5Dpkg.h +++ b/src/H5Dpkg.h @@ -271,6 +271,8 @@ H5_DLL ssize_t H5D_istore_writevv(const H5D_io_info_t *io_info, const void *buf); H5_DLL haddr_t H5D_istore_get_addr(const H5D_io_info_t *io_info, struct H5D_istore_ud1_t *_udata); +H5_DLL herr_t H5D_istore_copy(H5F_t *f_src, H5O_layout_t *layout_src, + H5F_t *f_dst, H5O_layout_t *layout_dst, hid_t dxpl_id); /* Functions that operate on external file list (efl) storage */ H5_DLL ssize_t H5D_efl_readvv(const H5D_io_info_t *io_info, diff --git a/src/H5Dpublic.h b/src/H5Dpublic.h index 83074f2..0edabb3 100644 --- a/src/H5Dpublic.h +++ b/src/H5Dpublic.h @@ -88,29 +88,28 @@ extern "C" { typedef herr_t (*H5D_operator_t)(void *elem, hid_t type_id, unsigned ndim, const hsize_t *point, void *operator_data); -H5_DLL hid_t H5Dcreate (hid_t file_id, const char *name, hid_t type_id, +H5_DLL hid_t H5Dcreate(hid_t file_id, const char *name, hid_t type_id, hid_t space_id, hid_t plist_id); -H5_DLL hid_t H5Dopen (hid_t file_id, const char *name); -H5_DLL herr_t H5Dclose (hid_t dset_id); -H5_DLL hid_t H5Dget_space (hid_t dset_id); -H5_DLL herr_t H5Dget_space_status(hid_t dset_id, - H5D_space_status_t *allocation); -H5_DLL hid_t H5Dget_type (hid_t dset_id); -H5_DLL hid_t H5Dget_create_plist (hid_t dset_id); +H5_DLL hid_t H5Dopen(hid_t file_id, const char *name); +H5_DLL herr_t H5Dclose(hid_t dset_id); +H5_DLL hid_t H5Dget_space(hid_t dset_id); +H5_DLL herr_t H5Dget_space_status(hid_t dset_id, H5D_space_status_t *allocation); +H5_DLL hid_t H5Dget_type(hid_t dset_id); +H5_DLL hid_t H5Dget_create_plist(hid_t dset_id); H5_DLL hsize_t H5Dget_storage_size(hid_t dset_id); H5_DLL haddr_t H5Dget_offset(hid_t dset_id); -H5_DLL herr_t H5Dread (hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id, +H5_DLL herr_t H5Dread(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id, hid_t file_space_id, hid_t plist_id, void *buf/*out*/); -H5_DLL herr_t H5Dwrite (hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id, +H5_DLL herr_t H5Dwrite(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id, hid_t file_space_id, hid_t plist_id, const void *buf); -H5_DLL herr_t H5Dextend (hid_t dset_id, const hsize_t *size); +H5_DLL herr_t H5Dextend(hid_t dset_id, const hsize_t *size); H5_DLL herr_t H5Diterate(void *buf, hid_t type_id, hid_t space_id, H5D_operator_t op, void *operator_data); H5_DLL herr_t H5Dvlen_reclaim(hid_t type_id, hid_t space_id, hid_t plist_id, void *buf); H5_DLL herr_t H5Dvlen_get_buf_size(hid_t dataset_id, hid_t type_id, hid_t space_id, hsize_t *size); H5_DLL herr_t H5Dfill(const void *fill, hid_t fill_type, void *buf, hid_t buf_type, hid_t space); -H5_DLL herr_t H5Dset_extent (hid_t dset_id, const hsize_t *size); +H5_DLL herr_t H5Dset_extent(hid_t dset_id, const hsize_t *size); H5_DLL herr_t H5Ddebug(hid_t dset_id); @@ -118,4 +117,3 @@ H5_DLL herr_t H5Ddebug(hid_t dset_id); } #endif #endif /* _H5Dpublic_H */ - @@ -91,7 +91,6 @@ /* Interface initialization */ #define H5_INTERFACE_INIT_FUNC H5G_init_interface - /* Packages needed by this file... */ #include "H5private.h" /* Generic Functions */ #include "H5Aprivate.h" /* Attributes */ @@ -108,7 +107,6 @@ /* Local macros */ #define H5G_INIT_HEAP 8192 #define H5G_RESERVED_ATOMS 0 -#define H5G_SIZE_HINT 256 /*default root grp size hint */ /* * During name lookups (see H5G_namei()) we sometimes want information about @@ -149,6 +147,8 @@ typedef struct H5G_typeinfo_t { char *desc; /*description of object type */ } H5G_typeinfo_t; +/* Package variables */ + /* Local variables */ static H5G_typeinfo_t *H5G_type_g = NULL; /*object typing info */ static size_t H5G_ntypes_g = 0; /*entries in type table */ @@ -163,6 +163,9 @@ H5FL_DEFINE(H5G_shared_t); /* Declare extern the PQ free list for the wrapped strings */ H5FL_BLK_EXTERN(str_buf); +/* Declare a free list to manage haddr_t's */ +H5FL_DEFINE(haddr_t); + /* Private prototypes */ static herr_t H5G_register_type(H5G_obj_t type, htri_t(*isa)(H5G_entry_t*, hid_t), const char *desc); @@ -200,6 +203,8 @@ static htri_t H5G_common_path(const H5RS_str_t *fullpath_r, const H5RS_str_t *prefix_r); static H5RS_str_t *H5G_build_fullpath(const H5RS_str_t *prefix_r, const H5RS_str_t *name_r); static int H5G_replace_ent(void *obj_ptr, hid_t obj_id, void *key); +static herr_t H5G_copy(H5G_entry_t *ent_src, H5G_entry_t *loc_dst, + const char *name_dst, hid_t plist_id); /*------------------------------------------------------------------------- @@ -1036,6 +1041,50 @@ done: FUNC_LEAVE_API(ret_value); } + +/*------------------------------------------------------------------------- + * Function: H5Gcopy + * + * Purpose: Copy an object to destination location + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Peter Cao + * June 4, 2005 + * + *------------------------------------------------------------------------- + */ +herr_t +H5Gcopy(hid_t id_src, hid_t loc_dst, const char *name_dst, hid_t plist_id) +{ + H5G_entry_t *ent_src = NULL, *ent_dst=NULL; + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_API(H5Gcopy, FAIL) + + /* Check arguments */ + if(NULL == (ent_src = H5G_loc(id_src))) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location") + if(NULL == (ent_dst = H5G_loc(loc_dst))) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a location") + if(!name_dst || !*name_dst) + HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name specified") + +/* Get correct property list */ +/* XXX: This is a kludge, to use the datatype creation property list - QAK */ +if(H5P_DEFAULT == plist_id) + plist_id = H5P_DATATYPE_CREATE_DEFAULT; +else + if(TRUE != H5P_isa_class(plist_id, H5P_DATATYPE_CREATE)) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not object create property list") + + if(H5G_copy(ent_src, ent_dst, name_dst, plist_id) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object") + +done: + FUNC_LEAVE_API(ret_value) +} /* end H5Gcopy() */ + /* *------------------------------------------------------------------------- *------------------------------------------------------------------------- @@ -4214,3 +4263,60 @@ H5G_unmount(H5G_t *grp) FUNC_LEAVE_NOAPI(SUCCEED); } /* end H5G_unmount() */ + +/*------------------------------------------------------------------------- + * Function: H5G_copy + * + * Purpose: Copy an object to destination location + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Peter Cao + * June 4, 2005 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +H5G_copy(H5G_entry_t *ent_src, H5G_entry_t *loc_dst, + const char *name_dst, hid_t plist_id) +{ + H5P_genplist_t *oc_plist; /* Property list created */ + hid_t dxpl_id = H5AC_dxpl_id; + H5G_entry_t ent_new; + hbool_t entry_inserted = FALSE; /* Flag to indicate that the new entry was inserted into a group */ + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(H5G_copy, FAIL); + + HDassert(ent_src); + HDassert(ent_src->file); + HDassert(loc_dst); + HDassert(loc_dst->file); + HDassert(name_dst); + + /* Get the property list */ + if(NULL == (oc_plist = H5I_object(plist_id))) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a property list") + + /* Reset group entry for new object */ + H5G_ent_reset(&ent_new); + ent_new.file = loc_dst->file; + + /* copy the object from the source file to the destination file */ + if(H5O_copy_header(ent_src, &ent_new, dxpl_id) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object") + + /* Insert the new object in the destination file's group */ + if(H5G_insert(loc_dst, name_dst, &ent_new, dxpl_id, oc_plist) < 0) + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to insert the name") + entry_inserted = TRUE; + +done: + /* Free the ID to name buffers */ + if(entry_inserted) + H5G_free_ent_name(&ent_new); + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5G_copy() */ diff --git a/src/H5Gnode.c b/src/H5Gnode.c index faff6ba..5e053fd 100644 --- a/src/H5Gnode.c +++ b/src/H5Gnode.c @@ -68,7 +68,6 @@ static herr_t H5G_node_clear(H5F_t *f, H5G_node_t *sym, hbool_t destroy); static herr_t H5G_compute_size(const H5F_t *f, const H5G_node_t *sym, size_t *size_ptr); /* B-tree callbacks */ -static size_t H5G_node_sizeof_rkey(const H5F_t *f, const void *_udata); static H5RC_t *H5G_node_get_shared(const H5F_t *f, const void *_udata); static herr_t H5G_node_create(H5F_t *f, hid_t dxpl_id, H5B_ins_t op, void *_lt_key, void *_udata, void *_rt_key, @@ -109,7 +108,6 @@ const H5AC_class_t H5AC_SNODE[1] = {{ H5B_class_t H5B_SNODE[1] = {{ H5B_SNODE_ID, /*id */ sizeof(H5G_node_key_t), /*sizeof_nkey */ - H5G_node_sizeof_rkey, /*get_sizeof_rkey */ H5G_node_get_shared, /*get_shared */ H5G_node_create, /*new */ H5G_node_cmp2, /*cmp2 */ @@ -124,9 +122,6 @@ H5B_class_t H5B_SNODE[1] = {{ H5G_node_debug_key, /*debug */ }}; -/* Declare a free list to manage the H5B_shared_t struct */ -H5FL_EXTERN(H5B_shared_t); - /* Declare a free list to manage the H5G_node_t struct */ H5FL_DEFINE_STATIC(H5G_node_t); @@ -142,33 +137,8 @@ H5FL_SEQ_DEFINE_STATIC(size_t); /* Declare a free list to manage the raw page information */ H5FL_BLK_DEFINE_STATIC(grp_page); - -/*------------------------------------------------------------------------- - * Function: H5G_node_sizeof_rkey - * - * Purpose: Returns the size of a raw B-link tree key for the specified - * file. - * - * Return: Success: Size of the key. - * - * Failure: never fails - * - * Programmer: Robb Matzke - * matzke@llnl.gov - * Jul 14 1997 - * - * Modifications: - * - *------------------------------------------------------------------------- - */ -static size_t -H5G_node_sizeof_rkey(const H5F_t *f, const void UNUSED * udata) -{ - /* Use FUNC_ENTER_NOAPI_NOINIT_NOFUNC here to avoid performance issues */ - FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5G_node_sizeof_rkey); - - FUNC_LEAVE_NOAPI(H5F_SIZEOF_SIZE(f)); /*the name offset */ -} +/* Declare extern the free list to manage haddr_t's */ +H5FL_EXTERN(haddr_t); /*------------------------------------------------------------------------- @@ -1803,7 +1773,7 @@ H5G_node_init(H5F_t *f) /* Set up the "global" information for this file's groups */ shared->type= H5B_SNODE; shared->two_k=2*H5F_KVALUE(f,H5B_SNODE); - shared->sizeof_rkey = H5G_node_sizeof_rkey(f, NULL); + shared->sizeof_rkey = H5F_SIZEOF_SIZE(f); /*the name offset */ assert(shared->sizeof_rkey); shared->sizeof_rnode = H5B_nodesize(f, shared, &shared->sizeof_keys); assert(shared->sizeof_rnode); @@ -1894,6 +1864,106 @@ H5G_node_shared_free (void *_shared) /*------------------------------------------------------------------------- + * Function: H5G_node_copy + * + * Purpose: This function gets called during a group iterate operation + * to copy objects of this node into a new location. + * + * Return: 0(zero) on success/Negative on failure + * + * Programmer: Peter Cao + * Sept 10, 2005 + * + *------------------------------------------------------------------------- + */ +int +H5G_node_copy(H5F_t *f, hid_t dxpl_id, const void UNUSED *_lt_key, haddr_t addr, + const void UNUSED *_rt_key, void *_udata) +{ + H5G_bt_it_ud5_t *udata = (H5G_bt_it_ud5_t *)_udata; + const H5HL_t *heap = NULL; + H5G_node_t *sn = NULL; + unsigned int i; /* Local index variable */ + int ret_value = H5B_ITER_CONT; + + FUNC_ENTER_NOAPI(H5G_node_copy, H5B_ITER_ERROR) + + /* Check arguments. */ + HDassert(f); + HDassert(H5F_addr_defined(addr)); + HDassert(udata); + + /* load the symbol table into memory from the source file */ + if(NULL == (sn = H5AC_protect(f, dxpl_id, H5AC_SNODE, addr, NULL, NULL, H5AC_READ))) + HGOTO_ERROR(H5E_SYM, H5E_CANTLOAD, H5B_ITER_ERROR, "unable to load symbol table node") + + /* get the base address of the heap */ + if(NULL == (heap = H5HL_protect(f, dxpl_id, udata->heap_addr))) + HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, H5B_ITER_ERROR, "unable to protect symbol name") + + /* copy object in this node one by one */ + for(i = 0; i < sn->nsyms; i++) { + H5G_entry_t ent_new; /* New entry to insert into dest. group */ + H5G_entry_t *ent_src = &(sn->entry[i]); /* Convenience variable to refer to current source group entry */ + const char *name; /* Name of source object */ + + /* Set up symbol table entry for destination */ + H5G_ent_reset(&ent_new); + ent_new.file = udata->loc_dst->file; + + /* Determine name of source object */ + name = H5HL_offset_into(f, heap, ent_src->name_off); + HDassert(name); + + /* Check if object in source group is a hard link */ + if(H5F_addr_defined(ent_src->header)) { + /* Copy the shared object from source to destination */ + /* (Increments link count on destination) */ + if(H5O_copy_header_map(ent_src, &ent_new, dxpl_id, udata->map_list) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, H5B_ITER_ERROR, "unable to copy object") + } /* ( H5F_addr_defined(ent_src->header)) */ + else if(H5G_CACHED_SLINK == ent_src->type) { + /* it is a soft link */ + H5O_stab_t stab_mesg; + size_t offset_link; + char *name_link = H5HL_offset_into(f, heap, ent_src->cache.slink.lval_offset); + + /* read the symbol table where the soft link to be inserted */ + if(NULL == H5O_read(udata->loc_dst, H5O_STAB_ID, 0, &stab_mesg, dxpl_id)) + HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, H5B_ITER_ERROR, "unable to determine local heap address") + if((size_t)(-1) == (offset_link = H5HL_insert(udata->loc_dst->file, dxpl_id, + stab_mesg.heap_addr, HDstrlen(name_link) + 1, name_link))) + HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, H5B_ITER_ERROR, "unable to write link value to local heap") + H5O_reset (H5O_STAB_ID, &stab_mesg); + + /* Set up soft link to insert */ + ent_new.type = H5G_CACHED_SLINK; + ent_new.cache.slink.lval_offset = offset_link; + } /* else if */ + else + HDassert(0 && "Unknown entry type"); + + /* Insert the new object in the destination file's group */ + /* (Don't increment the link count - that's already done above for hard links) */ + if(H5G_stab_insert(udata->loc_dst, name, &ent_new, FALSE, dxpl_id) < 0) + HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, H5B_ITER_ERROR, "unable to insert the name") + + /* Free the ID to name buffers */ + H5G_free_ent_name(&ent_new); + } /* end of for (i=0; i<sn->nsyms; i++) */ + +done: + if (heap && H5HL_unprotect(f, dxpl_id, heap, udata->heap_addr, H5AC__NO_FLAGS_SET) < 0) + HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_ITER_ERROR, "unable to unprotect symbol name") + + if (sn && H5AC_unprotect(f, dxpl_id, H5AC_SNODE, addr, sn, H5AC__NO_FLAGS_SET) != SUCCEED) + HDONE_ERROR(H5E_SYM, H5E_PROTECT, H5B_ITER_ERROR, "unable to release object header") + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5G_node_copy() */ + + +/*------------------------------------------------------------------------- * Function: H5G_node_debug * * Purpose: Prints debugging information about a symbol table node diff --git a/src/H5Gpkg.h b/src/H5Gpkg.h index adb546f..4c6ec68 100644 --- a/src/H5Gpkg.h +++ b/src/H5Gpkg.h @@ -31,8 +31,11 @@ #include "H5Gprivate.h" /* Other private headers needed by this file */ -#include "H5ACprivate.h" /* Metadata cache */ +#include "H5ACprivate.h" /* Metadata cache */ #include "H5Oprivate.h" /* Object headers */ +#include "H5SLprivate.h" /* Skip lists */ + +#define H5G_SIZE_HINT 256 /* default root grp size hint */ /* * A symbol table node is a collection of symbol table entries. It can @@ -166,6 +169,13 @@ typedef struct H5G_bt_it_ud4_t { /* upward */ } H5G_bt_it_ud4_t; +/* Data passed to B-tree iteration for copying copy symblol table content */ +typedef struct H5G_bt_it_ud5_t { + H5SL_t *map_list; /* skip list to map copied object addresses */ + haddr_t heap_addr; /* heap address of the source symbol table */ + H5G_entry_t *loc_dst; /* group where new object is inserted to */ +} H5G_bt_it_ud5_t; + /* * This is the class identifier to give to the B-tree functions. */ @@ -187,6 +197,9 @@ H5_DLL herr_t H5G_stab_insert(H5G_entry_t *grp_ent, const char *name, H5G_entry_t *obj_ent, hbool_t inc_link, hid_t dxpl_id); H5_DLL herr_t H5G_stab_delete(H5F_t *f, hid_t dxpl_id, const H5O_stab_t *stab, hbool_t adj_link); H5_DLL herr_t H5G_stab_remove(H5G_entry_t *grp_ent, const char *name, hid_t dxpl_id); +H5_DLL herr_t H5G_stab_copy_tmp(H5F_t *f_dst, H5O_stab_t *stab_dst, + hid_t dxpl_id); + /* * Functions that understand symbol table entries. @@ -206,4 +219,7 @@ H5_DLL int H5G_node_name(H5F_t *f, hid_t dxpl_id, const void *_lt_key, haddr_t a const void *_rt_key, void *_udata); H5_DLL int H5G_node_type(H5F_t *f, hid_t dxpl_id, const void *_lt_key, haddr_t addr, const void *_rt_key, void *_udata); +H5_DLL int H5G_node_copy(H5F_t *f, hid_t dxpl_id, const void *_lt_key, haddr_t addr, + const void *_rt_key, void *_udata); + #endif diff --git a/src/H5Gpublic.h b/src/H5Gpublic.h index 2f82536..1a7807a 100644 --- a/src/H5Gpublic.h +++ b/src/H5Gpublic.h @@ -14,15 +14,13 @@ /*------------------------------------------------------------------------- * - * Created: H5Gproto.h + * Created: H5Gpublic.h * Jul 11 1997 * Robb Matzke <matzke@llnl.gov> * * Purpose: Public declarations for the H5G package (symbol * tables). * - * Modifications: - * *------------------------------------------------------------------------- */ #ifndef _H5Gpublic_H @@ -123,6 +121,8 @@ H5_DLL int H5Gget_comment(hid_t loc_id, const char *name, size_t bufsize, char *buf); H5_DLL hid_t H5Gcreate_expand(hid_t loc_id, const char *name, hid_t gcpl_id, hid_t gapl_id); +H5_DLL herr_t H5Gcopy(hid_t id_src, hid_t loc_dst, const char *name_dst, + hid_t plist_id); #ifdef __cplusplus } diff --git a/src/H5Gstab.c b/src/H5Gstab.c index 8c83859..b63e1cd 100644 --- a/src/H5Gstab.c +++ b/src/H5Gstab.c @@ -315,3 +315,50 @@ H5G_stab_delete(H5F_t *f, hid_t dxpl_id, const H5O_stab_t *stab, hbool_t adj_lin done: FUNC_LEAVE_NOAPI(ret_value); } /* end H5G_stab_delete() */ + + +/*------------------------------------------------------------------------- + * Function: H5G_stab_copy_tmp + * + * Purpose: copy a group symbol table and memeber objects from SRC file to DST file. + * + * Return: Non-negative on success + * Negative on failure. + * + * Programmer: Peter Cao + * September 10, 2005 + * + * Note: This routine should be replaced with proper call to "real" + * stab creation routine after the "big group revision" checkin + * occurs. -QAK + * + *------------------------------------------------------------------------- + */ +herr_t +H5G_stab_copy_tmp(H5F_t *f_dst, H5O_stab_t *stab_dst, hid_t dxpl_id) +{ + size_t size_init, name_offset; + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI(H5G_stab_copy_tmp, FAIL) + + HDassert(f_dst); + HDassert(stab_dst); + + /* create B-tree private heap */ + size_init = MAX(H5G_SIZE_HINT, H5HL_SIZEOF_FREE(f_dst) + 2); + if (H5HL_create(f_dst, dxpl_id, size_init, &(stab_dst->heap_addr))<0) + HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "can't create heap") + + name_offset = H5HL_insert(f_dst, dxpl_id, stab_dst->heap_addr, 1, ""); + if ((size_t)(-1)==name_offset) + HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "can't initialize heap") + assert(0 == name_offset); + + /* create the B-tree */ + if (H5B_create(f_dst, dxpl_id, H5B_SNODE, NULL, &(stab_dst->btree_addr)) < 0) + HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "can't create B-tree") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5G_stab_copy_tmp() */ @@ -64,6 +64,12 @@ typedef struct { typedef herr_t (*H5O_operator_int_t)(H5O_mesg_t *mesg/*in,out*/, unsigned idx, unsigned * oh_flags_ptr, void *operator_data/*in,out*/); +/* Node in skip list to map addresses from one file to another during object header copy */ +typedef struct H5O_addr_map_t { + haddr_t src_addr; /* Address of object in source file */ + haddr_t dst_addr; /* Address of object in destination file */ +} H5O_addr_map_t; + /* PRIVATE PROTOTYPES */ static herr_t H5O_init(H5F_t *f, hid_t dxpl_id, size_t size_hint, H5G_entry_t *ent/*out*/, haddr_t header); @@ -107,6 +113,14 @@ static herr_t H5O_write_mesg(H5O_t *oh, unsigned idx, const H5O_class_t *type, unsigned * oh_flags_ptr); static herr_t H5O_iterate_real(const H5G_entry_t *ent, const H5O_class_t *type, H5AC_protect_t prot, hbool_t internal, void *op, void *op_data, hid_t dxpl_id); +static void * H5O_copy_mesg_file(const H5O_class_t *type, H5F_t *file_src, + void *mesg_src, H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void *udata); +static herr_t H5O_post_copy_mesg_file(const H5O_class_t *type, H5F_t *file_src, + const void *mesg_src, H5G_entry_t *loc_dst, + hid_t dxpl_id, H5SL_t *map_list); +static herr_t H5O_copy_header_real(const H5G_entry_t *ent_src, + H5G_entry_t *ent_dst /*out */, hid_t dxpl_id, H5SL_t *map_list); +static herr_t H5O_copy_free_addrmap_cb(void *item, void *key, void *op_data); /* Metadata cache callbacks */ static H5O_t *H5O_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_udata1, @@ -153,6 +167,8 @@ static const H5O_class_t *const message_type_g[] = { H5O_MTIME_NEW, /*0x0012 New Object modification date and time */ }; +/* Library private variables */ + /* * An array of functions indexed by symbol table entry cache type * (H5G_type_t) that are called to retrieve constant messages cached in the @@ -180,6 +196,9 @@ H5FL_EXTERN(time_t); /* Declare extern the free list for H5O_cont_t's */ H5FL_EXTERN(H5O_cont_t); +/* Declare a free list to manage the H5O_addr_map_t struct */ +H5FL_DEFINE_STATIC(H5O_addr_map_t); + /*------------------------------------------------------------------------- * Function: H5O_init_interface @@ -584,12 +603,8 @@ H5O_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED * _udata1, p += 3; /*reserved*/ /* Try to detect invalidly formatted object header messages */ - if (p + mesg_size > oh->chunk[chunkno].image + chunk_size) { - - HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, \ - "corrupt object header"); - } - + if (p + mesg_size > oh->chunk[chunkno].image + chunk_size) + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "corrupt object header"); /* Skip header messages we don't know about */ /* (Usually from future versions of the library */ @@ -680,7 +695,6 @@ H5O_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5O_t *oh) int id; unsigned u; H5O_mesg_t *curr_msg; /* Pointer to current message being operated on */ - H5O_cont_t *cont = NULL; herr_t (*encode)(H5F_t*, uint8_t*, const void*) = NULL; unsigned combine=0; /* Whether to combine the object header prefix & the first chunk */ herr_t ret_value=SUCCEED; /* Return value */ @@ -2259,8 +2273,7 @@ H5O_new_mesg(H5F_t *f, H5O_t *oh, unsigned *flags, const H5O_class_t *orig_type, HGOTO_ERROR (H5E_OHDR, H5E_CANTINIT, UFAIL, "object header message is too large (16k max)"); /* Allocate space in the object headed for the message */ - if ((ret_value = H5O_alloc(f, dxpl_id, oh, - orig_type, size, oh_flags_ptr)) == UFAIL) + if ((ret_value = H5O_alloc(f, dxpl_id, oh, orig_type, size, oh_flags_ptr)) == UFAIL) HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, UFAIL, "unable to allocate space for message"); /* Increment any links in message */ @@ -3045,8 +3058,8 @@ H5O_alloc_new_chunk(H5F_t *f, H5O_cont_t *cont = NULL; /*native continuation message */ int chunkno; unsigned u; - unsigned ret_value; /*return value */ haddr_t new_chunk_addr; + unsigned ret_value; /*return value */ FUNC_ENTER_NOAPI_NOINIT(H5O_alloc_new_chunk); @@ -3088,10 +3101,8 @@ H5O_alloc_new_chunk(H5F_t *f, * message, then make sure the new chunk has enough room for that * other message. */ - if ( found_null < 0 ) { - + if (found_null < 0) size += H5O_SIZEOF_MSGHDR(f) + oh->mesg[found_other].raw_size; - } /* * The total chunk size must include the requested space plus enough @@ -3103,11 +3114,8 @@ H5O_alloc_new_chunk(H5F_t *f, /* allocate space in file to hold the new chunk */ new_chunk_addr = H5MF_alloc(f, H5FD_MEM_OHDR, dxpl_id, (hsize_t)size); - if ( HADDR_UNDEF == new_chunk_addr ) { - - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, \ - "unable to allocate space for new chunk"); - } + if(HADDR_UNDEF == new_chunk_addr) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, "unable to allocate space for new chunk") /* * Create the new chunk giving it a file address. @@ -3117,11 +3125,8 @@ H5O_alloc_new_chunk(H5F_t *f, unsigned na = oh->alloc_nchunks + H5O_NCHUNKS; H5O_chunk_t *x = H5FL_SEQ_REALLOC (H5O_chunk_t, oh->chunk, (size_t)na); - if ( !x ) { - - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, \ - "memory allocation failed"); - } + if (!x) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, "memory allocation failed"); oh->alloc_nchunks = na; oh->chunk = x; } @@ -3142,11 +3147,8 @@ H5O_alloc_new_chunk(H5F_t *f, unsigned na = oh->alloc_nmesgs + MAX (H5O_NMESGS, 3); H5O_mesg_t *x = H5FL_SEQ_REALLOC (H5O_mesg_t, oh->mesg, (size_t)na); - if ( !x ) { - - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, \ - "memory allocation failed"); - } + if (!x) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL, "memory allocation failed"); oh->alloc_nmesgs = na; oh->mesg = x; @@ -3211,11 +3213,8 @@ H5O_alloc_new_chunk(H5F_t *f, */ oh->mesg[found_null].type = H5O_CONT; oh->mesg[found_null].dirty = TRUE; - if (NULL==(cont = H5FL_MALLOC(H5O_cont_t))) { - - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, \ - "memory allocation failed"); - } + if (NULL==(cont = H5FL_MALLOC(H5O_cont_t))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, "memory allocation failed") cont->addr = oh->chunk[chunkno].addr; cont->size = oh->chunk[chunkno].size; cont->chunkno = chunkno; @@ -3226,7 +3225,6 @@ H5O_alloc_new_chunk(H5F_t *f, done: FUNC_LEAVE_NOAPI(ret_value); - } /* H5O_alloc_new_chunk() */ @@ -3270,7 +3268,7 @@ H5O_alloc(H5F_t *f, size_t size, unsigned * oh_flags_ptr) { - unsigned idx = UFAIL; + unsigned idx; H5O_mesg_t *msg; /* Pointer to newly allocated message */ size_t aligned_size = H5O_ALIGN(size); htri_t tri_result; @@ -3310,8 +3308,7 @@ H5O_alloc(H5F_t *f, * Note that in this new version of this function, all chunks * must have file space allocated to them. */ - for ( chunkno = 0; chunkno < oh->nchunks; chunkno++ ) - { + for (chunkno = 0; chunkno < oh->nchunks; chunkno++) { HDassert( H5F_addr_defined(oh->chunk[chunkno].addr) ); tri_result = H5O_alloc_extend_chunk(f, oh, chunkno, size, &idx); @@ -3334,13 +3331,9 @@ H5O_alloc(H5F_t *f, /* if idx is still UFAIL, we were not able to extend a chunk. * Create a new one. */ - if (idx == UFAIL) { - - if ( (idx = H5O_alloc_new_chunk(f, dxpl_id, oh, size)) == UFAIL ) { - - HGOTO_ERROR(H5E_OHDR, H5E_NOSPACE, UFAIL, \ - "unable to create a new object header data chunk"); - } + if(idx == UFAIL) { + if((idx = H5O_alloc_new_chunk(f, dxpl_id, oh, size)) == UFAIL) + HGOTO_ERROR(H5E_OHDR, H5E_NOSPACE, UFAIL, "unable to create a new object header data chunk") } } @@ -3349,35 +3342,26 @@ H5O_alloc(H5F_t *f, /* do we need to split the null message? */ if (msg->raw_size > aligned_size) { - H5O_mesg_t *null_msg; /* Pointer to null message */ + size_t mesg_size = aligned_size+ H5O_SIZEOF_MSGHDR(f); /* Total size of newly allocated message */ - size_t mesg_size = aligned_size + H5O_SIZEOF_MSGHDR(f); - /* Total size of newly allocated message */ - - HDassert( msg->raw_size - aligned_size >= H5O_SIZEOF_MSGHDR(f) ); + HDassert(msg->raw_size - aligned_size >= H5O_SIZEOF_MSGHDR(f)); if (oh->nmesgs >= oh->alloc_nmesgs) { - int old_alloc=oh->alloc_nmesgs; unsigned na = oh->alloc_nmesgs + H5O_NMESGS; H5O_mesg_t *x = H5FL_SEQ_REALLOC(H5O_mesg_t, oh->mesg, (size_t)na); - if (!x) { - - HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, \ - "memory allocation failed"); - } - oh->alloc_nmesgs = na; - oh->mesg = x; + if (!x) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL, "memory allocation failed"); + oh->alloc_nmesgs = na; + oh->mesg = x; /* Set new object header info to zeros */ HDmemset(&oh->mesg[old_alloc],0, (oh->alloc_nmesgs-old_alloc)*sizeof(H5O_mesg_t)); - /* "Retarget" local 'msg' pointer into newly allocated array - * of messages - */ + /* "Retarget" local 'msg' pointer into newly allocated array of messages */ msg=&oh->mesg[idx]; } null_msg = &(oh->mesg[oh->nmesgs++]); @@ -3402,7 +3386,6 @@ H5O_alloc(H5F_t *f, done: FUNC_LEAVE_NOAPI(ret_value); - } /* H5O_alloc() */ #ifdef NOT_YET @@ -4078,6 +4061,432 @@ done: /*------------------------------------------------------------------------- + * Function: H5O_copy_mesg_file + * + * Purpose: Copies a message to file. If MESG is is the null pointer then a null + * pointer is returned with no error. + * + * Return: Success: Ptr to the new message + * + * Failure: NULL + * + * Programmer: Peter Cao + * June 4, 2005 + * + *------------------------------------------------------------------------- + */ +static void * +H5O_copy_mesg_file(const H5O_class_t *type, H5F_t *file_src, + void *native_src, H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void *udata) +{ + void *ret_value; + + FUNC_ENTER_NOAPI_NOINIT(H5O_copy_mesg_file) + + /* check args */ + HDassert(type); + HDassert(type->copy_file); + HDassert(file_src); + HDassert(native_src); + HDassert(file_dst); + HDassert(map_list); + + if(NULL == (ret_value = (type->copy_file)(file_src, native_src, file_dst, dxpl_id, map_list, udata))) + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "unable to copy object header message to file") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5O_copy_mesg_file() */ + + +/*------------------------------------------------------------------------- + * Function: H5O_post_copy_mesg_file + * + * Purpose: Copies what's left to file after the object a meesage is copied. + * This function is need for situations like copying symbol tables. + * Copying a member of symbol table requires the parent object header + * exists in file. For this case, the first round of the message will + * create symbol table enttries but will not go deep copying member + * objects in the symbol table. The post copy will do that. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Peter Cao + * September 28, 2005 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5O_post_copy_mesg_file (const H5O_class_t *type, H5F_t *file_src, + const void *mesg_src, H5G_entry_t *loc_dst, + hid_t dxpl_id, H5SL_t *map_list) +{ + herr_t ret_value = SUCCEED; + + FUNC_ENTER_NOAPI_NOINIT(H5O_post_copy_mesg_file) + + /* check args */ + HDassert(type); + HDassert(file_src); + HDassert(mesg_src); + HDassert(loc_dst->file); + HDassert(map_list); + + if(type->post_copy_file && (type->post_copy_file)(file_src, mesg_src, loc_dst, dxpl_id, map_list) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to copy object header message to file") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* H5O_post_copy_mesg_file */ + + +/*------------------------------------------------------------------------- + * Function: H5O_copy_header_real + * + * Purpose: copy header object from one location to another. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Peter Cao + * May 30, 2005 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +H5O_copy_header_real(const H5G_entry_t *ent_src, + H5G_entry_t *ent_dst /*out */, hid_t dxpl_id, H5SL_t *map_list) +{ + H5O_addr_map_t *addr_map; /* Address mapping of object copied */ + uint8_t buf[16], *p; + H5O_t *oh = NULL; + unsigned chunkno = 0, mesgno = 0; + size_t chunk_size, hdr_size; + haddr_t addr_new; + H5O_mesg_t *mesg_src; + H5O_chunk_t *chunk; + herr_t ret_value = SUCCEED; + + FUNC_ENTER_NOAPI_NOINIT(H5O_copy_header_real) + + HDassert(ent_src); + HDassert(ent_src->file); + HDassert(H5F_addr_defined(ent_src->header)); + HDassert(ent_dst->file); + HDassert(map_list); + + if(NULL == (oh = H5AC_protect(ent_src->file, dxpl_id, H5AC_OHDR, ent_src->header, NULL, NULL, H5AC_READ))) + HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header") + + /* get the size of the file header of the destination file */ + hdr_size = H5O_SIZEOF_HDR(ent_dst->file); + + /* allocate memory space for the destitnation chunks */ + if(NULL == (chunk = H5FL_SEQ_MALLOC(H5O_chunk_t, (size_t)oh->nchunks))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") + + /* Allocate space for the first chunk */ + if(HADDR_UNDEF == (addr_new = H5MF_alloc(ent_dst->file, H5FD_MEM_OHDR, dxpl_id, (hsize_t)hdr_size + oh->chunk[0].size))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for object header") + + /* Return the first chunk address */ + ent_dst->header = addr_new; + + /* Set chunk's address */ + chunk[0].addr = addr_new + (hsize_t)hdr_size; + + /* Encode header information */ + p = buf; + + /* encode version */ + *p++ = H5O_VERSION; + + /* reserved */ + *p++ = 0; + + /* encode number of messages */ + UINT16ENCODE(p, oh->nmesgs); + + /* encode link count (at zero initially) */ + UINT32ENCODE(p, 0); + + /* encode body size */ + UINT32ENCODE(p, oh->chunk[0].size); + + /* zero to alignment */ + HDmemset(p, 0, (size_t)(hdr_size-12)); + + /* need to allocate all the chunks for the destination before copy the chunk message + because continuation chunk message will need to know the chunk address of address of + continuation block. + */ + for(chunkno = 1; chunkno < oh->nchunks; chunkno++) { + if(HADDR_UNDEF == (chunk[chunkno].addr = H5MF_alloc(ent_dst->file, H5FD_MEM_OHDR, dxpl_id, (hsize_t)oh->chunk[chunkno].size))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for object header") + } /* end for */ + + /* Loop through chunks to copy chunk information */ + for(chunkno = 0; chunkno < oh->nchunks; chunkno++) { + chunk_size = oh->chunk[chunkno].size; + + /* copy chunk information */ + chunk[chunkno].dirty = oh->chunk[chunkno].dirty; + chunk[chunkno].size = chunk_size; + + /* create memory image for the new chunk */ + if(NULL == (chunk[chunkno].image = H5FL_BLK_MALLOC(chunk_image,chunk_size))) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") + + /* copy the chunk image from source to destination in memory */ + /* (This copies over all the messages which don't require special + * callbacks to fix them up.) + */ + HDmemcpy(chunk[chunkno].image, oh->chunk[chunkno].image, chunk_size); + + /* Loop through messages, to fix up any which refer to addresses in the source file, etc. */ + for(mesgno = 0; mesgno < oh->nmesgs; mesgno++) { + const H5O_class_t *copy_type; + + mesg_src = &(oh->mesg[mesgno]); + + /* check if the message belongs to this chunk */ + if(mesg_src->chunkno != chunkno) + continue; + + if (mesg_src->flags & H5O_FLAG_SHARED) + copy_type = H5O_SHARED; + else + copy_type = mesg_src->type; + + /* copy this message into destination file */ + HDassert(copy_type); + if(copy_type->copy_file) { + void *dst_native; /* Pointer to copy of native information for current message */ + + /* + * Decode the message if necessary. If the message is shared then d + * a shared message, ignoring the message type. + */ + if(NULL == mesg_src->native) { + /* Decode the message if necessary */ + HDassert(copy_type->decode); + if(NULL == (mesg_src->native = (copy_type->decode)(ent_src->file, dxpl_id, mesg_src->raw, NULL))) + HGOTO_ERROR(H5E_OHDR, H5E_CANTDECODE, FAIL, "unable to decode a message") + } /* end if (NULL == mesg_src->native) */ + + /* Copy the source message */ + if(H5O_CONT_ID == copy_type->id) { + if((dst_native = H5O_copy_mesg_file(copy_type, ent_src->file, mesg_src->native, + ent_dst->file, dxpl_id, map_list, chunk)) == NULL) + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object header message") + } /* end if */ + else { + if((dst_native = H5O_copy_mesg_file(copy_type, ent_src->file, mesg_src->native, + ent_dst->file, dxpl_id, map_list, NULL)) == NULL) + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object header message") + } /* end else */ + + /* Calculate address in destination raw chunk */ + p = chunk[chunkno].image + (mesg_src->raw - oh->chunk[chunkno].image); + + /* + * Encode the message. If the message is shared then we + * encode a Shared Object message instead of the object + * which is being shared. + */ + if((copy_type->encode)(ent_dst->file, p, dst_native) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTENCODE, FAIL, "unable to encode object header message") + + /* Release native destination info */ + H5O_free_real(copy_type, dst_native); + } /* end if (mesg_src->type && mesg_src->type->copy_file) */ + } /* end of mesgno loop */ + + /* Write the object header to the file if this is the first chunk */ + if(chunkno == 0) + if(H5F_block_write(ent_dst->file, H5FD_MEM_OHDR, addr_new, hdr_size, dxpl_id, buf) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "unable to write object header hdr to disk") + + /* Write this chunk into disk */ + if(H5F_block_write(ent_dst->file, H5FD_MEM_OHDR, chunk[chunkno].addr, chunk[chunkno].size, dxpl_id, chunk[chunkno].image) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "unable to write object header data to disk") + } /* end of chunkno loop */ + + /* Allocate space for the address mapping of the object copied */ + if(NULL == (addr_map = H5FL_MALLOC(H5O_addr_map_t))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed") + + /* Insert the address mapping for the new object into the copied list */ + /* (Do this here, because "post copy" possibly checks it) */ + addr_map->src_addr = ent_src->header; + addr_map->dst_addr = ent_dst->header; + if(H5SL_insert(map_list, addr_map, &(addr_map->src_addr)) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTINSERT, FAIL, "can't insert object into skip list") + + /* "post copy" loop over messages */ + for(mesgno = 0; mesgno < oh->nmesgs; mesgno++) { + const H5O_class_t *copy_type; + + mesg_src = &(oh->mesg[mesgno]); + + if (mesg_src->flags & H5O_FLAG_SHARED) + copy_type = H5O_SHARED; + else + copy_type = mesg_src->type; + + HDassert(copy_type); + if(mesg_src->native) { + if((H5O_post_copy_mesg_file(copy_type, ent_src->file, mesg_src->native, + ent_dst, dxpl_id, map_list)) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object header message") + } /* end if */ + } /* end for */ + +done: + /* Release pointer to object header itself */ + if(oh != NULL) { + for(chunkno = 0; chunkno < oh->nchunks; chunkno++) + H5FL_BLK_FREE(chunk_image, chunk[chunkno].image); + H5FL_SEQ_FREE(H5O_chunk_t, chunk); + + if(H5AC_unprotect(ent_src->file, dxpl_id, H5AC_OHDR, ent_src->header, oh, H5AC__NO_FLAGS_SET) < 0) + HDONE_ERROR(H5E_OHDR, H5E_PROTECT, FAIL, "unable to release object header") + } /* end if */ + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5O_copy_header_real() */ + + +/*------------------------------------------------------------------------- + * Function: H5O_copy_header_map + * + * Purpose: Copy header object from one location to another, detecting + * already mapped objects, etc. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Quincey Koziol + * November 1, 2005 + * + *------------------------------------------------------------------------- + */ +herr_t +H5O_copy_header_map(const H5G_entry_t *ent_src, + H5G_entry_t *ent_dst /*out */, hid_t dxpl_id, H5SL_t *map_list) +{ + H5O_addr_map_t *addr_map; /* Address mapping of object copied */ + herr_t ret_value = SUCCEED; + + FUNC_ENTER_NOAPI(H5O_copy_header_map, FAIL) + + /* Sanity check */ + HDassert(ent_src); + HDassert(ent_dst); + HDassert(ent_dst->file); + HDassert(map_list); + + /* Look up the address of the object to copy in the skip list */ + addr_map = (H5O_addr_map_t *)H5SL_search(map_list, &(ent_src->header)); + + /* Check if address is already in list of objects copied */ + if(addr_map == NULL) { + /* Copy object for the first time */ + + /* Copy object referred to */ + if(H5O_copy_header_real(ent_src, ent_dst, dxpl_id, map_list) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object") + } /* end if */ + else { + /* Object has already been copied, set it's address in destination file */ + ent_dst->header = addr_map->dst_addr; + } /* end else */ + + /* Increment destination object's link count */ + if(H5O_link(ent_dst, 1, dxpl_id) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to increment object link count") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5O_copy_header_map() */ + + +/*-------------------------------------------------------------------------- + NAME + H5O_copy_free_addrmap_cb + PURPOSE + Internal routine to free address maps from the skip list for copying objects + USAGE + herr_t H5O_copy_free_addrmap_cb(item, key, op_data) + void *item; IN/OUT: Pointer to addr + void *key; IN/OUT: (unused) + void *op_data; IN: (unused) + RETURNS + Returns zero on success, negative on failure. + DESCRIPTION + Releases the memory for the address. + GLOBAL VARIABLES + COMMENTS, BUGS, ASSUMPTIONS + EXAMPLES + REVISION LOG +--------------------------------------------------------------------------*/ +static herr_t +H5O_copy_free_addrmap_cb(void *item, void UNUSED *key, void UNUSED *op_data) +{ + FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_copy_free_addrmap_cb) + + HDassert(item); + + /* Release the item */ + H5FL_FREE(H5O_addr_map_t, item); + + FUNC_LEAVE_NOAPI(0) +} /* H5O_copy_free_addrmap_cb() */ + + +/*------------------------------------------------------------------------- + * Function: H5O_copy_header + * + * Purpose: copy header object from one location to another. + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Peter Cao + * May 30, 2005 + * + *------------------------------------------------------------------------- + */ +herr_t +H5O_copy_header(const H5G_entry_t *ent_src, + H5G_entry_t *ent_dst /*out */, hid_t dxpl_id) +{ + H5SL_t *map_list = NULL; /* Skip list to hold address mappings */ + herr_t ret_value = SUCCEED; + + FUNC_ENTER_NOAPI(H5O_copy_header, FAIL) + + HDassert(ent_src); + HDassert(ent_src->file); + HDassert(H5F_addr_defined(ent_src->header)); + HDassert(ent_dst->file); + + /* Create a skip list to keep track of which objects are copied */ + if((map_list = H5SL_create(H5SL_TYPE_HADDR, 0.5, 16)) == NULL) + HGOTO_ERROR(H5E_SLIST, H5E_CANTCREATE, FAIL, "cannot make skip list") + + /* copy the object from the source file to the destination file */ + if(H5O_copy_header_real(ent_src, ent_dst, dxpl_id, map_list) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object") + +done: + if(map_list) + H5SL_destroy(map_list, H5O_copy_free_addrmap_cb, NULL); + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5O_copy_header() */ + + +/*------------------------------------------------------------------------- * Function: H5O_debug_id * * Purpose: Act as a proxy for calling the 'debug' method for a diff --git a/src/H5Oattr.c b/src/H5Oattr.c index abff4f3..9ac5570 100644 --- a/src/H5Oattr.c +++ b/src/H5Oattr.c @@ -35,6 +35,8 @@ static herr_t H5O_attr_reset (void *_mesg); static herr_t H5O_attr_free (void *mesg); static herr_t H5O_attr_delete (H5F_t *f, hid_t dxpl_id, const void *_mesg, hbool_t adj_link); static herr_t H5O_attr_link(H5F_t *f, hid_t dxpl_id, const void *_mesg); +static void *H5O_attr_copy_file(H5F_t *file_src, void *native_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void *udata); static herr_t H5O_attr_debug (H5F_t *f, hid_t dxpl_id, const void *_mesg, FILE * stream, int indent, int fwidth); @@ -53,7 +55,9 @@ const H5O_class_t H5O_ATTR[1] = {{ H5O_attr_link, /* link method */ NULL, /* get share method */ NULL, /* set share method */ - H5O_attr_debug, /* debug the message */ + H5O_attr_copy_file, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_attr_debug /* debug the message */ }}; /* This is the initial version, which does not have support for shared datatypes */ @@ -65,12 +69,6 @@ const H5O_class_t H5O_ATTR[1] = {{ /* Flags for attribute flag encoding */ #define H5O_ATTR_FLAG_TYPE_SHARED 0x01 -/* Declare extern the free list for H5A_t's */ -H5FL_EXTERN(H5A_t); - -/* Declare extern the free list for attribute data buffers */ -H5FL_BLK_EXTERN(attr_buf); - /* Declare external the free list for H5S_t's */ H5FL_EXTERN(H5S_t); @@ -595,6 +593,95 @@ done: } /* end H5O_attr_link() */ +/*------------------------------------------------------------------------- + * Function: H5O_attr_copy_file + * + * Purpose: Copies a message from _MESG to _DEST in file + * + * Return: Success: Ptr to _DEST + * + * Failure: NULL + * + * Programmer: Quincey Koziol + * November 1, 2005 + * + *------------------------------------------------------------------------- + */ +static void * +H5O_attr_copy_file(H5F_t UNUSED *file_src, void *native_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void UNUSED *udata) +{ + H5A_t *attr_src = (H5A_t *)native_src; + H5A_t *attr_dst = NULL; + void *ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5O_attr_copy_file) + + /* check args */ + HDassert(attr_src); + HDassert(file_dst); + HDassert(map_list); + + /* Allocate space for the destination message */ + if(NULL == (attr_dst = H5FL_CALLOC(H5A_t))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + /* Copy the top level of the attribute */ + *attr_dst = *attr_src; + + /* Don't have an opened group entry for copy */ + H5G_ent_reset(&(attr_dst->ent)); + attr_dst->ent_opened = 0; + + /* Copy attribute's name */ + attr_dst->name = H5MM_strdup(attr_src->name); + + /* Copy attribute's datatype */ + /* (Start destination datatype as transient, even if source is named) */ + attr_dst->dt = H5T_copy(attr_src->dt, H5T_COPY_ALL); + + /* Check for named datatype being copied */ + if(H5T_committed(attr_src->dt)) { + H5G_entry_t *ent_src; /* Pointer to source datatype's group entry */ + H5G_entry_t *ent_dst; /* Pointer to dest. datatype's group entry */ + + /* Get group entries for source & destination */ + ent_src = H5T_entof(attr_src->dt); + HDassert(ent_src); + ent_dst = H5T_entof(attr_dst->dt); + HDassert(ent_dst); + + /* Reset group entry for new object */ + H5G_ent_reset(ent_dst); + ent_dst->file = file_dst; + + /* Copy the shared object from source to destination */ + if(H5O_copy_header_map(ent_src, ent_dst, dxpl_id, map_list) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy object") + } /* end if */ + + /* Copy the guts of the attribute */ + attr_dst->ds = H5S_copy(attr_src->ds, FALSE); + + if(attr_src->data) { + if(NULL == (attr_dst->data = H5FL_BLK_MALLOC(attr_buf, attr_src->data_size))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + HDmemcpy(attr_dst->data, attr_src->data, attr_src->data_size); + } /* end if */ + + /* Set return value */ + ret_value = attr_dst; + +done: + if(!ret_value) + if(attr_dst) + (void)H5A_free(attr_dst); + + FUNC_LEAVE_NOAPI(ret_value) +} /* H5O_attr_copy_file() */ + + /*-------------------------------------------------------------------------- NAME H5O_attr_debug diff --git a/src/H5Obogus.c b/src/H5Obogus.c index 54a52b2..7296860 100644 --- a/src/H5Obogus.c +++ b/src/H5Obogus.c @@ -60,7 +60,9 @@ const H5O_class_t H5O_BOGUS[1] = {{ NULL, /* link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_bogus_debug, /*debug the message */ + NULL, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_bogus_debug /*debug the message */ }}; diff --git a/src/H5Ocont.c b/src/H5Ocont.c index e62ca07..afa5ab7 100644 --- a/src/H5Ocont.c +++ b/src/H5Ocont.c @@ -42,6 +42,8 @@ static void *H5O_cont_decode(H5F_t *f, hid_t dxpl_id, const uint8_t *p, H5O_shar static herr_t H5O_cont_encode(H5F_t *f, uint8_t *p, const void *_mesg); static size_t H5O_cont_size(const H5F_t *f, const void *_mesg); static herr_t H5O_cont_free(void *mesg); +static void *H5O_cont_copy_file(H5F_t *file_src, void *mesg_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void *udata); static herr_t H5O_cont_debug(H5F_t *f, hid_t dxpl_id, const void *_mesg, FILE * stream, int indent, int fwidth); @@ -60,7 +62,9 @@ const H5O_class_t H5O_CONT[1] = {{ NULL, /* link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_cont_debug, /*debugging */ + H5O_cont_copy_file, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_cont_debug /*debugging */ }}; /* Declare the free list for H5O_cont_t's */ @@ -209,6 +213,54 @@ H5O_cont_free (void *mesg) /*------------------------------------------------------------------------- + * Function: H5O_cont_copy_file + * + * Purpose: Copies a continuation block message from _MESG to _DEST in file + * + * Return: Success: Ptr to _DEST + * + * Failure: NULL + * + * Programmer: Peter Cao + * September 22, 2005 + * + *------------------------------------------------------------------------- + */ +static void * +H5O_cont_copy_file(H5F_t UNUSED *file_src, void *mesg_src, + H5F_t *file_dst, hid_t UNUSED dxpl_id, H5SL_t UNUSED *map_list, void *udata) +{ + H5O_cont_t *cont_src = (H5O_cont_t *) mesg_src; + H5O_chunk_t *chunk = (H5O_chunk_t *)udata; + H5O_cont_t *cont_dst = NULL; + void *ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5O_cont_copy_file) + + /* check args */ + HDassert(cont_src); + HDassert(file_dst); + + /* Allocate space for the destination cont */ + if(NULL == (cont_dst = H5FL_MALLOC(H5O_cont_t))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + HDmemcpy(cont_dst, cont_src, sizeof(H5O_cont_t)); + cont_dst->addr = chunk[cont_src->chunkno].addr; + + /* Set return value */ + ret_value = cont_dst; + +done: + if(!ret_value) + if(cont_dst) + H5FL_FREE(H5O_cont_t, cont_dst); + + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5O_cont_copy_file() */ + + +/*------------------------------------------------------------------------- * Function: H5O_cont_debug * * Purpose: Prints debugging info. diff --git a/src/H5Odtype.c b/src/H5Odtype.c index 0eed438..05ca879 100644 --- a/src/H5Odtype.c +++ b/src/H5Odtype.c @@ -53,7 +53,9 @@ const H5O_class_t H5O_DTYPE[1] = {{ NULL, /* link method */ H5O_dtype_get_share, /* get share method */ H5O_dtype_set_share, /* set share method */ - H5O_dtype_debug, /* debug the message */ + NULL, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_dtype_debug /* debug the message */ }}; /* This is the correct version to create all datatypes which don't contain diff --git a/src/H5Oefl.c b/src/H5Oefl.c index 9106310..8c78cae 100644 --- a/src/H5Oefl.c +++ b/src/H5Oefl.c @@ -33,6 +33,8 @@ static herr_t H5O_efl_encode(H5F_t *f, uint8_t *p, const void *_mesg); static void *H5O_efl_copy(const void *_mesg, void *_dest, unsigned update_flags); static size_t H5O_efl_size(const H5F_t *f, const void *_mesg); static herr_t H5O_efl_reset(void *_mesg); +static void *H5O_efl_copy_file(H5F_t *file_src, void *mesg_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void *udata); static herr_t H5O_efl_debug(H5F_t *f, hid_t dxpl_id, const void *_mesg, FILE * stream, int indent, int fwidth); @@ -51,7 +53,9 @@ const H5O_class_t H5O_EFL[1] = {{ NULL, /* link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_efl_debug, /*debug the message */ + H5O_efl_copy_file, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_efl_debug /*debug the message */ }}; #define H5O_EFL_VERSION 1 @@ -415,6 +419,86 @@ done: /*------------------------------------------------------------------------- + * Function: H5O_efl_copy_file + * + * Purpose: Copies an efl message from _MESG to _DEST in file + * + * Return: Success: Ptr to _DEST + * + * Failure: NULL + * + * Programmer: Peter Cao + * September 29, 2005 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static void * +H5O_efl_copy_file(H5F_t UNUSED *file_src, void *mesg_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t UNUSED *map_list, void UNUSED *_udata) +{ + H5O_efl_t *efl_src = (H5O_efl_t *) mesg_src; + H5O_efl_t *efl_dst = NULL; + size_t idx, size, name_offset, heap_size; + void *ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5O_efl_copy_file) + + /* check args */ + HDassert(efl_src); + HDassert(file_dst); + + /* Allocate space for the destination efl */ + if(NULL == (efl_dst = H5MM_calloc(sizeof(H5O_efl_t)))) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + /* Copy the "top level" information */ + HDmemcpy(efl_dst, efl_src, sizeof(H5O_efl_t)); + + /* create name heap */ + heap_size = H5HL_ALIGN(1); + for(idx = 0; idx < efl_src->nused; idx++) + heap_size += H5HL_ALIGN(HDstrlen(efl_src->slot[idx].name) + 1); + + if(H5HL_create(file_dst, dxpl_id, heap_size, &efl_dst->heap_addr/*out*/) < 0) + HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, NULL, "can't create heap") + + name_offset = H5HL_insert(file_dst, dxpl_id, efl_dst->heap_addr, 1, ""); + if((size_t)(-1) == name_offset) + HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, NULL, "can't initialize heap") + HDassert(0 == name_offset); + + /* allocate array of external file entries */ + if(efl_src->nalloc > 0) { + size = efl_src->nalloc * sizeof(H5O_efl_entry_t); + if((efl_dst->slot = H5MM_calloc(size)) == NULL) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + /* copy content from the source. Need to update later */ + HDmemcpy(efl_dst->slot, efl_src->slot, size); + } + + /* copy the name from the source */ + for(idx = 0; idx < efl_src->nused; idx++) { + efl_dst->slot[idx].name = H5MM_xstrdup(efl_src->slot[idx].name); + efl_dst->slot[idx].name_offset = H5HL_insert(file_dst, dxpl_id, efl_dst->heap_addr, + HDstrlen(efl_dst->slot[idx].name)+1, efl_dst->slot[idx].name); + } + + /* Set return value */ + ret_value = efl_dst; + +done: + if(!ret_value) + if(efl_dst) + H5MM_xfree(efl_dst); + + FUNC_LEAVE_NOAPI(ret_value) +} + + +/*------------------------------------------------------------------------- * Function: H5O_efl_debug * * Purpose: Prints debugging info for a message. @@ -475,3 +559,4 @@ H5O_efl_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *_mesg, FILE * s FUNC_LEAVE_NOAPI(SUCCEED); } + diff --git a/src/H5Ofill.c b/src/H5Ofill.c index d0bf381..b68c106 100644 --- a/src/H5Ofill.c +++ b/src/H5Ofill.c @@ -63,7 +63,9 @@ const H5O_class_t H5O_FILL[1] = {{ NULL, /* link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_fill_debug, /*debug the message */ + NULL, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_fill_debug /*debug the message */ }}; /* This message derives from H5O, for new fill value after version 1.4 */ @@ -81,7 +83,9 @@ const H5O_class_t H5O_FILL_NEW[1] = {{ NULL, /* link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_fill_new_debug, /*debug the message */ + NULL, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_fill_new_debug /*debug the message */ }}; /* Initial version of the "old" fill value information */ diff --git a/src/H5Olayout.c b/src/H5Olayout.c index 4a6fdfe..3103053 100644 --- a/src/H5Olayout.c +++ b/src/H5Olayout.c @@ -18,16 +18,18 @@ * Purpose: Messages related to data layout. */ +#define H5D_PACKAGE /*suppress error about including H5Dpkg */ #define H5O_PACKAGE /*suppress error about including H5Opkg */ -#include "H5private.h" -#include "H5Dprivate.h" -#include "H5Eprivate.h" -#include "H5FLprivate.h" /*Free Lists */ +#include "H5private.h" /* Generic Functions */ +#include "H5Dpkg.h" /* Dataset functions */ +#include "H5Eprivate.h" /* Error handling */ +#include "H5FLprivate.h" /* Free Lists */ #include "H5MFprivate.h" /* File space management */ -#include "H5MMprivate.h" -#include "H5Opkg.h" /* Object header functions */ +#include "H5MMprivate.h" /* Memory management */ +#include "H5Opkg.h" /* Object headers */ +#include "H5Pprivate.h" /* Property lists */ /* PRIVATE PROTOTYPES */ static void *H5O_layout_decode(H5F_t *f, hid_t dxpl_id, const uint8_t *p, H5O_shared_t *sh); @@ -37,6 +39,8 @@ static size_t H5O_layout_size(const H5F_t *f, const void *_mesg); static herr_t H5O_layout_reset(void *_mesg); static herr_t H5O_layout_free(void *_mesg); static herr_t H5O_layout_delete(H5F_t *f, hid_t dxpl_id, const void *_mesg, hbool_t adj_link); +static void *H5O_layout_copy_file(H5F_t *file_src, void *mesg_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void *udata); static herr_t H5O_layout_debug(H5F_t *f, hid_t dxpl_id, const void *_mesg, FILE * stream, int indent, int fwidth); @@ -55,7 +59,9 @@ const H5O_class_t H5O_LAYOUT[1] = {{ NULL, /* link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_layout_debug, /*debug the message */ + H5O_layout_copy_file, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_layout_debug /*debug the message */ }}; /* For forward and backward compatibility. Version is 1 when space is @@ -599,6 +605,113 @@ done: /*------------------------------------------------------------------------- + * Function: H5O_layout_copy_file + * + * Purpose: Copies a data layout message from _MESG to _DEST in file + * + * Return: Success: Ptr to _DEST + * + * Failure: NULL + * + * Programmer: Peter Cao + * July 23, 2005 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static void * +H5O_layout_copy_file(H5F_t *file_src, void *mesg_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t UNUSED *map_list, void UNUSED *_udata) +{ + H5O_layout_t *layout_src = (H5O_layout_t *) mesg_src; + H5O_layout_t *layout_dst = NULL; + void *ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5O_layout_copy_file) + + /* check args */ + HDassert(layout_src); + HDassert(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") + + /* Copy the "top level" information */ + HDmemcpy(layout_dst, layout_src, sizeof(H5O_layout_t)); + + /* Copy the layout type specific information */ + switch(layout_src->type) { + case H5D_COMPACT: + if(layout_src->u.compact.buf) { + if(NULL == (layout_dst->u.compact.buf = H5MM_malloc(layout_src->u.compact.size))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "unable to allocate memory for compact dataset") + HDmemcpy(layout_dst->u.compact.buf, layout_src->u.compact.buf, layout_src->u.compact.size); + layout_dst->u.compact.dirty = TRUE; + } + break; + + case H5D_CONTIGUOUS: + if(H5F_addr_defined(layout_src->u.contig.addr)) { + haddr_t addr_src, addr_dst; + unsigned DRAW_BUF_SIZE = 4096; + uint8_t buf[4096]; + size_t nbytes=0, total_nbytes=0; + + /* create layout */ + if(H5D_contig_create (file_dst, dxpl_id, layout_dst)<0) + HGOTO_ERROR(H5E_IO, H5E_CANTINIT, NULL, "unable to initialize contiguous storage") + + /* copy raw data*/ + nbytes = total_nbytes = 0; + while(total_nbytes < layout_src->u.contig.size) { + addr_src = layout_src->u.contig.addr + total_nbytes; + addr_dst = layout_dst->u.contig.addr + total_nbytes; + + nbytes = layout_src->u.contig.size-total_nbytes; + if(nbytes > DRAW_BUF_SIZE) + nbytes = DRAW_BUF_SIZE; + total_nbytes += nbytes; + + if(H5F_block_read(file_src, H5FD_MEM_DRAW, addr_src, nbytes, H5P_DATASET_XFER_DEFAULT, buf)<0) + HGOTO_ERROR(H5E_SYM, H5E_READERROR, NULL, "unable to read raw data") + + if(H5F_block_write(file_dst, H5FD_MEM_DRAW, addr_dst, nbytes, H5P_DATASET_XFER_DEFAULT, buf)<0) + HGOTO_ERROR(H5E_SYM, H5E_READERROR, NULL, "unable to write raw data") + } + } /* if ( H5F_addr_defined(layout_src->u.contig.addr)) */ + break; + + case H5D_CHUNKED: + if(H5F_addr_defined(layout_src->u.chunk.addr)) { + + /* layout is not created in the destination file, undef btree address */ + layout_dst->u.chunk.addr = HADDR_UNDEF; + + /* create chunked layout */ + if(H5D_istore_copy(file_src, layout_src, file_dst, layout_dst, dxpl_id) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTINIT, NULL, "unable to copy chunked storage") + } /* if ( H5F_addr_defined(layout_srct->u.chunk.addr)) */ + break; + + default: + HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "Invalid layout class"); + } /* end switch */ + + /* Set return value */ + ret_value=layout_dst; + +done: + if(!ret_value) + if(layout_dst) + H5FL_FREE(H5O_layout_t, layout_dst); + + FUNC_LEAVE_NOAPI(ret_value) +} + + +/*------------------------------------------------------------------------- * Function: H5O_layout_debug * * Purpose: Prints debugging info for a message. diff --git a/src/H5Omtime.c b/src/H5Omtime.c index d3c2f3c..4244733 100644 --- a/src/H5Omtime.c +++ b/src/H5Omtime.c @@ -60,7 +60,9 @@ const H5O_class_t H5O_MTIME[1] = {{ NULL, /* link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_mtime_debug, /*debug the message */ + NULL, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_mtime_debug /*debug the message */ }}; /* This message derives from H5O */ @@ -79,7 +81,9 @@ const H5O_class_t H5O_MTIME_NEW[1] = {{ NULL, /* link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_mtime_debug, /*debug the message */ + NULL, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_mtime_debug /*debug the message */ }}; /* Current version of new mtime information */ diff --git a/src/H5Oname.c b/src/H5Oname.c index 64477af..ba4433a 100644 --- a/src/H5Oname.c +++ b/src/H5Oname.c @@ -57,7 +57,9 @@ const H5O_class_t H5O_NAME[1] = {{ NULL, /* link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_name_debug, /*debug the message */ + NULL, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_name_debug /*debug the message */ }}; diff --git a/src/H5Onull.c b/src/H5Onull.c index 028a535..074026e 100644 --- a/src/H5Onull.c +++ b/src/H5Onull.c @@ -46,5 +46,7 @@ const H5O_class_t H5O_NULL[1] = {{ NULL, /*no link method */ NULL, /*no get share method */ NULL, /*no set share method */ - NULL, /*no debug method */ + NULL, /*no copy native value to file */ + NULL, /*no post copy native value to file */ + NULL /*no debug method */ }}; diff --git a/src/H5Opkg.h b/src/H5Opkg.h index 83889f6..fdca31a 100644 --- a/src/H5Opkg.h +++ b/src/H5Opkg.h @@ -19,8 +19,11 @@ #ifndef _H5Opkg_H #define _H5Opkg_H -/* Include private header file */ -#include "H5Oprivate.h" /* Object header functions */ +/* Get package's private header */ +#include "H5Oprivate.h" /* Object headers */ + +/* Other private headers needed by this file */ +#include "H5SLprivate.h" /* Skip lists */ /* * Align messages on 8-byte boundaries because we would like to copy the @@ -69,6 +72,8 @@ typedef struct H5O_class_t { herr_t (*link)(H5F_t *, hid_t, const void *); /* Increment any links in file reference by this message */ herr_t (*get_share)(H5F_t*, const void*, struct H5O_shared_t*); /* Get shared information */ herr_t (*set_share)(H5F_t*, void*, const struct H5O_shared_t*); /* Set shared information */ + void *(*copy_file)(H5F_t *, void *, H5F_t *, hid_t, H5SL_t *, void *); /*copy native value to file */ + herr_t (*post_copy_file)(H5F_t *, const void *, H5G_entry_t *, hid_t, H5SL_t *); /*"post copy" action when copying native value to file */ herr_t (*debug)(H5F_t*, hid_t, const void*, FILE*, int, int); } H5O_class_t; diff --git a/src/H5Opline.c b/src/H5Opline.c index 280c8db..391c758 100644 --- a/src/H5Opline.c +++ b/src/H5Opline.c @@ -54,7 +54,9 @@ const H5O_class_t H5O_PLINE[1] = {{ NULL, /* link method */ NULL, /* get share method */ NULL, /* set share method */ - H5O_pline_debug, /* debug the message */ + NULL, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_pline_debug /* debug the message */ }}; diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h index e3043af..d619806 100644 --- a/src/H5Oprivate.h +++ b/src/H5Oprivate.h @@ -28,16 +28,17 @@ #define _H5Oprivate_H /* Include the public header file for this API */ -#include "H5Opublic.h" /* Object header functions */ +#include "H5Opublic.h" /* Object header functions */ /* Public headers needed by this file */ -#include "H5Dpublic.h" /* Dataset functions */ -#include "H5Spublic.h" /* Dataspace functions */ +#include "H5Dpublic.h" /* Dataset functions */ +#include "H5Spublic.h" /* Dataspace functions */ /* Private headers needed by this file */ -#include "H5HGprivate.h" /* Global heap functions */ -#include "H5Tprivate.h" /* Datatype functions */ -#include "H5Zprivate.h" /* I/O pipeline filters */ +#include "H5FLprivate.h" /* Free Lists */ +#include "H5HGprivate.h" /* Global heap functions */ +#include "H5Tprivate.h" /* Datatype functions */ +#include "H5Zprivate.h" /* I/O pipeline filters */ /* Object header macros */ #define H5O_MIN_SIZE H5O_ALIGN(32) /*min obj header data size */ @@ -249,6 +250,9 @@ typedef struct H5O_stab_t { typedef herr_t (*H5O_operator_t)(const void *mesg/*in*/, unsigned idx, void *operator_data/*in,out*/); +/* Forward declarations for prototype arguments */ +struct H5SL_t; + /* General message operators */ H5_DLL herr_t H5O_create(H5F_t *f, hid_t dxpl_id, size_t size_hint, H5G_entry_t *ent/*out*/); @@ -291,6 +295,10 @@ H5_DLL herr_t H5O_delete(H5F_t *f, hid_t dxpl_id, haddr_t addr); H5_DLL herr_t H5O_get_info(H5G_entry_t *ent, H5O_stat_t *ostat, hid_t dxpl_id); H5_DLL herr_t H5O_iterate(const H5G_entry_t *ent, unsigned type_id, H5O_operator_t op, void *op_data, hid_t dxpl_id); +H5_DLL herr_t H5O_copy_header(const H5G_entry_t *ent_src, + H5G_entry_t *ent_dst /*out */, hid_t dxpl_id); +H5_DLL herr_t H5O_copy_header_map(const H5G_entry_t *ent_src, + H5G_entry_t *ent_dst /*out */, hid_t dxpl_id, struct H5SL_t *obj_list); H5_DLL herr_t H5O_debug_id(hid_t type_id, H5F_t *f, hid_t dxpl_id, const void *mesg, FILE *stream, int indent, int fwidth); H5_DLL herr_t H5O_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE * stream, int indent, int fwidth); diff --git a/src/H5Osdspace.c b/src/H5Osdspace.c index cc3beb1..f4c5500 100644 --- a/src/H5Osdspace.c +++ b/src/H5Osdspace.c @@ -49,7 +49,9 @@ const H5O_class_t H5O_SDSPACE[1] = {{ NULL, /* link method */ NULL, /* get share method */ NULL, /* set share method */ - H5O_sdspace_debug, /* debug the message */ + NULL, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_sdspace_debug /* debug the message */ }}; /* Initial version of the "old" data space information */ diff --git a/src/H5Oshared.c b/src/H5Oshared.c index 8a0a291..09f273d 100644 --- a/src/H5Oshared.c +++ b/src/H5Oshared.c @@ -42,6 +42,8 @@ static void *H5O_shared_copy(const void *_mesg, void *_dest, unsigned update_fla static size_t H5O_shared_size (const H5F_t*, const void *_mesg); static herr_t H5O_shared_delete(H5F_t *f, hid_t dxpl_id, const void *_mesg, hbool_t adj_link); static herr_t H5O_shared_link(H5F_t *f, hid_t dxpl_id, const void *_mesg); +static void *H5O_shared_copy_file(H5F_t *file_src, void *native_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void *udata); static herr_t H5O_shared_debug (H5F_t*, hid_t dxpl_id, const void*, FILE*, int, int); /* This message derives from H5O */ @@ -59,7 +61,9 @@ const H5O_class_t H5O_SHARED[1] = {{ H5O_shared_link, /*link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_shared_debug, /*debug method */ + H5O_shared_copy_file, /* copy native value to file */ + NULL, /* post copy native value to file */ + H5O_shared_debug /*debug method */ }}; /* Old version, with full symbol table entry as link for object header sharing */ @@ -472,6 +476,63 @@ done: /*------------------------------------------------------------------------- + * Function: H5O_shared_copy_file + * + * Purpose: Copies a message from _MESG to _DEST in file + * + * Return: Success: Ptr to _DEST + * + * Failure: NULL + * + * Programmer: Quincey Koziol + * November 1, 2005 + * + *------------------------------------------------------------------------- + */ +static void * +H5O_shared_copy_file(H5F_t UNUSED *file_src, void *native_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void UNUSED *udata) +{ + H5O_shared_t *shared_src = (H5O_shared_t *)native_src; + H5O_shared_t *shared_dst = NULL; + void *ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5O_shared_copy_file) + + /* check args */ + HDassert(shared_src); + HDassert(file_dst); + HDassert(map_list); + + /* Allocate space for the destination message */ + if(NULL == (shared_dst = H5MM_malloc(sizeof(H5O_shared_t)))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + /* Can't handle copying message in global heap currently */ + HDassert(!shared_src->in_gh); + shared_dst->in_gh = FALSE; + + /* Reset group entry for new object */ + H5G_ent_reset(&(shared_dst->u.ent)); + shared_dst->u.ent.file = file_dst; + + /* Copy the shared object from source to destination */ + if(H5O_copy_header_map(&(shared_src->u.ent), &(shared_dst->u.ent), dxpl_id, map_list) < 0) + HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, NULL, "unable to copy object") + + /* Set return value */ + ret_value = shared_dst; + +done: + if(!ret_value) + if(shared_dst) + H5MM_xfree(shared_dst); + + FUNC_LEAVE_NOAPI(ret_value) +} /* H5O_shared_copy_file() */ + + +/*------------------------------------------------------------------------- * Function: H5O_shared_debug * * Purpose: Prints debugging info for the message diff --git a/src/H5Ostab.c b/src/H5Ostab.c index 21391bd..e03d6b1 100644 --- a/src/H5Ostab.c +++ b/src/H5Ostab.c @@ -42,8 +42,12 @@ static void *H5O_stab_copy(const void *_mesg, void *_dest, unsigned update_flags static size_t H5O_stab_size(const H5F_t *f, const void *_mesg); static herr_t H5O_stab_free(void *_mesg); static herr_t H5O_stab_delete(H5F_t *f, hid_t dxpl_id, const void *_mesg, hbool_t adj_link); +static void *H5O_stab_copy_file(H5F_t *file_src, void *native_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void *udata); +static herr_t H5O_stab_post_copy_file(H5F_t *file_src, const void *mesg_src, + H5G_entry_t *loc_dst, hid_t dxpl_id, H5SL_t *map_list); static herr_t H5O_stab_debug(H5F_t *f, hid_t dxpl_id, const void *_mesg, - FILE * stream, int indent, int fwidth); + FILE * stream, int indent, int fwidth); /* This message derives from H5O */ const H5O_class_t H5O_STAB[1] = {{ @@ -60,7 +64,9 @@ const H5O_class_t H5O_STAB[1] = {{ NULL, /* link method */ NULL, /*get share method */ NULL, /*set share method */ - H5O_stab_debug, /*debug the message */ + H5O_stab_copy_file, /* copy native value to file */ + H5O_stab_post_copy_file, /* post copy native value to file */ + H5O_stab_debug /*debug the message */ }}; /* Declare a free list to manage the H5O_stab_t struct */ @@ -337,6 +343,95 @@ done: /*------------------------------------------------------------------------- + * Function: H5O_stab_copy_file + * + * Purpose: Copies a message from _MESG to _DEST in file + * + * Return: Success: Ptr to _DEST + * + * Failure: NULL + * + * Programmer: Peter Cao + * September 10, 2005 + * + *------------------------------------------------------------------------- + */ +static void * +H5O_stab_copy_file(H5F_t UNUSED *file_src, void *native_src, + H5F_t *file_dst, hid_t dxpl_id, H5SL_t UNUSED *map_list, void UNUSED *udata) +{ + H5O_stab_t *stab_src = (H5O_stab_t *) native_src; + H5O_stab_t *stab_dst = NULL; + void *ret_value; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5O_stab_copy_file) + + /* check args */ + HDassert(stab_src); + HDassert(file_dst); + + /* Allocate space for the destination stab */ + if(NULL == (stab_dst = H5FL_MALLOC(H5O_stab_t))) + HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed") + + if(H5G_stab_copy_tmp(file_dst, stab_dst, dxpl_id) < 0) + HGOTO_ERROR(H5E_IO, H5E_CANTINIT, NULL, "unable to copy group symbol table") + + /* Set return value */ + ret_value = stab_dst; + +done: + if(!ret_value) + if(stab_dst) + H5FL_FREE(H5O_stab_t, stab_dst); + + FUNC_LEAVE_NOAPI(ret_value) +} /* H5O_stab_copy_file() */ + + +/*------------------------------------------------------------------------- + * Function: H5O_stab_post_copy_file + * + * Purpose: Copies entries of a symbol table message from _MESG to _DEST in file + * + * Return: Non-negative on success/Negative on failure + * + * Programmer: Peter Cao + * September 28, 2005 + * + *------------------------------------------------------------------------- + */ +static herr_t +H5O_stab_post_copy_file(H5F_t *file_src, const void *mesg_src, + H5G_entry_t *loc_dst, hid_t dxpl_id, H5SL_t *map_list) +{ + H5G_bt_it_ud5_t udata; /* B-tree user data */ + const H5O_stab_t *stab_src = (const H5O_stab_t *) mesg_src; + herr_t ret_value = SUCCEED; /* Return value */ + + FUNC_ENTER_NOAPI_NOINIT(H5O_stab_post_copy_file) + + /* check args */ + HDassert(file_src); + HDassert(stab_src); + HDassert(loc_dst->file); + HDassert(map_list); + + /* Set up B-tree iteration user data */ + udata.map_list = map_list; + udata.heap_addr = stab_src->heap_addr; + udata.loc_dst = loc_dst; + + /* Iterate over objects in group, copying them */ + if((H5B_iterate(file_src, dxpl_id, H5B_SNODE, H5G_node_copy, stab_src->btree_addr, &udata)) < 0) + HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "iteration operator failed") + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* H5O_stab_post_copy_file() */ + + +/*------------------------------------------------------------------------- * Function: H5O_stab_debug * * Purpose: Prints debugging info for a symbol table message. @@ -39,6 +39,7 @@ static herr_t H5S_set_extent_simple (H5S_t *space, unsigned rank, static htri_t H5S_is_simple(const H5S_t *sdim); static herr_t H5S_encode(H5S_t *obj, unsigned char *buf, size_t *nalloc); static H5S_t *H5S_decode(const unsigned char *buf); +static htri_t H5S_extent_equal(const H5S_t *ds1, const H5S_t *ds2); #ifdef H5S_DEBUG /* Names of the selection names, for debugging */ @@ -2225,6 +2226,106 @@ done: /*------------------------------------------------------------------------- + * Function: H5Sextent_equal + * + * Purpose: Determines if two dataspace extents are equal. + * + * Return: Success: TRUE if equal, FALSE if unequal + * + * Failure: Negative + * + * Programmer: Quincey Koziol + * Monday, October 24, 2005 + * + *------------------------------------------------------------------------- + */ +htri_t +H5Sextent_equal(hid_t space1_id, hid_t space2_id) +{ + const H5S_t *ds1, *ds2; /* Dataspaces to compare */ + htri_t ret_value; + + FUNC_ENTER_API(H5Sextent_equal, FAIL) + H5TRACE2("t","ii",space1_id,space2_id); + + /* check args */ + if(NULL == (ds1 = H5I_object_verify(space1_id, H5I_DATASPACE)) || + NULL == (ds2 = H5I_object_verify(space2_id, H5I_DATASPACE))) + HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace") + + /* Check dataspaces for extent's equality */ + if((ret_value = H5S_extent_equal(ds1, ds2)) < 0) + HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOMPARE, FAIL, "dataspace comparison failed") + +done: + FUNC_LEAVE_API(ret_value) +} /* end H5Sextent_equal() */ + + +/*-------------------------------------------------------------------------- + NAME + H5S_extent_equal + PURPOSE + Check if two dataspaces have equal extents + USAGE + htri_t H5S_extent_equal(ds1, ds2) + H5S_t *ds1, *ds2; IN: Dataspace objects to compare + RETURNS + TRUE if equal, FALSE if unequal on succeess/Negative on failure + DESCRIPTION + Compare two dataspaces if their extents are identical. +--------------------------------------------------------------------------*/ +static htri_t +H5S_extent_equal(const H5S_t *ds1, const H5S_t *ds2) +{ + unsigned u; /* Local index variable */ + htri_t ret_value = TRUE; /* Return value */ + + FUNC_ENTER_NOAPI(H5S_extent_equal, FAIL) + + /* Check args */ + HDassert(ds1); + HDassert(ds2); + + /* Make certain the dataspaces are the same type */ + if(ds1->extent.type != ds2->extent.type) + HGOTO_DONE(FALSE) + + /* Make certain the dataspaces are the same rank */ + if(ds1->extent.rank != ds2->extent.rank) + HGOTO_DONE(FALSE) + + /* Make certain the dataspaces' current dimensions are the same size */ + if(ds1->extent.rank > 0) { + HDassert(ds1->extent.size); + HDassert(ds2->extent.size); + for(u = 0; u < ds1->extent.rank; u++) { + if(ds1->extent.size[u] != ds2->extent.size[u]) + HGOTO_DONE(FALSE) + } /* end for */ + } /* end if */ + + /* Make certain the dataspaces' maximum dimensions are the same size */ + if(ds1->extent.rank > 0) { + /* Check for no maximum dimensions on dataspaces */ + if(ds1->extent.max != NULL && ds2->extent.max != NULL) { + for(u = 0; u < ds1->extent.rank; u++) { + if(ds1->extent.max[u] != ds2->extent.max[u]) + HGOTO_DONE(FALSE) + } /* end for */ + } /* end if */ + else + if((ds1->extent.max == NULL && ds2->extent.max != NULL) || + (ds1->extent.max != NULL && ds2->extent.max == NULL)) + HGOTO_DONE(FALSE) + } /* end if */ + +done: + FUNC_LEAVE_NOAPI(ret_value) +} /* end H5S_extent_equal() */ + + +/*------------------------------------------------------------------------- * Function: H5S_debug * * Purpose: Prints debugging information about a data space. diff --git a/src/H5Shyper.c b/src/H5Shyper.c index 1f75af4..83bebe9 100644 --- a/src/H5Shyper.c +++ b/src/H5Shyper.c @@ -5371,7 +5371,7 @@ H5S_hyper_rebuild_helper(const H5S_hyper_span_t *span, H5S_hyper_dim_t span_slab hsize_t curr_start; hsize_t curr_low; int outcount; - int i; + unsigned u; H5S_hyper_dim_t canon_down_span_slab_info[H5S_MAX_RANK]; hbool_t ret_value = TRUE; @@ -5414,17 +5414,17 @@ H5S_hyper_rebuild_helper(const H5S_hyper_span_t *span, H5S_hyper_dim_t span_slab /* Compare the slab information of the adjacent spans in the down span tree. We have to compare all the sub-tree slab information with the canon_down_span_slab_info.*/ - for( i = 0; i < rank - 1; i++) { - curr_down_span_slab_info = &span_slab_info[i]; + for( u = 0; u < rank - 1; u++) { + curr_down_span_slab_info = &span_slab_info[u]; - if(curr_down_span_slab_info->count > 0 && canon_down_span_slab_info[i].count > 0) { - if(curr_down_span_slab_info->start != canon_down_span_slab_info[i].start - || curr_down_span_slab_info->stride != canon_down_span_slab_info[i].stride - || curr_down_span_slab_info->block != canon_down_span_slab_info[i].block - || curr_down_span_slab_info->count != canon_down_span_slab_info[i].count) + if(curr_down_span_slab_info->count > 0 && canon_down_span_slab_info[u].count > 0) { + if(curr_down_span_slab_info->start != canon_down_span_slab_info[u].start + || curr_down_span_slab_info->stride != canon_down_span_slab_info[u].stride + || curr_down_span_slab_info->block != canon_down_span_slab_info[u].block + || curr_down_span_slab_info->count != canon_down_span_slab_info[u].count) HGOTO_DONE(FALSE) } /* end if */ - else if (!((curr_down_span_slab_info->count == 0) && (canon_down_span_slab_info[i].count == 0))) + else if (!((curr_down_span_slab_info->count == 0) && (canon_down_span_slab_info[u].count == 0))) HGOTO_DONE(FALSE) } } /* end if */ diff --git a/src/H5Spublic.h b/src/H5Spublic.h index 9efaeab..5e2177f 100644 --- a/src/H5Spublic.h +++ b/src/H5Spublic.h @@ -132,6 +132,7 @@ H5_DLL herr_t H5Sselect_elements(hid_t space_id, H5S_seloper_t op, H5_DLL H5S_class_t H5Sget_simple_extent_type(hid_t space_id); H5_DLL herr_t H5Sset_extent_none(hid_t space_id); H5_DLL herr_t H5Sextent_copy(hid_t dst_id,hid_t src_id); +H5_DLL herr_t H5Sextent_equal(hid_t sid1, hid_t sid2); H5_DLL herr_t H5Sselect_all(hid_t spaceid); H5_DLL herr_t H5Sselect_none(hid_t spaceid); H5_DLL herr_t H5Soffset_simple(hid_t space_id, const hssize_t *offset); @@ -3459,8 +3459,7 @@ H5T_copy(const H5T_t *old_dt, H5T_copy_t method) HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, NULL, "unable to copy entry"); } /* end if */ else { - HDmemset (&(new_dt->ent), 0, sizeof(new_dt->ent)); - new_dt->ent.header = HADDR_UNDEF; + H5G_ent_reset(&(new_dt->ent)); } /* end else */ /* Set return value */ diff --git a/src/Makefile.am b/src/Makefile.am index 15a09ed..b4307a0 100755 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -37,7 +37,8 @@ libhdf5_la_LDFLAGS= -version-info $(LT_VERS_INTERFACE):$(LT_VERS_REVISION):$(LT_ MOSTLYCLEANFILES=H5Tinit.c # library sources -libhdf5_la_SOURCES= H5.c H5A.c H5AC.c H5B.c H5B2.c H5B2cache.c H5B2dbg.c \ +libhdf5_la_SOURCES= H5.c H5A.c H5AC.c H5B.c H5Bcache.c H5B2.c H5B2cache.c \ + H5B2dbg.c \ H5B2test.c H5BP.c H5BPcache.c H5BPdbg.c H5BPtest.c \ H5BT.c H5BTbtree2.c H5BTcache.c H5BTdbg.c H5BTtest.c H5C.c \ H5D.c \ diff --git a/src/Makefile.in b/src/Makefile.in index 3d09c5a..516859b 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -82,10 +82,10 @@ am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(settingsdir)" \ libLTLIBRARIES_INSTALL = $(INSTALL) LTLIBRARIES = $(lib_LTLIBRARIES) libhdf5_la_LIBADD = -am_libhdf5_la_OBJECTS = H5.lo H5A.lo H5AC.lo H5B.lo H5B2.lo \ - H5B2cache.lo H5B2dbg.lo H5B2test.lo H5BP.lo H5BPcache.lo \ - H5BPdbg.lo H5BPtest.lo H5BT.lo H5BTbtree2.lo H5BTcache.lo \ - H5BTdbg.lo H5BTtest.lo H5C.lo H5D.lo H5Dcontig.lo \ +am_libhdf5_la_OBJECTS = H5.lo H5A.lo H5AC.lo H5B.lo H5Bcache.lo \ + H5B2.lo H5B2cache.lo H5B2dbg.lo H5B2test.lo H5BP.lo \ + H5BPcache.lo H5BPdbg.lo H5BPtest.lo H5BT.lo H5BTbtree2.lo \ + H5BTcache.lo H5BTdbg.lo H5BTtest.lo H5C.lo H5D.lo H5Dcontig.lo \ H5Dcompact.lo H5Defl.lo H5Dio.lo H5Distore.lo H5Dmpio.lo \ H5Dselect.lo H5Dtest.lo H5E.lo H5F.lo H5Fdbg.lo H5Fmount.lo \ H5Fsfile.lo H5Fsuper.lo H5FD.lo H5FDcore.lo H5FDfamily.lo \ @@ -384,7 +384,8 @@ libhdf5_la_LDFLAGS = -version-info $(LT_VERS_INTERFACE):$(LT_VERS_REVISION):$(LT MOSTLYCLEANFILES = H5Tinit.c # library sources -libhdf5_la_SOURCES = H5.c H5A.c H5AC.c H5B.c H5B2.c H5B2cache.c H5B2dbg.c \ +libhdf5_la_SOURCES = H5.c H5A.c H5AC.c H5B.c H5Bcache.c H5B2.c H5B2cache.c \ + H5B2dbg.c \ H5B2test.c H5BP.c H5BPcache.c H5BPdbg.c H5BPtest.c \ H5BT.c H5BTbtree2.c H5BTcache.c H5BTdbg.c H5BTtest.c H5C.c \ H5D.c \ @@ -563,6 +564,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5BTcache.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5BTdbg.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5BTtest.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Bcache.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5C.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5D.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dcompact.Plo@am__quote@ |