[svn-r15800] Description:

	Bring file free space branch changes through r15795 into trunk, which
includes a fair bit of code cleanup & rearrangement along with a couple of
bug fixes also.

Tested on:
        Mac OS X/32 10.5.5 (amazon) in debug mode
        Mac OS X/32 10.5.5 (amazon) w/C++ & FORTRAN, w/threadsafe,
                                in production mode
        FreeBSD/32 6.3 (duty) in debug mode
        FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
        Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
                                in debug mode
        Linux/64-amd64 2.6 (smirom) w/Intel compilers w/default API=1.6.x,
                                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                                in production mode
        Linux/64-ia64 2.4 (tg-login3) w/parallel, w/FORTRAN, in production mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode

1 files changed, 156 insertions, 551 deletions

diff --git a/src/H5HG.c b/src/H5HG.c
index f867147..b5f8988 100644
--- a/src/H5HG.c
+++ b/src/H5HG.c
@@ -37,33 +37,28 @@
  *		in the collection, and temporal locality.
  */
 
+/****************/
+/* Module Setup */
+/****************/
+
 #define H5F_PACKAGE		/*suppress error about including H5Fpkg	  */
 #define H5HG_PACKAGE		/*suppress error about including H5HGpkg	  */
 
 
+/***********/
+/* Headers */
+/***********/
 #include "H5private.h"		/* Generic Functions			*/
-#include "H5ACprivate.h"	/* Metadata cache			*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Fpkg.h"             /* File access				*/
-#include "H5FLprivate.h"	/* Free lists                           */
 #include "H5HGpkg.h"		/* Global heaps				*/
 #include "H5MFprivate.h"	/* File memory management		*/
 #include "H5MMprivate.h"	/* Memory management			*/
 
-/* Private macros */
 
-/*
- * Global heap collection version.
- */
-#define H5HG_VERSION	1
-
-/*
- * All global heap collections are at least this big.  This allows us to read
- * most collections with a single read() since we don't have to read a few
- * bytes of header to figure out the size.  If the heap is larger than this
- * then a second read gets the rest after we've decoded the header.
- */
-#define H5HG_MINSIZE	4096
+/****************/
+/* Local Macros */
+/****************/
 
 /*
  * Limit global heap collections to the some reasonable size.  This is
@@ -73,12 +68,6 @@
 #define H5HG_MAXSIZE	65536
 
 /*
- * Maximum length of the CWFS list, the list of remembered collections that
- * have free space.
- */
-#define H5HG_NCWFS	16
-
-/*
  * The maximum number of links allowed to a global heap object.
  */
 #define H5HG_MAXLINK	65535
@@ -88,63 +77,47 @@
  */
 #define H5HG_MAXIDX	65535
 
-/*
- * The size of the collection header, always a multiple of the alignment so
- * that the stuff that follows the header is aligned.
- */
-#define H5HG_SIZEOF_HDR(f)						      \
-    H5HG_ALIGN(4 +			/*magic number		*/	      \
-	       1 +			/*version number	*/	      \
-	       3 +			/*reserved		*/	      \
-	       H5F_SIZEOF_SIZE(f))	/*collection size	*/
 
-/*
- * The initial guess for the number of messages in a collection.  We assume
- * that all objects in that collection are zero length, giving the maximum
- * possible number of objects in the collection.  The collection itself has
- * some overhead and each message has some overhead.  The `+2' accounts for
- * rounding and for the free space object.
- */
-#define H5HG_NOBJS(f,z) (int)((((z)-H5HG_SIZEOF_HDR(f))/		      \
-			       H5HG_SIZEOF_OBJHDR(f)+2))
+/******************/
+/* Local Typedefs */
+/******************/
+
 
-/* Private typedefs */
+/********************/
+/* Package Typedefs */
+/********************/
+
+
+/********************/
+/* Local Prototypes */
+/********************/
 
-/* PRIVATE PROTOTYPES */
 static haddr_t H5HG_create(H5F_t *f, hid_t dxpl_id, size_t size);
-#ifdef NOT_YET
-static void *H5HG_peek(H5F_t *f, hid_t dxpl_id, H5HG_t *hobj);
-#endif /* NOT_YET */
-
-/* Metadata cache callbacks */
-static H5HG_heap_t *H5HG_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *udata1,
-			      void *udata2);
-static herr_t H5HG_flush(H5F_t *f, hid_t dxpl_id, hbool_t dest, haddr_t addr,
-			 H5HG_heap_t *heap, unsigned UNUSED * flags_ptr);
-static herr_t H5HG_dest(H5F_t *f, H5HG_heap_t *heap);
-static herr_t H5HG_clear(H5F_t *f, H5HG_heap_t *heap, hbool_t destroy);
-static herr_t H5HG_compute_size(const H5F_t *f, const H5HG_heap_t *heap, size_t *size_ptr);
 
