summaryrefslogtreecommitdiffstats
path: root/src/H5HL.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/H5HL.c')
-rw-r--r--src/H5HL.c1211
1 files changed, 608 insertions, 603 deletions
diff --git a/src/H5HL.c b/src/H5HL.c
index a12194b..4186d2a 100644
--- a/src/H5HL.c
+++ b/src/H5HL.c
@@ -100,78 +100,78 @@ H5FL_BLK_DEFINE(lheap_chunk);
*/
BEGIN_FUNC(PRIV, ERR, herr_t, SUCCEED, FAIL, H5HL_create(H5F_t *f, size_t size_hint, haddr_t *addr_p /*out*/))
-H5HL_t * heap = NULL; /* Heap created */
-H5HL_prfx_t *prfx = NULL; /* Heap prefix */
-hsize_t total_size = 0; /* Total heap size on disk */
-
-/* check arguments */
-HDassert(f);
-HDassert(addr_p);
-
-/* Adjust size hint as necessary */
-if (size_hint && size_hint < H5HL_SIZEOF_FREE(f))
- size_hint = H5HL_SIZEOF_FREE(f);
-size_hint = H5HL_ALIGN(size_hint);
-
-/* Allocate new heap structure */
-if (NULL == (heap = H5HL__new(H5F_SIZEOF_SIZE(f), H5F_SIZEOF_ADDR(f), H5HL_SIZEOF_HDR(f))))
- H5E_THROW(H5E_CANTALLOC, "can't allocate new heap struct");
-
-/* Allocate file space */
-total_size = heap->prfx_size + size_hint;
-if (HADDR_UNDEF == (heap->prfx_addr = H5MF_alloc(f, H5FD_MEM_LHEAP, total_size)))
- H5E_THROW(H5E_CANTALLOC, "unable to allocate file memory");
-
-/* Initialize info */
-heap->single_cache_obj = TRUE;
-heap->dblk_addr = heap->prfx_addr + (hsize_t)heap->prfx_size;
-heap->dblk_size = size_hint;
-if (size_hint)
- if (NULL == (heap->dblk_image = H5FL_BLK_CALLOC(lheap_chunk, size_hint)))
- H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
-
-/* free list */
-if (size_hint) {
- if (NULL == (heap->freelist = H5FL_MALLOC(H5HL_free_t)))
- H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
- heap->freelist->offset = 0;
- heap->freelist->size = size_hint;
- heap->freelist->prev = heap->freelist->next = NULL;
- heap->free_block = 0;
-} /* end if */
-else {
- heap->freelist = NULL;
- heap->free_block = H5HL_FREE_NULL;
-} /* end else */
-
-/* Allocate the heap prefix */
-if (NULL == (prfx = H5HL__prfx_new(heap)))
- H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
-
-/* Add to cache */
-if (FAIL == H5AC_insert_entry(f, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET))
- H5E_THROW(H5E_CANTINIT, "unable to cache local heap prefix");
-
-/* Set address to return */
-*addr_p = heap->prfx_addr;
-
-CATCH
-if (ret_value < 0) {
- *addr_p = HADDR_UNDEF;
- if (prfx) {
- if (FAIL == H5HL__prfx_dest(prfx))
- H5E_THROW(H5E_CANTFREE, "unable to destroy local heap prefix");
+ H5HL_t * heap = NULL; /* Heap created */
+ H5HL_prfx_t *prfx = NULL; /* Heap prefix */
+ hsize_t total_size = 0; /* Total heap size on disk */
+
+ /* check arguments */
+ HDassert(f);
+ HDassert(addr_p);
+
+ /* Adjust size hint as necessary */
+ if (size_hint && size_hint < H5HL_SIZEOF_FREE(f))
+ size_hint = H5HL_SIZEOF_FREE(f);
+ size_hint = H5HL_ALIGN(size_hint);
+
+ /* Allocate new heap structure */
+ if (NULL == (heap = H5HL__new(H5F_SIZEOF_SIZE(f), H5F_SIZEOF_ADDR(f), H5HL_SIZEOF_HDR(f))))
+ H5E_THROW(H5E_CANTALLOC, "can't allocate new heap struct");
+
+ /* Allocate file space */
+ total_size = heap->prfx_size + size_hint;
+ if (HADDR_UNDEF == (heap->prfx_addr = H5MF_alloc(f, H5FD_MEM_LHEAP, total_size)))
+ H5E_THROW(H5E_CANTALLOC, "unable to allocate file memory");
+
+ /* Initialize info */
+ heap->single_cache_obj = TRUE;
+ heap->dblk_addr = heap->prfx_addr + (hsize_t)heap->prfx_size;
+ heap->dblk_size = size_hint;
+ if (size_hint)
+ if (NULL == (heap->dblk_image = H5FL_BLK_CALLOC(lheap_chunk, size_hint)))
+ H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
+
+ /* free list */
+ if (size_hint) {
+ if (NULL == (heap->freelist = H5FL_MALLOC(H5HL_free_t)))
+ H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
+ heap->freelist->offset = 0;
+ heap->freelist->size = size_hint;
+ heap->freelist->prev = heap->freelist->next = NULL;
+ heap->free_block = 0;
} /* end if */
else {
- if (heap) {
- if (H5F_addr_defined(heap->prfx_addr))
- if (FAIL == H5MF_xfree(f, H5FD_MEM_LHEAP, heap->prfx_addr, total_size))
- H5E_THROW(H5E_CANTFREE, "can't release heap data?");
- if (FAIL == H5HL__dest(heap))
- H5E_THROW(H5E_CANTFREE, "unable to destroy local heap");
+ heap->freelist = NULL;
+ heap->free_block = H5HL_FREE_NULL;
+ } /* end else */
+
+ /* Allocate the heap prefix */
+ if (NULL == (prfx = H5HL__prfx_new(heap)))
+ H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
+
+ /* Add to cache */
+ if (FAIL == H5AC_insert_entry(f, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET))
+ H5E_THROW(H5E_CANTINIT, "unable to cache local heap prefix");
+
+ /* Set address to return */
+ *addr_p = heap->prfx_addr;
+
+ CATCH
+ if (ret_value < 0) {
+ *addr_p = HADDR_UNDEF;
+ if (prfx) {
+ if (FAIL == H5HL__prfx_dest(prfx))
+ H5E_THROW(H5E_CANTFREE, "unable to destroy local heap prefix");
} /* end if */
- } /* end else */
-} /* end if */
+ else {
+ if (heap) {
+ if (H5F_addr_defined(heap->prfx_addr))
+ if (FAIL == H5MF_xfree(f, H5FD_MEM_LHEAP, heap->prfx_addr, total_size))
+ H5E_THROW(H5E_CANTFREE, "can't release heap data?");
+ if (FAIL == H5HL__dest(heap))
+ H5E_THROW(H5E_CANTFREE, "unable to destroy local heap");
+ } /* end if */
+ } /* end else */
+ } /* end if */
END_FUNC(PRIV) /* end H5HL_create() */
@@ -190,103 +190,104 @@ END_FUNC(PRIV) /* end H5HL_create() */
*/
BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL, H5HL__minimize_heap_space(H5F_t *f, H5HL_t *heap))
-size_t new_heap_size = heap->dblk_size; /* New size of heap */
-
-/* check args */
-HDassert(f);
-HDassert(heap);
+ size_t new_heap_size = heap->dblk_size; /* New size of heap */
-/*
- * Check to see if we can reduce the size of the heap in memory by
- * eliminating free blocks at the tail of the buffer before flushing the
- * buffer out.
- */
-if (heap->freelist) {
- H5HL_free_t *tmp_fl;
- H5HL_free_t *last_fl = NULL;
-
- /* Search for a free block at the end of the buffer */
- for (tmp_fl = heap->freelist; tmp_fl; tmp_fl = tmp_fl->next)
- /* Check if the end of this free block is at the end of the buffer */
- if (tmp_fl->offset + tmp_fl->size == heap->dblk_size) {
- last_fl = tmp_fl;
- break;
- } /* end if */
+ /* check args */
+ HDassert(f);
+ HDassert(heap);
/*
- * Found free block at the end of the buffer, decide what to do
- * about it
+ * Check to see if we can reduce the size of the heap in memory by
+ * eliminating free blocks at the tail of the buffer before flushing the
+ * buffer out.
*/
- if (last_fl) {
+ if (heap->freelist) {
+ H5HL_free_t *tmp_fl;
+ H5HL_free_t *last_fl = NULL;
+
+ /* Search for a free block at the end of the buffer */
+ for (tmp_fl = heap->freelist; tmp_fl; tmp_fl = tmp_fl->next)
+ /* Check if the end of this free block is at the end of the buffer */
+ if (tmp_fl->offset + tmp_fl->size == heap->dblk_size) {
+ last_fl = tmp_fl;
+ break;
+ } /* end if */
+
/*
- * If the last free block's size is more than half the memory
- * buffer size (and the memory buffer is larger than the
- * minimum size), reduce or eliminate it.
+ * Found free block at the end of the buffer, decide what to do
+ * about it
*/
- if (last_fl->size >= (heap->dblk_size / 2) && heap->dblk_size > H5HL_MIN_HEAP) {
- /*
- * Reduce size of buffer until it's too small or would
- * eliminate the free block
- */
- while (new_heap_size > H5HL_MIN_HEAP && new_heap_size >= (last_fl->offset + H5HL_SIZEOF_FREE(f)))
- new_heap_size /= 2;
-
+ if (last_fl) {
/*
- * Check if reducing the memory buffer size would
- * eliminate the free block
+ * If the last free block's size is more than half the memory
+ * buffer size (and the memory buffer is larger than the
+ * minimum size), reduce or eliminate it.
*/
- if (new_heap_size < (last_fl->offset + H5HL_SIZEOF_FREE(f))) {
- /* Check if this is the only block on the free list */
- if (last_fl->prev == NULL && last_fl->next == NULL) {
- /* Double the new memory size */
- new_heap_size *= 2;
-
+ if (last_fl->size >= (heap->dblk_size / 2) && heap->dblk_size > H5HL_MIN_HEAP) {
+ /*
+ * Reduce size of buffer until it's too small or would
+ * eliminate the free block
+ */
+ while (new_heap_size > H5HL_MIN_HEAP &&
+ new_heap_size >= (last_fl->offset + H5HL_SIZEOF_FREE(f)))
+ new_heap_size /= 2;
+
+ /*
+ * Check if reducing the memory buffer size would
+ * eliminate the free block
+ */
+ if (new_heap_size < (last_fl->offset + H5HL_SIZEOF_FREE(f))) {
+ /* Check if this is the only block on the free list */
+ if (last_fl->prev == NULL && last_fl->next == NULL) {
+ /* Double the new memory size */
+ new_heap_size *= 2;
+
+ /* Truncate the free block */
+ last_fl->size = H5HL_ALIGN(new_heap_size - last_fl->offset);
+ new_heap_size = last_fl->offset + last_fl->size;
+ HDassert(last_fl->size >= H5HL_SIZEOF_FREE(f));
+ } /* end if */
+ else {
+ /*
+ * Set the size of the memory buffer to the start
+ * of the free list
+ */
+ new_heap_size = last_fl->offset;
+
+ /* Eliminate the free block from the list */
+ last_fl = H5HL__remove_free(heap, last_fl);
+ } /* end else */
+ } /* end if */
+ else {
/* Truncate the free block */
last_fl->size = H5HL_ALIGN(new_heap_size - last_fl->offset);
new_heap_size = last_fl->offset + last_fl->size;
HDassert(last_fl->size >= H5HL_SIZEOF_FREE(f));
- } /* end if */
- else {
- /*
- * Set the size of the memory buffer to the start
- * of the free list
- */
- new_heap_size = last_fl->offset;
-
- /* Eliminate the free block from the list */
- last_fl = H5HL__remove_free(heap, last_fl);
+ HDassert(last_fl->size == H5HL_ALIGN(last_fl->size));
} /* end else */
} /* end if */
- else {
- /* Truncate the free block */
- last_fl->size = H5HL_ALIGN(new_heap_size - last_fl->offset);
- new_heap_size = last_fl->offset + last_fl->size;
- HDassert(last_fl->size >= H5HL_SIZEOF_FREE(f));
- HDassert(last_fl->size == H5HL_ALIGN(last_fl->size));
- } /* end else */
- } /* end if */
- } /* end if */
-} /* end if */
+ } /* end if */
+ } /* end if */
-/*
- * If the heap grew smaller than disk storage then move the
- * data segment of the heap to another contiguous block of disk
- * storage.
- */
-if (new_heap_size != heap->dblk_size) {
- HDassert(new_heap_size < heap->dblk_size);
+ /*
+ * If the heap grew smaller than disk storage then move the
+ * data segment of the heap to another contiguous block of disk
+ * storage.
+ */
+ if (new_heap_size != heap->dblk_size) {
+ HDassert(new_heap_size < heap->dblk_size);
- /* Resize the memory buffer */
- if (NULL == (heap->dblk_image = H5FL_BLK_REALLOC(lheap_chunk, heap->dblk_image, new_heap_size)))
- H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
+ /* Resize the memory buffer */
+ if (NULL == (heap->dblk_image = H5FL_BLK_REALLOC(lheap_chunk, heap->dblk_image, new_heap_size)))
+ H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
- /* Reallocate data block in file */
- if (FAIL == H5HL__dblk_realloc(f, heap, new_heap_size))
- H5E_THROW(H5E_CANTRESIZE, "reallocating data block failed");
-} /* end if */
+ /* Reallocate data block in file */
+ if (FAIL == H5HL__dblk_realloc(f, heap, new_heap_size))
+ H5E_THROW(H5E_CANTRESIZE, "reallocating data block failed");
+ } /* end if */
-CATCH
-/* No special processing on errors */
+ CATCH
+ /* No special processing on errors */
END_FUNC(STATIC) /* H5HL__minimize_heap_space() */
@@ -305,64 +306,65 @@ END_FUNC(STATIC) /* H5HL__minimize_heap_space() */
*/
BEGIN_FUNC(PRIV, ERR, H5HL_t *, NULL, NULL, H5HL_protect(H5F_t *f, haddr_t addr, unsigned flags))
-H5HL_cache_prfx_ud_t prfx_udata; /* User data for protecting local heap prefix */
-H5HL_prfx_t * prfx = NULL; /* Local heap prefix */
-H5HL_dblk_t * dblk = NULL; /* Local heap data block */
-H5HL_t * heap = NULL; /* Heap data structure */
-unsigned prfx_cache_flags = H5AC__NO_FLAGS_SET; /* Cache flags for unprotecting prefix entry */
-unsigned dblk_cache_flags = H5AC__NO_FLAGS_SET; /* Cache flags for unprotecting data block entry */
-
-/* check arguments */
-HDassert(f);
-HDassert(H5F_addr_defined(addr));
-
-/* only the H5AC__READ_ONLY_FLAG may appear in flags */
-HDassert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0);
-
-/* Construct the user data for protect callback */
-prfx_udata.sizeof_size = H5F_SIZEOF_SIZE(f);
-prfx_udata.sizeof_addr = H5F_SIZEOF_ADDR(f);
-prfx_udata.prfx_addr = addr;
-prfx_udata.sizeof_prfx = H5HL_SIZEOF_HDR(f);
-
-/* Protect the local heap prefix */
-if (NULL == (prfx = (H5HL_prfx_t *)H5AC_protect(f, H5AC_LHEAP_PRFX, addr, &prfx_udata, flags)))
- H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
-
-/* Get the pointer to the heap */
-heap = prfx->heap;
-
-/* Check if the heap is already pinned in memory */
-/* (for re-entrant situation) */
-if (heap->prots == 0) {
- /* Check if heap has separate data block */
- if (heap->single_cache_obj)
- /* Set the flag for pinning the prefix when unprotecting it */
- prfx_cache_flags |= H5AC__PIN_ENTRY_FLAG;
- else {
- /* Protect the local heap data block */
- if (NULL == (dblk = (H5HL_dblk_t *)H5AC_protect(f, H5AC_LHEAP_DBLK, heap->dblk_addr, heap, flags)))
- H5E_THROW(H5E_CANTPROTECT, "unable to load heap data block");
+ H5HL_cache_prfx_ud_t prfx_udata; /* User data for protecting local heap prefix */
+ H5HL_prfx_t * prfx = NULL; /* Local heap prefix */
+ H5HL_dblk_t * dblk = NULL; /* Local heap data block */
+ H5HL_t * heap = NULL; /* Heap data structure */
+ unsigned prfx_cache_flags = H5AC__NO_FLAGS_SET; /* Cache flags for unprotecting prefix entry */
+ unsigned dblk_cache_flags = H5AC__NO_FLAGS_SET; /* Cache flags for unprotecting data block entry */
+
+ /* check arguments */
+ HDassert(f);
+ HDassert(H5F_addr_defined(addr));
+
+ /* only the H5AC__READ_ONLY_FLAG may appear in flags */
+ HDassert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0);
+
+ /* Construct the user data for protect callback */
+ prfx_udata.sizeof_size = H5F_SIZEOF_SIZE(f);
+ prfx_udata.sizeof_addr = H5F_SIZEOF_ADDR(f);
+ prfx_udata.prfx_addr = addr;
+ prfx_udata.sizeof_prfx = H5HL_SIZEOF_HDR(f);
+
+ /* Protect the local heap prefix */
+ if (NULL == (prfx = (H5HL_prfx_t *)H5AC_protect(f, H5AC_LHEAP_PRFX, addr, &prfx_udata, flags)))
+ H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
+
+ /* Get the pointer to the heap */
+ heap = prfx->heap;
+
+ /* Check if the heap is already pinned in memory */
+ /* (for re-entrant situation) */
+ if (heap->prots == 0) {
+ /* Check if heap has separate data block */
+ if (heap->single_cache_obj)
+ /* Set the flag for pinning the prefix when unprotecting it */
+ prfx_cache_flags |= H5AC__PIN_ENTRY_FLAG;
+ else {
+ /* Protect the local heap data block */
+ if (NULL ==
+ (dblk = (H5HL_dblk_t *)H5AC_protect(f, H5AC_LHEAP_DBLK, heap->dblk_addr, heap, flags)))
+ H5E_THROW(H5E_CANTPROTECT, "unable to load heap data block");
- /* Set the flag for pinning the data block when unprotecting it */
- dblk_cache_flags |= H5AC__PIN_ENTRY_FLAG;
- } /* end if */
-} /* end if */
+ /* Set the flag for pinning the data block when unprotecting it */
+ dblk_cache_flags |= H5AC__PIN_ENTRY_FLAG;
+ } /* end if */
+ } /* end if */
-/* Increment # of times heap is protected */
-heap->prots++;
+ /* Increment # of times heap is protected */
+ heap->prots++;
-/* Set return value */
-ret_value = heap;
+ /* Set return value */
+ ret_value = heap;
-CATCH
-/* Release the prefix from the cache, now pinned */
-if (prfx && heap && H5AC_unprotect(f, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, prfx_cache_flags) < 0)
- H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
+ CATCH
+ /* Release the prefix from the cache, now pinned */
+ if (prfx && heap && H5AC_unprotect(f, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, prfx_cache_flags) < 0)
+ H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
-/* Release the data block from the cache, now pinned */
-if (dblk && heap && H5AC_unprotect(f, H5AC_LHEAP_DBLK, heap->dblk_addr, dblk, dblk_cache_flags) < 0)
- H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap data block");
+ /* Release the data block from the cache, now pinned */
+ if (dblk && heap && H5AC_unprotect(f, H5AC_LHEAP_DBLK, heap->dblk_addr, dblk, dblk_cache_flags) < 0)
+ H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap data block");
END_FUNC(PRIV) /* end H5HL_protect() */
@@ -382,14 +384,14 @@ END_FUNC(PRIV) /* end H5HL_protect() */
*/
BEGIN_FUNC(PRIV, ERR, void *, NULL, NULL, H5HL_offset_into(const H5HL_t *heap, size_t offset))
-/* Sanity check */
-HDassert(heap);
-if (offset >= heap->dblk_size)
- H5E_THROW(H5E_CANTGET, "unable to offset into local heap data block");
+ /* Sanity check */
+ HDassert(heap);
+ if (offset >= heap->dblk_size)
+ H5E_THROW(H5E_CANTGET, "unable to offset into local heap data block");
-ret_value = heap->dblk_image + offset;
+ ret_value = heap->dblk_image + offset;
-CATCH
+ CATCH
/* No special processing on errors */
END_FUNC(PRIV) /* end H5HL_offset_into() */
@@ -407,33 +409,33 @@ END_FUNC(PRIV) /* end H5HL_offset_into() */
*/
BEGIN_FUNC(PRIV, ERR, herr_t, SUCCEED, FAIL, H5HL_unprotect(H5HL_t *heap))
-/* check arguments */
-HDassert(heap);
+ /* check arguments */
+ HDassert(heap);
-/* Decrement # of times heap is protected */
-heap->prots--;
+ /* Decrement # of times heap is protected */
+ heap->prots--;
-/* Check for last unprotection of heap */
-if (heap->prots == 0) {
- /* Check for separate heap data block */
- if (heap->single_cache_obj) {
- /* Mark local heap prefix as evictable again */
- if (FAIL == H5AC_unpin_entry(heap->prfx))
- H5E_THROW(H5E_CANTUNPIN, "unable to unpin local heap data block");
- } /* end if */
- else {
- /* Sanity check */
- HDassert(heap->dblk);
+ /* Check for last unprotection of heap */
+ if (heap->prots == 0) {
+ /* Check for separate heap data block */
+ if (heap->single_cache_obj) {
+ /* Mark local heap prefix as evictable again */
+ if (FAIL == H5AC_unpin_entry(heap->prfx))
+ H5E_THROW(H5E_CANTUNPIN, "unable to unpin local heap data block");
+ } /* end if */
+ else {
+ /* Sanity check */
+ HDassert(heap->dblk);
- /* Mark local heap data block as evictable again */
- /* (data block still pins prefix) */
- if (FAIL == H5AC_unpin_entry(heap->dblk))
- H5E_THROW(H5E_CANTUNPIN, "unable to unpin local heap data block");
- } /* end else */
-} /* end if */
+ /* Mark local heap data block as evictable again */
+ /* (data block still pins prefix) */
+ if (FAIL == H5AC_unpin_entry(heap->dblk))
+ H5E_THROW(H5E_CANTUNPIN, "unable to unpin local heap data block");
+ } /* end else */
+ } /* end if */
-CATCH
-/* No special processing on errors */
+ CATCH
+ /* No special processing on errors */
END_FUNC(PRIV) /* end H5HL_unprotect() */
@@ -452,16 +454,16 @@ END_FUNC(PRIV) /* end H5HL_unprotect() */
*/
BEGIN_FUNC(STATIC, NOERR, H5HL_free_t *, NULL, -, H5HL__remove_free(H5HL_t *heap, H5HL_free_t *fl))
-if (fl->prev)
- fl->prev->next = fl->next;
-if (fl->next)
- fl->next->prev = fl->prev;
+ if (fl->prev)
+ fl->prev->next = fl->next;
+ if (fl->next)
+ fl->next->prev = fl->prev;
-if (!fl->prev)
- heap->freelist = fl->next;
+ if (!fl->prev)
+ heap->freelist = fl->next;
-/* H5FL_FREE always returns NULL so we can't check for errors */
-ret_value = (H5HL_free_t *)H5FL_FREE(H5HL_free_t, fl);
+ /* H5FL_FREE always returns NULL so we can't check for errors */
+ ret_value = (H5HL_free_t *)H5FL_FREE(H5HL_free_t, fl);
END_FUNC(STATIC) /* end H5HL__remove_free() */
@@ -479,25 +481,25 @@ END_FUNC(STATIC) /* end H5HL__remove_free() */
*/
BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL, H5HL__dirty(H5HL_t *heap))
-/* check arguments */
-HDassert(heap);
-HDassert(heap->prfx);
+ /* check arguments */
+ HDassert(heap);
+ HDassert(heap->prfx);
-/* Mark heap data block as dirty, if there is one */
-if (!heap->single_cache_obj) {
- /* Sanity check */
- HDassert(heap->dblk);
+ /* Mark heap data block as dirty, if there is one */
+ if (!heap->single_cache_obj) {
+ /* Sanity check */
+ HDassert(heap->dblk);
- if (FAIL == H5AC_mark_entry_dirty(heap->dblk))
- H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap data block as dirty");
-} /* end if */
+ if (FAIL == H5AC_mark_entry_dirty(heap->dblk))
+ H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap data block as dirty");
+ } /* end if */
-/* Mark heap prefix as dirty */
-if (FAIL == H5AC_mark_entry_dirty(heap->prfx))
- H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap prefix as dirty");
+ /* Mark heap prefix as dirty */
+ if (FAIL == H5AC_mark_entry_dirty(heap->prfx))
+ H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap prefix as dirty");
-CATCH
-/* No special processing on errors */
+ CATCH
+ /* No special processing on errors */
END_FUNC(STATIC) /* end H5HL__dirty() */
@@ -517,192 +519,192 @@ END_FUNC(STATIC) /* end H5HL__dirty() */
BEGIN_FUNC(PRIV, ERR, size_t, UFAIL, UFAIL,
H5HL_insert(H5F_t *f, H5HL_t *heap, size_t buf_size, const void *buf))
-H5HL_free_t *fl = NULL, *last_fl = NULL;
-size_t offset = 0;
-size_t need_size;
-hbool_t found;
-
-/* check arguments */
-HDassert(f);
-HDassert(heap);
-HDassert(buf_size > 0);
-HDassert(buf);
-
-/* Mark heap as dirty in cache */
-/* (A bit early in the process, but it's difficult to determine in the
- * code below where to mark the heap as dirty, especially in error cases,
- * so we just accept that an extra flush of the heap info could occur
- * if an error occurs -QAK)
- */
-if (FAIL == H5HL__dirty(heap))
- H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap as dirty");
-
-/*
- * In order to keep the free list descriptors aligned on word boundaries,
- * whatever that might mean, we round the size up to the next multiple of
- * a word.
- */
-need_size = H5HL_ALIGN(buf_size);
+ H5HL_free_t *fl = NULL, *last_fl = NULL;
+ size_t offset = 0;
+ size_t need_size;
+ hbool_t found;
+
+ /* check arguments */
+ HDassert(f);
+ HDassert(heap);
+ HDassert(buf_size > 0);
+ HDassert(buf);
+
+ /* Mark heap as dirty in cache */
+ /* (A bit early in the process, but it's difficult to determine in the
+ * code below where to mark the heap as dirty, especially in error cases,
+ * so we just accept that an extra flush of the heap info could occur
+ * if an error occurs -QAK)
+ */
+ if (FAIL == H5HL__dirty(heap))
+ H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap as dirty");
-/*
- * Look for a free slot large enough for this object and which would
- * leave zero or at least H5G_SIZEOF_FREE bytes left over.
- */
-for (fl = heap->freelist, found = FALSE; fl; fl = fl->next) {
- if (fl->size > need_size && fl->size - need_size >= H5HL_SIZEOF_FREE(f)) {
- /* a big enough free block was found */
- offset = fl->offset;
- fl->offset += need_size;
- fl->size -= need_size;
- HDassert(fl->offset == H5HL_ALIGN(fl->offset));
- HDassert(fl->size == H5HL_ALIGN(fl->size));
- found = TRUE;
- break;
- }
- else if (fl->size == need_size) {
- /* free block of exact size found */
- offset = fl->offset;
- fl = H5HL__remove_free(heap, fl);
- found = TRUE;
- break;
- }
- else if (!last_fl || last_fl->offset < fl->offset) {
- /* track free space that's closest to end of heap */
- last_fl = fl;
- }
-} /* end for */
-
-/*
- * If no free chunk was large enough, then allocate more space and
- * add it to the free list. If the heap ends with a free chunk, we
- * can extend that free chunk. Otherwise we'll have to make another
- * free chunk. If the heap must expand, we double its size.
- */
-if (found == FALSE) {
- size_t need_more; /* How much more space we need */
- size_t new_dblk_size; /* Final size of space allocated for heap data block */
- size_t old_dblk_size; /* Previous size of space allocated for heap data block */
- htri_t was_extended; /* Whether the local heap's data segment on disk was extended */
-
- /* At least double the heap's size, making certain there's enough room
- * for the new object */
- need_more = MAX(need_size, heap->dblk_size);
-
- /* If there is no last free block or it's not at the end of the heap,
- * and the amount of space to allocate is not big enough to include at
- * least the new object and a free-list info, trim down the amount of
- * space requested to just the amount of space needed. (Generally
- * speaking, this only occurs when the heap is small -QAK)
+ /*
+ * In order to keep the free list descriptors aligned on word boundaries,
+ * whatever that might mean, we round the size up to the next multiple of
+ * a word.
*/
- if (!(last_fl && last_fl->offset + last_fl->size == heap->dblk_size) &&
- (need_more < (need_size + H5HL_SIZEOF_FREE(f))))
- need_more = need_size;
-
- new_dblk_size = heap->dblk_size + need_more;
- HDassert(heap->dblk_size < new_dblk_size);
- old_dblk_size = heap->dblk_size;
- H5_CHECK_OVERFLOW(heap->dblk_size, size_t, hsize_t);
- H5_CHECK_OVERFLOW(new_dblk_size, size_t, hsize_t);
-
- /* Extend current heap if possible */
- was_extended =
- H5MF_try_extend(f, H5FD_MEM_LHEAP, heap->dblk_addr, (hsize_t)(heap->dblk_size), (hsize_t)need_more);
- if (FAIL == was_extended)
- H5E_THROW(H5E_CANTEXTEND, "error trying to extend heap");
-
- /* Check if we extended the heap data block in file */
- if (was_extended == TRUE) {
- /* Check for prefix & data block contiguous */
- if (heap->single_cache_obj) {
- /* Resize prefix+data block */
- if (FAIL == H5AC_resize_entry(heap->prfx, (size_t)(heap->prfx_size + new_dblk_size)))
- H5E_THROW(H5E_CANTRESIZE, "unable to resize heap prefix in cache");
- } /* end if */
- else {
- /* Resize 'standalone' data block */
- if (FAIL == H5AC_resize_entry(heap->dblk, (size_t)new_dblk_size))
- H5E_THROW(H5E_CANTRESIZE, "unable to resize heap data block in cache");
- } /* end else */
+ need_size = H5HL_ALIGN(buf_size);
- /* Note new size */
- heap->dblk_size = new_dblk_size;
- } /* end if */
- else { /* ...if we can't, allocate a new chunk & release the old */
- /* Reallocate data block in file */
- if (FAIL == H5HL__dblk_realloc(f, heap, new_dblk_size))
- H5E_THROW(H5E_CANTRESIZE, "reallocating data block failed");
- } /* end if */
+ /*
+ * Look for a free slot large enough for this object and which would
+ * leave zero or at least H5G_SIZEOF_FREE bytes left over.
+ */
+ for (fl = heap->freelist, found = FALSE; fl; fl = fl->next) {
+ if (fl->size > need_size && fl->size - need_size >= H5HL_SIZEOF_FREE(f)) {
+ /* a big enough free block was found */
+ offset = fl->offset;
+ fl->offset += need_size;
+ fl->size -= need_size;
+ HDassert(fl->offset == H5HL_ALIGN(fl->offset));
+ HDassert(fl->size == H5HL_ALIGN(fl->size));
+ found = TRUE;
+ break;
+ }
+ else if (fl->size == need_size) {
+ /* free block of exact size found */
+ offset = fl->offset;
+ fl = H5HL__remove_free(heap, fl);
+ found = TRUE;
+ break;
+ }
+ else if (!last_fl || last_fl->offset < fl->offset) {
+ /* track free space that's closest to end of heap */
+ last_fl = fl;
+ }
+ } /* end for */
- /* If the last free list in the heap is at the end of the heap, extend it */
- if (last_fl && last_fl->offset + last_fl->size == old_dblk_size) {
- /*
- * Increase the size of the last free block.
+ /*
+ * If no free chunk was large enough, then allocate more space and
+ * add it to the free list. If the heap ends with a free chunk, we
+ * can extend that free chunk. Otherwise we'll have to make another
+ * free chunk. If the heap must expand, we double its size.
+ */
+ if (found == FALSE) {
+ size_t need_more; /* How much more space we need */
+ size_t new_dblk_size; /* Final size of space allocated for heap data block */
+ size_t old_dblk_size; /* Previous size of space allocated for heap data block */
+ htri_t was_extended; /* Whether the local heap's data segment on disk was extended */
+
+ /* At least double the heap's size, making certain there's enough room
+ * for the new object */
+ need_more = MAX(need_size, heap->dblk_size);
+
+ /* If there is no last free block or it's not at the end of the heap,
+ * and the amount of space to allocate is not big enough to include at
+ * least the new object and a free-list info, trim down the amount of
+ * space requested to just the amount of space needed. (Generally
+ * speaking, this only occurs when the heap is small -QAK)
*/
- offset = last_fl->offset;
- last_fl->offset += need_size;
- last_fl->size += need_more - need_size;
- HDassert(last_fl->offset == H5HL_ALIGN(last_fl->offset));
- HDassert(last_fl->size == H5HL_ALIGN(last_fl->size));
+ if (!(last_fl && last_fl->offset + last_fl->size == heap->dblk_size) &&
+ (need_more < (need_size + H5HL_SIZEOF_FREE(f))))
+ need_more = need_size;
+
+ new_dblk_size = heap->dblk_size + need_more;
+ HDassert(heap->dblk_size < new_dblk_size);
+ old_dblk_size = heap->dblk_size;
+ H5_CHECK_OVERFLOW(heap->dblk_size, size_t, hsize_t);
+ H5_CHECK_OVERFLOW(new_dblk_size, size_t, hsize_t);
+
+ /* Extend current heap if possible */
+ was_extended = H5MF_try_extend(f, H5FD_MEM_LHEAP, heap->dblk_addr, (hsize_t)(heap->dblk_size),
+ (hsize_t)need_more);
+ if (FAIL == was_extended)
+ H5E_THROW(H5E_CANTEXTEND, "error trying to extend heap");
+
+ /* Check if we extended the heap data block in file */
+ if (was_extended == TRUE) {
+ /* Check for prefix & data block contiguous */
+ if (heap->single_cache_obj) {
+ /* Resize prefix+data block */
+ if (FAIL == H5AC_resize_entry(heap->prfx, (size_t)(heap->prfx_size + new_dblk_size)))
+ H5E_THROW(H5E_CANTRESIZE, "unable to resize heap prefix in cache");
+ } /* end if */
+ else {
+ /* Resize 'standalone' data block */
+ if (FAIL == H5AC_resize_entry(heap->dblk, (size_t)new_dblk_size))
+ H5E_THROW(H5E_CANTRESIZE, "unable to resize heap data block in cache");
+ } /* end else */
+
+ /* Note new size */
+ heap->dblk_size = new_dblk_size;
+ } /* end if */
+ else { /* ...if we can't, allocate a new chunk & release the old */
+ /* Reallocate data block in file */
+ if (FAIL == H5HL__dblk_realloc(f, heap, new_dblk_size))
+ H5E_THROW(H5E_CANTRESIZE, "reallocating data block failed");
+ } /* end if */
- if (last_fl->size < H5HL_SIZEOF_FREE(f)) {
+ /* If the last free list in the heap is at the end of the heap, extend it */
+ if (last_fl && last_fl->offset + last_fl->size == old_dblk_size) {
+ /*
+ * Increase the size of the last free block.
+ */
+ offset = last_fl->offset;
+ last_fl->offset += need_size;
+ last_fl->size += need_more - need_size;
+ HDassert(last_fl->offset == H5HL_ALIGN(last_fl->offset));
+ HDassert(last_fl->size == H5HL_ALIGN(last_fl->size));
+
+ if (last_fl->size < H5HL_SIZEOF_FREE(f)) {
#ifdef H5HL_DEBUG
- if (H5DEBUG(HL) && last_fl->size) {
- HDfprintf(H5DEBUG(HL), "H5HL: lost %lu bytes at line %d\n", (unsigned long)(last_fl->size),
- __LINE__);
- }
+ if (H5DEBUG(HL) && last_fl->size) {
+ HDfprintf(H5DEBUG(HL), "H5HL: lost %lu bytes at line %d\n",
+ (unsigned long)(last_fl->size), __LINE__);
+ }
#endif
- last_fl = H5HL__remove_free(heap, last_fl);
- }
- } /* end if */
- else {
- /*
- * Create a new free list element large enough that we can
- * take some space out of it right away.
- */
- offset = old_dblk_size;
- if (need_more - need_size >= H5HL_SIZEOF_FREE(f)) {
- if (NULL == (fl = H5FL_MALLOC(H5HL_free_t)))
- H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
- fl->offset = old_dblk_size + need_size;
- fl->size = need_more - need_size;
- HDassert(fl->offset == H5HL_ALIGN(fl->offset));
- HDassert(fl->size == H5HL_ALIGN(fl->size));
- fl->prev = NULL;
- fl->next = heap->freelist;
- if (heap->freelist)
- heap->freelist->prev = fl;
- heap->freelist = fl;
+ last_fl = H5HL__remove_free(heap, last_fl);
+ }
+ } /* end if */
+ else {
+ /*
+ * Create a new free list element large enough that we can
+ * take some space out of it right away.
+ */
+ offset = old_dblk_size;
+ if (need_more - need_size >= H5HL_SIZEOF_FREE(f)) {
+ if (NULL == (fl = H5FL_MALLOC(H5HL_free_t)))
+ H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
+ fl->offset = old_dblk_size + need_size;
+ fl->size = need_more - need_size;
+ HDassert(fl->offset == H5HL_ALIGN(fl->offset));
+ HDassert(fl->size == H5HL_ALIGN(fl->size));
+ fl->prev = NULL;
+ fl->next = heap->freelist;
+ if (heap->freelist)
+ heap->freelist->prev = fl;
+ heap->freelist = fl;
#ifdef H5HL_DEBUG
- }
- else if (H5DEBUG(HL) && need_more > need_size) {
- HDfprintf(H5DEBUG(HL), "H5HL_insert: lost %lu bytes at line %d\n",
- (unsigned long)(need_more - need_size), __LINE__);
+ }
+ else if (H5DEBUG(HL) && need_more > need_size) {
+ HDfprintf(H5DEBUG(HL), "H5HL_insert: lost %lu bytes at line %d\n",
+ (unsigned long)(need_more - need_size), __LINE__);
#endif
- }
- } /* end else */
+ }
+ } /* end else */
#ifdef H5HL_DEBUG
- if (H5DEBUG(HL)) {
- HDfprintf(H5DEBUG(HL), "H5HL: resize mem buf from %lu to %lu bytes\n", (unsigned long)(old_dblk_size),
- (unsigned long)(old_dblk_size + need_more));
- }
+ if (H5DEBUG(HL)) {
+ HDfprintf(H5DEBUG(HL), "H5HL: resize mem buf from %lu to %lu bytes\n",
+ (unsigned long)(old_dblk_size), (unsigned long)(old_dblk_size + need_more));
+ }
#endif
- if (NULL == (heap->dblk_image = H5FL_BLK_REALLOC(lheap_chunk, heap->dblk_image, heap->dblk_size)))
- H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
+ if (NULL == (heap->dblk_image = H5FL_BLK_REALLOC(lheap_chunk, heap->dblk_image, heap->dblk_size)))
+ H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
- /* Clear new section so junk doesn't appear in the file */
- /* (Avoid clearing section which will be overwritten with newly inserted data) */
- HDmemset(heap->dblk_image + offset + buf_size, 0, (new_dblk_size - (offset + buf_size)));
-} /* end if */
+ /* Clear new section so junk doesn't appear in the file */
+ /* (Avoid clearing section which will be overwritten with newly inserted data) */
+ HDmemset(heap->dblk_image + offset + buf_size, 0, (new_dblk_size - (offset + buf_size)));
+ } /* end if */
-/* Copy the data into the heap */
-H5MM_memcpy(heap->dblk_image + offset, buf, buf_size);
+ /* Copy the data into the heap */
+ H5MM_memcpy(heap->dblk_image + offset, buf, buf_size);
-/* Set return value */
-ret_value = offset;
+ /* Set return value */
+ ret_value = offset;
-CATCH
-/* No special processing on errors */
+ CATCH
+ /* No special processing on errors */
END_FUNC(PRIV) /* H5HL_insert() */
@@ -731,125 +733,125 @@ END_FUNC(PRIV) /* H5HL_insert() */
*/
BEGIN_FUNC(PRIV, ERR, herr_t, SUCCEED, FAIL, H5HL_remove(H5F_t *f, H5HL_t *heap, size_t offset, size_t size))
-H5HL_free_t *fl = NULL;
+ H5HL_free_t *fl = NULL;
-/* check arguments */
-HDassert(f);
-HDassert(heap);
-HDassert(size > 0);
-HDassert(offset == H5HL_ALIGN(offset));
+ /* check arguments */
+ HDassert(f);
+ HDassert(heap);
+ HDassert(size > 0);
+ HDassert(offset == H5HL_ALIGN(offset));
-size = H5HL_ALIGN(size);
+ size = H5HL_ALIGN(size);
-HDassert(offset < heap->dblk_size);
-HDassert(offset + size <= heap->dblk_size);
+ HDassert(offset < heap->dblk_size);
+ HDassert(offset + size <= heap->dblk_size);
-/* Mark heap as dirty in cache */
-/* (A bit early in the process, but it's difficult to determine in the
- * code below where to mark the heap as dirty, especially in error cases,
- * so we just accept that an extra flush of the heap info could occur
- * if an error occurs -QAK)
- */
-if (FAIL == H5HL__dirty(heap))
- H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap as dirty");
+ /* Mark heap as dirty in cache */
+ /* (A bit early in the process, but it's difficult to determine in the
+ * code below where to mark the heap as dirty, especially in error cases,
+ * so we just accept that an extra flush of the heap info could occur
+ * if an error occurs -QAK)
+ */
+ if (FAIL == H5HL__dirty(heap))
+ H5E_THROW(H5E_CANTMARKDIRTY, "unable to mark heap as dirty");
-/*
- * Check if this chunk can be prepended or appended to an already
- * free chunk. It might also fall between two chunks in such a way
- * that all three chunks can be combined into one.
- */
-fl = heap->freelist;
-while (fl) {
- H5HL_free_t *fl2 = NULL;
-
- if ((offset + size) == fl->offset) {
- fl->offset = offset;
- fl->size += size;
- HDassert(fl->offset == H5HL_ALIGN(fl->offset));
- HDassert(fl->size == H5HL_ALIGN(fl->size));
- fl2 = fl->next;
- while (fl2) {
- if ((fl2->offset + fl2->size) == fl->offset) {
- fl->offset = fl2->offset;
- fl->size += fl2->size;
- HDassert(fl->offset == H5HL_ALIGN(fl->offset));
- HDassert(fl->size == H5HL_ALIGN(fl->size));
- fl2 = H5HL__remove_free(heap, fl2);
- if (((fl->offset + fl->size) == heap->dblk_size) && ((2 * fl->size) > heap->dblk_size)) {
- if (FAIL == H5HL__minimize_heap_space(f, heap))
- H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
+ /*
+ * Check if this chunk can be prepended or appended to an already
+ * free chunk. It might also fall between two chunks in such a way
+ * that all three chunks can be combined into one.
+ */
+ fl = heap->freelist;
+ while (fl) {
+ H5HL_free_t *fl2 = NULL;
+
+ if ((offset + size) == fl->offset) {
+ fl->offset = offset;
+ fl->size += size;
+ HDassert(fl->offset == H5HL_ALIGN(fl->offset));
+ HDassert(fl->size == H5HL_ALIGN(fl->size));
+ fl2 = fl->next;
+ while (fl2) {
+ if ((fl2->offset + fl2->size) == fl->offset) {
+ fl->offset = fl2->offset;
+ fl->size += fl2->size;
+ HDassert(fl->offset == H5HL_ALIGN(fl->offset));
+ HDassert(fl->size == H5HL_ALIGN(fl->size));
+ fl2 = H5HL__remove_free(heap, fl2);
+ if (((fl->offset + fl->size) == heap->dblk_size) && ((2 * fl->size) > heap->dblk_size)) {
+ if (FAIL == H5HL__minimize_heap_space(f, heap))
+ H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
+ }
+ H5_LEAVE(SUCCEED);
}
- H5_LEAVE(SUCCEED);
+ fl2 = fl2->next;
}
- fl2 = fl2->next;
- }
- if (((fl->offset + fl->size) == heap->dblk_size) && ((2 * fl->size) > heap->dblk_size)) {
- if (FAIL == H5HL__minimize_heap_space(f, heap))
- H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
+ if (((fl->offset + fl->size) == heap->dblk_size) && ((2 * fl->size) > heap->dblk_size)) {
+ if (FAIL == H5HL__minimize_heap_space(f, heap))
+ H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
+ }
+ H5_LEAVE(SUCCEED);
}
- H5_LEAVE(SUCCEED);
- }
- else if (fl->offset + fl->size == offset) {
- fl->size += size;
- fl2 = fl->next;
- HDassert(fl->size == H5HL_ALIGN(fl->size));
- while (fl2) {
- if (fl->offset + fl->size == fl2->offset) {
- fl->size += fl2->size;
- HDassert(fl->size == H5HL_ALIGN(fl->size));
- fl2 = H5HL__remove_free(heap, fl2);
- if (((fl->offset + fl->size) == heap->dblk_size) && ((2 * fl->size) > heap->dblk_size)) {
- if (FAIL == H5HL__minimize_heap_space(f, heap))
- H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
+ else if (fl->offset + fl->size == offset) {
+ fl->size += size;
+ fl2 = fl->next;
+ HDassert(fl->size == H5HL_ALIGN(fl->size));
+ while (fl2) {
+ if (fl->offset + fl->size == fl2->offset) {
+ fl->size += fl2->size;
+ HDassert(fl->size == H5HL_ALIGN(fl->size));
+ fl2 = H5HL__remove_free(heap, fl2);
+ if (((fl->offset + fl->size) == heap->dblk_size) && ((2 * fl->size) > heap->dblk_size)) {
+ if (FAIL == H5HL__minimize_heap_space(f, heap))
+ H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
+ } /* end if */
+ H5_LEAVE(SUCCEED);
} /* end if */
- H5_LEAVE(SUCCEED);
+ fl2 = fl2->next;
+ } /* end while */
+ if (((fl->offset + fl->size) == heap->dblk_size) && ((2 * fl->size) > heap->dblk_size)) {
+ if (FAIL == H5HL__minimize_heap_space(f, heap))
+ H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
} /* end if */
- fl2 = fl2->next;
- } /* end while */
- if (((fl->offset + fl->size) == heap->dblk_size) && ((2 * fl->size) > heap->dblk_size)) {
- if (FAIL == H5HL__minimize_heap_space(f, heap))
- H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
+ H5_LEAVE(SUCCEED);
} /* end if */
- H5_LEAVE(SUCCEED);
- } /* end if */
- fl = fl->next;
-} /* end while */
+ fl = fl->next;
+ } /* end while */
-/*
- * The amount which is being removed must be large enough to
- * hold the free list data. If not, the freed chunk is forever
- * lost.
- */
-if (size < H5HL_SIZEOF_FREE(f)) {
+ /*
+ * The amount which is being removed must be large enough to
+ * hold the free list data. If not, the freed chunk is forever
+ * lost.
+ */
+ if (size < H5HL_SIZEOF_FREE(f)) {
#ifdef H5HL_DEBUG
- if (H5DEBUG(HL)) {
- HDfprintf(H5DEBUG(HL), "H5HL: lost %lu bytes\n", (unsigned long)size);
- }
+ if (H5DEBUG(HL)) {
+ HDfprintf(H5DEBUG(HL), "H5HL: lost %lu bytes\n", (unsigned long)size);
+ }
#endif
- H5_LEAVE(SUCCEED);
-} /* end if */
+ H5_LEAVE(SUCCEED);
+ } /* end if */
-/*
- * Add an entry to the free list.
- */
-if (NULL == (fl = H5FL_MALLOC(H5HL_free_t)))
- H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
-fl->offset = offset;
-fl->size = size;
-HDassert(fl->offset == H5HL_ALIGN(fl->offset));
-HDassert(fl->size == H5HL_ALIGN(fl->size));
-fl->prev = NULL;
-fl->next = heap->freelist;
-if (heap->freelist)
- heap->freelist->prev = fl;
-heap->freelist = fl;
-
-if (((fl->offset + fl->size) == heap->dblk_size) && ((2 * fl->size) > heap->dblk_size))
- if (FAIL == H5HL__minimize_heap_space(f, heap))
- H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
-
-CATCH
-/* No special processing on exit */
+ /*
+ * Add an entry to the free list.
+ */
+ if (NULL == (fl = H5FL_MALLOC(H5HL_free_t)))
+ H5E_THROW(H5E_CANTALLOC, "memory allocation failed");
+ fl->offset = offset;
+ fl->size = size;
+ HDassert(fl->offset == H5HL_ALIGN(fl->offset));
+ HDassert(fl->size == H5HL_ALIGN(fl->size));
+ fl->prev = NULL;
+ fl->next = heap->freelist;
+ if (heap->freelist)
+ heap->freelist->prev = fl;
+ heap->freelist = fl;
+
+ if (((fl->offset + fl->size) == heap->dblk_size) && ((2 * fl->size) > heap->dblk_size))
+ if (FAIL == H5HL__minimize_heap_space(f, heap))
+ H5E_THROW(H5E_CANTFREE, "heap size minimization failed");
+
+ CATCH
+ /* No special processing on exit */
END_FUNC(PRIV) /* end H5HL_remove() */
@@ -867,47 +869,48 @@ END_FUNC(PRIV) /* end H5HL_remove() */
*/
BEGIN_FUNC(PRIV, ERR, herr_t, SUCCEED, FAIL, H5HL_delete(H5F_t *f, haddr_t addr))
-H5HL_t * heap = NULL; /* Local heap to delete */
-H5HL_cache_prfx_ud_t prfx_udata; /* User data for protecting local heap prefix */
-H5HL_prfx_t * prfx = NULL; /* Local heap prefix */
-H5HL_dblk_t * dblk = NULL; /* Local heap data block */
-unsigned cache_flags = H5AC__NO_FLAGS_SET; /* Flags for unprotecting heap */
+ H5HL_t * heap = NULL; /* Local heap to delete */
+ H5HL_cache_prfx_ud_t prfx_udata; /* User data for protecting local heap prefix */
+ H5HL_prfx_t * prfx = NULL; /* Local heap prefix */
+ H5HL_dblk_t * dblk = NULL; /* Local heap data block */
+ unsigned cache_flags = H5AC__NO_FLAGS_SET; /* Flags for unprotecting heap */
-/* check arguments */
-HDassert(f);
-HDassert(H5F_addr_defined(addr));
+ /* check arguments */
+ HDassert(f);
+ HDassert(H5F_addr_defined(addr));
-/* Construct the user data for protect callback */
-prfx_udata.sizeof_size = H5F_SIZEOF_SIZE(f);
-prfx_udata.sizeof_addr = H5F_SIZEOF_ADDR(f);
-prfx_udata.prfx_addr = addr;
-prfx_udata.sizeof_prfx = H5HL_SIZEOF_HDR(f);
+ /* Construct the user data for protect callback */
+ prfx_udata.sizeof_size = H5F_SIZEOF_SIZE(f);
+ prfx_udata.sizeof_addr = H5F_SIZEOF_ADDR(f);
+ prfx_udata.prfx_addr = addr;
+ prfx_udata.sizeof_prfx = H5HL_SIZEOF_HDR(f);
-/* Protect the local heap prefix */
-if (NULL == (prfx = (H5HL_prfx_t *)H5AC_protect(f, H5AC_LHEAP_PRFX, addr, &prfx_udata, H5AC__NO_FLAGS_SET)))
- H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
+ /* Protect the local heap prefix */
+ if (NULL ==
+ (prfx = (H5HL_prfx_t *)H5AC_protect(f, H5AC_LHEAP_PRFX, addr, &prfx_udata, H5AC__NO_FLAGS_SET)))
+ H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
-/* Get the pointer to the heap */
-heap = prfx->heap;
+ /* Get the pointer to the heap */
+ heap = prfx->heap;
-/* Check if heap has separate data block */
-if (!heap->single_cache_obj)
- /* Protect the local heap data block */
- if (NULL ==
- (dblk = (H5HL_dblk_t *)H5AC_protect(f, H5AC_LHEAP_DBLK, heap->dblk_addr, heap, H5AC__NO_FLAGS_SET)))
- H5E_THROW(H5E_CANTPROTECT, "unable to load heap data block");
+ /* Check if heap has separate data block */
+ if (!heap->single_cache_obj)
+ /* Protect the local heap data block */
+ if (NULL == (dblk = (H5HL_dblk_t *)H5AC_protect(f, H5AC_LHEAP_DBLK, heap->dblk_addr, heap,
+ H5AC__NO_FLAGS_SET)))
+ H5E_THROW(H5E_CANTPROTECT, "unable to load heap data block");
-/* Set the flags for releasing the prefix and data block */
-cache_flags |= H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG;
+ /* Set the flags for releasing the prefix and data block */
+ cache_flags |= H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG;
-CATCH
-/* Release the data block from the cache, now deleted */
-if (dblk && heap && H5AC_unprotect(f, H5AC_LHEAP_DBLK, heap->dblk_addr, dblk, cache_flags) < 0)
- H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap data block");
+ CATCH
+ /* Release the data block from the cache, now deleted */
+ if (dblk && heap && H5AC_unprotect(f, H5AC_LHEAP_DBLK, heap->dblk_addr, dblk, cache_flags) < 0)
+ H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap data block");
-/* Release the prefix from the cache, now deleted */
-if (prfx && heap && H5AC_unprotect(f, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, cache_flags) < 0)
- H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
+ /* Release the prefix from the cache, now deleted */
+ if (prfx && heap && H5AC_unprotect(f, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, cache_flags) < 0)
+ H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
END_FUNC(PRIV) /* end H5HL_delete() */
@@ -925,34 +928,35 @@ END_FUNC(PRIV) /* end H5HL_delete() */
*/
BEGIN_FUNC(PRIV, ERR, herr_t, SUCCEED, FAIL, H5HL_get_size(H5F_t *f, haddr_t addr, size_t *size))
-H5HL_cache_prfx_ud_t prfx_udata; /* User data for protecting local heap prefix */
-H5HL_prfx_t * prfx = NULL; /* Local heap prefix */
-H5HL_t * heap; /* Heap data structure */
+ H5HL_cache_prfx_ud_t prfx_udata; /* User data for protecting local heap prefix */
+ H5HL_prfx_t * prfx = NULL; /* Local heap prefix */
+ H5HL_t * heap; /* Heap data structure */
-/* check arguments */
-HDassert(f);
-HDassert(H5F_addr_defined(addr));
-HDassert(size);
+ /* check arguments */
+ HDassert(f);
+ HDassert(H5F_addr_defined(addr));
+ HDassert(size);
-/* Construct the user data for protect callback */
-prfx_udata.sizeof_size = H5F_SIZEOF_SIZE(f);
-prfx_udata.sizeof_addr = H5F_SIZEOF_ADDR(f);
-prfx_udata.prfx_addr = addr;
-prfx_udata.sizeof_prfx = H5HL_SIZEOF_HDR(f);
+ /* Construct the user data for protect callback */
+ prfx_udata.sizeof_size = H5F_SIZEOF_SIZE(f);
+ prfx_udata.sizeof_addr = H5F_SIZEOF_ADDR(f);
+ prfx_udata.prfx_addr = addr;
+ prfx_udata.sizeof_prfx = H5HL_SIZEOF_HDR(f);
-/* Protect the local heap prefix */
-if (NULL == (prfx = (H5HL_prfx_t *)H5AC_protect(f, H5AC_LHEAP_PRFX, addr, &prfx_udata, H5AC__READ_ONLY_FLAG)))
- H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
+ /* Protect the local heap prefix */
+ if (NULL ==
+ (prfx = (H5HL_prfx_t *)H5AC_protect(f, H5AC_LHEAP_PRFX, addr, &prfx_udata, H5AC__READ_ONLY_FLAG)))
+ H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
-/* Get the pointer to the heap */
-heap = prfx->heap;
+ /* Get the pointer to the heap */
+ heap = prfx->heap;
-/* Set the size to return */
-*size = heap->dblk_size;
+ /* Set the size to return */
+ *size = heap->dblk_size;
-CATCH
-if (prfx && FAIL == H5AC_unprotect(f, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET))
- H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
+ CATCH
+ if (prfx && FAIL == H5AC_unprotect(f, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET))
+ H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
END_FUNC(PRIV) /* end H5HL_get_size() */
@@ -971,33 +975,34 @@ END_FUNC(PRIV) /* end H5HL_get_size() */
*/
BEGIN_FUNC(PRIV, ERR, herr_t, SUCCEED, FAIL, H5HL_heapsize(H5F_t *f, haddr_t addr, hsize_t *heap_size))
-H5HL_cache_prfx_ud_t prfx_udata; /* User data for protecting local heap prefix */
-H5HL_prfx_t * prfx = NULL; /* Local heap prefix */
-H5HL_t * heap; /* Heap data structure */
+ H5HL_cache_prfx_ud_t prfx_udata; /* User data for protecting local heap prefix */
+ H5HL_prfx_t * prfx = NULL; /* Local heap prefix */
+ H5HL_t * heap; /* Heap data structure */
-/* check arguments */
-HDassert(f);
-HDassert(H5F_addr_defined(addr));
-HDassert(heap_size);
+ /* check arguments */
+ HDassert(f);
+ HDassert(H5F_addr_defined(addr));
+ HDassert(heap_size);
-/* Construct the user data for protect callback */
-prfx_udata.sizeof_size = H5F_SIZEOF_SIZE(f);
-prfx_udata.sizeof_addr = H5F_SIZEOF_ADDR(f);
-prfx_udata.prfx_addr = addr;
-prfx_udata.sizeof_prfx = H5HL_SIZEOF_HDR(f);
+ /* Construct the user data for protect callback */
+ prfx_udata.sizeof_size = H5F_SIZEOF_SIZE(f);
+ prfx_udata.sizeof_addr = H5F_SIZEOF_ADDR(f);
+ prfx_udata.prfx_addr = addr;
+ prfx_udata.sizeof_prfx = H5HL_SIZEOF_HDR(f);
-/* Protect the local heap prefix */
-if (NULL == (prfx = (H5HL_prfx_t *)H5AC_protect(f, H5AC_LHEAP_PRFX, addr, &prfx_udata, H5AC__READ_ONLY_FLAG)))
- H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
+ /* Protect the local heap prefix */
+ if (NULL ==
+ (prfx = (H5HL_prfx_t *)H5AC_protect(f, H5AC_LHEAP_PRFX, addr, &prfx_udata, H5AC__READ_ONLY_FLAG)))
+ H5E_THROW(H5E_CANTPROTECT, "unable to load heap prefix");
-/* Get the pointer to the heap */
-heap = prfx->heap;
+ /* Get the pointer to the heap */
+ heap = prfx->heap;
-/* Accumulate the size of the local heap */
-*heap_size += (hsize_t)(heap->prfx_size + heap->dblk_size);
+ /* Accumulate the size of the local heap */
+ *heap_size += (hsize_t)(heap->prfx_size + heap->dblk_size);
-CATCH
-if (prfx && FAIL == H5AC_unprotect(f, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET))
- H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
+ CATCH
+ if (prfx && FAIL == H5AC_unprotect(f, H5AC_LHEAP_PRFX, heap->prfx_addr, prfx, H5AC__NO_FLAGS_SET))
+ H5E_THROW(H5E_CANTUNPROTECT, "unable to release local heap prefix");
END_FUNC(PRIV) /* end H5HL_heapsize() */