[svn-r333] Changes since 19980324

----------------------

./MANIFEST
./src/H5HG.c		[new]
./src/H5HGprivate.h	[new]
./src/H5HGpublic.h	[new]
./src/Makefile.in
	Added global heaps, H5HG.  This compiles but is untested.

./src/H5D.c
./src/H5G.c
./src/H5Gnode.c
./src/H5Gstab.c
./src/H5HL.c		[renamed from H5H.c]
./src/H5HLprivate.h	[renamed from H5Hprivate.h]
./src/H5HLpublic.h	[renamed from H5Hpublic.h]
./src/H5Oefl.c
./src/Makefile.in
./src/hdf5.h
./test/theap.c
	Renamed local heaps from H5H to H5HL.

./src/H5AC.c
./src/H5ACprivate.h
./src/debug.c
	Added debugging support for global heap collections.

./html/H5.format.html
	Ripped out the old small object heap documentation and added
	documentation for the new global heap.

./html/H5.api.html
./src/H5P.c
./src/H5Ppublic.h
./src/H5F.c
./src/H5Fprivate.h
./src/H5private.h
	The H5Pget_version() function no longer returns a small object
	heap version number.  Instead, each collection of the global
	heap has its own version number instead of a single number in
	the file boot block.

./bin/release
	Omit files marked for removal by CVS even though the removal
	hasn't been committed yet.

./test/iopipe.c
	Removed warnings about casting unsigned int to double on Irix64.

./MANIFEST
	Removed ./test/testpar/phdf5sup.c

1 files changed, 972 insertions, 0 deletions