-/*
- * H5HG inherits cache-like properties from H5AC
- */
-const H5AC_class_t H5AC_GHEAP[1] = {{
-    H5AC_GHEAP_ID,
-    (H5AC_load_func_t)H5HG_load,
-    (H5AC_flush_func_t)H5HG_flush,
-    (H5AC_dest_func_t)H5HG_dest,
-    (H5AC_clear_func_t)H5HG_clear,
-    (H5AC_size_func_t)H5HG_compute_size,
-}};
+
+/*********************/
+/* Package Variables */
+/*********************/
+
+
+/*****************************/
+/* Library Private Variables */
+/*****************************/
+
+
+/*******************/
+/* Local Variables */
+/*******************/
 
 /* Declare a free list to manage the H5HG_t struct */
-H5FL_DEFINE_STATIC(H5HG_heap_t);
+H5FL_DEFINE(H5HG_heap_t);
 
 /* Declare a free list to manage sequences of H5HG_obj_t's */
-H5FL_SEQ_DEFINE_STATIC(H5HG_obj_t);
+H5FL_SEQ_DEFINE(H5HG_obj_t);
 
 /* Declare a PQ free list to manage heap chunks */
-H5FL_BLK_DEFINE_STATIC(heap_chunk);
+H5FL_BLK_DEFINE(gheap_chunk);
+
 
 
 /*-------------------------------------------------------------------------
@@ -213,7 +186,7 @@ H5HG_create (H5F_t *f, hid_t dxpl_id, size_t size)
     heap->addr = addr;
     heap->size = size;
 
-    if (NULL==(heap->chunk = H5FL_BLK_MALLOC (heap_chunk,size)))
+    if (NULL==(heap->chunk = H5FL_BLK_MALLOC (gheap_chunk,size)))
 	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, HADDR_UNDEF, \
                      "memory allocation failed");
 #ifdef H5_CLEAR_MEMORY
@@ -294,361 +267,6 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5HG_load
- *
- * Purpose:	Loads a global heap collection from disk.
- *
- * Return:	Success:	Ptr to a global heap collection.
- *
- *		Failure:	NULL
- *
- * Programmer:	Robb Matzke
- *              Friday, March 27, 1998
- *
- * Modifications:
- *		Robb Matzke, 1999-07-28
- *		The ADDR argument is passed by value.
- *
- *	Quincey Koziol, 2002-7-180
- *	Added dxpl parameter to allow more control over I/O from metadata
- *      cache.
- *-------------------------------------------------------------------------
- */
-static H5HG_heap_t *
-H5HG_load (H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED * udata1,
-	   void UNUSED * udata2)
-{
-    H5HG_heap_t	*heap = NULL;
-    uint8_t	*p = NULL;
-    int	i;
-    size_t	nalloc, need;
-    size_t      max_idx=0;              /* The maximum index seen */
-    H5HG_heap_t	*ret_value = NULL;      /* Return value */
-
-    FUNC_ENTER_NOAPI(H5HG_load, NULL);
-
-    /* check arguments */
-    assert (f);
-    assert (H5F_addr_defined (addr));
-    assert (!udata1);
-    assert (!udata2);
-
-    /* Read the initial 4k page */
-    if(NULL == (heap = H5FL_CALLOC (H5HG_heap_t)))
-	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-    heap->addr = addr;
-    if(NULL == (heap->chunk = H5FL_BLK_MALLOC(heap_chunk, (size_t)H5HG_MINSIZE)))
-	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-    if(H5F_block_read(f, H5FD_MEM_GHEAP, addr, (size_t)H5HG_MINSIZE, dxpl_id, heap->chunk)<0)
-	HGOTO_ERROR (H5E_HEAP, H5E_READERROR, NULL, "unable to read global heap collection");
-
-    /* Magic number */
-    if(HDmemcmp(heap->chunk, H5HG_MAGIC, (size_t)H5_SIZEOF_MAGIC))
-	HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL, "bad global heap collection signature");
-    p = heap->chunk + H5_SIZEOF_MAGIC;
-
-    /* Version */
-    if (H5HG_VERSION!=*p++)
-	HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, NULL, "wrong version number in global heap");
-
-    /* Reserved */
-    p += 3;
-
-    /* Size */
-    H5F_DECODE_LENGTH (f, p, heap->size);
-    assert (heap->size>=H5HG_MINSIZE);
-
-    /*
-     * If we didn't read enough in the first try, then read the rest of the
-     * collection now.
-     */
-    if (heap->size > H5HG_MINSIZE) {
-	haddr_t next_addr = addr + (hsize_t)H5HG_MINSIZE;
-	if (NULL==(heap->chunk = H5FL_BLK_REALLOC (heap_chunk, heap->chunk, heap->size)))
-	    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-	if (H5F_block_read (f, H5FD_MEM_GHEAP, next_addr, (heap->size-H5HG_MINSIZE), dxpl_id, heap->chunk+H5HG_MINSIZE)<0)
-	    HGOTO_ERROR (H5E_HEAP, H5E_READERROR, NULL, "unable to read global heap collection");
-    }
-
-    /* Decode each object */
-    p = heap->chunk + H5HG_SIZEOF_HDR (f);
-    nalloc = H5HG_NOBJS (f, heap->size);
-    if (NULL==(heap->obj = H5FL_SEQ_MALLOC (H5HG_obj_t,nalloc)))
-	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-    heap->obj[0].size=heap->obj[0].nrefs=0;
-    heap->obj[0].begin=NULL;
-
-    heap->nalloc = nalloc;
-    while (p<heap->chunk+heap->size) {
-	if (p+H5HG_SIZEOF_OBJHDR(f)>heap->chunk+heap->size) {
-	    /*
-	     * The last bit of space is too tiny for an object header, so we
-	     * assume that it's free space.
-	     */
-	    assert (NULL==heap->obj[0].begin);
-	    heap->obj[0].size = (heap->chunk+heap->size) - p;
-	    heap->obj[0].begin = p;
-	    p += heap->obj[0].size;
-	} else {
-	    unsigned idx;
-	    uint8_t *begin = p;
-
-	    UINT16DECODE (p, idx);
-
-            /* Check if we need more room to store heap objects */
-            if(idx>=heap->nalloc) {
-                size_t new_alloc;       /* New allocation number */
-                H5HG_obj_t *new_obj;	/* New array of object descriptions */
-
-                /* Determine the new number of objects to index */
-                new_alloc=MAX(heap->nalloc*2,(idx+1));
-
-                /* Reallocate array of objects */
-                if (NULL==(new_obj = H5FL_SEQ_REALLOC (H5HG_obj_t, heap->obj, new_alloc)))
-                    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-
-                /* Update heap information */
-                heap->nalloc=new_alloc;
-                heap->obj=new_obj;
-            } /* end if */
-
-	    UINT16DECODE (p, heap->obj[idx].nrefs);
-	    p += 4; /*reserved*/
-	    H5F_DECODE_LENGTH (f, p, heap->obj[idx].size);
-	    heap->obj[idx].begin = begin;
-	    /*
-	     * The total storage size includes the size of the object header
-	     * and is zero padded so the next object header is properly
-	     * aligned. The last bit of space is the free space object whose
-	     * size is never padded and already includes the object header.
-	     */
-	    if (idx>0) {
-		need = H5HG_SIZEOF_OBJHDR(f) + H5HG_ALIGN(heap->obj[idx].size);
-
-                /* Check for "gap" in index numbers (caused by deletions) and fill in heap object values */
-                if(idx>(max_idx+1))
-                    HDmemset(&heap->obj[max_idx+1],0,sizeof(H5HG_obj_t)*(idx-(max_idx+1)));
-                max_idx=idx;
-	    } else {
-		need = heap->obj[idx].size;
-	    }
-	    p = begin + need;
-	}
-    }
-    assert(p==heap->chunk+heap->size);
-    assert(H5HG_ISALIGNED(heap->obj[0].size));
-
-    /* Set the next index value to use */
-    if(max_idx>0)
-        heap->nused=max_idx+1;
-    else
-        heap->nused=1;
-
-    /*
-     * Add the new heap to the CWFS list, removing some other entry if
-     * necessary to make room. We remove the right-most entry that has less
-     * free space than this heap.
-     */
-    if (!f->shared->cwfs) {
-        f->shared->cwfs = (H5HG_heap_t **)H5MM_malloc(H5HG_NCWFS * sizeof(H5HG_heap_t *));
-        if(NULL == f->shared->cwfs)
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
-        f->shared->ncwfs = 1;
-        f->shared->cwfs[0] = heap;
-    } else if(H5HG_NCWFS == f->shared->ncwfs) {
-        for(i = H5HG_NCWFS - 1; i >= 0; --i) {
-            if(f->shared->cwfs[i]->obj[0].size < heap->obj[0].size) {
-                HDmemmove(f->shared->cwfs + 1, f->shared->cwfs, i * sizeof(H5HG_heap_t *));
-                f->shared->cwfs[0] = heap;
-                break;
-            } /* end if */
-        } /* end for */
-    } else {
-        HDmemmove(f->shared->cwfs + 1, f->shared->cwfs, f->shared->ncwfs * sizeof(H5HG_heap_t *));
-        f->shared->ncwfs += 1;
-        f->shared->cwfs[0] = heap;
-    } /* end else */
-
-    ret_value = heap;
-
-done:
-    if (!ret_value && heap) {
-        if(H5HG_dest(f,heap)<0)
-	    HDONE_ERROR(H5E_HEAP, H5E_CANTFREE, NULL, "unable to destroy global heap collection");
-    }
-    FUNC_LEAVE_NOAPI(ret_value);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5HG_flush
- *
- * Purpose:	Flushes a global heap collection from memory to disk if it's
- *		dirty.  Optionally deletes teh heap from memory.
- *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	Robb Matzke
- *              Friday, March 27, 1998
- *
- * Modifications:
- *		Robb Matzke, 1999-07-28
- *		The ADDR argument is passed by value.
- *
- *	Quincey Koziol, 2002-7-180
- *	Added dxpl parameter to allow more control over I/O from metadata
- *      cache.
- *
- *      JRM -- 8/21/06
- *      Added the flags_ptr parameter.  This parameter exists to
- *      allow the flush routine to report to the cache if the
- *      entry is resized or renamed as a result of the flush.
- *      *flags_ptr is set to H5C_CALLBACK__NO_FLAGS_SET on entry.
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5HG_flush (H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5HG_heap_t *heap, unsigned UNUSED * flags_ptr)
-{
-    herr_t      ret_value=SUCCEED;       /* Return value */
-
-    FUNC_ENTER_NOAPI(H5HG_flush, FAIL);
-
-    /* Check arguments */
-    assert (f);
-    assert (H5F_addr_defined (addr));
-    assert (H5F_addr_eq (addr, heap->addr));
-    assert (heap);
-
-    if (heap->cache_info.is_dirty) {
-	if (H5F_block_write (f, H5FD_MEM_GHEAP, addr, heap->size, dxpl_id, heap->chunk)<0)
-	    HGOTO_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL, "unable to write global heap collection to file");
-	heap->cache_info.is_dirty = FALSE;
-    }
-
-    if (destroy) {
-        if(H5HG_dest(f,heap)<0)
-	    HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy global heap collection");
-    }
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value);
-}
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5HG_dest
- *
- * Purpose:	Destroys a global heap collection in memory
- *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	Quincey Koziol
- *              Wednesday, January 15, 2003
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5HG_dest (H5F_t *f, H5HG_heap_t *heap)
-{
-    int		i;
-
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HG_dest)
-
-    /* Check arguments */
-    HDassert(heap);
-
-    /* Verify that node is clean */
-    HDassert(heap->cache_info.is_dirty == FALSE);
-
-    for(i = 0; i < f->shared->ncwfs; i++) {
-        if(f->shared->cwfs[i] == heap) {
-            f->shared->ncwfs -= 1;
-            HDmemmove(f->shared->cwfs + i, f->shared->cwfs + i + 1, (f->shared->ncwfs - i) * sizeof(H5HG_heap_t *));
-            break;
-        } /* end if */
-    } /* end for */
-
-    if(heap->chunk)
-        heap->chunk = H5FL_BLK_FREE(heap_chunk, heap->chunk);
-    if(heap->obj)
-        heap->obj = (H5HG_obj_t *)H5FL_SEQ_FREE(H5HG_obj_t, heap->obj);
-    (void)H5FL_FREE(H5HG_heap_t, heap);
-
-    FUNC_LEAVE_NOAPI(SUCCEED)
-} /* H5HG_dest() */
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5HG_clear
- *
- * Purpose:	Mark a global heap in memory as non-dirty.
- *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	Quincey Koziol
- *              Thursday, March 20, 2003
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5HG_clear(H5F_t *f, H5HG_heap_t *heap, hbool_t destroy)
-{
-    herr_t ret_value = SUCCEED;
-
-    FUNC_ENTER_NOAPI_NOINIT(H5HG_clear);
-
-    /* Check arguments */
-    assert (heap);
-
-    /* Mark heap as clean */
-    heap->cache_info.is_dirty = FALSE;
-
-    if (destroy)
-        if (H5HG_dest(f, heap) < 0)
-	    HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy global heap collection");
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value);
-} /* H5HG_clear() */
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5HG_compute_size
- *
- * Purpose:	Compute the size in bytes of the specified instance of
- *              H5HG_heap_t on disk, and return it in *len_ptr.  On failure,
- *              the value of *len_ptr is undefined.
- *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	John Mainzer
- *              5/13/04
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5HG_compute_size(const H5F_t UNUSED *f, const H5HG_heap_t *heap, size_t *size_ptr)
-{
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5HG_compute_size);
-
-    /* Check arguments */
-    HDassert(heap);
-    HDassert(size_ptr);
-
-    *size_ptr = heap->size;
-
-    FUNC_LEAVE_NOAPI(SUCCEED);
-} /* H5HG_compute_size() */
-
-
-/*-------------------------------------------------------------------------
  * Function:	H5HG_alloc
  *
  * Purpose:	Given a heap with enough free space, this function will split
@@ -714,7 +332,7 @@ H5HG_alloc (H5F_t *f, H5HG_heap_t *heap, size_t size, unsigned * heap_flags_ptr)
 
         /* Reallocate array of objects */
         if (NULL==(new_obj = H5FL_SEQ_REALLOC (H5HG_obj_t, heap->obj, new_alloc)))
