mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-11-27 02:10:55 +08:00
Code Issues Packages Projects Releases Wiki Activity
93bdf382dc
hdf5/src/H5HFspace.c
Quincey Koziol 42306f8ed4 [svn-r22233] Description: 
Correct several errors in fractal heap code: root indirect block was
getting pinned/protected more than once, "single" free space sections weren't
getting "re-parented" correctly when the heap transitioned between having a
root indirect block and a root direct block, and several related issues.  Also
cleaned up some warnings in library/tests.

Tested on:
    FreeBSD/32 8.2 (loyalty) w/gcc4.6, w/C++ & FORTRAN, in debug mode
    FreeBSD/64 8.2 (freedom) w/gcc4.6, w/C++ & FORTRAN, in debug mode
    Linux/32 2.6 (jam) w/PGI compilers, w/default API=1.8.x,
        w/C++ & FORTRAN, w/threadsafe, in debug mode
    Linux/64-amd64 2.6 (koala) w/Intel compilers, w/default API=1.6.x,
        w/C++ & FORTRAN, in production mode
    Mac OSX/64 10.7.3 (amazon) w/debug
2012-04-01 18:53:17 -05:00

640 lines
19 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*-------------------------------------------------------------------------
*
* Created: H5HFspace.c
* May 2 2006
* Quincey Koziol <koziol@ncsa.uiuc.edu>
*
* Purpose: Space allocation routines for fractal heaps.
*
*-------------------------------------------------------------------------
*/
/****************/
/* 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 */
/****************/
/* Local Macros */
/****************/
#define H5HF_FSPACE_SHRINK 80 /* Percent of "normal" size to shrink serialized free space size */
#define H5HF_FSPACE_EXPAND 120 /* Percent of "normal" size to expand serialized free space size */
#define H5HF_FSPACE_THRHD_DEF 1 /* Default: no alignment threshold */
#define H5HF_FSPACE_ALIGN_DEF 1 /* Default: no alignment */
/******************/
/* Local Typedefs */
/******************/
/********************/
/* Package Typedefs */
/********************/
/********************/
/* Local Prototypes */
/********************/
/*********************/
/* Package Variables */
/*********************/
/*****************************/
/* Library Private Variables */
/*****************************/
/*******************/
/* Local Variables */
/*******************/
/*-------------------------------------------------------------------------
* Function: H5HF_space_start
*
* Purpose: "Start up" free space for heap - open existing free space
* structure if one exists, otherwise create a new free space
* structure
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* May 2 2006
*
* Modifications:
* Vailin Choi, July 29th, 2008
* Pass values of alignment and threshold to FS_create() and FS_open()
* for handling alignment.
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_space_start(H5HF_hdr_t *hdr, hid_t dxpl_id, hbool_t may_create)
{
const H5FS_section_class_t *classes[] = { /* Free space section classes implemented for fractal heap */
H5HF_FSPACE_SECT_CLS_SINGLE,
H5HF_FSPACE_SECT_CLS_FIRST_ROW,
H5HF_FSPACE_SECT_CLS_NORMAL_ROW,
H5HF_FSPACE_SECT_CLS_INDIRECT};
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(hdr);
/* Check for creating free space info for the heap */
if(H5F_addr_defined(hdr->fs_addr)) {
/* Open an existing free space structure for the heap */
if(NULL == (hdr->fspace = H5FS_open(hdr->f, dxpl_id, hdr->fs_addr,
NELMTS(classes), classes, hdr, (hsize_t)H5HF_FSPACE_THRHD_DEF, (hsize_t)H5HF_FSPACE_ALIGN_DEF)))
HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't initialize free space info")
} /* end if */
else {
/* Check if we are allowed to create the free space manager */
if(may_create) {
H5FS_create_t fs_create; /* Free space creation parameters */
/* Set the free space creation parameters */
fs_create.client = H5FS_CLIENT_FHEAP_ID;
fs_create.shrink_percent = H5HF_FSPACE_SHRINK;
fs_create.expand_percent = H5HF_FSPACE_EXPAND;
fs_create.max_sect_size = hdr->man_dtable.cparam.max_direct_size;
fs_create.max_sect_addr = hdr->man_dtable.cparam.max_index;
/* Create the free space structure for the heap */
if(NULL == (hdr->fspace = H5FS_create(hdr->f, dxpl_id, &hdr->fs_addr,
&fs_create, NELMTS(classes), classes, hdr, (hsize_t)H5HF_FSPACE_THRHD_DEF, (hsize_t)H5HF_FSPACE_ALIGN_DEF)))
HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't initialize free space info")
HDassert(H5F_addr_defined(hdr->fs_addr));
} /* end if */
} /* end else */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_start() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_add
*
* Purpose: Add a section to the free space for the heap
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* May 15 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_space_add(H5HF_hdr_t *hdr, hid_t dxpl_id, H5HF_free_section_t *node,
unsigned flags)
{
H5HF_sect_add_ud_t udata; /* User data for free space manager 'add' */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(node);
/* Check if the free space for the heap has been initialized */
if(!hdr->fspace)
if(H5HF_space_start(hdr, dxpl_id, TRUE) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't initialize heap free space")
/* Construct user data */
udata.hdr = hdr;
udata.dxpl_id = dxpl_id;
/* Add to the free space for the heap */
if(H5FS_sect_add(hdr->f, dxpl_id, hdr->fspace, (H5FS_section_info_t *)node, flags, &udata) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTINSERT, FAIL, "can't add section to heap free space")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_add() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_find
*
* Purpose: Attempt to find space in a fractal heap
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* May 2 2006
*
*-------------------------------------------------------------------------
*/
htri_t
H5HF_space_find(H5HF_hdr_t *hdr, hid_t dxpl_id, hsize_t request, H5HF_free_section_t **node)
{
htri_t node_found = FALSE; /* Whether an existing free list node was found */
htri_t ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(request);
HDassert(node);
/* Check if the free space for the heap has been initialized */
if(!hdr->fspace)
if(H5HF_space_start(hdr, dxpl_id, FALSE) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't initialize heap free space")
/* Search for free space in the heap */
if(hdr->fspace)
if((node_found = H5FS_sect_find(hdr->f, dxpl_id, hdr->fspace, request, (H5FS_section_info_t **)node)) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "can't locate free space in fractal heap")
/* Set return value */
ret_value = node_found;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_find() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_revert_root_cb
*
* Purpose: Callback routine from iterator, to reset 'parent' pointers in
* sections, when the heap is changing from having a root indirect
* block to a direct block.
*
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Feb 24 2012
*
*-------------------------------------------------------------------------
*/
static herr_t
H5HF_space_revert_root_cb(H5FS_section_info_t *_sect, void UNUSED *_udata)
{
H5HF_free_section_t *sect = (H5HF_free_section_t *)_sect; /* Section to dump info */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(sect);
/* Only modify "live" single blocks... */
if(sect->sect_info.type == H5HF_FSPACE_SECT_SINGLE && sect->sect_info.state == H5FS_SECT_LIVE) {
/* Release hold on previous indirect block (we must have one) */
HDassert(sect->u.single.parent);
if(H5HF_iblock_decr(sect->u.single.parent) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't decrement reference count on section's indirect block")
/* Reset parent information */
sect->u.single.parent = NULL;
sect->u.single.par_entry = 0;
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_revert_root_cb() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_revert_root
*
* Purpose: Reset 'parent' pointers in sections, when the heap is
* changing from having a root indirect block to a direct block.
*
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Feb 23 2012
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_space_revert_root(const H5HF_hdr_t *hdr, hid_t dxpl_id)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(hdr);
/* Only need to scan the sections if the free space has been initialized */
if(hdr->fspace) {
/* Iterate over all sections, reseting the parent pointers in 'single' sections */
if(H5FS_sect_iterate(hdr->f, dxpl_id, hdr->fspace, H5HF_space_revert_root_cb, NULL) < 0)
HGOTO_ERROR(H5E_FSPACE, H5E_BADITER, FAIL, "can't iterate over sections to reset parent pointers")
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_revert_root() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_create_root_cb
*
* Purpose: Callback routine from iterator, to set 'parent' pointers in
* sections to newly created root indirect block, when the heap
* is changing from having a root direct block to an indirect block.
*
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Feb 24 2012
*
*-------------------------------------------------------------------------
*/
static herr_t
H5HF_space_create_root_cb(H5FS_section_info_t *_sect, void *_udata)
{
H5HF_free_section_t *sect = (H5HF_free_section_t *)_sect; /* Section to dump info */
H5HF_indirect_t *root_iblock = (H5HF_indirect_t *)_udata; /* User data for callback */
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(sect);
HDassert(root_iblock);
/* Sanity check sections */
/* (If we are switching from a direct block for the root block of the heap, */
/* there should only be 'single' type sections. -QAK) */
HDassert(sect->sect_info.type == H5HF_FSPACE_SECT_SINGLE);
/* Increment ref. count on new root indirect block */
if(H5HF_iblock_incr(root_iblock) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on section's indirect block")
/* Set parent info ("live" section must _NOT_ have a parent right now) */
if(sect->sect_info.state == H5FS_SECT_SERIALIZED)
sect->sect_info.state = H5FS_SECT_LIVE; /* Mark "live" now */
else
HDassert(!sect->u.single.parent);
sect->u.single.parent = root_iblock;
sect->u.single.par_entry = 0;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_create_root_cb() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_create_root
*
* Purpose: Set 'parent' pointers in sections to new indirect block, when
* the heap is changing from having a root direct block to a
* indirect block.
*
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* Feb 24 2012
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_space_create_root(const H5HF_hdr_t *hdr, hid_t dxpl_id, H5HF_indirect_t *root_iblock)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(root_iblock);
/* Only need to scan the sections if the free space has been initialized */
if(hdr->fspace) {
/* Iterate over all sections, seting the parent pointers in 'single' sections to the new indirect block */
if(H5FS_sect_iterate(hdr->f, dxpl_id, hdr->fspace, H5HF_space_create_root_cb, root_iblock) < 0)
HGOTO_ERROR(H5E_FSPACE, H5E_BADITER, FAIL, "can't iterate over sections to set parent pointers")
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_create_root() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_size
*
* Purpose: Query the size of the heap's free space info on disk
*
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@hdfgroup.org
* August 14 2007
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_space_size(H5HF_hdr_t *hdr, hid_t dxpl_id, hsize_t *fs_size)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(fs_size);
/* Check if the free space for the heap has been initialized */
if(!hdr->fspace)
if(H5HF_space_start(hdr, dxpl_id, FALSE) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't initialize heap free space")
/* Get free space metadata size */
if(hdr->fspace) {
if(H5FS_size(hdr->f, hdr->fspace, fs_size) < 0)
HGOTO_ERROR(H5E_FSPACE, H5E_CANTGET, FAIL, "can't retrieve FS meta storage info")
} /* end if */
else
*fs_size = 0;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_size() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_remove
*
* Purpose: Remove a section from the free space for the heap
*
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* July 24 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_space_remove(H5HF_hdr_t *hdr, hid_t dxpl_id, H5HF_free_section_t *node)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(hdr->fspace);
HDassert(node);
/* Remove from the free space for the heap */
if(H5FS_sect_remove(hdr->f, dxpl_id, hdr->fspace, (H5FS_section_info_t *)node) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTREMOVE, FAIL, "can't remove section from heap free space")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_remove() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_close
*
* Purpose: Close the free space for the heap
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* May 2 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_space_close(H5HF_hdr_t *hdr, hid_t dxpl_id)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(hdr);
/* Check if the free space was ever opened */
if(hdr->fspace) {
hsize_t nsects; /* Number of sections for this heap */
/* Retrieve the number of sections for this heap */
if(H5FS_sect_stats(hdr->fspace, NULL, &nsects) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTCOUNT, FAIL, "can't query free space section count")
#ifdef QAK
HDfprintf(stderr, "%s: nsects = %Hu\n", FUNC, nsects);
#endif /* QAK */
/* Close the free space for the heap */
if(H5FS_close(hdr->f, dxpl_id, hdr->fspace) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't release free space info")
hdr->fspace = NULL;
/* Check if we can delete the free space manager for this heap */
if(!nsects) {
if(H5FS_delete(hdr->f, dxpl_id, hdr->fs_addr) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTDELETE, FAIL, "can't delete free space info")
hdr->fs_addr = HADDR_UNDEF;
} /* end if */
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_close() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_delete
*
* Purpose: Delete the free space manager for the heap
*
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* Aug 7 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_space_delete(H5HF_hdr_t *hdr, hid_t dxpl_id)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
/*
* Check arguments.
*/
HDassert(hdr);
/* Delete the free space manager */
if(H5FS_delete(hdr->f, dxpl_id, hdr->fs_addr) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "can't delete to free space manager")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_delete() */
/*-------------------------------------------------------------------------
* Function: H5HF_space_change_sect_class
*
* Purpose: Change a section's class
*
* Return: Success: non-negative
*
* Failure: negative
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* July 10 2006
*
*-------------------------------------------------------------------------
*/
herr_t
H5HF_space_sect_change_class(H5HF_hdr_t *hdr, hid_t dxpl_id, H5HF_free_section_t *sect, unsigned new_class)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT
#ifdef QAK
HDfprintf(stderr, "%s: Called\n", FUNC);
#endif /* QAK */
/*
* Check arguments.
*/
HDassert(hdr);
HDassert(hdr->fspace);
HDassert(sect);
/* Notify the free space manager that a section has changed class */
if(H5FS_sect_change_class(hdr->f, dxpl_id, hdr->fspace, (H5FS_section_info_t *)sect, new_class) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTMODIFY, FAIL, "can't modify class of free space section")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5HF_space_sect_change_class() */
Reference in New Issue View Git Blame Copy Permalink