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

[svn-r12562] Description:

Browse Source 
Initial revision to add support for "huge" objects in the heap (which are
actually stored directly in the file, but are tracked with v2 B-tree that is
accessed through heap header).

Testing:
    FreeBSD 4.11 (sleipnir)
    Linux/64 2.4 (mir)
    Linux/32 2.4 (heping)
    Mac OS X.4 (amazon)
This commit is contained in:
Quincey Koziol 2006-08-09 22:45:06 -05:00
parent f06e8744a5
commit b648c14f13
16 changed files with 1699 additions and 578 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
MANIFEST
View File

@ -498,11 +498,13 @@
./src/H5Gtest.c
./src/H5Gtraverse.c
./src/H5HF.c
./src/H5HFbtree2.c
./src/H5HFcache.c
./src/H5HFdbg.c
./src/H5HFdblock.c
./src/H5HFdtable.c
./src/H5HFhdr.c
./src/H5HFhuge.c
./src/H5HFiblock.c
./src/H5HFint.c
./src/H5HFiter.c

4
src/H5FDpublic.h
View File

@ -53,11 +53,15 @@ typedef enum H5FD_mem_t {
* Map "fractal heap" direct blocks to 'lheap' type file memory, since they
* will be replacing local heaps.
*
* Map "fractal heap" 'huge' objects to 'draw' type file memory, since they
* represent large objects that are directly stored in the file.
*
* -QAK
*/
#define H5FD_MEM_FHEAP_HDR H5FD_MEM_OHDR
#define H5FD_MEM_FHEAP_IBLOCK H5FD_MEM_OHDR
#define H5FD_MEM_FHEAP_DBLOCK H5FD_MEM_LHEAP
#define H5FD_MEM_FHEAP_HUGE_OBJ H5FD_MEM_DRAW
/* Map "free space" header blocks to 'ohdr' type file memory, since its
* a fair amount of work to add a new kind of file memory and they are similar

93
src/H5HF.c
View File

@ -355,7 +355,9 @@ HDfprintf(stderr, "%s: size = %Zu\n", FUNC, size);
/* Check if object is large enough to be standalone */
if(size > hdr->max_man_size) {
HGOTO_ERROR(H5E_HEAP, H5E_UNSUPPORTED, FAIL, "standalone blocks not supported yet")
/* Store 'huge' object in heap */
if(H5HF_huge_insert(hdr, dxpl_id, size, obj, id) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't allocate space for 'managed' object in fractal heap")
} /* end if */
else {
/* Check if we are in "append only" mode, or if there's enough room for the object */
@ -363,15 +365,9 @@ HGOTO_ERROR(H5E_HEAP, H5E_UNSUPPORTED, FAIL, "standalone blocks not supported ye
HGOTO_ERROR(H5E_HEAP, H5E_UNSUPPORTED, FAIL, "'write once' managed blocks not supported yet")
} /* end if */
else {
H5HF_free_section_t *sec_node; /* Pointer to free space section */
/* Find free space in heap */
if(H5HF_man_find(hdr, dxpl_id, size, &sec_node) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't allocate space in fractal heap")
/* Use free space for allocating object */
if(H5HF_man_insert(hdr, dxpl_id, sec_node, size, obj, id) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't allocate space for object in fractal heap")
/* Allocate space for object in 'managed' heap */
if(H5HF_man_insert(hdr, dxpl_id, size, obj, id) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't allocate space for 'managed' object in fractal heap")
} /* end else */
} /* end else */
@ -397,7 +393,7 @@ HDfprintf(stderr, "%s: Leaving, ret_value = %d\n", FUNC, ret_value);
*-------------------------------------------------------------------------
*/
herr_t
H5HF_get_obj_len(H5HF_t *fh, const void *_id, size_t *obj_len_p)
H5HF_get_obj_len(H5HF_t *fh, hid_t dxpl_id, const void *_id, size_t *obj_len_p)
{
const uint8_t *id = (const uint8_t *)_id; /* Object ID */
uint8_t id_flags; /* Heap ID flag bits */
@ -419,7 +415,7 @@ H5HF_get_obj_len(H5HF_t *fh, const void *_id, size_t *obj_len_p)
if((id_flags & H5HF_ID_VERS_MASK) != H5HF_ID_VERS_CURR)
HGOTO_ERROR(H5E_HEAP, H5E_VERSION, FAIL, "incorrect heap ID version")
/* Check for managed object */
/* Check type of object in heap */
if((id_flags & H5HF_ID_TYPE_MASK) == H5HF_ID_TYPE_MAN) {
/* Skip over object offset */
id += fh->hdr->heap_off_size;
@ -427,6 +423,10 @@ H5HF_get_obj_len(H5HF_t *fh, const void *_id, size_t *obj_len_p)
/* Retrieve the entry length */
UINT64DECODE_VAR(id, *obj_len_p, fh->hdr->heap_len_size);
} /* end if */
else if((id_flags & H5HF_ID_TYPE_MASK) == H5HF_ID_TYPE_HUGE) {
if(H5HF_huge_get_obj_len(fh->hdr, dxpl_id, id, obj_len_p) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get 'huge' object's length")
} /* end if */
else {
HDfprintf(stderr, "%s: Heap ID type not supported yet!\n", FUNC);
HGOTO_ERROR(H5E_HEAP, H5E_UNSUPPORTED, FAIL, "heap ID type not supported yet")
@ -473,22 +473,17 @@ H5HF_read(H5HF_t *fh, hid_t dxpl_id, const void *_id, void *obj/*out*/)
if((id_flags & H5HF_ID_VERS_MASK) != H5HF_ID_VERS_CURR)
HGOTO_ERROR(H5E_HEAP, H5E_VERSION, FAIL, "incorrect heap ID version")
/* Check for managed object */
/* Check type of object in heap */
if((id_flags & H5HF_ID_TYPE_MASK) == H5HF_ID_TYPE_MAN) {
hsize_t obj_off; /* Object's offset in heap */
size_t obj_len; /* Object's length in heap */
/* Decode the object offset within the heap & it's length */
UINT64DECODE_VAR(id, obj_off, fh->hdr->heap_off_size);
UINT64DECODE_VAR(id, obj_len, fh->hdr->heap_len_size);
#ifdef QAK
HDfprintf(stderr, "%s: obj_off = %Hu, obj_len = %Zu\n", FUNC, obj_off, obj_len);
#endif /* QAK */
/* Read object from managed heap blocks */
if(H5HF_man_read(fh->hdr, dxpl_id, obj_off, obj_len, obj) < 0)
if(H5HF_man_read(fh->hdr, dxpl_id, id, obj) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't read object from fractal heap")
} /* end if */
else if((id_flags & H5HF_ID_TYPE_MASK) == H5HF_ID_TYPE_HUGE) {
/* Read 'huge' object from file */
if(H5HF_huge_read(fh->hdr, dxpl_id, id, obj) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't read 'huge' object from fractal heap")
} /* end if */
else {
HDfprintf(stderr, "%s: Heap ID type not supported yet!\n", FUNC);
HGOTO_ERROR(H5E_HEAP, H5E_UNSUPPORTED, FAIL, "heap ID type not supported yet")
@ -535,29 +530,17 @@ H5HF_remove(H5HF_t *fh, hid_t dxpl_id, const void *_id)
if((id_flags & H5HF_ID_VERS_MASK) != H5HF_ID_VERS_CURR)
HGOTO_ERROR(H5E_HEAP, H5E_VERSION, FAIL, "incorrect heap ID version")
/* Check for managed object */
/* Check type of object in heap */
if((id_flags & H5HF_ID_TYPE_MASK) == H5HF_ID_TYPE_MAN) {
hsize_t obj_off; /* Object's offset in heap */
size_t obj_len; /* Object's length in heap */
/* Decode the object offset within the heap & it's length */
#ifdef QAK
HDfprintf(stderr, "%s: fh->hdr->heap_off_size = %u, fh->hdr->heap_len_size = %u\n", FUNC, (unsigned)fh->hdr->heap_off_size, (unsigned)fh->hdr->heap_len_size);
#endif /* QAK */
UINT64DECODE_VAR(id, obj_off, fh->hdr->heap_off_size);
UINT64DECODE_VAR(id, obj_len, fh->hdr->heap_len_size);
#ifdef QAK
HDfprintf(stderr, "%s: obj_off = %Hu, obj_len = %Zu\n", FUNC, obj_off, obj_len);
#endif /* QAK */
/* Sanity check parameters */
HDassert(obj_off);
HDassert(obj_len);
/* Remove object from managed heap blocks */
if(H5HF_man_remove(fh->hdr, dxpl_id, obj_off, obj_len) < 0)
if(H5HF_man_remove(fh->hdr, dxpl_id, id) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTREMOVE, FAIL, "can't remove object from fractal heap")
} /* end if */
else if((id_flags & H5HF_ID_TYPE_MASK) == H5HF_ID_TYPE_HUGE) {
/* Remove 'huge' object from file & v2 B-tree tracker */
if(H5HF_huge_remove(fh->hdr, dxpl_id, id) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTREMOVE, FAIL, "can't remove 'huge' object from fractal heap")
} /* end if */
else {
HDfprintf(stderr, "%s: Heap ID type not supported yet!\n", FUNC);
HGOTO_ERROR(H5E_HEAP, H5E_UNSUPPORTED, FAIL, "heap ID type not supported yet")
@ -611,7 +594,7 @@ H5HF_close(H5HF_t *fh, hid_t dxpl_id)
if(H5HF_space_close(fh->hdr, dxpl_id) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't release free space info")
/* Reset the block iterator */
/* Reset the block iterator, if necessary */
/* (Can't put this in header "destroy" routine, because it has
* pointers to indirect blocks in the heap, which would create
* a reference loop and the objects couldn't be removed from
@ -622,15 +605,21 @@ HDfprintf(stderr, "%s; fh->hdr->man_iter_off = %Hu\n", FUNC, fh->hdr->man_iter_o
HDfprintf(stderr, "%s; fh->hdr->man_size = %Hu\n", FUNC, fh->hdr->man_size);
HDfprintf(stderr, "%s; fh->hdr->rc = %Zu\n", FUNC, fh->hdr->rc);
#endif /* QAK */
/* Reset block iterator, if necessary */
if(H5HF_man_iter_ready(&fh->hdr->next_block)) {
if(H5HF_man_iter_ready(&fh->hdr->next_block))
if(H5HF_man_iter_reset(&fh->hdr->next_block) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't reset block iterator")
} /* end if */
#ifdef QAK
HDfprintf(stderr, "%s; After iterator reset fh->hdr->rc = %Zu\n", FUNC, fh->hdr->rc);
#endif /* QAK */
/* Shut down the huge object information */
/* (Can't put this in header "destroy" routine, because it has
* has the address of an object in the file, which might be
* by the shutdown routine - QAK)
*/
if(H5HF_huge_term(fh->hdr, dxpl_id) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't release 'huge' object info")
/* Decrement the reference count on the heap header */
if(H5HF_hdr_decr(fh->hdr) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't decrement reference count on shared heap header")
@ -712,6 +701,16 @@ HDfprintf(stderr, "%s: hdr->man_dtable.table_addr = %a\n", FUNC, hdr->man_dtable
} /* end else */
} /* end if */
/* Check for 'huge' objects in heap */
if(H5F_addr_defined(hdr->huge_bt2_addr)) {
#ifdef QAK
HDfprintf(stderr, "%s: hdr->huge_bt2_addr = %a\n", FUNC, hdr->huge_bt2_addr);
#endif /* QAK */
/* Delete huge objects in heap and their tracker */
if(H5HF_huge_delete(hdr, dxpl_id) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to release fractal heap 'huge' objects and tracker")
} /* end if */
/* Release header's disk space */
if(H5MF_xfree(f, H5FD_MEM_FHEAP_HDR, dxpl_id, fh_addr, (hsize_t)H5HF_HEADER_SIZE(hdr)) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to release fractal heap header")

370
src/H5HFbtree2.c Normal file
View File

@ -0,0 +1,370 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* 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: H5HFbtree2.c
* Aug 7 2006
* Quincey Koziol <koziol@hdfgroup.org>
*
* Purpose: v2 B-tree callbacks for "huge" object tracker
*
*-------------------------------------------------------------------------
*/
/****************/
/* Module Setup */
/****************/
#define H5HF_PACKAGE /*suppress error about including H5HFpkg */
/***********/
/* Headers */
/***********/
#include "H5private.h" /* Generic Functions */
#include "H5Eprivate.h" /* Error handling */
#include "H5HFpkg.h" /* Fractal heaps */
#include "H5MFprivate.h" /* File memory management */
/****************/
/* Local Macros */
/****************/
/******************/
/* Local Typedefs */
/******************/
/********************/
/* Package Typedefs */
/********************/
/********************/
/* Local Prototypes */
/********************/
/* v2 B-tree function callbacks */
herr_t H5HF_huge_bt2_found(const void *nrecord, void *op_data);
herr_t H5HF_huge_bt2_remove(const void *nrecord, void *op_data);
/* v2 B-tree driver callbacks */
static herr_t H5HF_huge_btree2_store(const H5B2_class_t *cls, void *native, const void *udata);
static herr_t H5HF_huge_btree2_retrieve(const H5B2_class_t *cls, void *udata, const void *native);
static herr_t H5HF_huge_btree2_compare(const H5B2_class_t *cls, const void *rec1, const void *rec2);
static herr_t H5HF_huge_btree2_encode(const H5F_t *f, const H5B2_class_t *cls, uint8_t *raw,
const void *native);
static herr_t H5HF_huge_btree2_decode(const H5F_t *f, const H5B2_class_t *cls, const uint8_t *raw,
void *native);
static herr_t H5HF_huge_btree2_debug(FILE *stream, const H5F_t *f, hid_t dxpl_id,
int indent, int fwidth, const H5B2_class_t *cls, const void *record, const void *_udata);
/*********************/
/* Package Variables */
/*********************/
const H5B2_class_t H5HF_BTREE2[1]={{ /* B-tree class information */
H5B2_FHEAP_ID, /* Type of B-tree */
0, /* Size of native record */
/* (computed at run-time for each heap) */
NULL, /* Class private information */
H5HF_huge_btree2_store, /* Record storage callback */
H5HF_huge_btree2_retrieve, /* Record retrieval callback */
H5HF_huge_btree2_compare, /* Record comparison callback */
H5HF_huge_btree2_encode, /* Record encoding callback */
H5HF_huge_btree2_decode, /* Record decoding callback */
H5HF_huge_btree2_debug /* Record debugging callback */
}};
/*****************************/
/* Library Private Variables */
/*****************************/
/*******************/
/* Local Variables */
/*******************/
/*-------------------------------------------------------------------------
* Function: H5HF_huge_bt2_found
*
* Purpose: Retrieve record for 'huge' object, when it's found in the
* v2 B-tree
*
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* Tuesday, August 8, 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_huge_bt2_found(const void *nrecord, void *op_data)
{
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HF_huge_bt2_found)
#ifdef QAK
HDfprintf(stderr, "%s: nrecord = {%a, %Hu, %Hu}\n", "H5HF_huge_bt2_store",
((const H5HF_huge_bt2_rec_t *)nrecord)->addr,
((const H5HF_huge_bt2_rec_t *)nrecord)->len,
((const H5HF_huge_bt2_rec_t *)nrecord)->id);
#endif /* QAK */
*(H5HF_huge_bt2_rec_t *)op_data = *(const H5HF_huge_bt2_rec_t *)nrecord;
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5HF_huge_bt2_found() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_bt2_remove
*
* Purpose: Free space for 'huge' object, as v2 B-tree is being deleted
*
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* Tuesday, August 8, 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_huge_bt2_remove(const void *nrecord, void *_udata)
{
H5HF_huge_remove_ud1_t *udata = (H5HF_huge_remove_ud1_t *)_udata; /* User callback data */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_huge_bt2_remove)
/* Free the space in the file for the object being removed */
if(H5MF_xfree(udata->hdr->f, H5FD_MEM_FHEAP_HUGE_OBJ, udata->dxpl_id, ((const H5HF_huge_bt2_rec_t *)nrecord)->addr, ((const H5HF_huge_bt2_rec_t *)nrecord)->len) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to free space for huge object on disk")
/* Set the length of the object removed */
udata->obj_len = ((const H5HF_huge_bt2_rec_t *)nrecord)->len;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5HF_huge_bt2_remove() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_btree2_store
*
* Purpose: Store native information into record for v2 B-tree
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* Monday, August 7, 2006
*
*-------------------------------------------------------------------------
*/
static herr_t
H5HF_huge_btree2_store(const H5B2_class_t UNUSED *cls, void *nrecord, const void *udata)
{
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HF_huge_btree2_store)
*(H5HF_huge_bt2_rec_t *)nrecord = *(const H5HF_huge_bt2_rec_t *)udata;
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5HF_huge_btree2_store() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_btree2_retrieve
*
* Purpose: Retrieve native information from record for v2 B-tree
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* Monday, August 7, 2006
*
*-------------------------------------------------------------------------
*/
static herr_t
H5HF_huge_btree2_retrieve(const H5B2_class_t UNUSED *cls, void *udata, const void *nrecord)
{
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HF_huge_btree2_retrieve)
*(H5HF_huge_bt2_rec_t *)udata = *(const H5HF_huge_bt2_rec_t *)nrecord;
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5HF_huge_btree2_retrieve() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_btree2_compare
*
* Purpose: Compare two native information records, according to some key
*
* Return: <0 if rec1 < rec2
* =0 if rec1 == rec2
* >0 if rec1 > rec2
*
* Programmer: Quincey Koziol
* Monday, August 7, 2006
*
*-------------------------------------------------------------------------
*/
static herr_t
H5HF_huge_btree2_compare(const H5B2_class_t *cls, const void *_rec1, const void *_rec2)
{
const H5HF_huge_bt2_rec_t *rec1 = (const H5HF_huge_bt2_rec_t *)_rec1;
const H5HF_huge_bt2_rec_t *rec2 = (const H5HF_huge_bt2_rec_t *)_rec2;
const H5HF_hdr_t *hdr = (const H5HF_hdr_t *)cls->cls_private;
herr_t ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HF_huge_btree2_compare)
#ifdef QAK
HDfprintf(stderr, "%s: hdr->huge_ids_direct = %t\n", "H5HF_huge_btree2_compare", hdr->huge_ids_direct);
HDfprintf(stderr, "%s: rec1 = {%a, %Hu, %Hu}\n", "H5HF_huge_btree2_compare", rec1->addr, rec1->len, rec1->id);
HDfprintf(stderr, "%s: rec2 = {%a, %Hu, %Hu}\n", "H5HF_huge_btree2_compare", rec2->addr, rec2->len, rec2->id);
#endif /* QAK */
/* Sort differently, depending on whether 'huge' object directly reference disk */
if(hdr->huge_ids_direct) {
if(rec1->addr < rec2->addr)
ret_value = -1;
else if(rec1->addr > rec2->addr)
ret_value = 1;
else if(rec1->len < rec2->len)
ret_value = -1;
else if(rec1->len > rec2->len)
ret_value = 1;
else
ret_value = 0;
} /* end if */
else
ret_value = (herr_t)(rec1->id - rec2->id);
FUNC_LEAVE_NOAPI(ret_value);
} /* H5HF_huge_btree2_compare() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_btree2_encode
*
* Purpose: Encode native information into raw form for storing on disk
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* Monday, August 7, 2006
*
*-------------------------------------------------------------------------
*/
static herr_t
H5HF_huge_btree2_encode(const H5F_t *f, const H5B2_class_t *cls, uint8_t *raw, const void *_nrecord)
{
const H5HF_huge_bt2_rec_t *nrecord = (const H5HF_huge_bt2_rec_t *)_nrecord;
const H5HF_hdr_t *hdr = (const H5HF_hdr_t *)cls->cls_private;
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HF_huge_btree2_encode)
/* Encode the record's common fields */
H5F_addr_encode(f, &raw, nrecord->addr);
H5F_ENCODE_LENGTH(f, raw, nrecord->len);
/* If 'huge' objects in this heap are not accessed directly, encode the ID also */
if(!hdr->huge_ids_direct)
UINT64ENCODE_VAR(raw, nrecord->id, hdr->huge_id_size)
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5HF_huge_btree2_encode() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_btree2_decode
*
* Purpose: Decode raw disk form of record into native form
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* Monday, August 7, 2006
*
*-------------------------------------------------------------------------
*/
static herr_t
H5HF_huge_btree2_decode(const H5F_t *f, const H5B2_class_t *cls, const uint8_t *raw, void *_nrecord)
{
H5HF_huge_bt2_rec_t *nrecord = (H5HF_huge_bt2_rec_t *)_nrecord;
const H5HF_hdr_t *hdr = (const H5HF_hdr_t *)cls->cls_private;
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HF_huge_btree2_decode)
/* Decode the record's common fields */
H5F_addr_decode(f, &raw, &nrecord->addr);
H5F_DECODE_LENGTH(f, raw, nrecord->len);
/* If 'huge' objects in this heap are not accessed directly, decode the ID also */
if(!hdr->huge_ids_direct)
UINT64DECODE_VAR(raw, nrecord->id, hdr->huge_id_size)
else
nrecord->id = 0;
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5HF_huge_btree2_decode() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_btree2_debug
*
* Purpose: Debug native form of record
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* Monday, August 7, 2006
*
*-------------------------------------------------------------------------
*/
static herr_t
H5HF_huge_btree2_debug(FILE *stream, const H5F_t UNUSED *f, hid_t UNUSED dxpl_id,
int indent, int fwidth, const H5B2_class_t *cls, const void *_nrecord,
const void UNUSED *_udata)
{
const H5HF_huge_bt2_rec_t *nrecord = (const H5HF_huge_bt2_rec_t *)_nrecord;
const H5HF_hdr_t *hdr = (const H5HF_hdr_t *)cls->cls_private;
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HF_huge_btree2_debug)
HDassert(nrecord);
if(hdr->huge_ids_direct)
HDfprintf(stream, "%*s%-*s {%a, %Hu}\n", indent, "", fwidth, "Record:",
nrecord->addr, nrecord->len);
else
HDfprintf(stream, "%*s%-*s {%a, %Hu, %Hu}\n", indent, "", fwidth, "Record:",
nrecord->addr, nrecord->len, nrecord->id);
FUNC_LEAVE_NOAPI(SUCCEED)
} /* H5HF_huge_btree2_debug() */

4
src/H5HFcache.c
View File

@ -317,7 +317,7 @@ HDfprintf(stderr, "%s: Load heap header, addr = %a\n", FUNC, addr);
/* "Huge" object information */
UINT32DECODE(p, hdr->max_man_size); /* Max. size of "managed" objects */
H5F_DECODE_LENGTH(f, p, hdr->huge_next_id); /* Next ID to use for "huge" object */
H5F_addr_decode(f, &p, &hdr->huge_bt_addr); /* Address of "huge" object tracker B-tree */
H5F_addr_decode(f, &p, &hdr->huge_bt2_addr); /* Address of "huge" object tracker B-tree */
/* "Managed" object free space information */
H5F_DECODE_LENGTH(f, p, hdr->total_man_free); /* Internal free space in managed direct blocks */
@ -428,7 +428,7 @@ HDfprintf(stderr, "%s: Flushing heap header, addr = %a, destroy = %u\n", FUNC, a
/* "Huge" object information */
UINT32ENCODE(p, hdr->max_man_size); /* Max. size of "managed" objects */
H5F_ENCODE_LENGTH(f, p, hdr->huge_next_id); /* Next ID to use for "huge" object */
H5F_addr_encode(f, &p, hdr->huge_bt_addr); /* Address of "huge" object tracker B-tree */
H5F_addr_encode(f, &p, hdr->huge_bt2_addr); /* Address of "huge" object tracker B-tree */
/* "Managed" object free space information */
H5F_ENCODE_LENGTH(f, p, hdr->total_man_free); /* Internal free space in managed direct blocks */

2
src/H5HFdbg.c
View File

@ -256,7 +256,7 @@ H5HF_hdr_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
hdr->huge_next_id);
HDfprintf(stream, "%*s%-*s %Hu\n", indent, "", fwidth,
"Address of v2 B-tree for 'huge' objects:",
hdr->huge_bt_addr);
hdr->huge_bt2_addr);
HDfprintf(stream, "%*sManaged Objects Doubling-Table Info...\n", indent, "");
H5HF_dtable_debug(&hdr->man_dtable, stream, indent + 3, MAX(0, fwidth -3));

8
src/H5HFhdr.c
View File

@ -249,6 +249,10 @@ HDfprintf(stderr, "%s: row_max_dblock_free[%Zu] = %Zu\n", FUNC, u, hdr->man_dtab
if(H5HF_man_iter_init(&hdr->next_block) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't initialize space search block iterator")
/* Initialize the information for tracking 'huge' objects */
if(H5HF_huge_init(hdr) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't informan for tracking huge objects")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_hdr_finish_init() */
@ -318,8 +322,8 @@ H5HF_hdr_init(H5HF_hdr_t *hdr, haddr_t fh_addr, const H5HF_create_t *cparam)
/* Set free list header address to indicate that the heap is empty currently */
hdr->fs_addr = HADDR_UNDEF;
/* Set "huge" object tracker B-tree address to indicate that there aren't any yet */
hdr->huge_bt_addr = HADDR_UNDEF;
/* Set "huge" object tracker v2 B-tree address to indicate that there aren't any yet */
hdr->huge_bt2_addr = HADDR_UNDEF;
/* Note that the shared info is dirty (it's not written to the file yet) */
hdr->dirty = TRUE;

574
src/H5HFhuge.c Normal file
View File

@ -0,0 +1,574 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* 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: H5HFhuge.c
* Aug 7 2006
* Quincey Koziol <koziol@hdfgroup.org>
*
* Purpose: Routines for "huge" objects in fractal heap
*
*-------------------------------------------------------------------------
*/
/****************/
/* Module Setup */
/****************/
#define H5HF_PACKAGE /*suppress error about including H5HFpkg */
/***********/
/* Headers */
/***********/
#include "H5private.h" /* Generic Functions */
#include "H5Eprivate.h" /* Error handling */
#include "H5HFpkg.h" /* Fractal heaps */
#include "H5MFprivate.h" /* File memory management */
/****************/
/* Local Macros */
/****************/
/* v2 B-tree creation macros */
#define H5HF_HUGE_BT2_NODE_SIZE 512
#define H5HF_HUGE_BT2_SPLIT_PERC 100
#define H5HF_HUGE_BT2_MERGE_PERC 40
/******************/
/* Local Typedefs */
/******************/
/********************/
/* Package Typedefs */
/********************/
/********************/
/* Local Prototypes */
/********************/
/* local v2 B-tree operations */
static herr_t H5HF_huge_bt2_create(H5HF_hdr_t *hdr, hid_t dxpl_id);
/* v2 B-tree function callbacks (in H5HFbtree2.c) */
herr_t H5HF_huge_bt2_found(const void *nrecord, void *op_data);
herr_t H5HF_huge_bt2_remove(const void *nrecord, void *op_data);
/*********************/
/* Package Variables */
/*********************/
/* The v2 B-tree class for tracking huge objects */
H5_DLLVAR const H5B2_class_t H5HF_BTREE2[1];
/*****************************/
/* Library Private Variables */
/*****************************/
/*******************/
/* Local Variables */
/*******************/
/*-------------------------------------------------------------------------
* Function: H5HF_huge_bt2_create
*
* Purpose: Create the v2 B-tree for tracking the huge objects in the heap
*
* Return: SUCCEED/FAIL
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Aug 7 2006
*
*-------------------------------------------------------------------------
*/
static herr_t
H5HF_huge_bt2_create(H5HF_hdr_t *hdr, hid_t dxpl_id)
{
size_t rrec_size; /* Size of 'raw' records on disk */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_huge_bt2_create)
/*
* Check arguments.
*/
HDassert(hdr);
/* Compute the size of 'raw' records on disk */
if(hdr->huge_ids_direct)
rrec_size = hdr->sizeof_addr + hdr->sizeof_size;
else
rrec_size = hdr->sizeof_addr + hdr->sizeof_size + hdr->huge_id_size;
/* Create v2 B-tree for tracking 'huge' objects */
if(H5B2_create(hdr->f, dxpl_id, &hdr->huge_bt2_class, H5HF_HUGE_BT2_NODE_SIZE, rrec_size,
H5HF_HUGE_BT2_SPLIT_PERC, H5HF_HUGE_BT2_MERGE_PERC, &hdr->huge_bt2_addr/*out*/) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTCREATE, FAIL, "can't create v2 B-tree for tracking 'huge' heap objects")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_huge_bt2_create() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_init
*
* Purpose: Initialize information for tracking 'huge' objects
*
* Return: SUCCEED/FAIL
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Aug 7 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_huge_init(H5HF_hdr_t *hdr)
{
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HF_huge_init)
/*
* Check arguments.
*/
HDassert(hdr);
/* Compute information about 'huge' objects for the heap */
/* Check if we can completely hold the 'huge' object's offset & length in
* the file in the heap ID (which will speed up accessing it)
*/
if((hdr->sizeof_addr + hdr->sizeof_size) <= (hdr->id_len - 1)) {
/* Indicate that v2 B-tree doesn't have to be used to locate object */
hdr->huge_ids_direct = TRUE;
/* Set the size of 'huge' object IDs */
hdr->huge_id_size = hdr->sizeof_addr + hdr->sizeof_size;
} /* end if */
else {
/* Indicate that v2 B-tree must be used to locate object */
hdr->huge_ids_direct = FALSE;
/* Set the size and maximum value of 'huge' object ID */
if((hdr->id_len - 1) < sizeof(hsize_t)) {
hdr->huge_id_size = hdr->id_len - 1;
hdr->huge_max_id = ((hsize_t)1 << (hdr->huge_id_size * 8)) - 1;
} /*end if */
else {
hdr->huge_id_size = sizeof(hsize_t);
hdr->huge_max_id = HSIZET_MAX;
} /* end else */
} /* end else */
/* Set up the v2 B-tree for tracking 'huge' objects in the heap */
/* Copy the standard v2 B-tree class */
HDmemcpy(&hdr->huge_bt2_class, H5HF_BTREE2, sizeof(H5B2_class_t));
/* Set the native record size for the v2 B-tree */
hdr->huge_bt2_class.nrec_size = sizeof(H5HF_huge_bt2_rec_t);
/* Set v2 B-tree class's "class private" pointer to the heap header */
hdr->huge_bt2_class.cls_private = hdr;
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5HF_huge_init() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_insert
*
* Purpose: Insert a huge object into the file and track it
*
* Return: SUCCEED/FAIL
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Aug 7 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_huge_insert(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t obj_size, const void *obj,
void *_id)
{
H5HF_huge_bt2_rec_t obj_rec; /* Record for tracking object */
uint8_t *id = (uint8_t *)_id; /* Pointer to ID buffer */
haddr_t obj_addr; /* Address of object in the file */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_huge_insert)
#ifdef QAK
HDfprintf(stderr, "%s: obj_size = %Zu\n", FUNC, obj_size);
#endif /* QAK */
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(obj_size > hdr->max_man_size);
HDassert(obj);
HDassert(id);
/* Check if the v2 B-tree for tracking 'huge' heap objects has been created yet */
if(!H5F_addr_defined(hdr->huge_bt2_addr))
if(H5HF_huge_bt2_create(hdr, dxpl_id) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTCREATE, FAIL, "can't create v2 B-tree for tracking 'huge' heap objects")
/* Allocate space in the file for storing the 'huge' object */
if(HADDR_UNDEF == (obj_addr = H5MF_alloc(hdr->f, H5FD_MEM_FHEAP_HUGE_OBJ, dxpl_id, (hsize_t)obj_size)))
HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap huge object")
/* Write the object's data to disk */
if(H5F_block_write(hdr->f, H5FD_MEM_FHEAP_HUGE_OBJ, obj_addr, obj_size, dxpl_id, obj) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "writing 'huge' object to file failed")
/* Initialize shared part of record for tracking object in v2 B-tree */
obj_rec.addr = obj_addr;
obj_rec.len = obj_size;
/* If the 'huge' object will be indirectly accessed, through the v2 B-tree,
* create an ID for it, otherwise put a zero in for ID
*/
if(hdr->huge_ids_direct)
obj_rec.id = 0;
else {
/* Check for wrapping around 'huge' object ID space */
if(hdr->huge_ids_wrapped)
/* Fail for now - eventually should iterate through v2 B-tree, looking for available ID */
HGOTO_ERROR(H5E_HEAP, H5E_UNSUPPORTED, FAIL, "wrapping 'huge' object IDs not supported yet")
else {
/* Get new 'huge' object ID to use for object */
/* (avoid using ID 0) */
obj_rec.id = ++hdr->huge_next_id;
/* Check for wrapping 'huge' object IDs around */
if(hdr->huge_next_id == hdr->huge_max_id)
hdr->huge_ids_wrapped = TRUE;
} /* end else */
} /* end else */
#ifdef QAK
HDfprintf(stderr, "%s: obj_rec = {%a, %Hu, %Hu}\n", FUNC, obj_rec.addr, obj_rec.len, obj_rec.id);
#endif /* QAK */
/* Insert record for object in v2 B-tree */
if(H5B2_insert(hdr->f, dxpl_id, &hdr->huge_bt2_class, hdr->huge_bt2_addr, &obj_rec) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTINSERT, FAIL, "couldn't insert object tracking record in v2 B-tree")
/* Encode ID for user */
*id++ = H5HF_ID_VERS_CURR | H5HF_ID_TYPE_HUGE;
if(hdr->huge_ids_direct) {
H5F_addr_encode(hdr->f, &id, obj_addr);
H5F_ENCODE_LENGTH(hdr->f, id, (hsize_t)obj_size);
} /* end if */
else
UINT64ENCODE_VAR(id, obj_rec.id, hdr->huge_id_size)
/* Update statistics about heap */
hdr->huge_size += obj_size;
hdr->huge_nobjs++;
/* Mark heap header as modified */
if(H5HF_hdr_dirty(hdr) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_huge_insert() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_get_obj_len
*
* Purpose: Get the size of a 'huge' object in a fractal heap
*
* Return: SUCCEED/FAIL
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Aug 8 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_huge_get_obj_len(H5HF_hdr_t *hdr, hid_t dxpl_id, const uint8_t *id,
size_t *obj_len_p)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(H5HF_huge_get_obj_len, FAIL)
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(H5F_addr_defined(hdr->huge_bt2_addr));
HDassert(id);
HDassert(obj_len_p);
/* Check if 'huge' object ID encodes address & length directly */
if(hdr->huge_ids_direct) {
/* Skip over object offset in file */
id += hdr->sizeof_addr;
/* Retrieve the object's length */
H5F_DECODE_LENGTH(hdr->f, id, *obj_len_p);
} /* end if */
else {
H5HF_huge_bt2_rec_t found_rec; /* Record found from tracking object */
H5HF_huge_bt2_rec_t search_rec; /* Record for searching for object */
/* Get ID for looking up 'huge' object in v2 B-tree */
UINT64DECODE_VAR(id, search_rec.id, hdr->huge_id_size)
/* Look up object in v2 B-tree */
if(H5B2_find(hdr->f, dxpl_id, &hdr->huge_bt2_class, hdr->huge_bt2_addr,
&search_rec, H5HF_huge_bt2_found, &found_rec) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_NOTFOUND, FAIL, "can't find object in B-tree")
/* Retrieve the object's length */
*obj_len_p = (size_t)found_rec.len;
} /* end else */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_huge_get_obj_len() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_read
*
* Purpose: Read a 'huge' object from the heap
*
* Return: SUCCEED/FAIL
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Aug 8 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_huge_read(H5HF_hdr_t *hdr, hid_t dxpl_id, const uint8_t *id, void *obj)
{
haddr_t obj_addr; /* Object's address in the file */
hsize_t obj_size; /* Object's size in the file */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_huge_read)
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(id);
HDassert(obj);
/* Check for 'huge' object ID that encodes address & length directly */
if(hdr->huge_ids_direct) {
/* Retrieve the object's address and length */
H5F_addr_decode(hdr->f, &id, &obj_addr);
H5F_DECODE_LENGTH(hdr->f, id, obj_size);
} /* end if */
else {
H5HF_huge_bt2_rec_t found_rec; /* Record found from tracking object */
H5HF_huge_bt2_rec_t search_rec; /* Record for searching for object */
/* Get ID for looking up 'huge' object in v2 B-tree */
UINT64DECODE_VAR(id, search_rec.id, hdr->huge_id_size)
/* Look up object in v2 B-tree */
if(H5B2_find(hdr->f, dxpl_id, &hdr->huge_bt2_class, hdr->huge_bt2_addr,
&search_rec, H5HF_huge_bt2_found, &found_rec) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_NOTFOUND, FAIL, "can't find object in B-tree")
/* Retrieve the object's address & length */
obj_addr = found_rec.addr;
obj_size = found_rec.len;
} /* end else */
/* Read the object's data from the file */
if (H5F_block_read(hdr->f, H5FD_MEM_FHEAP_HUGE_OBJ, obj_addr, (size_t)obj_size, dxpl_id, obj) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_READERROR, FAIL, "can't read 'huge' object's data from the file")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_huge_read() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_remove
*
* Purpose: Remove a 'huge' object from the file and the v2 B-tree tracker
*
* Return: SUCCEED/FAIL
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Aug 8 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_huge_remove(H5HF_hdr_t *hdr, hid_t dxpl_id, const uint8_t *id)
{
H5HF_huge_bt2_rec_t search_rec; /* Record for searching for object */
H5HF_huge_remove_ud1_t udata; /* User callback data for v2 B-tree remove call */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_huge_remove)
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(id);
/* Check for 'huge' object ID that encodes address & length directly */
if(hdr->huge_ids_direct) {
/* Retrieve the object's address and length */
/* (used as key in v2 B-tree record) */
H5F_addr_decode(hdr->f, &id, &search_rec.addr);
H5F_DECODE_LENGTH(hdr->f, id, search_rec.len);
} /* end if */
else
/* Get ID for looking up 'huge' object in v2 B-tree */
UINT64DECODE_VAR(id, search_rec.id, hdr->huge_id_size)
/* Set up the callback info */
udata.hdr = hdr;
udata.dxpl_id = dxpl_id;
/* Remove the record for tracking the 'huge' object from the v2 B-tree */
/* (space in the file for the object is freed in the 'remove' callback) */
if(H5B2_remove(hdr->f, dxpl_id, &hdr->huge_bt2_class, hdr->huge_bt2_addr,
&search_rec, H5HF_huge_bt2_remove, &udata) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTREMOVE, FAIL, "can't remove object from B-tree")
/* Update statistics about heap */
hdr->huge_size -= udata.obj_len;
hdr->huge_nobjs--;
/* Mark heap header as modified */
if(H5HF_hdr_dirty(hdr) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_huge_remove() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_term
*
* Purpose: Shut down the information for tracking 'huge' objects
*
* Return: SUCCEED/FAIL
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Aug 8 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_huge_term(H5HF_hdr_t *hdr, hid_t dxpl_id)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_huge_term)
/*
* Check arguments.
*/
HDassert(hdr);
/* Check if there are no more 'huge' objects in the heap and delete the
* v2 B-tree that tracks them, if so
*/
if(H5F_addr_defined(hdr->huge_bt2_addr) && hdr->huge_nobjs == 0) {
/* Sanity check */
HDassert(hdr->huge_size == 0);
/* Delete the v2 B-tree */
if(H5B2_delete(hdr->f, dxpl_id, &hdr->huge_bt2_class, hdr->huge_bt2_addr, NULL, NULL) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTDELETE, FAIL, "can't delete v2 B-tree")
/* Reset the information about 'huge' objects in the file */
hdr->huge_bt2_addr = HADDR_UNDEF;
hdr->huge_next_id = 0;
hdr->huge_ids_wrapped = FALSE;
/* Mark heap header as modified */
if(H5HF_hdr_dirty(hdr) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty")
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_huge_term() */
/*-------------------------------------------------------------------------
* Function: H5HF_huge_delete
*
* Purpose: Delete all the 'huge' objects in the heap, and the v2 B-tree
* tracker for them
*
* Return: SUCCEED/FAIL
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Aug 8 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_huge_delete(H5HF_hdr_t *hdr, hid_t dxpl_id)
{
H5HF_huge_remove_ud1_t udata; /* User callback data for v2 B-tree remove call */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_huge_delete)
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(H5F_addr_defined(hdr->huge_bt2_addr));
HDassert(hdr->huge_nobjs);
HDassert(hdr->huge_size);
/* Set up the callback info */
udata.hdr = hdr;
udata.dxpl_id = dxpl_id;
/* Delete the v2 B-tree */
if(H5B2_delete(hdr->f, dxpl_id, &hdr->huge_bt2_class, hdr->huge_bt2_addr, H5HF_huge_bt2_remove, &udata) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTDELETE, FAIL, "can't delete v2 B-tree")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_huge_delete() */

116
src/H5HFint.c
View File

@ -14,7 +14,7 @@
/*-------------------------------------------------------------------------
*
* Created: H5HFint.c
* Created: H5HFman.c
* Feb 24 2006
* Quincey Koziol <koziol@ncsa.uiuc.edu>
*
@ -204,64 +204,6 @@ done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_locate_block() */
/*-------------------------------------------------------------------------
* Function: H5HF_man_find
*
* Purpose: Find space for an object in a managed obj. heap
*
* Return: Non-negative on success (with direct block info
* filled in), negative on failure
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* Mar 13 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_man_find(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t request,
H5HF_free_section_t **sec_node/*out*/)
{
htri_t node_found; /* Whether an existing free list node was found */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_man_find)
#ifdef QAK
HDfprintf(stderr, "%s: request = %Zu\n", FUNC, request);
#endif /* QAK */
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(request > 0);
HDassert(sec_node);
/* Look for free space */
if((node_found = H5HF_space_find(hdr, dxpl_id, (hsize_t)request, sec_node)) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't locate free space in fractal heap")
#ifdef QAK
HDfprintf(stderr, "%s: After H5HF_space_find(), node_found = %t\n", FUNC, node_found);
#endif /* QAK */
/* If we didn't find a node, go create a direct block big enough to hold the requested block */
if(!node_found)
/* Allocate direct block big enough to hold requested size */
if(H5HF_man_dblock_new(hdr, dxpl_id, request, sec_node) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTCREATE, FAIL, "can't create fractal heap direct block")
HDassert(*sec_node);
#ifdef QAK
HDfprintf(stderr, "%s: (*sec_node)->sect_info.addr = %a\n", FUNC, (*sec_node)->sect_info.addr);
HDfprintf(stderr, "%s: (*sec_node)->sect_info.size = %Hu\n", FUNC, (*sec_node)->sect_info.size);
HDfprintf(stderr, "%s: (*sec_node)->sect_info.type = %u\n", FUNC, (*sec_node)->sect_info.type);
#endif /* QAK */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_man_find() */
/*-------------------------------------------------------------------------
* Function: H5HF_man_insert
@ -277,13 +219,15 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
H5HF_man_insert(H5HF_hdr_t *hdr, hid_t dxpl_id, H5HF_free_section_t *sec_node,
size_t obj_size, const void *obj, void *_id)
H5HF_man_insert(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t obj_size, const void *obj,
void *_id)
{
H5HF_free_section_t *sec_node; /* Pointer to free space section */
H5HF_direct_t *dblock = NULL; /* Pointer to direct block to modify */
haddr_t dblock_addr = HADDR_UNDEF; /* Direct block address */
uint8_t *id = (uint8_t *)_id; /* Pointer to ID buffer */
size_t blk_off; /* Offset of object within block */
htri_t node_found; /* Whether an existing free list node was found */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_man_insert)
@ -299,6 +243,19 @@ HDfprintf(stderr, "%s: obj_size = %Zu\n", FUNC, obj_size);
HDassert(obj);
HDassert(id);
/* Look for free space */
if((node_found = H5HF_space_find(hdr, dxpl_id, (hsize_t)obj_size, &sec_node)) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't locate free space in fractal heap")
#ifdef QAK
HDfprintf(stderr, "%s: After H5HF_space_find(), node_found = %t\n", FUNC, node_found);
#endif /* QAK */
/* If we didn't find a node, go create a direct block big enough to hold the requested block */
if(!node_found)
/* Allocate direct block big enough to hold requested size */
if(H5HF_man_dblock_new(hdr, dxpl_id, obj_size, &sec_node) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTCREATE, FAIL, "can't create fractal heap direct block")
/* Check for row section */
if(sec_node->sect_info.type == H5HF_FSPACE_SECT_FIRST_ROW ||
sec_node->sect_info.type == H5HF_FSPACE_SECT_NORMAL_ROW) {
@ -318,7 +275,7 @@ HDfprintf(stderr, "%s: sec_node->u.row.num_entries = %u\n", FUNC, sec_node->u.ro
} /* end if */
HDassert(sec_node->sect_info.type == H5HF_FSPACE_SECT_SINGLE);
/* Check for serialized 'single' section */
/* Check for 'single' section being serialized */
if(sec_node->sect_info.state == H5FS_SECT_SERIALIZED) {
if(H5HF_sect_single_revive(hdr, dxpl_id, sec_node) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't revive single free section")
@ -417,9 +374,11 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
H5HF_man_read(H5HF_hdr_t *hdr, hid_t dxpl_id, hsize_t obj_off, size_t obj_len, void *obj)
H5HF_man_read(H5HF_hdr_t *hdr, hid_t dxpl_id, const uint8_t *id, void *obj)
{
H5HF_direct_t *dblock; /* Pointer to direct block to query */
hsize_t obj_off; /* Object's offset in heap */
size_t obj_len; /* Object's length in heap */
size_t blk_off; /* Offset of object in block */
uint8_t *p; /* Temporary pointer to obj info in block */
haddr_t dblock_addr; /* Direct block address */
@ -427,17 +386,22 @@ H5HF_man_read(H5HF_hdr_t *hdr, hid_t dxpl_id, hsize_t obj_off, size_t obj_len, v
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_man_read)
#ifdef QAK
HDfprintf(stderr, "%s: obj_off = %Hu, obj_len = %Zu\n", FUNC, obj_off, obj_len);
#endif /* QAK */
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(id);
HDassert(obj);
/* Decode the object offset within the heap & it's length */
UINT64DECODE_VAR(id, obj_off, hdr->heap_off_size);
UINT64DECODE_VAR(id, obj_len, hdr->heap_len_size);
#ifdef QAK
HDfprintf(stderr, "%s: obj_off = %Hu, obj_len = %Zu\n", FUNC, obj_off, obj_len);
#endif /* QAK */
HDassert(obj_off > 0);
HDassert(obj_len > 0);
HDassert(obj);
/* Check for root direct block */
if(hdr->man_dtable.curr_root_rows == 0) {
@ -511,24 +475,34 @@ done:
*-------------------------------------------------------------------------
*/
herr_t
H5HF_man_remove(H5HF_hdr_t *hdr, hid_t dxpl_id, hsize_t obj_off, size_t obj_len)
H5HF_man_remove(H5HF_hdr_t *hdr, hid_t dxpl_id, const uint8_t *id)
{
H5HF_free_section_t *sec_node; /* Pointer to free space section for block */
H5HF_direct_t *dblock; /* Pointer to direct block to query */
hsize_t obj_off; /* Object's offset in heap */
size_t obj_len; /* Object's length in heap */
haddr_t dblock_addr; /* Direct block address */
size_t dblock_size; /* Direct block size */
size_t blk_off; /* Offset of object in block */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_man_remove)
#ifdef QAK
HDfprintf(stderr, "%s: obj_off = %Hu, obj_len = %Zu\n", FUNC, obj_off, obj_len);
#endif /* QAK */
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(id);
/* Decode the object offset within the heap & it's length */
#ifdef QAK
HDfprintf(stderr, "%s: fh->hdr->heap_off_size = %u, fh->hdr->heap_len_size = %u\n", FUNC, (unsigned)fh->hdr->heap_off_size, (unsigned)fh->hdr->heap_len_size);
#endif /* QAK */
UINT64DECODE_VAR(id, obj_off, hdr->heap_off_size);
UINT64DECODE_VAR(id, obj_len, hdr->heap_len_size);
#ifdef QAK
HDfprintf(stderr, "%s: obj_off = %Hu, obj_len = %Zu\n", FUNC, obj_off, obj_len);
#endif /* QAK */
HDassert(obj_off > 0);
HDassert(obj_len > 0);

55
src/H5HFpkg.h
View File

@ -32,6 +32,7 @@
/* Other private headers needed by this file */
#include "H5ACprivate.h" /* Metadata cache */
#include "H5B2private.h" /* v2 B-trees */
#include "H5FLprivate.h" /* Free Lists */
#include "H5FSprivate.h" /* File free space */
#include "H5SLprivate.h" /* Skip lists */
@ -296,7 +297,7 @@ typedef struct H5HF_hdr_t {
hbool_t debug_objs; /* Is the heap storing objects in 'debug' format */
hbool_t have_io_filter; /* Does the heap have I/O filters for the direct blocks? */
hbool_t write_once; /* Is heap being written in "write once" mode? */
hbool_t huge_ids_wrapped; /* Have "huge" object IDs wrapped around? */
hbool_t huge_ids_wrapped; /* Have "huge" object IDs wrapped around? */
/* Doubling table information (partially stored in header) */
/* (Partially set by user, partially derived/updated internally) */
@ -308,8 +309,8 @@ typedef struct H5HF_hdr_t {
/* "Huge" object support (stored in header) */
uint32_t max_man_size; /* Max. size of object to manage in doubling table */
hsize_t huge_next_id; /* Next ID to use for "huge" object */
haddr_t huge_bt_addr; /* Address of B-tree for storing "huge" object info */
hsize_t huge_next_id; /* Next ID to use for indirectly tracked 'huge' object */
haddr_t huge_bt2_addr; /* Address of v2 B-tree for tracking "huge" object info */
/* Statistics for heap (stored in header) */
hsize_t man_size; /* Total amount of managed space in heap */
@ -330,6 +331,10 @@ typedef struct H5HF_hdr_t {
size_t id_len; /* Size of heap IDs (in bytes) */
H5FS_t *fspace; /* Free space list for objects in heap */
H5HF_block_iter_t next_block; /* Block iterator for searching for next block with space */
H5B2_class_t huge_bt2_class; /* v2 B-tree class information for "huge" object tracking */
hsize_t huge_max_id; /* Max. 'huge' heap ID before rolling 'huge' heap IDs over */
hbool_t huge_ids_direct; /* Flag to indicate that 'huge' object's offset & length are stored directly in heap ID */
unsigned char huge_id_size; /* Size of 'huge' heap IDs (in bytes) */
unsigned char heap_off_size; /* Size of heap offsets (in bytes) */
unsigned char heap_len_size; /* Size of heap ID lengths (in bytes) */
} H5HF_hdr_t;
@ -396,7 +401,21 @@ typedef struct H5HF_parent_t {
typedef struct {
H5HF_hdr_t *hdr; /* Fractal heap header */
hid_t dxpl_id; /* DXPL ID for operation */
} H5HF_add_ud1_t;
} H5HF_sect_add_ud1_t;
/* User data for v2 B-tree 'remove' callback on 'huge' objects */
typedef struct {
H5HF_hdr_t *hdr; /* Fractal heap header (in) */
hid_t dxpl_id; /* DXPL ID for operation (in) */
hsize_t obj_len; /* Length of object removed (out) */
} H5HF_huge_remove_ud1_t;
/* Typedef for 'huge' object's records in the v2 B-tree */
typedef struct H5HF_huge_bt2_rec_t {
haddr_t addr; /* Address of the object in the file */
hsize_t len; /* Length of the object in the file */
hsize_t id; /* ID used for object (not used for 'huge' objects directly accessed) */
} H5HF_huge_bt2_rec_t;
/*****************************/
/* Package Private Variables */
@ -516,19 +535,27 @@ H5_DLL H5HF_direct_t *H5HF_man_dblock_protect(H5HF_hdr_t *hdr, hid_t dxpl_id,
H5_DLL herr_t H5HF_man_dblock_delete(H5F_t *f, hid_t dxpl_id, haddr_t dblock_addr,
hsize_t dblock_size);
/* Routines for internal operations */
/* Managed object routines */
H5_DLL herr_t H5HF_man_locate_block(H5HF_hdr_t *hdr, hid_t dxpl_id,
hsize_t obj_off, hbool_t locate_indirect, H5HF_indirect_t **par_iblock,
unsigned *par_entry, H5AC_protect_t rw);
H5_DLL herr_t H5HF_man_find(H5HF_hdr_t *fh, hid_t dxpl_id, size_t request,
H5HF_free_section_t **sec_node/*out*/);
H5_DLL herr_t H5HF_man_insert(H5HF_hdr_t *fh, hid_t dxpl_id,
H5HF_free_section_t *sec_node, size_t obj_size, const void *obj,
void *id);
H5_DLL herr_t H5HF_man_read(H5HF_hdr_t *fh, hid_t dxpl_id, hsize_t obj_off,
size_t obj_len, void *obj);
H5_DLL herr_t H5HF_man_remove(H5HF_hdr_t *hdr, hid_t dxpl_id, hsize_t obj_off,
size_t obj_len);
H5_DLL herr_t H5HF_man_insert(H5HF_hdr_t *fh, hid_t dxpl_id, size_t obj_size,
const void *obj, void *id);
H5_DLL herr_t H5HF_man_read(H5HF_hdr_t *fh, hid_t dxpl_id, const uint8_t *id,
void *obj);
H5_DLL herr_t H5HF_man_remove(H5HF_hdr_t *hdr, hid_t dxpl_id, const uint8_t *id);
/* "Huge" object routines */
H5_DLL herr_t H5HF_huge_init(H5HF_hdr_t *hdr);
H5_DLL herr_t H5HF_huge_insert(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t obj_size,
const void *obj, void *id);
H5_DLL herr_t H5HF_huge_get_obj_len(H5HF_hdr_t *hdr, hid_t dxpl_id,
const uint8_t *id, size_t *obj_len_p);
H5_DLL herr_t H5HF_huge_read(H5HF_hdr_t *fh, hid_t dxpl_id, const uint8_t *id,
void *obj);
H5_DLL herr_t H5HF_huge_remove(H5HF_hdr_t *fh, hid_t dxpl_id, const uint8_t *id);
H5_DLL herr_t H5HF_huge_term(H5HF_hdr_t *hdr, hid_t dxpl_id);
H5_DLL herr_t H5HF_huge_delete(H5HF_hdr_t *hdr, hid_t dxpl_id);
/* Metadata cache callbacks */
H5_DLL herr_t H5HF_cache_hdr_dest(H5F_t *f, H5HF_hdr_t *hdr);

3
src/H5HFprivate.h
View File

@ -91,7 +91,8 @@ H5_DLL herr_t H5HF_get_id_len(H5HF_t *fh, size_t *id_len_p/*out*/);
H5_DLL herr_t H5HF_get_heap_addr(H5HF_t *fh, haddr_t *heap_addr);
H5_DLL herr_t H5HF_insert(H5HF_t *fh, hid_t dxpl_id, size_t size,
const void *obj, void *id/*out*/);
H5_DLL herr_t H5HF_get_obj_len(H5HF_t *fh, const void *id, size_t *obj_len_p/*out*/);
H5_DLL herr_t H5HF_get_obj_len(H5HF_t *fh, hid_t dxpl_id, const void *id,
size_t *obj_len_p/*out*/);
H5_DLL herr_t H5HF_read(H5HF_t *fh, hid_t dxpl_id, const void *id,
void *obj/*out*/);
H5_DLL herr_t H5HF_remove(H5HF_t *fh, hid_t dxpl_id, const void *id);

14
src/H5HFsection.c
View File

@ -758,7 +758,7 @@ H5HF_sect_single_add(H5FS_section_info_t *_sect, unsigned *flags, void *_udata)
*/
if(!(*flags & H5FS_ADD_DESERIALIZING)) {
H5HF_free_section_t *sect = (H5HF_free_section_t *)_sect; /* Fractal heap free section */
H5HF_add_ud1_t *udata = (H5HF_add_ud1_t *)_udata; /* User callback data */
H5HF_sect_add_ud1_t *udata = (H5HF_sect_add_ud1_t *)_udata; /* User callback data */
H5HF_hdr_t *hdr = udata->hdr; /* Fractal heap header */
hid_t dxpl_id = udata->dxpl_id; /* DXPL ID for operation */
@ -899,7 +899,7 @@ H5HF_sect_single_merge(H5FS_section_info_t *_sect1, H5FS_section_info_t *_sect2,
{
H5HF_free_section_t *sect1 = (H5HF_free_section_t *)_sect1; /* Fractal heap free section */
H5HF_free_section_t *sect2 = (H5HF_free_section_t *)_sect2; /* Fractal heap free section */
H5HF_add_ud1_t *udata = (H5HF_add_ud1_t *)_udata; /* User callback data */
H5HF_sect_add_ud1_t *udata = (H5HF_sect_add_ud1_t *)_udata; /* User callback data */
H5HF_hdr_t *hdr = udata->hdr; /* Fractal heap header */
hid_t dxpl_id = udata->dxpl_id; /* DXPL ID for operation */
herr_t ret_value = SUCCEED; /* Return value */
@ -962,7 +962,7 @@ static htri_t
H5HF_sect_single_can_shrink(const H5FS_section_info_t *_sect, void *_udata)
{
const H5HF_free_section_t *sect = (const H5HF_free_section_t *)_sect; /* Fractal heap free section */
H5HF_add_ud1_t *udata = (H5HF_add_ud1_t *)_udata; /* User callback data */
H5HF_sect_add_ud1_t *udata = (H5HF_sect_add_ud1_t *)_udata; /* User callback data */
H5HF_hdr_t *hdr = udata->hdr; /* Fractal heap header */
htri_t ret_value = FALSE; /* Return value */
@ -1026,7 +1026,7 @@ static herr_t
H5HF_sect_single_shrink(H5FS_section_info_t **_sect, void UNUSED *_udata)
{
H5HF_free_section_t **sect = (H5HF_free_section_t **)_sect; /* Fractal heap free section */
H5HF_add_ud1_t *udata = (H5HF_add_ud1_t *)_udata; /* User callback data */
H5HF_sect_add_ud1_t *udata = (H5HF_sect_add_ud1_t *)_udata; /* User callback data */
H5HF_hdr_t *hdr = udata->hdr; /* Fractal heap header */
hid_t dxpl_id = udata->dxpl_id; /* DXPL ID for operation */
H5HF_direct_t *dblock; /* Pointer to direct block for section */
@ -1768,7 +1768,7 @@ H5HF_sect_row_merge(H5FS_section_info_t *_sect1, H5FS_section_info_t *_sect2,
{
H5HF_free_section_t *sect1 = (H5HF_free_section_t *)_sect1; /* Fractal heap free section */
H5HF_free_section_t *sect2 = (H5HF_free_section_t *)_sect2; /* Fractal heap free section */
H5HF_add_ud1_t *udata = (H5HF_add_ud1_t *)_udata; /* User callback data */
H5HF_sect_add_ud1_t *udata = (H5HF_sect_add_ud1_t *)_udata; /* User callback data */
H5HF_hdr_t *hdr = udata->hdr; /* Fractal heap header */
hid_t dxpl_id = udata->dxpl_id; /* DXPL ID for operation */
herr_t ret_value = SUCCEED; /* Return value */
@ -1847,7 +1847,7 @@ static htri_t
H5HF_sect_row_can_shrink(const H5FS_section_info_t *_sect, void UNUSED *_udata)
{
const H5HF_free_section_t *sect = (const H5HF_free_section_t *)_sect; /* Fractal heap free section */
H5HF_add_ud1_t *udata = (H5HF_add_ud1_t *)_udata; /* User callback data */
H5HF_sect_add_ud1_t *udata = (H5HF_sect_add_ud1_t *)_udata; /* User callback data */
H5HF_hdr_t *hdr = udata->hdr; /* Fractal heap header */
htri_t ret_value = FALSE; /* Return value */
@ -1893,7 +1893,7 @@ H5HF_sect_row_shrink(H5FS_section_info_t **_sect, void *_udata)
{
H5HF_free_section_t **sect = (H5HF_free_section_t **)_sect; /* Fractal heap free section */
H5HF_free_section_t *top_indir_sect; /* Top indirect section for row */
H5HF_add_ud1_t *udata = (H5HF_add_ud1_t *)_udata; /* User callback data */
H5HF_sect_add_ud1_t *udata = (H5HF_sect_add_ud1_t *)_udata; /* User callback data */
H5HF_hdr_t *hdr = udata->hdr; /* Fractal heap header */
hid_t dxpl_id = udata->dxpl_id; /* DXPL ID for operation */
herr_t ret_value = SUCCEED; /* Return value */

2
src/H5HFspace.c
View File

@ -156,7 +156,7 @@ herr_t
H5HF_space_add(H5HF_hdr_t *hdr, hid_t dxpl_id, H5HF_free_section_t *node,
unsigned flags)
{
H5HF_add_ud1_t udata; /* User data for free space manager 'add' */
H5HF_sect_add_ud1_t udata; /* User data for free space manager 'add' */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5HF_space_add)

4
src/Makefile.am
View File

@ -51,8 +51,8 @@ libhdf5_la_SOURCES= H5.c H5dbg.c H5A.c H5AC.c H5B.c H5Bcache.c \
H5FDstream.c H5FL.c H5FO.c H5FS.c H5FScache.c H5FSdbg.c H5FSsection.c \
H5G.c H5Gdeprec.c H5Gent.c H5Glink.c H5Gloc.c H5Gname.c H5Gnode.c \
H5Gobj.c H5Goh.c H5Gstab.c H5Gtest.c H5Gtraverse.c \
H5HF.c H5HFcache.c H5HFdbg.c H5HFdblock.c H5HFdtable.c \
H5HFhdr.c H5HFiblock.c H5HFint.c H5HFiter.c H5HFsection.c \
H5HF.c H5HFbtree2.c H5HFcache.c H5HFdbg.c H5HFdblock.c H5HFdtable.c \
H5HFhdr.c H5HFhuge.c H5HFiblock.c H5HFiter.c H5HFint.c H5HFsection.c \
H5HFspace.c H5HFstat.c H5HFtest.c \
H5HG.c H5HGdbg.c H5HL.c H5HLdbg.c H5HP.c H5I.c H5MF.c H5MM.c \
H5MP.c H5MPtest.c H5L.c H5Lexternal.c H5O.c H5Oattr.c H5Obogus.c H5Ocache.c \

12
src/Makefile.in
View File

@ -93,9 +93,9 @@ am_libhdf5_la_OBJECTS = H5.lo H5dbg.lo H5A.lo H5AC.lo H5B.lo \
H5FDstream.lo H5FL.lo H5FO.lo H5FS.lo H5FScache.lo H5FSdbg.lo \
H5FSsection.lo H5G.lo H5Gdeprec.lo H5Gent.lo H5Glink.lo \
H5Gloc.lo H5Gname.lo H5Gnode.lo H5Gobj.lo H5Goh.lo H5Gstab.lo \
H5Gtest.lo H5Gtraverse.lo H5HF.lo H5HFcache.lo H5HFdbg.lo \
H5HFdblock.lo H5HFdtable.lo H5HFhdr.lo H5HFiblock.lo \
H5HFint.lo H5HFiter.lo H5HFsection.lo H5HFspace.lo H5HFstat.lo \
H5Gtest.lo H5Gtraverse.lo H5HF.lo H5HFbtree2.lo H5HFcache.lo H5HFdbg.lo \
H5HFdblock.lo H5HFdtable.lo H5HFhdr.lo H5HFhuge.lo H5HFiblock.lo \
H5HFiter.lo H5HFint.lo H5HFsection.lo H5HFspace.lo H5HFstat.lo \
H5HFtest.lo H5HG.lo H5HGdbg.lo H5HL.lo H5HLdbg.lo H5HP.lo \
H5I.lo H5MF.lo H5MM.lo H5MP.lo H5MPtest.lo H5L.lo \
H5Lexternal.lo H5O.lo H5Oattr.lo H5Obogus.lo H5Ocache.lo \
@ -399,8 +399,8 @@ libhdf5_la_SOURCES = H5.c H5dbg.c H5A.c H5AC.c H5B.c H5Bcache.c \
H5FDstream.c H5FL.c H5FO.c H5FS.c H5FScache.c H5FSdbg.c H5FSsection.c \
H5G.c H5Gdeprec.c H5Gent.c H5Glink.c H5Gloc.c H5Gname.c H5Gnode.c \
H5Gobj.c H5Goh.c H5Gstab.c H5Gtest.c H5Gtraverse.c \
H5HF.c H5HFcache.c H5HFdbg.c H5HFdblock.c H5HFdtable.c \
H5HFhdr.c H5HFiblock.c H5HFint.c H5HFiter.c H5HFsection.c \
H5HF.c H5HFbtree2.c H5HFcache.c H5HFdbg.c H5HFdblock.c H5HFdtable.c \
H5HFhdr.c H5HFhuge.c H5HFiblock.c H5HFint.c H5HFiter.c H5HFsection.c \
H5HFspace.c H5HFstat.c H5HFtest.c \
H5HG.c H5HGdbg.c H5HL.c H5HLdbg.c H5HP.c H5I.c H5MF.c H5MM.c \
H5MP.c H5MPtest.c H5L.c H5Lexternal.c H5O.c H5Oattr.c H5Obogus.c H5Ocache.c \
@ -609,11 +609,13 @@ distclean-compile:
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Gtest.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Gtraverse.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HF.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HFbtree2.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HFcache.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HFdbg.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HFdblock.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HFdtable.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HFhdr.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HFhuge.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HFiblock.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HFint.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5HFiter.Plo@am__quote@

1014
test/fheap.c
View File

File diff suppressed because it is too large Load Diff