-            HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed");
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed")
 
         /* Update heap information */
         heap->nalloc=new_alloc;
@@ -803,75 +421,60 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HG_extend (H5F_t *f, H5HG_heap_t *heap, size_t size, unsigned * heap_flags_ptr)
+H5HG_extend(H5F_t *f, H5HG_heap_t *heap, size_t need, unsigned *heap_flags_ptr)
 {
-    size_t  need;                   /* Actual space needed to store object */
     size_t  old_size;               /* Previous size of the heap's chunk */
-    uint8_t *new_chunk=NULL;        /* Pointer to new chunk information */
+    uint8_t *new_chunk = NULL;      /* Pointer to new chunk information */
     uint8_t *p = NULL;              /* Pointer to raw heap info */
     unsigned u;                     /* Local index variable */
-    herr_t  ret_value=SUCCEED;      /* Return value */
+    herr_t  ret_value = SUCCEED;    /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT(H5HG_extend);
+    FUNC_ENTER_NOAPI_NOINIT(H5HG_extend)
 
     /* Check args */
-    assert (f);
-    assert (heap);
-    assert (heap_flags_ptr);
-
-    /* Compute total space need to add to this heap */
-    need = H5HG_SIZEOF_OBJHDR(f) + H5HG_ALIGN(size);
-
-    /* Decrement the amount needed in the heap by the amount of free space available */
-    assert(need>heap->obj[0].size);
-    need -= heap->obj[0].size;
-
-    /* Don't do anything less than double the size of the heap */
-    need = MAX(heap->size,need);
-
-    /* Extend the space allocated for this heap on disk */
-    if(H5MF_extend(f,H5FD_MEM_GHEAP,heap->addr,(hsize_t)heap->size,(hsize_t)need)<0)
-	HGOTO_ERROR (H5E_HEAP, H5E_NOSPACE, FAIL, "can't extend heap on disk");
+    HDassert(f);
+    HDassert(heap);
+    HDassert(heap_flags_ptr);
 
     /* Re-allocate the heap information in memory */
-    if (NULL==(new_chunk = H5FL_BLK_REALLOC (heap_chunk, heap->chunk, heap->size+need)))
-        HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "new heap allocation failed");
+    if(NULL == (new_chunk = H5FL_BLK_REALLOC(gheap_chunk, heap->chunk, (heap->size + need))))
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "new heap allocation failed")
 #ifdef H5_CLEAR_MEMORY
 HDmemset(new_chunk + heap->size, 0, need);
 #endif /* H5_CLEAR_MEMORY */
 
     /* Adjust the size of the heap */
