mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-02-17 16:10:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r5662] Purpose:

Browse Source 
Bug fix.

Description:
    The chunking code was using internal allocation routines to put blocks on
    a free list for reuse, instead of using the system allocation routines (ie.
    malloc, free, etc.).  This causes problems when user filters attempt to
    allocate/free chunks for their algorithm's use.

Solution:
    Switched the chunking code back to using the system allocation routines,
    we can address performance issues with them if it becomes a real problem.

Platforms tested:
    Linux 2.2.x (eirene) && IRIX64 6.5 (modi4)
This commit is contained in:
Quincey Koziol 2002-06-18 09:39:26 -05:00
parent 972707dcd3
commit 64b7be4a52
5 changed files with 32 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
release_docs/RELEASE.txt
View File

@ -35,6 +35,10 @@ Bug Fixes since HDF5-1.4.0
Library Library
------- -------
* Fixed bug in chunking routines where they were using internal allocation
free routines, instead of malloc/free, preventing user filters from
working correctly. Chunks are now allocated/freed with malloc/free and
so should the chunks in user filters. QAK 2002/06/18
* Fixed bug where regular hyperslab selection could get incorrectly * Fixed bug where regular hyperslab selection could get incorrectly
transferred when the number of elements in a row did not fit evenly transferred when the number of elements in a row did not fit evenly
into the buffer provided. QAK 2002/06/12 into the buffer provided. QAK 2002/06/12

116
src/H5Distore.c
View File