diff --git a/src/H5HL.c b/src/H5HL.c
new file mode 100644
index 0000000..f6fa4f0
--- /dev/null
+++ b/src/H5HL.c
@@ -0,0 +1,972 @@
+/*-------------------------------------------------------------------------
+ * Copyright (C) 1997	National Center for Supercomputing Applications.
+ *			All rights reserved.
+ *
+ *-------------------------------------------------------------------------
+ *
+ * Created:		H5HL.c
+ *			Jul 16 1997
+ *			Robb Matzke <matzke@llnl.gov>
+ *
+ * Purpose:		Heap functions for the local heaps used by symbol
+ *			tables to store names (among other things).
+ *
+ * Modifications:
+ *
+ *	Robb Matzke, 5 Aug 1997
+ *	Added calls to H5E.
+ *
+ *-------------------------------------------------------------------------
+ */
+#include <H5private.h>			/*library		  	*/
+#include <H5ACprivate.h>		/*cache				*/
+#include <H5Eprivate.h>			/*error handling	  	*/
+#include <H5HLprivate.h>		/*self				*/
+#include <H5MFprivate.h>		/*file memory management  	*/
+#include <H5MMprivate.h>		/*core memory management  	*/
+
+#define H5HL_FREE_NULL	1		/*end of free list on disk	*/
+#define PABLO_MASK	H5HL_mask
+
+typedef struct H5HL_free_t {
+    size_t		offset;		/*offset of free block		*/
+    size_t		size;		/*size of free block		*/
+    struct H5HL_free_t	*prev;		/*previous entry in free list	*/
+    struct H5HL_free_t	*next;		/*next entry in free list	*/
+} H5HL_free_t;
+
+typedef struct H5HL_t {
+    intn		    dirty;
+    haddr_t		    addr;	/*address of data		*/
+    size_t		    disk_alloc;	/*data bytes allocated on disk	*/
+    size_t		    mem_alloc;	/*data bytes allocated in mem	*/
+    uint8		   *chunk;	/*the chunk, including header	*/
+    H5HL_free_t		   *freelist;	/*the free list			*/
+} H5HL_t;
+
+/* PRIVATE PROTOTYPES */
+static H5HL_t *H5HL_load(H5F_t *f, const haddr_t *addr, const void *udata1,
+			 void *udata2);
+static herr_t H5HL_flush(H5F_t *f, hbool_t dest, const haddr_t *addr,
+			 H5HL_t *heap);
+
+/*
+ * H5HL inherits cache-like properties from H5AC
+ */
+static const H5AC_class_t H5AC_LHEAP[1] = {{
+    H5AC_LHEAP_ID,
+    (void *(*)(H5F_t*, const haddr_t*, const void*, void*))H5HL_load,
+    (herr_t (*)(H5F_t*, hbool_t, const haddr_t*, void*))H5HL_flush,
+}};
+
+/* Interface initialization */
+static intn interface_initialize_g = FALSE;
+#define INTERFACE_INIT NULL
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5HL_create
+ *
+ * Purpose:	Creates a new heap data structure on disk and caches it
+ *		in memory.  SIZE_HINT is a hint for the initial size of the
+ *		data area of the heap.	If size hint is invalid then a
+ *		reasonable (but probably not optimal) size will be chosen.
+ *		If the heap ever has to grow, then REALLOC_HINT is the
+ *		minimum amount by which the heap will grow.
+ *
+ * Return:	Success:	SUCCEED. The file address of new heap is
+ *				returned through the ADDR argument.
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 16 1997
+ *
+ * Modifications:
+ *
+ *	Robb Matzke, 5 Aug 1997
+ *	Takes a flag that determines the type of heap that is
+ *	created.
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5HL_create(H5F_t *f, size_t size_hint, haddr_t *addr/*out*/)
+{
+    H5HL_t	*heap = NULL;
+    size_t	total_size;		/*total heap size on disk	*/
+
+    FUNC_ENTER(H5HL_create, FAIL);
+
+    /* check arguments */
+    assert(f);
+    assert(addr);
+
+    if (size_hint && size_hint < H5HL_SIZEOF_FREE(f)) {
+	size_hint = H5HL_SIZEOF_FREE(f);
+    }
+    size_hint = H5HL_ALIGN(size_hint);
+
+    /* allocate file version */
+    total_size = H5HL_SIZEOF_HDR(f) + size_hint;
+    if (H5MF_alloc(f, H5MF_META, total_size, addr/*out*/) < 0) {
+	HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
+		      "unable to allocate file memory");
+    }
+
+    /* allocate memory version */
+    heap = H5MM_xcalloc(1, sizeof(H5HL_t));
+    heap->addr = *addr;
+    H5F_addr_inc(&(heap->addr), H5HL_SIZEOF_HDR(f));
+    heap->disk_alloc = size_hint;
+    heap->mem_alloc = size_hint;
+    heap->chunk = H5MM_xcalloc(1, H5HL_SIZEOF_HDR(f) + size_hint);
+
+    /* free list */
+    if (size_hint) {
+	heap->freelist = H5MM_xmalloc(sizeof(H5HL_free_t));
+	heap->freelist->offset = 0;
+	heap->freelist->size = size_hint;
+	heap->freelist->prev = heap->freelist->next = NULL;
+    } else {
+	heap->freelist = NULL;
+    }
+
+    /* add to cache */
+    heap->dirty = 1;
+    if (H5AC_set(f, H5AC_LHEAP, addr, heap) < 0) {
+	heap->chunk = H5MM_xfree(heap->chunk);
+	heap->freelist = H5MM_xfree(heap->freelist);
+	HRETURN_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL,
+		      "unable to cache heap");
+    }
+    FUNC_LEAVE(SUCCEED);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5HL_load
+ *
+ * Purpose:	Loads a heap from disk.
+ *
+ * Return:	Success:	Ptr to a local heap memory data structure.
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 17 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static H5HL_t *
+H5HL_load(H5F_t *f, const haddr_t *addr, const void *udata1, void *udata2)
+{
+    uint8		hdr[52];
+    const uint8		*p = NULL;
+    H5HL_t		*heap = NULL;
+    H5HL_free_t		*fl = NULL, *tail = NULL;
+    size_t		free_block = H5HL_FREE_NULL;
+    H5HL_t		*ret_value = NULL;
+
+    FUNC_ENTER(H5HL_load, NULL);
+
+    /* check arguments */
+    assert(f);
+    assert(addr && H5F_addr_defined(addr));
+    assert(H5HL_SIZEOF_HDR(f) <= sizeof hdr);
+    assert(!udata1);
+    assert(!udata2);
+
+    if (H5F_block_read(f, addr, H5HL_SIZEOF_HDR(f), hdr) < 0) {
+	HRETURN_ERROR(H5E_HEAP, H5E_READERROR, NULL,
+		      "unable to read heap header");
+    }
+    p = hdr;
+    heap = H5MM_xcalloc(1, sizeof(H5HL_t));
+
+    /* magic number */
+    if (HDmemcmp(hdr, H5HL_MAGIC, H5HL_SIZEOF_MAGIC)) {
+	HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL,
+		    "bad heap signature");
+    }
+    p += H5HL_SIZEOF_MAGIC;
+
+    /* Reserved */
+    p += 4;
+
+    /* heap data size */
+    H5F_decode_length(f, p, heap->disk_alloc);
+    heap->mem_alloc = heap->disk_alloc;
+
+    /* free list head */
+    H5F_decode_length(f, p, free_block);
+    if (free_block != H5HL_FREE_NULL && free_block >= heap->disk_alloc) {
+	HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL,
+		    "bad heap free list");
+    }
+
+    /* data */
+    H5F_addr_decode(f, &p, &(heap->addr));
+    heap->chunk = H5MM_xcalloc(1, H5HL_SIZEOF_HDR(f) + heap->mem_alloc);
+    if (heap->disk_alloc &&
+	H5F_block_read(f, &(heap->addr), heap->disk_alloc,
+		       heap->chunk + H5HL_SIZEOF_HDR(f)) < 0) {
+	HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL,
+		    "unable to read heap data");
+    }
+
+    /* free list */
+    while (H5HL_FREE_NULL != free_block) {
+	if (free_block >= heap->disk_alloc) {
+	    HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL,
+			"bad heap free list");
+	}
+	fl = H5MM_xmalloc(sizeof(H5HL_free_t));
+	fl->offset = free_block;
+	fl->prev = tail;
+	fl->next = NULL;
+	if (tail) tail->next = fl;
+	tail = fl;
+	if (!heap->freelist) heap->freelist = fl;
+
+	p = heap->chunk + H5HL_SIZEOF_HDR(f) + free_block;
+	H5F_decode_length(f, p, free_block);
+	H5F_decode_length(f, p, fl->size);
+
+	if (fl->offset + fl->size > heap->disk_alloc) {
+	    HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL,
+			"bad heap free list");
+	}
+    }
+
+    ret_value = heap;
+
+  done:
+    if (!ret_value && heap) {
+	heap->chunk = H5MM_xfree(heap->chunk);
+	H5MM_xfree(heap);
+	for (fl = heap->freelist; fl; fl = tail) {
+	    tail = fl->next;
+	    H5MM_xfree(fl);
+	}
+    }
+    FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5HL_flush
+ *
+ * Purpose:	Flushes a heap from memory to disk if it's dirty.  Optionally
+ *		deletes the heap from memory.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 17 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5HL_flush(H5F_t *f, hbool_t destroy, const haddr_t *addr, H5HL_t *heap)
+{
+    uint8	*p = heap->chunk;
+    H5HL_free_t	*fl = heap->freelist;
+    haddr_t	hdr_end_addr;
+
+    FUNC_ENTER(H5HL_flush, FAIL);
+
+    /* check arguments */
+    assert(f);
+    assert(addr && H5F_addr_defined(addr));
+    assert(heap);
+
+    if (heap->dirty) {
+	/*
+	 * If the heap grew larger than disk storage then move the
+	 * data segment of the heap to a larger contiguous block of
+	 * disk storage.
+	 */
+	if (heap->mem_alloc > heap->disk_alloc) {
+	    haddr_t old_addr = heap->addr, new_addr;
+	    if (H5MF_alloc(f, H5MF_META, heap->mem_alloc,
+			   &new_addr/*out*/)<0) {
+		HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
+			      "unable to allocate file space for heap");
+	    }
+	    heap->addr = new_addr;
+	    H5MF_free(f, &old_addr, heap->disk_alloc);
+	    H5E_clear(); /*don't really care if the free failed */
+	    heap->disk_alloc = heap->mem_alloc;
+	}
+
+	/*
+	 * Write the header.
+	 */
+	HDmemcpy(p, H5HL_MAGIC, H5HL_SIZEOF_MAGIC);
+	p += H5HL_SIZEOF_MAGIC;
+	*p++ = 0;	/*reserved*/
+	*p++ = 0;	/*reserved*/
+	*p++ = 0;	/*reserved*/
+	*p++ = 0;	/*reserved*/
+	H5F_encode_length(f, p, heap->mem_alloc);
+	H5F_encode_length(f, p, fl ? fl->offset : H5HL_FREE_NULL);
+	H5F_addr_encode(f, &p, &(heap->addr));
+
+	/*
+	 * Write the free list.
+	 */
+	while (fl) {
+	    assert (fl->offset == H5HL_ALIGN (fl->offset));
+	    p = heap->chunk + H5HL_SIZEOF_HDR(f) + fl->offset;
+	    if (fl->next) {
+		H5F_encode_length(f, p, fl->next->offset);
+	    } else {
+		H5F_encode_length(f, p, H5HL_FREE_NULL);
+	    }
+	    H5F_encode_length(f, p, fl->size);
+	    fl = fl->next;
+	}
+
+	/*
+	 * Copy buffer to disk.
+	 */
+	hdr_end_addr = *addr;
+	H5F_addr_inc(&hdr_end_addr, H5HL_SIZEOF_HDR(f));
+	if (H5F_addr_eq(&(heap->addr), &hdr_end_addr)) {
+	    /* The header and data are contiguous */
+	    if (H5F_block_write(f, addr, H5HL_SIZEOF_HDR(f) + heap->disk_alloc,
+				heap->chunk) < 0) {
+		HRETURN_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL,
+			    "unable to write heap header and data to file");
+	    }
+	} else {
+	    if (H5F_block_write(f, addr, H5HL_SIZEOF_HDR(f), heap->chunk)<0) {
+		HRETURN_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL,
+			      "unable to write heap header to file");
+	    }
+	    if (H5F_block_write(f, &(heap->addr), heap->disk_alloc,
+				heap->chunk + H5HL_SIZEOF_HDR(f)) < 0) {
+		HRETURN_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL,
+			      "unable to write heap data to file");
+	    }
+	}
+
+	heap->dirty = 0;
+    }
+
+    /*
+     * Should we destroy the memory version?
+     */
+    if (destroy) {
+	heap->chunk = H5MM_xfree(heap->chunk);
+	while (heap->freelist) {
+	    fl = heap->freelist;
+	    heap->freelist = fl->next;
+	    H5MM_xfree(fl);
+	}
+	H5MM_xfree(heap);
+    }
+    FUNC_LEAVE(SUCCEED);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5HL_read
+ *
+ * Purpose:	Reads some object (or part of an object) from the heap
+ *		whose address is ADDR in file F.  OFFSET is the byte offset
+ *		from the beginning of the heap at which to begin reading
+ *		and SIZE is the number of bytes to read.
+ *
+ *		If BUF is the null pointer then a buffer is allocated by
+ *		this function.
+ *
+ *		Attempting to read past the end of an object may cause this
+ *		function to fail.
+ *
+ * Return:	Success:	BUF (or the allocated buffer)
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 16 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+void *
+H5HL_read(H5F_t *f, const haddr_t *addr, size_t offset, size_t size, void *buf)
+{
+    H5HL_t	*heap = NULL;
+
+    FUNC_ENTER(H5HL_read, NULL);
+
+    /* check arguments */
+    assert(f);
+    assert (addr && H5F_addr_defined(addr));
+
+    if (NULL == (heap = H5AC_find(f, H5AC_LHEAP, addr, NULL, NULL))) {
+	HRETURN_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL,
+		      "unable to load heap");
+    }
+    assert(offset < heap->mem_alloc);
+    assert(offset + size <= heap->mem_alloc);
+
+    if (!buf) buf = H5MM_xmalloc(size);
+    HDmemcpy(buf, heap->chunk + H5HL_SIZEOF_HDR(f) + offset, size);
+
+    FUNC_LEAVE(buf);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5HL_peek
+ *
+ * Purpose:	This function is a more efficient version of H5HL_read.
+ *		Instead of copying a heap object into a caller-supplied
+ *		buffer, this function returns a pointer directly into the
+ *		cache where the heap is being held.  Thus, the return pointer
+ *		is valid only until the next call to the cache.
+ *
+ *		The address of the heap is ADDR in file F.  OFFSET is the
+ *		byte offset of the object from the beginning of the heap and
+ *		may include an offset into the interior of the object.
+ *
+ * Return:	Success:	Ptr to the object.  The pointer points to
+ *				a chunk of memory large enough to hold the
+ *				object from the specified offset (usually
+ *				the beginning of the object) to the end
+ *				of the object.	Do not attempt to read past
+ *				the end of the object.
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 16 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+const void *
+H5HL_peek(H5F_t *f, const haddr_t *addr, size_t offset)
+{
+    H5HL_t		*heap = NULL;
+    const void		*retval = NULL;
+
+    FUNC_ENTER(H5HL_peek, NULL);
+
+    /* check arguments */
+    assert(f);
+    assert(addr && H5F_addr_defined(addr));
+
+    if (NULL == (heap = H5AC_find(f, H5AC_LHEAP, addr, NULL, NULL))) {
+	HRETURN_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL, "unable to load heap");
+    }
+    assert(offset < heap->mem_alloc);
+
+    retval = heap->chunk + H5HL_SIZEOF_HDR(f) + offset;
+    FUNC_LEAVE(retval);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5HL_remove_free
+ *
+ * Purpose:	Removes free list element FL from the specified heap and
+ *		frees it.
+ *
+ * Return:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 17 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static H5HL_free_t *
+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) heap->freelist = fl->next;
+    return H5MM_xfree(fl);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5HL_insert
+ *
+ * Purpose:	Inserts a new item into the heap.
+ *
+ * Return:	Success:	Offset of new item within heap.
+ *
+ *		Failure:	(size_t)(-1)
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 17 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t
+H5HL_insert(H5F_t *f, const haddr_t *addr, size_t buf_size, const void *buf)
+{
+    H5HL_t	*heap = NULL;
+    H5HL_free_t	*fl = NULL, *max_fl = NULL;
+    size_t	offset = 0;
+    size_t	need_size, old_size, need_more;
+    hbool_t	found;
+#ifndef NDEBUG
+    static int	nmessages = 0;
+#endif
+
+    FUNC_ENTER(H5HL_insert, (size_t)(-1));
+
+    /* check arguments */
+    assert(f);
+    assert(addr && H5F_addr_defined(addr));
+    assert(buf_size > 0);
+    assert(buf);
+
+    if (NULL == (heap = H5AC_find(f, H5AC_LHEAP, addr, NULL, NULL))) {
+	HRETURN_ERROR(H5E_HEAP, H5E_CANTLOAD, (size_t)(-1),
+		      "unable to load heap");
+    }
+    heap->dirty += 1;
+
+    /*
+     * 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);
+
+    /*
+     * 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 bigger free block was found */
+	    offset = fl->offset;
+	    fl->offset += need_size;
+	    fl->size -= need_size;
+	    assert (fl->offset==H5HL_ALIGN (fl->offset));
+	    assert (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 (!max_fl || max_fl->offset < fl->offset) {
+	    /* use worst fit */
+	    max_fl = fl;
+	}
+    }
+
+    /*
+     * 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) {
+	need_more = MAX3(need_size, heap->mem_alloc, H5HL_SIZEOF_FREE(f));
+
+	if (max_fl && max_fl->offset + max_fl->size == heap->mem_alloc) {
+	    /*
+	     * Increase the size of the maximum free block.
+	     */
+	    offset = max_fl->offset;
+	    max_fl->offset += need_size;
+	    max_fl->size += need_more - need_size;
+	    assert (max_fl->offset==H5HL_ALIGN (max_fl->offset));
+	    assert (max_fl->size==H5HL_ALIGN (max_fl->size));
+
+	    if (max_fl->size < H5HL_SIZEOF_FREE(f)) {
+#ifndef NDEBUG
+		if (max_fl->size) {
+		    fprintf(stderr, "H5HL_insert: lost %lu bytes at line %d\n",
+			    (unsigned long) (max_fl->size), __LINE__);
+		    if (0 == nmessages++) {
+			fprintf(stderr, "Messages from H5HL_insert() will go "
+				"away when assertions are turned off.\n");
+		    }
+		}
+#endif
+		max_fl = H5HL_remove_free(heap, max_fl);
+	    }
+	} else {
+	    /*
+	     * Create a new free list element large enough that we can
+	     * take some space out of it right away.
+	     */
+	    offset = heap->mem_alloc;
+	    if (need_more - need_size >= H5HL_SIZEOF_FREE(f)) {
+		fl = H5MM_xmalloc(sizeof(H5HL_free_t));
+		fl->offset = heap->mem_alloc + need_size;
+		fl->size = need_more - need_size;
+		assert (fl->offset==H5HL_ALIGN (fl->offset));
+		assert (fl->size==H5HL_ALIGN (fl->size));
+		fl->prev = NULL;
+		fl->next = heap->freelist;
+		if (heap->freelist) heap->freelist->prev = fl;
+		heap->freelist = fl;
+#ifndef NDEBUG
+	    } else if (need_more > need_size) {
+		fprintf(stderr, "H5HL_insert: lost %lu bytes at line %d\n",
+			(unsigned long) (need_more - need_size), __LINE__);
+		if (0 == nmessages++) {
+		    fprintf(stderr, "Messages from H5HL_insert() will go away "
+			    "when assertions are turned off.\n");
+		}
+#endif
+	    }
+	}
+
+#ifndef NDEBUG
+	fprintf(stderr, "H5HL_insert: resize mem buf from %lu to %lu bytes\n",
+		(unsigned long) (heap->mem_alloc),
+		(unsigned long) (heap->mem_alloc + need_more));
+	if (0 == nmessages++) {
+	    fprintf(stderr, "Messages from H5HL_insert() will go away "
+		    "when assertions are turned off.\n");
+	}
+#endif
+	old_size = heap->mem_alloc;
+	heap->mem_alloc += need_more;
+	heap->chunk = H5MM_xrealloc(heap->chunk,
+				    H5HL_SIZEOF_HDR(f) + heap->mem_alloc);
+
+	/* clear new section so junk doesn't appear in the file */
+	HDmemset(heap->chunk + H5HL_SIZEOF_HDR(f) + old_size, 0, need_more);
+    }
+    /*
+     * Copy the data into the heap
+     */
+    HDmemcpy(heap->chunk + H5HL_SIZEOF_HDR(f) + offset, buf, buf_size);
+    FUNC_LEAVE(offset);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5HL_write
+ *
+ * Purpose:	Writes (overwrites) the object (or part of object) stored
+ *		in BUF to the heap at file address ADDR in file F.  The
+ *		writing begins at byte offset OFFSET from the beginning of
+ *		the heap and continues for SIZE bytes.
+ *
+ *		Do not partially write an object to create it;	the first
+ *		write for an object must be for the entire object.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 16 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5HL_write(H5F_t *f, const haddr_t *addr, size_t offset, size_t size,
+	  const void *buf)
+{
+    H5HL_t *heap = NULL;
+
+    FUNC_ENTER(H5HL_write, FAIL);
+
+    /* check arguments */
+    assert(f);
+    assert(addr && H5F_addr_defined(addr));
+    assert(buf);
+    assert (offset==H5HL_ALIGN (offset));
+
+    if (NULL == (heap = H5AC_find(f, H5AC_LHEAP, addr, NULL, NULL))) {
+	HRETURN_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL,
+		      "unable to load heap");
+    }
+    assert(offset < heap->mem_alloc);
+    assert(offset + size <= heap->mem_alloc);
+
+    heap->dirty += 1;
+    HDmemcpy(heap->chunk + H5HL_SIZEOF_HDR(f) + offset, buf, size);
+
+    FUNC_LEAVE(SUCCEED);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5HL_remove
+ *
+ * Purpose:	Removes an object or part of an object from the heap at
+ *		address ADDR of file F.	 The object (or part) to remove
+ *		begins at byte OFFSET from the beginning of the heap and
+ *		continues for SIZE bytes.
+ *
+ *		Once part of an object is removed, one must not attempt
+ *		to access that part.  Removing the beginning of an object
+ *		results in the object OFFSET increasing by the amount
+ *		truncated.  Removing the end of an object results in
+ *		object truncation.  Removing the middle of an object results
+ *		in two separate objects, one at the original offset and
+ *		one at the first offset past the removed portion.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Jul 16 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5HL_remove(H5F_t *f, const haddr_t *addr, size_t offset, size_t size)
+{
+    H5HL_t		*heap = NULL;
+    H5HL_free_t		*fl = heap->freelist, *fl2 = NULL;
+#ifndef NDEBUG
+    static int		nmessages = 0;
+#endif
+
+    FUNC_ENTER(H5HL_remove, FAIL);
+
+    /* check arguments */
+    assert(f);
+    assert(addr && H5F_addr_defined(addr));
+    assert(size > 0);
+    assert (offset==H5HL_ALIGN (offset));
+    size = H5HL_ALIGN (size);
+
+    if (NULL == (heap = H5AC_find(f, H5AC_LHEAP, addr, NULL, NULL))) {
+	HRETURN_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL,
+		      "unable to load heap");
+    }
+    assert(offset < heap->mem_alloc);
+    assert(offset + size <= heap->mem_alloc);
+
+    heap->dirty += 1;
+
+    /*
+     * 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.
+     */
+    while (fl) {
+	if (offset + size == fl->offset) {
+	    fl->offset = offset;
+	    fl->size += size;
+	    assert (fl->offset==H5HL_ALIGN (fl->offset));
+	    assert (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;
+		    assert (fl->offset==H5HL_ALIGN (fl->offset));
+		    assert (fl->size==H5HL_ALIGN (fl->size));
+		    fl2 = H5HL_remove_free(heap, fl2);
+		    HRETURN(SUCCEED);
+		}
+	    }
+	    HRETURN(SUCCEED);
+
+	} else if (fl->offset + fl->size == offset) {
+	    fl->size += size;
+	    fl2 = fl->next;
+	    assert (fl->size==H5HL_ALIGN (fl->size));
+	    while (fl2) {
+		if (fl->offset + fl->size == fl2->offset) {
+		    fl->size += fl2->size;
+		    assert (fl->size==H5HL_ALIGN (fl->size));
+		    fl2 = H5HL_remove_free(heap, fl2);
+		    HRETURN(SUCCEED);
+		}
+	    }
+	    HRETURN(SUCCEED);
+	}
+	fl = fl->next;
+    }
+
+    /*
+     * 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)) {
+#ifndef NDEBUG
+	fprintf(stderr, "H5HL_remove: lost %lu bytes\n", (unsigned long) size);
+	if (0 == nmessages++) {
+	    fprintf(stderr, "Messages from H5HL_remove() will go away "
+		    "when assertions are turned off.\n");
+	}
+#endif
+	HRETURN(SUCCEED);
+    }
+    /*
+     * Add an entry to the free list.
+     */
+    fl = H5MM_xmalloc(sizeof(H5HL_free_t));
+    fl->offset = offset;
+    fl->size = size;
+    assert (fl->offset==H5HL_ALIGN (fl->offset));
+    assert (fl->size==H5HL_ALIGN (fl->size));
+    fl->prev = NULL;
+    fl->next = heap->freelist;
+    if (heap->freelist) heap->freelist->prev = fl;
+    heap->freelist = fl;
+
+    FUNC_LEAVE(SUCCEED);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5HL_debug
+ *
+ * Purpose:	Prints debugging information about a heap.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *		matzke@llnl.gov
+ *		Aug  1 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5HL_debug(H5F_t *f, const haddr_t *addr, FILE * stream, intn indent,
+	  intn fwidth)
+{
+    H5HL_t		*h = NULL;
+    int			i, j, overlap;
+    uint8		c;
+    H5HL_free_t		*freelist = NULL;
+    uint8		*marker = NULL;
+    size_t		amount_free = 0;
+
+    FUNC_ENTER(H5HL_debug, FAIL);
+
+    /* check arguments */
+    assert(f);
+    assert(addr && H5F_addr_defined(addr));
+    assert(stream);
+    assert(indent >= 0);
+    assert(fwidth >= 0);
+
+    if (NULL == (h = H5AC_find(f, H5AC_LHEAP, addr, NULL, NULL))) {
+	HRETURN_ERROR(H5E_HEAP, H5E_CANTLOAD, FAIL,
+		      "unable to load heap");
+    }
+    fprintf(stream, "%*sHeap...\n", indent, "");
+    fprintf(stream, "%*s%-*s %d\n", indent, "", fwidth,
+	    "Dirty:",
+	    (int) (h->dirty));
+    fprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	    "Data bytes allocated on disk:",
+	    (unsigned long) (h->disk_alloc));
+    fprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
+	    "Data bytes allocated in core:",
+	    (unsigned long) (h->mem_alloc));
+
+    /*
+     * Traverse the free list and check that all free blocks fall within
+     * the heap and that no two free blocks point to the same region of
+     * the heap.
+     */
+    marker = H5MM_xcalloc(h->mem_alloc, 1);
+    for (freelist = h->freelist; freelist; freelist = freelist->next) {
+	fprintf(stream, "%*s%-*s %8lu, %8lu\n", indent, "", fwidth,
+		"Free Block (offset,size):",
+		(unsigned long) (freelist->offset),
+		(unsigned long) (freelist->size));
+	if (freelist->offset + freelist->size > h->mem_alloc) {
+	    fprintf(stream, "***THAT FREE BLOCK IS OUT OF BOUNDS!\n");
+	} else {
+	    for (i = overlap = 0; i < freelist->size; i++) {
+		if (marker[freelist->offset + i])
+		    overlap++;
+		marker[freelist->offset + i] = 1;
+	    }
+	    if (overlap) {
+		fprintf(stream, "***THAT FREE BLOCK OVERLAPPED A PREVIOUS "
+			"ONE!\n");
+	    } else {
+		amount_free += freelist->size;
+	    }
+	}
+    }
+
+    if (h->mem_alloc) {
+	fprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
+		"Percent of heap used:",
+		(unsigned long) (100 * (h->mem_alloc - amount_free) /
+				 h->mem_alloc));
+    }
+    /*
+     * Print the data in a VMS-style octal dump.
+     */
+    fprintf(stream, "%*sData follows (`__' indicates free region)...\n",
+	    indent, "");
+    for (i = 0; i < h->disk_alloc; i += 16) {
+	fprintf(stream, "%*s %8d: ", indent, "", i);
+	for (j = 0; j < 16; j++) {
+	    if (i + j < h->disk_alloc) {
+		if (marker[i + j]) {
+		    fprintf(stream, "__ ");
+		} else {
+		    c = h->chunk[H5HL_SIZEOF_HDR(f) + i + j];
+		    fprintf(stream, "%02x ", c);
+		}
+	    } else {
+		fprintf(stream, "   ");
+	    }
+	    if (7 == j)
+		HDfputc(' ', stream);
+	}
+
+	for (j = 0; j < 16; j++) {
+	    if (i + j < h->disk_alloc) {
+		if (marker[i + j]) {
+		    HDfputc(' ', stream);
+		} else {
+		    c = h->chunk[H5HL_SIZEOF_HDR(f) + i + j];
+		    if (c > ' ' && c < '~')
+			HDfputc(c, stream);
+		    else
+			HDfputc('.', stream);
+		}
+	    }
+	}
+
+	HDfputc('\n', stream);
+    }
+
+    H5MM_xfree(marker);
+    FUNC_LEAVE(SUCCEED);
+}