-    old_size=heap->size;
-    heap->size+=need;
+    old_size = heap->size;
+    heap->size += need;
 
     /* Encode the new size of the heap */
     p = new_chunk + H5_SIZEOF_MAGIC + 1 /* version */ + 3 /* reserved */;
-    H5F_ENCODE_LENGTH (f, p, heap->size);
+    H5F_ENCODE_LENGTH(f, p, heap->size);
 
     /* Move the pointers to the existing objects to their new locations */
-    for (u=0; u<heap->nused; u++)
+    for(u = 0; u < heap->nused; u++)
         if(heap->obj[u].begin)
             heap->obj[u].begin = new_chunk + (heap->obj[u].begin - heap->chunk);
 
     /* Update the heap chunk pointer now */
-    heap->chunk=new_chunk;
+    heap->chunk = new_chunk;
 
     /* Update the free space information for the heap  */
-    heap->obj[0].size+=need;
-    if(heap->obj[0].begin==NULL)
-        heap->obj[0].begin=heap->chunk+old_size;
+    heap->obj[0].size += need;
+    if(heap->obj[0].begin == NULL)
+        heap->obj[0].begin = heap->chunk+old_size;
     p = heap->obj[0].begin;
     UINT16ENCODE(p, 0);	/*id*/
     UINT16ENCODE(p, 0);	/*nrefs*/
     UINT32ENCODE(p, 0);	/*reserved*/