@ -191,106 +191,12 @@ H5B_class_t H5B_ISTORE[1] = {{
#define H5F_HASH(F,ADDR) H5F_addr_hash((ADDR/H5F_HASH_DIVISOR),(F)->shared->rdcc.nslots) #define H5F_HASH(F,ADDR) H5F_addr_hash((ADDR/H5F_HASH_DIVISOR),(F)->shared->rdcc.nslots)
/* Declare a free list to manage the chunk information */
H5FL_BLK_DEFINE_STATIC(istore_chunk);
/* Declare a free list to manage H5F_rdcc_ent_t objects */ /* Declare a free list to manage H5F_rdcc_ent_t objects */
H5FL_DEFINE_STATIC(H5F_rdcc_ent_t); H5FL_DEFINE_STATIC(H5F_rdcc_ent_t);
/* Declare a PQ free list to manage the H5F_rdcc_ent_ptr_t array information */ /* Declare a PQ free list to manage the H5F_rdcc_ent_ptr_t array information */
H5FL_ARR_DEFINE_STATIC(H5F_rdcc_ent_ptr_t,-1); H5FL_ARR_DEFINE_STATIC(H5F_rdcc_ent_ptr_t,-1);
/*-------------------------------------------------------------------------
* Function: H5F_istore_chunk_alloc
*
* Purpose: Allocates memory for a chunk of a dataset. This routine is used
* instead of malloc because the chunks can be kept on a free list so
* they don't thrash malloc/free as much.
*
* Return: Success: valid pointer to the chunk
*
* Failure: NULL
*
* Programmer: Quincey Koziol
* Tuesday, March 21, 2000
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void *
H5F_istore_chunk_alloc(size_t chunk_size)
{
void *ret_value; /* Pointer to the chunk to return to the user */
FUNC_ENTER_NOAPI(H5F_istore_chunk_alloc, NULL);
ret_value=H5FL_BLK_ALLOC(istore_chunk,chunk_size,0);
FUNC_LEAVE(ret_value);
} /* end H5F_istore_chunk_alloc() */
/*-------------------------------------------------------------------------
* Function: H5F_istore_chunk_free
*
* Purpose: Releases memory for a chunk of a dataset. This routine is used
* instead of free because the chunks can be kept on a free list so
* they don't thrash malloc/free as much.
*
* Return: Success: NULL
*
* Failure: never fails
*
* Programmer: Quincey Koziol
* Tuesday, March 21, 2000
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void *
H5F_istore_chunk_free(void *chunk)
{
FUNC_ENTER_NOAPI(H5F_istore_chunk_free, NULL);
H5FL_BLK_FREE(istore_chunk,chunk);
FUNC_LEAVE(NULL);
} /* end H5F_istore_chunk_free() */
/*-------------------------------------------------------------------------
* Function: H5F_istore_chunk_realloc
*
* Purpose: Resizes a chunk in chunking memory allocation system. This
* does things the straightforward, simple way, not actually using
* realloc.
*
* Return: Success: NULL
*
* Failure: never fails
*
* Programmer: Quincey Koziol
* Tuesday, March 21, 2000
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void *
H5F_istore_chunk_realloc(void *chunk, size_t new_size)
{
void *ret_value=NULL; /* Return value */
FUNC_ENTER_NOAPI(H5F_istore_chunk_realloc, NULL);
ret_value=H5FL_BLK_REALLOC(istore_chunk,chunk,new_size);
FUNC_LEAVE(ret_value);
} /* end H5F_istore_chunk_realloc() */
/*------------------------------------------------------------------------- /*-------------------------------------------------------------------------
* Function: H5F_istore_sizeof_rkey * Function: H5F_istore_sizeof_rkey
@ -1016,7 +922,7 @@ H5F_istore_flush_entry(H5F_t *f, H5F_rdcc_ent_t *ent, hbool_t reset)
* for later. * for later.
*/ */
alloc = ent->chunk_size; alloc = ent->chunk_size;
if (NULL==(buf = H5F_istore_chunk_alloc(alloc))) { if (NULL==(buf = H5MM_malloc(alloc))) {
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
"memory allocation failed for pipeline"); "memory allocation failed for pipeline");
} }
@ -1060,7 +966,7 @@ H5F_istore_flush_entry(H5F_t *f, H5F_rdcc_ent_t *ent, hbool_t reset)
ent->pline = H5O_free(H5O_PLINE, ent->pline); ent->pline = H5O_free(H5O_PLINE, ent->pline);
if (buf==ent->chunk) buf = NULL; if (buf==ent->chunk) buf = NULL;
if(ent->chunk!=NULL) if(ent->chunk!=NULL)
ent->chunk = H5F_istore_chunk_free(ent->chunk); ent->chunk = H5MM_xfree(ent->chunk);
} }
ret_value = SUCCEED; ret_value = SUCCEED;
@ -1068,7 +974,7 @@ H5F_istore_flush_entry(H5F_t *f, H5F_rdcc_ent_t *ent, hbool_t reset)
done: done:
/* Free the temp buffer only if it's different than the entry chunk */ /* Free the temp buffer only if it's different than the entry chunk */
if (buf!=ent->chunk) if (buf!=ent->chunk)
H5F_istore_chunk_free(buf); H5MM_xfree(buf);
/* /*
* If we reached the point of no return then we have no choice but to * If we reached the point of no return then we have no choice but to
@ -1080,7 +986,7 @@ done:
ent->layout = H5O_free(H5O_LAYOUT, ent->layout); ent->layout = H5O_free(H5O_LAYOUT, ent->layout);
ent->pline = H5O_free(H5O_PLINE, ent->pline); ent->pline = H5O_free(H5O_PLINE, ent->pline);
if(ent->chunk) if(ent->chunk)
ent->chunk = H5F_istore_chunk_free(ent->chunk); ent->chunk = H5MM_xfree(ent->chunk);
} }
FUNC_LEAVE(ret_value); FUNC_LEAVE(ret_value);
} }
@ -1131,7 +1037,7 @@ H5F_istore_preempt(H5F_t *f, H5F_rdcc_ent_t * ent, hbool_t flush)
ent->layout = H5O_free(H5O_LAYOUT, ent->layout); ent->layout = H5O_free(H5O_LAYOUT, ent->layout);
ent->pline = H5O_free(H5O_PLINE, ent->pline); ent->pline = H5O_free(H5O_PLINE, ent->pline);
if(ent->chunk != NULL) if(ent->chunk != NULL)
ent->chunk = H5F_istore_chunk_free(ent->chunk); ent->chunk = H5MM_xfree(ent->chunk);
} }
@ -1467,7 +1373,7 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
} }
H5_ASSIGN_OVERFLOW(chunk_size,tempchunk_size,hsize_t,size_t); H5_ASSIGN_OVERFLOW(chunk_size,tempchunk_size,hsize_t,size_t);
chunk_alloc = chunk_size; chunk_alloc = chunk_size;
if (NULL==(chunk=H5F_istore_chunk_alloc (chunk_alloc))) { if (NULL==(chunk=H5MM_malloc (chunk_alloc))) {
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL,
"memory allocation failed for raw data chunk"); "memory allocation failed for raw data chunk");
} }
@ -1487,7 +1393,7 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
udata.addr = HADDR_UNDEF; udata.addr = HADDR_UNDEF;
status = H5B_find (f, H5B_ISTORE, layout->addr, &udata); status = H5B_find (f, H5B_ISTORE, layout->addr, &udata);
H5E_clear (); H5E_clear ();
if (NULL==(chunk = H5F_istore_chunk_alloc (chunk_alloc))) { if (NULL==(chunk = H5MM_malloc (chunk_alloc))) {
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL,
"memory allocation failed for raw data chunk"); "memory allocation failed for raw data chunk");
} }
@ -1645,7 +1551,7 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
done: done:
if (!ret_value) if (!ret_value)
H5F_istore_chunk_free (chunk); H5MM_xfree (chunk);
FUNC_LEAVE (ret_value); FUNC_LEAVE (ret_value);
} }
@ -1731,7 +1637,7 @@ H5F_istore_unlock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
H5F_istore_flush_entry (f, &x, TRUE); H5F_istore_flush_entry (f, &x, TRUE);
} else { } else {
if(chunk) if(chunk)
H5F_istore_chunk_free (chunk); H5MM_xfree (chunk);
} }
} else { } else {
/* /*
@ -2490,7 +2396,7 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
/* Check if fill values should be written to blocks */ /* Check if fill values should be written to blocks */
if(fill_time != H5D_FILL_TIME_NEVER) { if(fill_time != H5D_FILL_TIME_NEVER) {
/* Allocate chunk buffer for processes to use when writing fill values */ /* Allocate chunk buffer for processes to use when writing fill values */
if (NULL==(chunk = H5F_istore_chunk_alloc(chunk_size))) if (NULL==(chunk = H5MM_malloc(chunk_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk"); HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk");
/* Fill the chunk with the proper values */ /* Fill the chunk with the proper values */
@ -2569,7 +2475,7 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
done: done:
/* Free the chunk for fill values */ /* Free the chunk for fill values */
if(chunk!=NULL) if(chunk!=NULL)
H5F_istore_chunk_free(chunk); H5MM_xfree(chunk);
FUNC_LEAVE(ret_value); FUNC_LEAVE(ret_value);
} }

116
src/H5Fistore.c
View File

@ -191,106 +191,12 @@ H5B_class_t H5B_ISTORE[1] = {{
#define H5F_HASH(F,ADDR) H5F_addr_hash((ADDR/H5F_HASH_DIVISOR),(F)->shared->rdcc.nslots) #define H5F_HASH(F,ADDR) H5F_addr_hash((ADDR/H5F_HASH_DIVISOR),(F)->shared->rdcc.nslots)
/* Declare a free list to manage the chunk information */
H5FL_BLK_DEFINE_STATIC(istore_chunk);
/* Declare a free list to manage H5F_rdcc_ent_t objects */ /* Declare a free list to manage H5F_rdcc_ent_t objects */
H5FL_DEFINE_STATIC(H5F_rdcc_ent_t); H5FL_DEFINE_STATIC(H5F_rdcc_ent_t);
/* Declare a PQ free list to manage the H5F_rdcc_ent_ptr_t array information */ /* Declare a PQ free list to manage the H5F_rdcc_ent_ptr_t array information */
H5FL_ARR_DEFINE_STATIC(H5F_rdcc_ent_ptr_t,-1); H5FL_ARR_DEFINE_STATIC(H5F_rdcc_ent_ptr_t,-1);
/*-------------------------------------------------------------------------
* Function: H5F_istore_chunk_alloc
*
* Purpose: Allocates memory for a chunk of a dataset. This routine is used
* instead of malloc because the chunks can be kept on a free list so
* they don't thrash malloc/free as much.
*
* Return: Success: valid pointer to the chunk
*
* Failure: NULL
*
* Programmer: Quincey Koziol
* Tuesday, March 21, 2000
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void *
H5F_istore_chunk_alloc(size_t chunk_size)
{
void *ret_value; /* Pointer to the chunk to return to the user */
FUNC_ENTER_NOAPI(H5F_istore_chunk_alloc, NULL);
ret_value=H5FL_BLK_ALLOC(istore_chunk,chunk_size,0);
FUNC_LEAVE(ret_value);
} /* end H5F_istore_chunk_alloc() */
/*-------------------------------------------------------------------------
* Function: H5F_istore_chunk_free
*
* Purpose: Releases memory for a chunk of a dataset. This routine is used
* instead of free because the chunks can be kept on a free list so
* they don't thrash malloc/free as much.
*
* Return: Success: NULL
*
* Failure: never fails
*
* Programmer: Quincey Koziol
* Tuesday, March 21, 2000
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void *
H5F_istore_chunk_free(void *chunk)
{
FUNC_ENTER_NOAPI(H5F_istore_chunk_free, NULL);
H5FL_BLK_FREE(istore_chunk,chunk);
FUNC_LEAVE(NULL);
} /* end H5F_istore_chunk_free() */
/*-------------------------------------------------------------------------
* Function: H5F_istore_chunk_realloc
*
* Purpose: Resizes a chunk in chunking memory allocation system. This
* does things the straightforward, simple way, not actually using
* realloc.
*
* Return: Success: NULL
*
* Failure: never fails
*
* Programmer: Quincey Koziol
* Tuesday, March 21, 2000
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void *
H5F_istore_chunk_realloc(void *chunk, size_t new_size)
{
void *ret_value=NULL; /* Return value */
FUNC_ENTER_NOAPI(H5F_istore_chunk_realloc, NULL);
ret_value=H5FL_BLK_REALLOC(istore_chunk,chunk,new_size);
FUNC_LEAVE(ret_value);
} /* end H5F_istore_chunk_realloc() */
/*------------------------------------------------------------------------- /*-------------------------------------------------------------------------
* Function: H5F_istore_sizeof_rkey * Function: H5F_istore_sizeof_rkey
@ -1016,7 +922,7 @@ H5F_istore_flush_entry(H5F_t *f, H5F_rdcc_ent_t *ent, hbool_t reset)
* for later. * for later.
*/ */
alloc = ent->chunk_size; alloc = ent->chunk_size;
if (NULL==(buf = H5F_istore_chunk_alloc(alloc))) { if (NULL==(buf = H5MM_malloc(alloc))) {
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
"memory allocation failed for pipeline"); "memory allocation failed for pipeline");
} }
@ -1060,7 +966,7 @@ H5F_istore_flush_entry(H5F_t *f, H5F_rdcc_ent_t *ent, hbool_t reset)
ent->pline = H5O_free(H5O_PLINE, ent->pline); ent->pline = H5O_free(H5O_PLINE, ent->pline);
if (buf==ent->chunk) buf = NULL; if (buf==ent->chunk) buf = NULL;
if(ent->chunk!=NULL) if(ent->chunk!=NULL)
ent->chunk = H5F_istore_chunk_free(ent->chunk); ent->chunk = H5MM_xfree(ent->chunk);
} }
ret_value = SUCCEED; ret_value = SUCCEED;
@ -1068,7 +974,7 @@ H5F_istore_flush_entry(H5F_t *f, H5F_rdcc_ent_t *ent, hbool_t reset)
done: done:
/* Free the temp buffer only if it's different than the entry chunk */ /* Free the temp buffer only if it's different than the entry chunk */
if (buf!=ent->chunk) if (buf!=ent->chunk)
H5F_istore_chunk_free(buf); H5MM_xfree(buf);
/* /*
* If we reached the point of no return then we have no choice but to * If we reached the point of no return then we have no choice but to
@ -1080,7 +986,7 @@ done:
ent->layout = H5O_free(H5O_LAYOUT, ent->layout); ent->layout = H5O_free(H5O_LAYOUT, ent->layout);
ent->pline = H5O_free(H5O_PLINE, ent->pline); ent->pline = H5O_free(H5O_PLINE, ent->pline);
if(ent->chunk) if(ent->chunk)
ent->chunk = H5F_istore_chunk_free(ent->chunk); ent->chunk = H5MM_xfree(ent->chunk);
} }
FUNC_LEAVE(ret_value); FUNC_LEAVE(ret_value);
} }
@ -1131,7 +1037,7 @@ H5F_istore_preempt(H5F_t *f, H5F_rdcc_ent_t * ent, hbool_t flush)
ent->layout = H5O_free(H5O_LAYOUT, ent->layout); ent->layout = H5O_free(H5O_LAYOUT, ent->layout);
ent->pline = H5O_free(H5O_PLINE, ent->pline); ent->pline = H5O_free(H5O_PLINE, ent->pline);
if(ent->chunk != NULL) if(ent->chunk != NULL)
ent->chunk = H5F_istore_chunk_free(ent->chunk); ent->chunk = H5MM_xfree(ent->chunk);
} }
@ -1467,7 +1373,7 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
} }
H5_ASSIGN_OVERFLOW(chunk_size,tempchunk_size,hsize_t,size_t); H5_ASSIGN_OVERFLOW(chunk_size,tempchunk_size,hsize_t,size_t);
chunk_alloc = chunk_size; chunk_alloc = chunk_size;
if (NULL==(chunk=H5F_istore_chunk_alloc (chunk_alloc))) { if (NULL==(chunk=H5MM_malloc (chunk_alloc))) {
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL,
"memory allocation failed for raw data chunk"); "memory allocation failed for raw data chunk");
} }
@ -1487,7 +1393,7 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
udata.addr = HADDR_UNDEF; udata.addr = HADDR_UNDEF;
status = H5B_find (f, H5B_ISTORE, layout->addr, &udata); status = H5B_find (f, H5B_ISTORE, layout->addr, &udata);
H5E_clear (); H5E_clear ();
if (NULL==(chunk = H5F_istore_chunk_alloc (chunk_alloc))) { if (NULL==(chunk = H5MM_malloc (chunk_alloc))) {
HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL,
"memory allocation failed for raw data chunk"); "memory allocation failed for raw data chunk");
} }
@ -1645,7 +1551,7 @@ H5F_istore_lock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
done: done:
if (!ret_value) if (!ret_value)
H5F_istore_chunk_free (chunk); H5MM_xfree (chunk);
FUNC_LEAVE (ret_value); FUNC_LEAVE (ret_value);
} }
@ -1731,7 +1637,7 @@ H5F_istore_unlock(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
H5F_istore_flush_entry (f, &x, TRUE); H5F_istore_flush_entry (f, &x, TRUE);
} else { } else {
if(chunk) if(chunk)
H5F_istore_chunk_free (chunk); H5MM_xfree (chunk);
} }
} else { } else {
/* /*
@ -2490,7 +2396,7 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
/* Check if fill values should be written to blocks */ /* Check if fill values should be written to blocks */
if(fill_time != H5D_FILL_TIME_NEVER) { if(fill_time != H5D_FILL_TIME_NEVER) {
/* Allocate chunk buffer for processes to use when writing fill values */ /* Allocate chunk buffer for processes to use when writing fill values */
if (NULL==(chunk = H5F_istore_chunk_alloc(chunk_size))) if (NULL==(chunk = H5MM_malloc(chunk_size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk"); HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for chunk");
/* Fill the chunk with the proper values */ /* Fill the chunk with the proper values */
@ -2569,7 +2475,7 @@ H5F_istore_allocate(H5F_t *f, hid_t dxpl_id, const H5O_layout_t *layout,
done: done:
/* Free the chunk for fill values */ /* Free the chunk for fill values */
if(chunk!=NULL) if(chunk!=NULL)
H5F_istore_chunk_free(chunk); H5MM_xfree(chunk);
FUNC_LEAVE(ret_value); FUNC_LEAVE(ret_value);
} }

5
src/H5Fprivate.h
View File

@ -400,11 +400,6 @@ __DLL__ herr_t H5F_istore_initialize_by_extent( H5F_t *f,
const struct H5O_layout_t *layout, struct H5P_genplist_t *dc_plist, const struct H5O_layout_t *layout, struct H5P_genplist_t *dc_plist,
const struct H5S_t *space ); const struct H5S_t *space );
/* Functions for allocation/releasing chunks */
__DLL__ void * H5F_istore_chunk_alloc(size_t chunk_size);
__DLL__ void * H5F_istore_chunk_realloc(void *chunk, size_t new_size);
__DLL__ void * H5F_istore_chunk_free(void *chunk);
/* Address-related functions */ /* Address-related functions */
__DLL__ void H5F_addr_encode(H5F_t *, uint8_t** /*in,out*/, haddr_t); __DLL__ void H5F_addr_encode(H5F_t *, uint8_t** /*in,out*/, haddr_t);
__DLL__ void H5F_addr_decode(H5F_t *, const uint8_t** /*in,out*/, __DLL__ void H5F_addr_decode(H5F_t *, const uint8_t** /*in,out*/,

12
src/H5Zdeflate.c
View File

@ -72,7 +72,7 @@ H5Z_filter_deflate (unsigned UNUSED flags, size_t cd_nelmts,
z_stream z_strm; z_stream z_strm;
size_t nalloc = *buf_size; size_t nalloc = *buf_size;
if (NULL==(outbuf = H5F_istore_chunk_alloc(nalloc))) { if (NULL==(outbuf = H5MM_malloc(nalloc))) {
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0,
"memory allocation failed for deflate uncompression"); "memory allocation failed for deflate uncompression");
} }
@ -93,7 +93,7 @@ H5Z_filter_deflate (unsigned UNUSED flags, size_t cd_nelmts,
} }
if (Z_OK==status && 0==z_strm.avail_out) { if (Z_OK==status && 0==z_strm.avail_out) {
nalloc *= 2; nalloc *= 2;
if (NULL==(outbuf = H5F_istore_chunk_realloc(outbuf, nalloc))) { if (NULL==(outbuf = H5MM_realloc(outbuf, nalloc))) {
inflateEnd(&z_strm); inflateEnd(&z_strm);
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0,
"memory allocation failed for deflate " "memory allocation failed for deflate "
@ -104,7 +104,7 @@ H5Z_filter_deflate (unsigned UNUSED flags, size_t cd_nelmts,
} }
} }
H5F_istore_chunk_free(*buf); H5MM_xfree(*buf);
*buf = outbuf; *buf = outbuf;
outbuf = NULL; outbuf = NULL;
*buf_size = nalloc; *buf_size = nalloc;
@ -122,7 +122,7 @@ H5Z_filter_deflate (unsigned UNUSED flags, size_t cd_nelmts,
uLongf z_dst_nbytes = (uLongf)nbytes; uLongf z_dst_nbytes = (uLongf)nbytes;
uLong z_src_nbytes = (uLong)nbytes; uLong z_src_nbytes = (uLong)nbytes;
if (NULL==(z_dst=outbuf=H5F_istore_chunk_alloc(nbytes))) { if (NULL==(z_dst=outbuf=H5MM_malloc(nbytes))) {
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0,
"unable to allocate deflate destination buffer"); "unable to allocate deflate destination buffer");
} }
@ -135,7 +135,7 @@ H5Z_filter_deflate (unsigned UNUSED flags, size_t cd_nelmts,
} else if (Z_OK!=status) { } else if (Z_OK!=status) {
HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, 0, "deflate error"); HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, 0, "deflate error");
} else { } else {
H5F_istore_chunk_free(*buf); H5MM_xfree(*buf);
*buf = outbuf; *buf = outbuf;
outbuf = NULL; outbuf = NULL;
*buf_size = nbytes; *buf_size = nbytes;
@ -149,6 +149,6 @@ H5Z_filter_deflate (unsigned UNUSED flags, size_t cd_nelmts,
done: done:
if(outbuf) if(outbuf)
H5F_istore_chunk_free(outbuf); H5MM_xfree(outbuf);
FUNC_LEAVE (ret_value); FUNC_LEAVE (ret_value);
} }