/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* 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: H5MF.c
* Jul 11 1997
* Robb Matzke <matzke@llnl.gov>
*
* Purpose: File memory management functions.
*
* Modifications:
* Robb Matzke, 5 Aug 1997
* Added calls to H5E.
*
* Robb Matzke, 8 Jun 1998
* Implemented a very simple free list which is not persistent and which
* is lossy.
*
*-------------------------------------------------------------------------
*/
#define H5F_PACKAGE /*suppress error about including H5Fpkg */
#include "H5private.h"
#include "H5Eprivate.h"
#include "H5Fpkg.h"
#include "H5FDprivate.h"
#include "H5MFprivate.h"
/*-------------------------------------------------------------------------
* Function: H5MF_alloc
*
* Purpose: Allocate SIZE bytes of file memory and return the relative
* address where that contiguous chunk of file memory exists.
* The TYPE argument describes the purpose for which the storage
* is being requested.
*
* Return: Success: The file address of new chunk.
*
* Failure: HADDR_UNDEF
*
* Programmer: Robb Matzke
* matzke@llnl.gov
* Jul 11 1997
*
* Modifications:
* Robb Matzke, 1999-08-04
* Modified to work with the virtual file layer.
*-------------------------------------------------------------------------
*/
haddr_t
H5MF_alloc(H5F_t *f, H5FD_mem_t type, hid_t dxpl_id, hsize_t size)
{
haddr_t ret_value;
FUNC_ENTER_NOAPI(H5MF_alloc, HADDR_UNDEF);
/* check arguments */
assert(f);
assert(size > 0);
/* Fail if we don't have write access */
if (0==(f->intent & H5F_ACC_RDWR))
HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, HADDR_UNDEF, "file is read-only");
/* Check that the file can address the new space */
if( H5MF_alloc_overflow(f, size) )
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, HADDR_UNDEF, "not enough address space in file");
/* Allocate space from the virtual file layer */
if (HADDR_UNDEF==(ret_value=H5FD_alloc(f->shared->lf, type, dxpl_id, size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, HADDR_UNDEF, "file allocation failed");
/* Convert absolute file address to relative file address */
assert(ret_value>=f->shared->base_addr);
/* Set return value */
ret_value -= f->shared->base_addr;
done:
FUNC_LEAVE_NOAPI(ret_value);
}
/*-------------------------------------------------------------------------
* Function: H5MF_xfree
*
* Purpose: Frees part of a file, making that part of the file
* available for reuse.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Robb Matzke
* matzke@llnl.gov
* Jul 17 1997
*
* Modifications:
* Robb Matzke, 1999-07-28
* The ADDR argument is passed by value
*
* Robb Matzke, 1999-08-03
* Modified to use the virtual file layer.
*-------------------------------------------------------------------------
*/
herr_t
H5MF_xfree(H5F_t *f, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, hsize_t size)
{
herr_t ret_value=SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOFUNC(H5MF_xfree);
/* check arguments */
assert(f);
if (!H5F_addr_defined(addr) || 0 == size)
HGOTO_DONE(SUCCEED);
assert(addr!=0);
/* Convert relative address to absolute address */
addr += f->shared->base_addr;
/* Allow virtual file layer to free block */
if (H5FD_free(f->shared->lf, type, dxpl_id, addr, size)<0) {
#ifdef H5MF_DEBUG
if (H5DEBUG(MF)) {
fprintf(H5DEBUG(MF),
"H5MF_free: lost %lu bytes of file storage\n",
(unsigned long)size);
}
#endif
}
done:
FUNC_LEAVE_NOAPI(ret_value);
}
/*-------------------------------------------------------------------------
* Function: H5MF_realloc
*
* Purpose: Changes the size of an allocated chunk, possibly moving it to
* a new address. The chunk to change is at address OLD_ADDR
* and is exactly OLD_SIZE bytes (if these are H5F_ADDR_UNDEF
* and zero then this function acts like H5MF_alloc). The new
* size will be NEW_SIZE and its address is the return value (if
* NEW_SIZE is zero then this function acts like H5MF_free and
* an undefined address is returned).
*
* If the new size is less than the old size then the new
* address will be the same as the old address (except for the
* special case where the new size is zero).
*
* If the new size is more than the old size then most likely a
* new address will be returned. However, under certain
* circumstances the library may return the same address.
*
* Return: Success: The relative file address of the new block.
*
* Failure: HADDR_UNDEF
*
* Programmer: Robb Matzke
* Thursday, April 16, 1998
*
* Modifications:
* Robb Matzke, 1999-07-28
* The ORIG_ADDR is passed by value. The name of NEW_ADDR has
* been changed to NEW_ADDR_P
*
* Robb Matzke, 1999-08-04
* Modified to work with the virtual file layer.
*-------------------------------------------------------------------------
*/
haddr_t
H5MF_realloc(H5F_t *f, H5FD_mem_t type, hid_t dxpl_id, haddr_t old_addr, hsize_t old_size,
hsize_t new_size)
{
haddr_t ret_value;
FUNC_ENTER_NOAPI(H5MF_realloc, HADDR_UNDEF);
/* Convert old relative address to absolute address */
old_addr += f->shared->base_addr;
/* Check that the file can address the new space. */
/* In the worst case, this means adding new_size bytes to the end of the file. */
if( H5MF_alloc_overflow(f, new_size) )
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, HADDR_UNDEF, "not enough address space in file");
/* Reallocate memory from the virtual file layer */
ret_value = H5FD_realloc(f->shared->lf, type, dxpl_id, old_addr, old_size,
new_size);
if (HADDR_UNDEF==ret_value)
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, HADDR_UNDEF, "unable to allocate new file memory");
/* Convert return value to relative address */
assert(ret_value>=f->shared->base_addr);
/* Set return value */
ret_value -= f->shared->base_addr;
done:
FUNC_LEAVE_NOAPI(ret_value);
}
/*-------------------------------------------------------------------------
* Function: H5MF_reserve
*
* Purpose: Sets aside file space that has not yet been allocated, but will
* be (or might be in the worst case). This number is used to
* ensure that there is room in the file when it is flushed to disk.
*
* Nothing changes (and no error is generated) if the file is opened
* as read-only.
*
* Return: Success: 0
*
* Failure: negative
*
* Programmer: James Laird
* Nat Furrer
* Thursday, May 27, 2004
*
* Modifications:
*-------------------------------------------------------------------------
*/
herr_t
H5MF_reserve(H5F_t *f, hsize_t size)
{
herr_t ret_value = SUCCEED;
FUNC_ENTER_NOAPI(H5MF_reserve, FAIL);
/* Check arguments */
assert(f);
/* Check that there is room in the file to reserve this space */
if( H5MF_alloc_overflow( f, size ) )
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "not enough address space in file");
f->shared->lf->reserved_alloc += size;
done:
FUNC_LEAVE_NOAPI(ret_value);
}
/*-------------------------------------------------------------------------
* Function: H5MF_free_reserved
*
* Purpose: Releases the file space set aside by H5MF_reserve. This should
* be called immediately before allocating the file space for which
* the space was reserved.
*
* Return: None
*
* Programmer: James Laird
* Nat Furrer
* Thursday, May 27, 2004
*
* Modifications:
*-------------------------------------------------------------------------
*/
herr_t
H5MF_free_reserved(H5F_t *f, hsize_t size)
{
FUNC_ENTER_NOAPI_NOFUNC(H5MF_free_reserved)
/* Check arguments */
assert(f);
/* If this assert breaks, it means that HDF5 is trying to free file space
* that was never reserved.
*/
assert(size <= f->shared->lf->reserved_alloc);
f->shared->lf->reserved_alloc -= size;
FUNC_LEAVE_NOAPI(SUCCEED)
}
/*-------------------------------------------------------------------------
* Function: H5MF_alloc_overflow
*
* Purpose: Checks if an allocation of file space would cause an overflow.
* F is the file whose space is being allocated, SIZE is the amount
* of space needed.
*
* Return: 0 if no overflow would result
* 1 if overflow would result (the allocation should not be allowed)
*
* Programmer: James Laird
* Nat Furrer
* Tuesday, June 1, 2004
*
* Modifications:
*-------------------------------------------------------------------------
*/
hbool_t
H5MF_alloc_overflow(H5F_t *f, hsize_t size)
{
hsize_t space_needed; /* Accumulator variable */
size_t c; /* Local index variable */
hbool_t ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOFUNC(H5MF_alloc_overflow)
/* Start with the current end of the file's address. */
space_needed = (hsize_t)H5F_get_eoa(f);
HDassert(H5F_addr_defined(space_needed));
/* Subtract the file's base address to get the actual amount of
* space being used:
* (end of allocated space - beginning of allocated space)
*/
HDassert(H5F_BASE_ADDR(f) < space_needed);
space_needed -= (hsize_t)H5F_BASE_ADDR(f);
/* Add the amount of space requested for this allocation */
space_needed += size;
/* Also add space that is "reserved" for data to be flushed
* to disk (e.g., for object headers and the heap).
* This is the total amount of file space that will be
* allocated.
*/
space_needed += f->shared->lf->reserved_alloc;
/* Ensure that this final number is less than the file's
* address space. We do this by shifting in multiples
* of 16 bits because some systems will do nothing if
* we shift by the size of a long long (64 bits) all at
* once (<cough> Linux <cough>). Thus, we break one shift
* into several smaller shifts.
*/
for(c=0; c < H5F_SIZEOF_ADDR(f); c += 2)
space_needed = space_needed >> 16;
if(space_needed != 0)
ret_value=TRUE;
else
ret_value=FALSE;
FUNC_LEAVE_NOAPI(ret_value)
}
/*-------------------------------------------------------------------------
* Function: H5MF_can_extend
*
* Purpose: Check if a block in the file can be extended.
*
* This is a simple check currently, which only checks for the
* block being at the end of the file. A more sophisticated check
* would also use the free space list to see if there is a block
* appropriately placed to accomodate the space requested.
*
* Return: Success: TRUE(1)/FALSE(0)
*
* Failure: FAIL
*
* Programmer: Quincey Koziol
* Friday, June 11, 2004
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
htri_t
H5MF_can_extend(H5F_t *f, H5FD_mem_t type, haddr_t addr, hsize_t size, hsize_t extra_requested)
{
htri_t ret_value; /* Return value */
FUNC_ENTER_NOAPI(H5MF_can_extend, FAIL);
/* Convert old relative address to absolute address */
addr += H5F_BASE_ADDR(f);
/* Pass the request down to the virtual file layer */
if((ret_value=H5FD_can_extend(f->shared->lf, type, addr, size, extra_requested))<0)
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate new file memory");
/* Make sure there is enough addressable space to satisfy the request */
if (ret_value == TRUE)
ret_value = !H5MF_alloc_overflow(f, extra_requested);
done:
FUNC_LEAVE_NOAPI(ret_value);
} /* end H5MF_can_extend() */
/*-------------------------------------------------------------------------
* Function: H5MF_extend
*
* Purpose: Extend a block in the file.
*
* Return: Success: TRUE(1)/FALSE(0)
*
* Failure: FAIL
*
* Programmer: Quincey Koziol
* Saturday, June 12, 2004
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
htri_t
H5MF_extend(H5F_t *f, H5FD_mem_t type, haddr_t addr, hsize_t size, hsize_t extra_requested)
{
htri_t ret_value; /* Return value */
FUNC_ENTER_NOAPI(H5MF_extend, FAIL);
/* Make sure there is enough addressable space to satisfy the request */
if ( H5MF_alloc_overflow(f, extra_requested) )
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate new file memory: out of address space");
/* Convert old relative address to absolute address */
addr += H5F_BASE_ADDR(f);
/* Pass the request down to the virtual file layer */
if((ret_value=H5FD_extend(f->shared->lf, type, addr, size, extra_requested))<0)
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate new file memory");
done:
FUNC_LEAVE_NOAPI(ret_value);
} /* end H5MF_extend() */
syntax highlighted by Code2HTML, v. 0.9.1