-    H5F_ENCODE_LENGTH (f, p, heap->obj[0].size);
+    H5F_ENCODE_LENGTH(f, p, heap->obj[0].size);
     assert(H5HG_ISALIGNED(heap->obj[0].size));
 
     /* Mark the heap as dirty */
     *heap_flags_ptr |= H5AC__DIRTIED_FLAG;
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5HG_extend() */
 
 
@@ -922,26 +525,26 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5HG_insert (H5F_t *f, hid_t dxpl_id, size_t size, void *obj, H5HG_t *hobj/*out*/)
+H5HG_insert(H5F_t *f, hid_t dxpl_id, size_t size, void *obj, H5HG_t *hobj/*out*/)
 {
     size_t	need;		/*total space needed for object		*/
-    int	cwfsno;
+    int	        cwfsno;
     size_t	idx;
     haddr_t	addr = HADDR_UNDEF;
     H5HG_heap_t	*heap = NULL;
     unsigned 	heap_flags = H5AC__NO_FLAGS_SET;
-    hbool_t     found=0;        /* Flag to indicate a heap with enough space was found */
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    hbool_t     found = FALSE;          /* Flag to indicate a heap with enough space was found */
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
-    FUNC_ENTER_NOAPI(H5HG_insert, FAIL);
+    FUNC_ENTER_NOAPI(H5HG_insert, FAIL)
 
     /* Check args */
-    assert (f);
-    assert (0==size || obj);
-    assert (hobj);
+    HDassert(f);
+    HDassert(0 == size || obj);
+    HDassert(hobj);
 
-    if (0==(f->intent & H5F_ACC_RDWR))
-	HGOTO_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL, "no write intent on file");
+    if(0 == (f->intent & H5F_ACC_RDWR))
+	HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "no write intent on file")
 
     /* Find a large enough collection on the CWFS list */
     need = H5HG_SIZEOF_OBJHDR(f) + H5HG_ALIGN(size);
@@ -970,20 +573,18 @@ H5HG_insert (H5F_t *f, hid_t dxpl_id, size_t size, void *obj, H5HG_t *hobj/*out*
      * take any of it as gospel.
      *                                        JRM - 5/24/04
      */
-
-    for (cwfsno=0; cwfsno<f->shared->ncwfs; cwfsno++) {
-	if (f->shared->cwfs[cwfsno]->obj[0].size>=need) {
+    for(cwfsno = 0; cwfsno < f->shared->ncwfs; cwfsno++)
+	if(f->shared->cwfs[cwfsno]->obj[0].size >= need) {
 	    addr = f->shared->cwfs[cwfsno]->addr;
-            found=1;
+            found = TRUE;
 	    break;
 	} /* end if */
-    } /* end for */
 
     /*
      * If we didn't find any collection with enough free space the check if
      * we can extend any of the collections to make enough room.
      */
-    if (!found) {
+    if(!found) {
         size_t new_need;
 
         for (cwfsno=0; cwfsno<f->shared->ncwfs; cwfsno++) {
@@ -991,12 +592,19 @@ H5HG_insert (H5F_t *f, hid_t dxpl_id, size_t size, void *obj, H5HG_t *hobj/*out*
             new_need -= f->shared->cwfs[cwfsno]->obj[0].size;
             new_need = MAX(f->shared->cwfs[cwfsno]->size, new_need);
 
-            if((f->shared->cwfs[cwfsno]->size+new_need)<=H5HG_MAXSIZE && H5MF_can_extend(f,H5FD_MEM_GHEAP,f->shared->cwfs[cwfsno]->addr,(hsize_t)f->shared->cwfs[cwfsno]->size,(hsize_t)new_need)) {
-                if(H5HG_extend(f,f->shared->cwfs[cwfsno],size, &heap_flags)<0)
-                    HGOTO_ERROR (H5E_HEAP, H5E_CANTINIT, FAIL, "unable to extend global heap collection");
-	        addr = f->shared->cwfs[cwfsno]->addr;
-                found=1;
-                break;
+            if((f->shared->cwfs[cwfsno]->size + new_need) <= H5HG_MAXSIZE) {
+                htri_t extended;        /* Whether the heap was extended */
+
+                extended = H5MF_try_extend(f, dxpl_id, H5FD_MEM_GHEAP, f->shared->cwfs[cwfsno]->addr, (hsize_t)f->shared->cwfs[cwfsno]->size, (hsize_t)new_need);
+                if(extended < 0)
+                    HGOTO_ERROR(H5E_HEAP, H5E_CANTEXTEND, FAIL, "error trying to extend heap")
+                else if(extended == TRUE) {
+                    if(H5HG_extend(f, f->shared->cwfs[cwfsno], new_need, &heap_flags) < 0)
+                        HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "unable to extend global heap collection")
+                    addr = f->shared->cwfs[cwfsno]->addr;
+                    found = TRUE;
+                    break;
+                } /* end if */
             } /* end if */
         } /* end for */
     } /* end if */
@@ -1005,43 +613,40 @@ H5HG_insert (H5F_t *f, hid_t dxpl_id, size_t size, void *obj, H5HG_t *hobj/*out*
      * If we didn't find any collection with enough free space then allocate a
      * new collection large enough for the message plus the collection header.
      */
-    if (!found) {
-
+    if(!found) {
         addr = H5HG_create(f, dxpl_id, need+H5HG_SIZEOF_HDR (f));
 
-        if ( ! H5F_addr_defined(addr) )
-	    HGOTO_ERROR (H5E_HEAP, H5E_CANTINIT, FAIL, \
-                         "unable to allocate a global heap collection");
+        if(!H5F_addr_defined(addr))
+	    HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "unable to allocate a global heap collection")
 	cwfsno = 0;
     } /* end if */
     else {
-
         /* Move the collection forward in the CWFS list, if it's not
          * already at the front
          */
-        if (cwfsno>0) {
+        if(cwfsno > 0) {
             H5HG_heap_t *tmp = f->shared->cwfs[cwfsno];
-            f->shared->cwfs[cwfsno] = f->shared->cwfs[cwfsno-1];
-            f->shared->cwfs[cwfsno-1] = tmp;
+
+            f->shared->cwfs[cwfsno] = f->shared->cwfs[cwfsno - 1];
+            f->shared->cwfs[cwfsno - 1] = tmp;
             --cwfsno;
         } /* end if */
     } /* end else */
 
     HDassert(H5F_addr_defined(addr));
-
-    if(NULL == (heap = (H5HG_heap_t *)H5AC_protect(f, dxpl_id, H5AC_GHEAP, addr, NULL, NULL, H5AC_WRITE)) )
-        HGOTO_ERROR (H5E_HEAP, H5E_CANTLOAD, FAIL, "unable to load heap");
+    if(NULL == (heap = (H5HG_heap_t *)H5AC_protect(f, dxpl_id, H5AC_GHEAP, addr, NULL, NULL, H5AC_WRITE)))
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL, "unable to load heap")
 
     /* Split the free space to make room for the new object */
-    idx = H5HG_alloc (f, heap, size, &heap_flags);
+    idx = H5HG_alloc(f, heap, size, &heap_flags);
 
     /* Copy data into the heap */
-    if(size>0) {
-        HDmemcpy(heap->obj[idx].begin+H5HG_SIZEOF_OBJHDR(f), obj, size);
+    if(size > 0) {
+        HDmemcpy(heap->obj[idx].begin + H5HG_SIZEOF_OBJHDR(f), obj, size);
 #ifdef OLD_WAY
 /* Don't bother zeroing out the rest of the info in the heap -QAK */
-        HDmemset(heap->obj[idx].begin+H5HG_SIZEOF_OBJHDR(f)+size, 0,
-                 need-(H5HG_SIZEOF_OBJHDR(f)+size));
+        HDmemset(heap->obj[idx].begin + H5HG_SIZEOF_OBJHDR(f) + size, 0,
+                 need - (H5HG_SIZEOF_OBJHDR(f) + size));
 #endif /* OLD_WAY */
     } /* end if */
     heap_flags |= H5AC__DIRTIED_FLAG;
@@ -1051,10 +656,10 @@ H5HG_insert (H5F_t *f, hid_t dxpl_id, size_t size, void *obj, H5HG_t *hobj/*out*
     hobj->idx = idx;
 
 done:
-    if ( heap && H5AC_unprotect(f, dxpl_id, H5AC_GHEAP, heap->addr, heap, heap_flags) < 0 )
-        HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to unprotect heap.");
+    if(heap && H5AC_unprotect(f, dxpl_id, H5AC_GHEAP, heap->addr, heap, heap_flags) < 0)
+        HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to unprotect heap.")
 
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* H5HG_insert() */
 
 
@@ -1180,19 +785,19 @@ H5HG_link (H5F_t *f, hid_t dxpl_id, const H5HG_t *hobj, int adjust)
     assert (f);
     assert (hobj);
     if (0==(f->intent & H5F_ACC_RDWR))
-	HGOTO_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL, "no write intent on file");
+	HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "no write intent on file")
 
     if(adjust!=0) {
         /* Load the heap */
         if (NULL == (heap = (H5HG_heap_t *)H5AC_protect(f, dxpl_id, H5AC_GHEAP, hobj->addr, NULL, NULL, H5AC_WRITE)))
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL, "unable to load heap");
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL, "unable to load heap")
 
         assert (hobj->idx<heap->nused);
         assert (heap->obj[hobj->idx].begin);
         if (heap->obj[hobj->idx].nrefs+adjust<0)
-            HGOTO_ERROR (H5E_HEAP, H5E_BADRANGE, FAIL, "new link count would be out of range");
+            HGOTO_ERROR (H5E_HEAP, H5E_BADRANGE, FAIL, "new link count would be out of range")
         if (heap->obj[hobj->idx].nrefs+adjust>H5HG_MAXLINK)
-            HGOTO_ERROR (H5E_HEAP, H5E_BADVALUE, FAIL, "new link count would be out of range");
+            HGOTO_ERROR (H5E_HEAP, H5E_BADVALUE, FAIL, "new link count would be out of range")
         heap->obj[hobj->idx].nrefs += adjust;
         heap_flags |= H5AC__DIRTIED_FLAG;
     } /* end if */
@@ -1202,7 +807,7 @@ H5HG_link (H5F_t *f, hid_t dxpl_id, const H5HG_t *hobj, int adjust)
 
 done:
     if (heap && H5AC_unprotect(f, dxpl_id, H5AC_GHEAP, hobj->addr, heap, heap_flags)<0)
-        HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release object header");
+        HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release object header")
 
     FUNC_LEAVE_NOAPI(ret_value);
 }
@@ -1230,88 +835,88 @@ done:
 herr_t
 H5HG_remove (H5F_t *f, hid_t dxpl_id, H5HG_t *hobj)
 {
-    uint8_t	*p=NULL, *obj_start=NULL;
     H5HG_heap_t	*heap = NULL;
+    uint8_t	*p = NULL, *obj_start = NULL;
     size_t	need;
-    int	i;
     unsigned	u;
-    unsigned    flags=H5AC__NO_FLAGS_SET;/* Whether the heap gets deleted */
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    unsigned    flags = H5AC__NO_FLAGS_SET;/* Whether the heap gets deleted */
+    herr_t      ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI(H5HG_remove, FAIL);
 
     /* Check args */
-    assert (f);
-    assert (hobj);
-    if (0==(f->intent & H5F_ACC_RDWR))
-        HGOTO_ERROR (H5E_HEAP, H5E_WRITEERROR, FAIL, "no write intent on file");
+    HDassert(f);
+    HDassert(hobj);
+    if(0 == (f->intent & H5F_ACC_RDWR))
+        HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "no write intent on file")
 
     /* Load the heap */
-    if (NULL == (heap = (H5HG_heap_t *)H5AC_protect(f, dxpl_id, H5AC_GHEAP, hobj->addr, NULL, NULL, H5AC_WRITE)))
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL, "unable to load heap");
+    if(NULL == (heap = (H5HG_heap_t *)H5AC_protect(f, dxpl_id, H5AC_GHEAP, hobj->addr, NULL, NULL, H5AC_WRITE)))
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL, "unable to load heap")
 
-    assert (hobj->idx<heap->nused);
-    assert (heap->obj[hobj->idx].begin);
+    HDassert(hobj->idx < heap->nused);
+    HDassert(heap->obj[hobj->idx].begin);
     obj_start = heap->obj[hobj->idx].begin;
     /* Include object header size */
-    need = H5HG_ALIGN(heap->obj[hobj->idx].size)+H5HG_SIZEOF_OBJHDR(f);
+    need = H5HG_ALIGN(heap->obj[hobj->idx].size) + H5HG_SIZEOF_OBJHDR(f);
 
     /* Move the new free space to the end of the heap */
-    for (u=0; u<heap->nused; u++) {
-        if (heap->obj[u].begin > heap->obj[hobj->idx].begin)
+    for(u = 0; u < heap->nused; u++)
+        if(heap->obj[u].begin > heap->obj[hobj->idx].begin)
             heap->obj[u].begin -= need;
-    }
-    if (NULL==heap->obj[0].begin) {
-        heap->obj[0].begin = heap->chunk + (heap->size-need);
+    if(NULL == heap->obj[0].begin) {
+        heap->obj[0].begin = heap->chunk + (heap->size - need);
         heap->obj[0].size = need;
         heap->obj[0].nrefs = 0;
-    } else {
+    } /* end if */
+    else
         heap->obj[0].size += need;
-    }
-    HDmemmove (obj_start, obj_start+need,
-	       heap->size-((obj_start+need)-heap->chunk));
-    if (heap->obj[0].size>=H5HG_SIZEOF_OBJHDR (f)) {
+    HDmemmove(obj_start, obj_start + need,
+	       heap->size - ((obj_start + need) - heap->chunk));
+    if(heap->obj[0].size >= H5HG_SIZEOF_OBJHDR(f)) {
         p = heap->obj[0].begin;
         UINT16ENCODE(p, 0); /*id*/
         UINT16ENCODE(p, 0); /*nrefs*/
         UINT32ENCODE(p, 0); /*reserved*/
         H5F_ENCODE_LENGTH (f, p, heap->obj[0].size);
-    }
-    HDmemset (heap->obj+hobj->idx, 0, sizeof(H5HG_obj_t));
+    } /* end if */
+    HDmemset(heap->obj + hobj->idx, 0, sizeof(H5HG_obj_t));
     flags |= H5AC__DIRTIED_FLAG;
 
-    if (heap->obj[0].size+H5HG_SIZEOF_HDR(f)==heap->size) {
+    if((heap->obj[0].size + H5HG_SIZEOF_HDR(f)) == heap->size) {
         /*
          * The collection is empty. Remove it from the CWFS list and return it
          * to the file free list.
          */
-        H5_CHECK_OVERFLOW(heap->size,size_t,hsize_t);
-        H5MF_xfree(f, H5FD_MEM_GHEAP, dxpl_id, heap->addr, (hsize_t)heap->size);
-        flags |= H5C__DELETED_FLAG; /* Indicate that the object was deleted, for the unprotect call */
-    } else {
+        H5_CHECK_OVERFLOW(heap->size, size_t, hsize_t);
+        flags |= H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG; /* Indicate that the object was deleted, for the unprotect call */
+    } /* end if */
+    else {
+        int	i;              /* Local index variable */
+
         /*
          * If the heap is in the CWFS list then advance it one position.  The
          * H5AC_protect() might have done that too, but that's okay.  If the
          * heap isn't on the CWFS list then add it to the end.
          */
-        for (i=0; i<f->shared->ncwfs; i++) {
-            if (f->shared->cwfs[i]==heap) {
-                if (i) {
-                    f->shared->cwfs[i] = f->shared->cwfs[i-1];
-                    f->shared->cwfs[i-1] = heap;
-                }
+        for(i = 0; i < f->shared->ncwfs; i++)
+            if(f->shared->cwfs[i] == heap) {
+                if(i) {
+                    f->shared->cwfs[i] = f->shared->cwfs[i - 1];
+                    f->shared->cwfs[i - 1] = heap;
+                } /* end if */
                 break;
-            }
-        }
-        if (i>=f->shared->ncwfs) {
-            f->shared->ncwfs = MIN (f->shared->ncwfs+1, H5HG_NCWFS);
-            f->shared->cwfs[f->shared->ncwfs-1] = heap;
-        }
-    }
+            } /* end if */
+        if(i >= f->shared->ncwfs) {
+            f->shared->ncwfs = MIN(f->shared->ncwfs + 1, H5HG_NCWFS);
+            f->shared->cwfs[f->shared->ncwfs - 1] = heap;
+        } /* end if */
+    } /* end else */
 
 done:
-    if (heap && H5AC_unprotect(f, dxpl_id, H5AC_GHEAP, hobj->addr, heap, flags) != SUCCEED)
-        HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release object header");
+    if(heap && H5AC_unprotect(f, dxpl_id, H5AC_GHEAP, hobj->addr, heap, flags) < 0)
+        HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release object header")
 
     FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5HG_remove() */
+