[svn-r12525] Description:

    Refactored free space manager to use metadata cache for serialized free
space sections.  This speeds up the fractal heap test considerably...

Tested:
    FreeBSD 4.11 (sleipnir)
    Linux 2.4/32 (chicago)
    Linux 2.4/64 (mir)
    Mac OS X (amazon)

1 files changed, 1899 insertions, 0 deletions

diff --git a/src/H5FSsection.c b/src/H5FSsection.c
new file mode 100644
index 0000000..5de42d8
--- /dev/null
+++ b/src/H5FSsection.c
@@ -0,0 +1,1899 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by the Board of Trustees of the University of Illinois.         *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This file is part of HDF5.  The full HDF5 copyright notice, including     *
+ * terms governing use, modification, and redistribution, is contained in    *
+ * the files COPYING and Copyright.html.  COPYING can be found at the root   *
+ * of the source code distribution tree; Copyright.html can be found at the  *
+ * root level of an installed copy of the electronic HDF5 document set and   *
+ * is linked from the top-level documents page.  It can also be found at     *
+ * http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html.  If you do not have     *
+ * access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Programmer:	Quincey Koziol <koziol@hdfgroup.org>
+ *              Monday, July 31, 2006
+ *
+ * Purpose:	Free space tracking functions.
+ *
+ */
+
+/****************/
+/* Module Setup */
+/****************/
+
+#define H5FS_PACKAGE		/*suppress error about including H5FSpkg  */
+
+/***********/
+/* Headers */
+/***********/
+#include "H5private.h"		/* Generic Functions			*/
+#include "H5Eprivate.h"		/* Error handling		  	*/
+#include "H5FSpkg.h"		/* File free space			*/
+#include "H5MFprivate.h"	/* File memory management		*/
+#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+
+/****************/
+/* Local Macros */
+/****************/
+
+/* Default starting size of section buffer */
+#define H5FS_SINFO_SIZE_DEFAULT  64
+
+/* Max. height of the skip list holding free list nodes */
+#define H5FS_DEFAULT_SKIPLIST_HEIGHT     16
+
+
+/******************/
+/* Local Typedefs */
+/******************/
+
+/* User data for skip list iterator callback for iterating over section size nodes */
+typedef struct {
+    H5FS_t *fspace;             /* Free space manager info */
+    H5FS_operator_t op;         /* Operator for the iteration */
+    void *op_data;              /* Information to pass to the operator */
+} H5FS_iter_ud_t;
+
+
+/********************/
+/* Package Typedefs */
+/********************/
+
+
+/********************/
+/* Local Prototypes */
+/********************/
+static herr_t H5FS_sect_increase(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    const H5FS_section_class_t *cls);
+static herr_t H5FS_sect_decrease(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    const H5FS_section_class_t *cls);
+static herr_t H5FS_size_node_decr(H5FS_sinfo_t *sinfo, unsigned bin, H5FS_node_t *fspace_node,
+    const H5FS_section_class_t *cls);
+static herr_t H5FS_sect_unlink_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls,
+    H5FS_section_info_t *sect);
+static herr_t H5FS_sect_unlink_rest(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    const H5FS_section_class_t *cls, H5FS_section_info_t *sect);
+static herr_t H5FS_sect_link_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls,
+    H5FS_section_info_t *sect);
+static herr_t H5FS_sect_link_rest(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    const H5FS_section_class_t *cls, H5FS_section_info_t *sect);
+static herr_t H5FS_sect_link(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    H5FS_section_info_t *sect);
+static herr_t H5FS_sect_merge(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    H5FS_section_info_t **sect, void *op_data);
+static htri_t H5FS_sect_find_node(H5FS_t *fspace, hsize_t request, H5FS_section_info_t **node);
+static herr_t H5FS_sect_serialize_size(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace);
+
+
+/*********************/
+/* Package Variables */
+/*********************/
+
+/* Declare a free list to manage the H5FS_node_t struct */
+H5FL_DEFINE(H5FS_node_t);
+
+/* Declare a free list to manage the H5FS_bin_t sequence information */
+H5FL_SEQ_DEFINE(H5FS_bin_t);
+
+/* Declare a free list to manage the H5FS_sinfo_t struct */
+H5FL_DEFINE(H5FS_sinfo_t);
+
+
+/*****************************/
+/* Library Private Variables */
+/*****************************/
+
+
+/*******************/
+/* Local Variables */
+/*******************/
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sinfo_new
+ *
+ * Purpose:	Create new section info structure
+ *
+ * Return:	Success:	non-NULL, pointer to new section info struct
+ *		Failure:	NULL
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, July 31, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+H5FS_sinfo_t *
+H5FS_sinfo_new(H5F_t *f, H5FS_t *fspace)
+{
+    H5FS_sinfo_t *sinfo = NULL; /* Section information struct created */
+    H5FS_sinfo_t *ret_value;    /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sinfo_new)
+
+    /* Check arguments. */
+    HDassert(f);
+    HDassert(fspace);
+
+    /* Allocate the free space header */
+    if(NULL == (sinfo = H5FL_CALLOC(H5FS_sinfo_t)))
+	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+
+    /* Set non-zero values */
+    sinfo->nbins = H5V_log2_gen(fspace->max_sect_size);
+    sinfo->sect_prefix_size = H5FS_SINFO_PREFIX_SIZE(f);
+    sinfo->sect_off_size = (fspace->max_sect_addr + 7) / 8;
+    sinfo->sect_len_size = (H5V_log2_gen(fspace->max_sect_size) + 7) / 8;
+    sinfo->fspace = fspace;
+#ifdef QAK
+HDfprintf(stderr, "%s: sinfo->nbins = %u\n", FUNC, sinfo->nbins);
+HDfprintf(stderr, "%s: sinfo->sect_off_size = %u, sinfo->sect_len_size = %u\n", FUNC, sinfo->sect_off_size, sinfo->sect_len_size);
+#endif /* QAK */
+
+    /* Allocate space for the section size bins */
+    if(NULL == (sinfo->bins = H5FL_SEQ_CALLOC(H5FS_bin_t, sinfo->nbins)))
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for free space section bin array")
+
+    /* Set return value */
+    ret_value = sinfo;
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sinfo_new() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sinfo_pin
+ *
+ * Purpose:	Pin the section info for the free space manager in memory
+ *              Either loads section info from disk, or creates new section info
+ *
+ * Return:	Success:	non-NULL, pointer to section info struct
+ *		Failure:	NULL
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, July 31, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static H5FS_sinfo_t *
+H5FS_sinfo_pin(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace)
+{
+    H5FS_sinfo_t *sinfo;        /* Section information struct created */
+    H5FS_sinfo_t *ret_value;    /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sinfo_pin)
+
+    /* Check arguments. */
+    HDassert(f);
+    HDassert(fspace);
+
+    /* Create new section info, if it doesn't exist yet */
+    if(!H5F_addr_defined(fspace->sect_addr)) {
+        /* Sanity check */
+        HDassert(fspace->tot_sect_count == 0);
+        HDassert(fspace->serial_sect_count == 0);
+        HDassert(fspace->ghost_sect_count == 0);
+
+        /* Allocate and initialize free space section info */
+        if(NULL == (sinfo = H5FS_sinfo_new(f, fspace)))
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTCREATE, NULL, "can't create section info")
+
+        /* Allocate space for the section info */
+        fspace->sect_size = H5FS_SINFO_SIZE_DEFAULT;
+        fspace->alloc_sect_size = (size_t)fspace->sect_size;
+        if(HADDR_UNDEF == (fspace->sect_addr = H5MF_alloc(f, H5FD_MEM_FSPACE_SINFO, dxpl_id, fspace->alloc_sect_size)))
+            HGOTO_ERROR(H5E_STORAGE, H5E_NOSPACE, NULL, "file allocation failed for free space sections")
+
+        /* Cache the new free space section info */
+        if(H5AC_set(f, dxpl_id, H5AC_FSPACE_SINFO, fspace->sect_addr, sinfo, H5AC__NO_FLAGS_SET) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTINIT, NULL, "can't add free space sections to cache")
+        sinfo = NULL;
+
+        /* Mark free space header as dirty */
+        if(H5AC_mark_pinned_or_protected_entry_dirty(f, fspace) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, NULL, "unable to mark free space header as dirty")
+    } /* end if */
+
+    /* Protect the free space sections */
+    if(NULL == (sinfo = H5AC_protect(f, dxpl_id, H5AC_FSPACE_SINFO, fspace->sect_addr, NULL, fspace, H5AC_WRITE)))
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTPROTECT, NULL, "unable to load free space sections")
+
+    /* Pin them in the cache */
+    if(H5AC_pin_protected_entry(f, sinfo) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTPIN, NULL, "unable to pin free space sections")
+
+    /* Unlock free space sections, now pinned */
+    if(H5AC_unprotect(f, dxpl_id, H5AC_FSPACE_SINFO, fspace->sect_addr, sinfo, H5AC__NO_FLAGS_SET) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTUNPROTECT, NULL, "unable to release free space sections")
+
+    /* Update pointer to free space header for section info */
+    sinfo->fspace = fspace;
+
+    /* Set return value */
+    ret_value = sinfo;
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sinfo_pin() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_increase
+ *
+ * Purpose:	Increase the size of the serialized free space section info
+ *              on disk
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, May  8, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_sect_increase(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    const H5FS_section_class_t *cls)
+{
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_increase)
+
+    /* Check arguments. */
+    HDassert(fspace);
+    HDassert(fspace->sinfo);
+    HDassert(cls);
+
+    /* Increment total # of sections on free space list */
+    fspace->tot_sect_count++;
+
+    /* Check for serializable or 'ghost' section */
+    if(cls->flags & H5FS_CLS_GHOST_OBJ) {
+        /* Sanity check */
+        HDassert(cls->serial_size == 0);
+
+        /* Increment # of ghost sections */
+        fspace->ghost_sect_count++;
+    } /* end if */
+    else {
+        /* Increment # of serializable sections */
+        fspace->serial_sect_count++;
+
+        /* Increment amount of space required to serialize all sections */
+#ifdef QAK
+HDfprintf(stderr, "%s: sinfo->serial_size = %Zu\n", FUNC, sinfo->serial_size);
+HDfprintf(stderr, "%s: cls->serial_size = %Zu\n", FUNC, cls->serial_size);
+#endif /* QAK */
+        fspace->sinfo->serial_size += cls->serial_size;
+
+        /* Update the free space sections' serialized size */
+        if(H5FS_sect_serialize_size(f, dxpl_id, fspace) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTCOMPUTE, FAIL, "can't adjust free space section size on disk")
+    } /* end else */
+
+    /* Mark free space header as dirty */
+    if(H5AC_mark_pinned_or_protected_entry_dirty(f, fspace) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space header as dirty")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_increase() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_decrease
+ *
+ * Purpose:	Decrease the size of the serialized free space section info
+ *              on disk
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, May  8, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_sect_decrease(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace, const H5FS_section_class_t *cls)
+{
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_decrease)
+
+    /* Check arguments. */
+    HDassert(fspace);
+    HDassert(fspace->sinfo);
+    HDassert(cls);
+
+    /* Decrement total # of sections in free space manager */
+    fspace->tot_sect_count--;
+
+    /* Check for serializable or 'ghost' section */
+    if(cls->flags & H5FS_CLS_GHOST_OBJ) {
+        /* Sanity check */
+        HDassert(cls->serial_size == 0);
+
+        /* Decrement # of ghost sections */
+        fspace->ghost_sect_count--;
+    } /* end if */
+    else {
+        /* Decrement # of serializable sections */
+        fspace->serial_sect_count--;
+
+        /* Decrement amount of space required to serialize all sections */
+#ifdef QAK
+HDfprintf(stderr, "%s: fspace->serial_size = %Zu\n", FUNC, fspace->serial_size);
+HDfprintf(stderr, "%s: cls->serial_size = %Zu\n", FUNC, cls->serial_size);
+#endif /* QAK */
+        fspace->sinfo->serial_size -= cls->serial_size;
+
+        /* Update the free space sections' serialized size */
+        if(H5FS_sect_serialize_size(f, dxpl_id, fspace) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTCOMPUTE, FAIL, "can't adjust free space section size on disk")
+    } /* end else */
+
+    /* Mark free space header as dirty */
+    if(H5AC_mark_pinned_or_protected_entry_dirty(f, fspace) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space header as dirty")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_decrease() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_size_node_decr
+ *
+ * Purpose:	Decrement the number of sections of a particular size
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Wednesday, May 17, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_size_node_decr(H5FS_sinfo_t *sinfo, unsigned bin, H5FS_node_t *fspace_node,
+    const H5FS_section_class_t *cls)
+{
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_size_node_decr)
+
+    /* Check arguments. */
+    HDassert(sinfo);
+    HDassert(fspace_node);
+    HDassert(cls);
+
+    /* Decrement the # of sections in this bin */
+    /* (Different from the # of items in the bin's skiplist, since each node on
+     *  the bin's skiplist is also a skiplist...)
+     */
+    sinfo->bins[bin].tot_sect_count--;
+#ifdef QAK
+HDfprintf(stderr, "%s: sinfo->bins[%u].sect_count = %Zu\n", FUNC, bin, sinfo->bins[bin].sect_count);
+#endif /* QAK */
+
+    /* Check for 'ghost' or 'serializable' section */
+    if(cls->flags & H5FS_CLS_GHOST_OBJ) {
+        /* Decrement node's ghost section count */
+        fspace_node->ghost_count--;
+
+        /* Decrement bin's ghost section count */
+        sinfo->bins[bin].ghost_sect_count--;
+
+        /* If the node has no more ghost sections, decrement number of ghost section sizes managed */
+        if(fspace_node->ghost_count == 0)
+            sinfo->ghost_size_count--;
+    } /* end if */
+    else {
+        /* Decrement node's serializable section count */
+        fspace_node->serial_count--;
+
+        /* Decrement bin's serializable section count */
+        sinfo->bins[bin].serial_sect_count--;
+
+        /* If the node has no more serializable sections, decrement number of serializable section sizes managed */
+        if(fspace_node->serial_count == 0)
+            sinfo->serial_size_count--;
+    } /* end else */
+
+    /* Check for no more nodes on list of that size */
+    if(H5SL_count(fspace_node->sect_list) == 0) {
+        H5FS_node_t *tmp_fspace_node;       /* Free space list size node */
+
+        /* Sanity checks */
+        HDassert(fspace_node->ghost_count == 0);
+        HDassert(fspace_node->serial_count == 0);
+
+        /* Remove size tracking list from bin */
+        tmp_fspace_node = H5SL_remove(sinfo->bins[bin].bin_list, &fspace_node->sect_size);
+        if(tmp_fspace_node == NULL || tmp_fspace_node != fspace_node)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTREMOVE, FAIL, "can't remove free space node from skip list")
+
+        /* Destroy skip list for size tracking node */
+        if(H5SL_close(fspace_node->sect_list) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTCLOSEOBJ, FAIL, "can't destroy size tracking node's skip list")
+
+        /* Release free space list node */
+        H5FL_FREE(H5FS_node_t, fspace_node);
+
+        /* Decrement total number of section sizes managed */
+        sinfo->tot_size_count--;
+    } /* end if */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_size_node_decr() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_unlink_size
+ *
+ * Purpose:	Remove a section node from size tracking data structures for
+ *              a free space manager
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Wednesday, May 17, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_sect_unlink_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls,
+    H5FS_section_info_t *sect)
+{
+    H5FS_node_t *fspace_node;       /* Free list size node */
+    H5FS_section_info_t *tmp_sect_node; /* Temporary section node */
+    unsigned bin;                   /* Bin to put the free space section in */
+    herr_t ret_value = SUCCEED;     /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_unlink_size)
+
+    /* Check arguments. */
+    HDassert(sinfo);
+    HDassert(sinfo->bins);
+    HDassert(sect);
+    HDassert(cls);
+
+    /* Determine correct bin which holds items of at least the section's size */
+    bin = H5V_log2_gen(sect->size);
+    HDassert(bin < sinfo->nbins);
+    if(sinfo->bins[bin].bin_list == NULL)
+        HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "node's bin is empty?")
+
+    /* Find space node for section's size */
+    if((fspace_node = H5SL_search(sinfo->bins[bin].bin_list, &sect->size)) == NULL)
+        HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "can't find section size node")
+
+    /* Remove the section's node from the list */
+    tmp_sect_node = H5SL_remove(fspace_node->sect_list, &sect->addr);
+    if(tmp_sect_node == NULL || tmp_sect_node != sect)
+        HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "can't find section node on size list")
+
+    /* Decrement # of sections in section size node */
+    if(H5FS_size_node_decr(sinfo, bin, fspace_node, cls) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTREMOVE, FAIL, "can't remove free space size node from skip list")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_unlink_size() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_unlink_rest
+ *
+ * Purpose:	Finish unlinking a section from the rest of the free space
+ *              manager's data structures, after the section has been removed
+ *              from the size tracking data structures
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Wednesday, May 17, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_sect_unlink_rest(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    const H5FS_section_class_t *cls, H5FS_section_info_t *sect)
+{
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_unlink_rest)
+
+    /* Check arguments. */
+    HDassert(f);
+    HDassert(fspace);
+    HDassert(fspace->sinfo);
+    HDassert(cls);
+    HDassert(sect);
+
+    /* Remove node from merge list, if it was entered there */
+    if(!(cls->flags & H5FS_CLS_SEPAR_OBJ)) {
+        H5FS_section_info_t *tmp_sect_node; /* Temporary section node */
+
+#ifdef QAK
+HDfprintf(stderr, "%s: removing object from merge list, sect->type = %u\n", FUNC, (unsigned)sect->type);
+#endif /* QAK */
+        tmp_sect_node = H5SL_remove(fspace->sinfo->merge_list, &sect->addr);
+        if(tmp_sect_node == NULL || tmp_sect_node != sect)
+            HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "can't find section node on size list")
+    } /* end if */
+
+    /* Update section info & check if we need less room for the serialized free space sections */
+    if(H5FS_sect_decrease(f, dxpl_id, fspace, cls) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't increase free space section size on disk")
+
+    /* Decrement amount of free space managed */
+#ifdef QAK
+HDfprintf(stderr, "%s: fspace->tot_space = %Hu\n", FUNC, fspace->tot_space);
+#endif /* QAK */
+    fspace->tot_space -= sect->size;
+
+    /* Mark free space sections as changed */
+    if(H5AC_mark_pinned_or_protected_entry_dirty(f, fspace->sinfo) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space sections as dirty")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_unlink_rest() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_remove
+ *
+ * Purpose:	Remove a section from the free space manager
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Wednesday, May 17, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5FS_sect_remove(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    H5FS_section_info_t *sect)
+{
+    const H5FS_section_class_t *cls;    /* Class of section */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_remove)
+
+    /* Check arguments. */
+    HDassert(f);
+    HDassert(fspace);
+    HDassert(fspace->sinfo);
+    HDassert(sect);
+
+    /* Get section's class */
+    cls = &fspace->sect_cls[sect->type];
+
+    /* Remove node from size tracked data structures */
+    if(H5FS_sect_unlink_size(fspace->sinfo, cls, sect) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL, "can't remove section from size tracking data structures")
+
+    /* Update rest of free space manager data structures for node removal */
+    if(H5FS_sect_unlink_rest(f, dxpl_id, fspace, cls, sect) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL, "can't remove section from non-size tracking data structures")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_remove() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_link_size
+ *
+ * Purpose:	Add a section of free space to the free list bins
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, March 20, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_sect_link_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls,
+    H5FS_section_info_t *sect)
+{
+    H5FS_node_t *fspace_node = NULL;     /* Pointer to free space node of the correct size */
+    unsigned bin;                       /* Bin to put the free space section in */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_link_size)
+#ifdef QAK
+HDfprintf(stderr, "%s: sect->size = %Hu, sect->addr = %a\n", FUNC, sect->size, sect->addr);
+#endif /* QAK */
+
+    /* Check arguments. */
+    HDassert(sinfo);
+    HDassert(sect);
+    HDassert(H5F_addr_defined(sect->addr));
+    HDassert(sect->size);
+
+    /* Determine correct bin which holds items of the section's size */
+    bin = H5V_log2_gen(sect->size);
+    HDassert(bin < sinfo->nbins);
+    if(sinfo->bins[bin].bin_list == NULL) {
+        if(NULL == (sinfo->bins[bin].bin_list = H5SL_create(H5SL_TYPE_HSIZE, 0.5, H5FS_DEFAULT_SKIPLIST_HEIGHT)))
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTCREATE, FAIL, "can't create skip list for free space nodes")
+    } /* end if */
+    else {
+        /* Check for node list of the correct size already */
+        fspace_node = H5SL_search(sinfo->bins[bin].bin_list, &sect->size);
+    } /* end else */
+
+    /* Check if we need to create a new skip list for nodes of this size */
+    if(fspace_node == NULL) {
+        /* Allocate new free list size node */
+        if(NULL == (fspace_node = H5FL_MALLOC(H5FS_node_t)))
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for free space node")
+
+        /* Initialize the free list size node */
+        fspace_node->sect_size = sect->size;
+        fspace_node->serial_count = fspace_node->ghost_count = 0;
+        if(NULL == (fspace_node->sect_list = H5SL_create(H5SL_TYPE_HADDR, 0.5, H5FS_DEFAULT_SKIPLIST_HEIGHT)))
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTCREATE, FAIL, "can't create skip list for free space nodes")
+
+        /* Insert new free space size node into bin's list */
+        if(H5SL_insert(sinfo->bins[bin].bin_list, fspace_node, &fspace_node->sect_size) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space node into skip list")
+
+        /* Increment number of section sizes */
+        sinfo->tot_size_count++;
+    } /* end if */
+
+    /* Increment # of section in bin */
+    /* (Different from the # of items in the bin's skiplist, since each node on
+     *  the bin's skiplist is also a skiplist...)
+     */
+#ifdef QAK
+HDfprintf(stderr, "%s: sinfo->bins[%u].sect_count = %Zu\n", FUNC, bin, sinfo->bins[bin].sect_count);
+#endif /* QAK */
+    sinfo->bins[bin].tot_sect_count++;
+    if(cls->flags & H5FS_CLS_GHOST_OBJ) {
+        sinfo->bins[bin].ghost_sect_count++;
+        fspace_node->ghost_count++;
+
+        /* Check for first ghost section in node */
+        if(fspace_node->ghost_count == 1)
+            sinfo->ghost_size_count++;
+    } /* end if */
+    else {
+        sinfo->bins[bin].serial_sect_count++;
+        fspace_node->serial_count++;
+
+        /* Check for first serializable section in node */
+        if(fspace_node->serial_count == 1)
+            sinfo->serial_size_count++;
+    } /* end else */
+
+    /* Insert free space node into correct skip list */
+    if(H5SL_insert(fspace_node->sect_list, sect, &sect->addr) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space node into skip list")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_link_size() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_link_rest
+ *
+ * Purpose:	Link a section into the rest of the non-size tracking
+ *              free space manager data structures
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Wednesday, May 17, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_sect_link_rest(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace, const H5FS_section_class_t *cls,
+    H5FS_section_info_t *sect)
+{
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_link_rest)
+
+    /* Check arguments. */
+    HDassert(f);
+    HDassert(fspace);
+    HDassert(fspace->sinfo);
+    HDassert(sect);
+
+    /* Add section to the address-ordered list of sections, if allowed */
+    if(!(cls->flags & H5FS_CLS_SEPAR_OBJ)) {
+#ifdef QAK
+HDfprintf(stderr, "%s: inserting object into merge list, sect->type = %u\n", FUNC, (unsigned)sect->type);
+#endif /* QAK */
+        if(fspace->sinfo->merge_list == NULL)
+            if(NULL == (fspace->sinfo->merge_list = H5SL_create(H5SL_TYPE_HADDR, 0.5, H5FS_DEFAULT_SKIPLIST_HEIGHT)))
+                HGOTO_ERROR(H5E_FSPACE, H5E_CANTCREATE, FAIL, "can't create skip list for merging free space sections")
+        if(H5SL_insert(fspace->sinfo->merge_list, sect, &sect->addr) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space node into merging skip list")
+    } /* end if */
+
+    /* Update section info & check if we need more room for the serialized free space sections */
+    if(H5FS_sect_increase(f, dxpl_id, fspace, cls) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't increase free space section size on disk")
+
+    /* Increment amount of free space managed */
+    fspace->tot_space += sect->size;
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_link_rest() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_link
+ *
+ * Purpose:	Link a section into the internal data structures
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Wednesday, May 17, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_sect_link(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    H5FS_section_info_t *sect)
+{
+    const H5FS_section_class_t *cls;    /* Class of section */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_link)
+
+    /* Check arguments. */
+    HDassert(f);
+    HDassert(fspace);
+    HDassert(fspace->sinfo);
+    HDassert(sect);
+
+    /* Get section's class */
+    cls = &fspace->sect_cls[sect->type];
+
+    /* Add section to size tracked data structures */
+#ifdef QAK
+HDfprintf(stderr, "%s: Check 1.0 - fspace->tot_space = %Hu\n", FUNC, fspace->tot_space);
+#endif /* QAK */
+    if(H5FS_sect_link_size(fspace->sinfo, cls, sect) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't add section to size tracking data structures")
+
+#ifdef QAK
+HDfprintf(stderr, "%s: Check 2.0 - fspace->tot_space = %Hu\n", FUNC, fspace->tot_space);
+#endif /* QAK */
+    /* Update rest of free space manager data structures for section addition */
+    if(H5FS_sect_link_rest(f, dxpl_id, fspace, cls, sect) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't add section to non-size tracking data structures")
+#ifdef QAK
+HDfprintf(stderr, "%s: Check 3.0 - fspace->tot_space = %Hu\n", FUNC, fspace->tot_space);
+#endif /* QAK */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_link() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_merge
+ *
+ * Purpose:	Attempt to merge a returned free space section with existing
+ *              free space.
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Wednesday, May 17, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_sect_merge(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    H5FS_section_info_t **sect, void *op_data)
+{
+    H5FS_section_class_t *sect_cls;     /* Section's class */
+    H5FS_section_info_t *tmp_sect_node; /* Temporary free space section */
+    hbool_t modified;                   /* Flag to indicate merge or shrink occurred */
+    htri_t status;                      /* Status value */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_merge)
+
+    /* Check arguments. */
+    HDassert(fspace);
+    HDassert(*sect);
+    HDassert(H5F_addr_defined((*sect)->addr));
+    HDassert((*sect)->size);
+
+    /* Loop until no more merging */
+    if(fspace->sinfo->merge_list) {
+        do {
+            H5FS_section_class_t *tmp_sect_cls;     /* Temporary section's class */
+
+            /* Reset 'modification occurred' flag */
+            modified = FALSE;
+
+            /* Look for neighboring section before new section */
+            tmp_sect_node = H5SL_less(fspace->sinfo->merge_list, &(*sect)->addr);
+
+            /* Check for node before new node able to merge with new node */
+            if(tmp_sect_node) {
+                /* Get classes for right & left sections */
+                tmp_sect_cls = &fspace->sect_cls[tmp_sect_node->type];
+                sect_cls = &fspace->sect_cls[(*sect)->type];
+
+                /* Check if sections of the left most class can merge with sections
+                 *  of another class & whether the sections are the same type,
+                 *  then check for 'can merge' callback
+                 */
+                if((!(tmp_sect_cls->flags & H5FS_CLS_MERGE_SYM) || (tmp_sect_node->type == (*sect)->type))
+                        && tmp_sect_cls->can_merge) {
+                    /* Determine if the sections can merge */
+                    if((status = (*tmp_sect_cls->can_merge)(tmp_sect_node, *sect, op_data)) < 0)
+                        HGOTO_ERROR(H5E_FSPACE, H5E_CANTMERGE, FAIL, "can't check for merging sections")
+                    if(status > 0) {
+                        /* Sanity check */
+                        HDassert(tmp_sect_cls->merge);
+
+                        /* Remove 'less than' node from data structures */
+                        if(H5FS_sect_remove(f, dxpl_id, fspace, tmp_sect_node) < 0)
+                            HGOTO_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't remove section from internal data structures")
+
+                        /* Merge the two sections together */
+                        if((*tmp_sect_cls->merge)(tmp_sect_node, *sect, op_data) < 0)
+                            HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't merge two sections")
+
+                        /* Retarget section pointer to 'less than' node that was merged into */
+                        *sect = tmp_sect_node;
+
+                        /* Indicate successful merge occurred */
+                        modified = TRUE;
+                    } /* end if */
+                } /* end if */
+            } /* end if */
+
+            /* Look for section after new (or merged) section */
+            tmp_sect_node = H5SL_greater(fspace->sinfo->merge_list, &(*sect)->addr);
+
+            /* Check for node after new node able to merge with new node */
+            if(tmp_sect_node) {
+                /* Get classes for right & left sections */
+                sect_cls = &fspace->sect_cls[(*sect)->type];
+                tmp_sect_cls = &fspace->sect_cls[tmp_sect_node->type];
+
+                /* Check if sections of the left most class can merge with sections
+                 *  of another class & whether the sections are the same type,
+                 *  then check for 'can merge' callback
+                 */
+                if((!(sect_cls->flags & H5FS_CLS_MERGE_SYM) || ((*sect)->type == tmp_sect_node->type))
+                        && sect_cls->can_merge) {
+
+                    /* Determine if the sections can merge */
+                    if((status = (*sect_cls->can_merge)(*sect, tmp_sect_node, op_data)) < 0)
+                        HGOTO_ERROR(H5E_FSPACE, H5E_CANTMERGE, FAIL, "can't check for merging sections")
+                    if(status > 0) {
+                        /* Sanity check */
+                        HDassert(sect_cls->merge);
+
+                        /* Remove 'greater than' node from data structures */
+                        if(H5FS_sect_remove(f, dxpl_id, fspace, tmp_sect_node) < 0)
+                            HGOTO_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't remove section from internal data structures")
+
+                        /* Merge the two sections together */
+                        if((*sect_cls->merge)(*sect, tmp_sect_node, op_data) < 0)
+                            HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't merge two sections")
+
+                        /* Indicate successful merge occurred */
+                        modified = TRUE;
+                    } /* end if */
+                } /* end if */
+            } /* end if */
+        } while(modified);
+    } /* end if */
+    HDassert(*sect);
+#ifdef QAK
+HDfprintf(stderr, "%s: Done merging, (*sect) = {%a, %Hu, %u, %s}\n", FUNC, (*sect)->addr, (*sect)->size, (*sect)->type, ((*sect)->state == H5FS_SECT_LIVE ? "H5FS_SECT_LIVE" : "H5FS_SECT_SERIALIZED"));
+#endif /* QAK */
+
+    /* Loop until no more shrinking */
+    do {
+        /* Reset 'modification occurred' flag */
+        modified = FALSE;
+
+        /* Check for (possibly merged) section able to shrink the size of the container */
+        sect_cls = &fspace->sect_cls[(*sect)->type];
+        if(sect_cls->can_shrink) {
+            if((status = (*sect_cls->can_shrink)(*sect, op_data)) < 0)
+                HGOTO_ERROR(H5E_FSPACE, H5E_CANTSHRINK, FAIL, "can't check for shrinking container")
+            if(status > 0) {
+#ifdef QAK
+HDfprintf(stderr, "%s: Can shrink!\n", FUNC);
+#endif /* QAK */
+                /* Look for neighboring section before new section */
+                if(fspace->sinfo->merge_list) {
+                    tmp_sect_node = H5SL_less(fspace->sinfo->merge_list, &(*sect)->addr);
+
+                    /* Make certain there isn't a section after the new section */
+                    HDassert(H5SL_greater(fspace->sinfo->merge_list, &(*sect)->addr) == NULL);
+                } /* end if */
+                else
+                    tmp_sect_node = NULL;
+
+                /* Shrink the container */
+                /* (callback can indicate that it has discarded the section by setting *sect to NULL) */
+                HDassert(sect_cls->shrink);
+                if((*sect_cls->shrink)(sect, op_data) < 0)
+                    HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't shrink free space container")
+
+                /* Check if the new section was removed */
+                if(*sect == NULL && tmp_sect_node) {
+                    /* Remove 'less than' node from data structures */
+                    if(H5FS_sect_remove(f, dxpl_id, fspace, tmp_sect_node) < 0)
+                        HGOTO_ERROR(H5E_FSPACE, H5E_CANTRELEASE, FAIL, "can't remove section from internal data structures")
+
+                    *sect = tmp_sect_node;
+                } /* end if */
+
+                /* Indicate successful merge occurred */
+                modified = TRUE;
+            } /* end if */
+        } /* end if */
+    } while(modified && *sect);
+#ifdef QAK
+HDfprintf(stderr, "%s: Done shrinking\n", FUNC);
+if(*sect)
+    HDfprintf(stderr, "%s: (*sect) = {%a, %Hu, %u, %s}\n", FUNC, (*sect)->addr, (*sect)->size, (*sect)->type, ((*sect)->state == H5FS_SECT_LIVE ? "H5FS_SECT_LIVE" : "H5FS_SECT_SERIALIZED"));
+else
+    HDfprintf(stderr, "%s: *sect = %p\n", FUNC, *sect);
+#endif /* QAK */
+
+done:
+#ifdef QAK
+HDfprintf(stderr, "%s: Leaving, ret_value = %d\n", FUNC, ret_value);
+#endif /* QAK */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_merge() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_add
+ *
+ * Purpose:	Add a section of free space to the free list
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Tuesday, March  7, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5FS_sect_add(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace, H5FS_section_info_t *sect,
+    unsigned flags, void *op_data)
+{
+    H5FS_section_class_t *cls;          /* Section's class */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI(H5FS_sect_add, FAIL)
+
+#ifdef QAK
+HDfprintf(stderr, "%s: *sect = {%a, %Hu, %u, %s}\n", FUNC, sect->addr, sect->size, sect->type, (sect->state == H5FS_SECT_LIVE ? "H5FS_SECT_LIVE" : "H5FS_SECT_SERIALIZED"));
+#endif /* QAK */
+
+    /* Check arguments. */
+    HDassert(fspace);
+    HDassert(sect);
+    HDassert(H5F_addr_defined(sect->addr));
+    HDassert(sect->size);
+
+    /* Check if we need to go get the sections */
+    if(fspace->sinfo == NULL) {
+        if(NULL == (fspace->sinfo = H5FS_sinfo_pin(f, dxpl_id, fspace)))
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTDECODE, FAIL, "can't pin sections")
+    } /* end if */
+
+    /* Call "add" section class callback, if there is one */
+    cls = &fspace->sect_cls[sect->type];
+    if(cls->add) {
+        if((*cls->add)(sect, &flags, op_data) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "'add' section class callback failed")
+    } /* end if */
+
+    /* Check for merging returned space with existing section node */
+    if(flags & H5FS_ADD_RETURNED_SPACE) {
+#ifdef QAK
+HDfprintf(stderr, "%s: Returning space\n", FUNC);
+#endif /* QAK */
+
+        /* Attempt to merge returned section with existing sections */
+        if(H5FS_sect_merge(f, dxpl_id, fspace, &sect, op_data) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTMERGE, FAIL, "can't merge sections")
+    } /* end if */
+
+    /* Add new (possibly merged) node to free sections data structures */
+    /* (If section has been completely merged or shrunk away, 'sect' will
+     *  be NULL at this point - QAK)
+     */
+    if(sect)
+        if(H5FS_sect_link(f, dxpl_id, fspace, sect) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space section into skip list")
+
+#ifdef QAK
+HDfprintf(stderr, "%s: fspace->hdr->tot_space = %Hu\n", FUNC, fspace->hdr->tot_space);
+#endif /* QAK */
+    /* Mark free space sections as changed */
+    /* (if adding sections while deserializing sections, don't set the flag) */
+    if(!(flags & H5FS_ADD_DESERIALIZING)) {
+        if(H5AC_mark_pinned_or_protected_entry_dirty(f, fspace->sinfo) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space sections as dirty")
+    } /* end if */
+
+done:
+#ifdef H5FS_DEBUG
+if(!(flags & (H5FS_ADD_DESERIALIZING | H5FS_ADD_SKIP_VALID)))
+    H5FS_assert(fspace);
+#endif /* H5FS_DEBUG */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_add() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_find_node
+ *
+ * Purpose:	Locate a section of free space (in existing free space list
+ *              bins) that is large enough to fulfill request.
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, March 20, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static htri_t
+H5FS_sect_find_node(H5FS_t *fspace, hsize_t request, H5FS_section_info_t **node)
+{
+    H5FS_node_t *fspace_node;        /* Free list size node */
+    unsigned bin;                   /* Bin to put the free space section in */
+    htri_t ret_value = FALSE;       /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_find_node)
+
+    /* Check arguments. */
+    HDassert(fspace);
+    HDassert(fspace->sinfo);
+    HDassert(fspace->sinfo->bins);
+    HDassert(request > 0);
+    HDassert(node);
+
+    /* Determine correct bin which holds items of at least the section's size */
+    bin = H5V_log2_gen(request);
+    HDassert(bin < fspace->sinfo->nbins);
+    while(bin < fspace->sinfo->nbins && fspace->sinfo->bins[bin].bin_list == NULL)
+        bin++;
+
+    /* Find the first free space section that is large enough to fulfill request */
+    /* (Since the bins use skip lists to track the sizes of the address-ordered
+     *  lists, this is actually a "best fit" algorithm)
+     */
+#ifdef QAK
+HDfprintf(stderr, "%s: fspace->sinfo->nbins = %u\n", FUNC, fspace->sinfo->nbins);
+HDfprintf(stderr, "%s: bin = %u\n", FUNC, bin);
+#endif /* QAK */
+    if(bin < fspace->sinfo->nbins)
+        do {
+            /* Look for large enough free space section in this bin */
+            if(fspace->sinfo->bins[bin].bin_list)
+                /* Check for large enough list of sections on list */
+                if((fspace_node = H5SL_greater(fspace->sinfo->bins[bin].bin_list, &request))) {
+                    const H5FS_section_class_t *cls;    /* Class of section */
+
+                    /* Take first node off of the list (ie. node w/lowest address) */
+                    if(NULL == (*node = H5SL_remove_first(fspace_node->sect_list)))
+                        HGOTO_ERROR(H5E_FSPACE, H5E_CANTREMOVE, FAIL, "can't remove free space node from skip list")
+
+                    /* Get section's class */
+                    cls = &fspace->sect_cls[(*node)->type];
+
+                    /* Decrement # of sections in section size node */
+                    if(H5FS_size_node_decr(fspace->sinfo, bin, fspace_node, cls) < 0)
+                        HGOTO_ERROR(H5E_FSPACE, H5E_CANTREMOVE, FAIL, "can't remove free space size node from skip list")
+
+                    /* Indicate that we found a node for the request */
+                    HGOTO_DONE(TRUE)
+                } /* end if */
+
+            /* Advance to next larger bin */
+            bin++;
+        } while(bin < fspace->sinfo->nbins);
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_find_node() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_find
+ *
+ * Purpose:	Locate a section of free space (in existing free space list) that
+ *              is large enough to fulfill request.
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Tuesday, March  7, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+htri_t
+H5FS_sect_find(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace, hsize_t request,
+    H5FS_section_info_t **node)
+{
+    htri_t ret_value = FALSE;           /* Return value */
+
+    FUNC_ENTER_NOAPI(H5FS_sect_find, FAIL)
+
+#ifdef QAK
+HDfprintf(stderr, "%s: request = %Hu\n", FUNC, request);
+#endif /* QAK */
+
+    /* Check arguments. */
+    HDassert(fspace);
+    HDassert(request);
+    HDassert(node);
+
+    /* Check if we need to go get the sections */
+    if(fspace->sinfo == NULL) {
+        if(NULL == (fspace->sinfo = H5FS_sinfo_pin(f, dxpl_id, fspace)))
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTDECODE, FAIL, "can't pin sections")
+    } /* end if */
+
+    /* Check for any sections on free space list */
+#ifdef QAK
+HDfprintf(stderr, "%s: fspace->tot_sect_count = %Hu\n", FUNC, fspace->tot_sect_count);
+HDfprintf(stderr, "%s: fspace->serial_sect_count = %Hu\n", FUNC, fspace->serial_sect_count);
+HDfprintf(stderr, "%s: fspace->ghost_sect_count = %Hu\n", FUNC, fspace->ghost_sect_count);
+#endif /* QAK */
+    if(fspace->tot_sect_count > 0) {
+        /* Look for node in bins */
+        if((ret_value = H5FS_sect_find_node(fspace, request, node)) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL, "can't remove section from bins")
+
+        /* Decrement # of sections on free list, if we found an object */
+        if(ret_value > 0) {
+            const H5FS_section_class_t *cls;    /* Class of section */
+
+            /* Get section's class */
+            cls = &fspace->sect_cls[(*node)->type];
+
+            /* Update rest of free space manager data structures for node removal */
+            if(H5FS_sect_unlink_rest(f, dxpl_id, fspace, cls, *node) < 0)
+                HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL, "can't remove section from non-size tracking data structures")
+#ifdef QAK
+HDfprintf(stderr, "%s: (*node)->size = %Hu, (*node)->addr = %a, (*node)->type = %u\n", FUNC, (*node)->size, (*node)->addr, (*node)->type);
+#endif /* QAK */
+        } /* end if */
+    } /* end if */
+
+done:
+#ifdef H5FS_DEBUG
+    H5FS_assert(fspace);
+#endif /* H5FS_DEBUG */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_find() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_serialize_size
+ *
+ * Purpose:	Determine serialized size of all sections in free space manager
+ *              And adjust space on disk for storing serialized sections
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, May  8, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_sect_serialize_size(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace)
+{
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_serialize_size)
+
+    /* Check arguments. */
+    HDassert(fspace);
+
+    /* Compute the size of the buffer required to serialize all the sections */
+    if(fspace->serial_sect_count > 0) {
+        size_t sect_buf_size;               /* Section buffer size */
+
+        /* Serialized sections prefix */
+        sect_buf_size = fspace->sinfo->sect_prefix_size;
+
+        /* Count for each differently sized serializable section */
+#ifdef QAK
+    HDfprintf(stderr, "%s: fspace->sinfo->serial_size_count = %Zu\n", FUNC, fspace->sinfo->serial_size_count);
+    HDfprintf(stderr, "%s: fspace->serial_sect_count = %Hu\n", FUNC, fspace->serial_sect_count);
+#endif /* QAK */
+        sect_buf_size += fspace->sinfo->serial_size_count * MAX(1, ((H5V_log2_gen(fspace->serial_sect_count) + 7) / 8));
+
+        /* Size for each differently sized serializable section */
+        sect_buf_size += fspace->sinfo->serial_size_count * fspace->sinfo->sect_len_size;
+
+        /* Offsets of each section in address space */
+        sect_buf_size += fspace->serial_sect_count * fspace->sinfo->sect_off_size;
+
+        /* Class of each section */
+        sect_buf_size += fspace->serial_sect_count * 1;
+
+        /* Extra space required to serialize each section */
+        sect_buf_size += fspace->sinfo->serial_size;
+
+        /* Update section size in header */
+        fspace->sect_size = sect_buf_size;
+    } /* end if */
+    else
+        /* Reset section size in header */
+        fspace->sect_size = H5FS_SINFO_SIZE_DEFAULT;
+
+#ifdef QAK
+HDfprintf(stderr, "%s: fspace->hdr->sect_size = %Hu\n", FUNC, fspace->hdr->sect_size);
+HDfprintf(stderr, "%s: fspace->hdr->alloc_sect_size = %Hu\n", FUNC, fspace->hdr->alloc_sect_size);
+#endif /* QAK */
+    if(fspace->sect_size > fspace->alloc_sect_size) {
+        size_t new_size;        /* New size of space for serialized sections */
+        haddr_t old_addr;       /* Old address of serialized sections */
+
+/* Currently, the old block data is "thrown away" after the space is reallocated,
+ * so avoid data copy in H5MF_realloc() call by just free'ing the space and
+ * allocating new space.
+ *
+ * This also keeps the file smaller, by freeing the space and then
+ * allocating new space, instead of vice versa (in H5MF_realloc).
+ *
+ * QAK - 5/ 8/2006
+ */
+        /* Free previous serialized sections disk space */
+        old_addr = fspace->sect_addr;
+        if(H5MF_xfree(f, H5FD_MEM_FSPACE_SINFO, dxpl_id, old_addr, fspace->alloc_sect_size) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL, "unable to free free space sections")
+
+        /* Compute new size */
+        new_size = fspace->alloc_sect_size;
+        while(new_size < fspace->sect_size)
+            new_size *= (double)fspace->expand_percent / 100.0;
+        fspace->alloc_sect_size = new_size;
+
+        /* Allocate space for the new serialized sections on disk */
+#ifdef QAK
+HDfprintf(stderr, "%s: Allocating space for larger serialized sections, new_size = %Zu\n", FUNC, new_size);
+#endif /* QAK */
+        if(HADDR_UNDEF == (fspace->sect_addr = H5MF_alloc(f, H5FD_MEM_FSPACE_SINFO, dxpl_id, (hsize_t)fspace->alloc_sect_size)))
+            HGOTO_ERROR(H5E_FSPACE, H5E_NOSPACE, FAIL, "file allocation failed for free space sections")
+
+        /* Move object in cache, if it actually was relocated */
+        if(H5F_addr_ne(fspace->sect_addr, old_addr)) {
+            if(H5AC_rename(f, H5AC_FSPACE_SINFO, old_addr, fspace->sect_addr) < 0)
+                HGOTO_ERROR(H5E_FSPACE, H5E_CANTRENAME, FAIL, "unable to move free space section info")
+        } /* end if */
+        else {
+            /* Mark free space section as dirty */
+            if(H5AC_mark_pinned_or_protected_entry_dirty(f, fspace->sinfo) < 0)
+                HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space section info as dirty")
+        } /* end else */
+
+        /* Mark free space header as dirty */
+        if(H5AC_mark_pinned_or_protected_entry_dirty(f, fspace) < 0)
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space header as dirty")
+    } /* end if */
+    else {
+        size_t decrease_threshold;      /* Size threshold for decreasing serialized section size */
+        size_t new_size;                /* New size of space for serialized sections */
+        haddr_t old_addr;               /* Old address of serialized sections */
+
+        /* Compute the threshold for decreasing the sections' serialized size */
+        decrease_threshold = ((size_t)fspace->alloc_sect_size * (double)fspace->shrink_percent) / 100.0;
+
+        if(fspace->alloc_sect_size > H5FS_SINFO_SIZE_DEFAULT &&
+                fspace->sect_size < decrease_threshold) {
+/* Currently, the old block data is "thrown away" after the space is reallocated,
+ * so avoid data copy in H5MF_realloc() call by just free'ing the space and
+ * allocating new space.
+ *
+ * This also keeps the file smaller, by freeing the space and then
+ * allocating new space, instead of vice versa (in H5MF_realloc).
+ *
+ * QAK - 5/ 8/2006
+ */
+            /* Free previous serialized sections disk space */
+            old_addr = fspace->sect_addr;
+            if(H5MF_xfree(f, H5FD_MEM_FSPACE_SINFO, dxpl_id, old_addr, fspace->alloc_sect_size) < 0)
+                HGOTO_ERROR(H5E_FSPACE, H5E_CANTFREE, FAIL, "unable to free free space sections")
+
+            /* Compute new size */
+            while(fspace->sect_size < decrease_threshold) {
+                new_size = decrease_threshold;
+
+                decrease_threshold *= (double)fspace->shrink_percent / 100.0;
+            } /* end while */
+            if(new_size < H5FS_SINFO_SIZE_DEFAULT)
+                new_size = H5FS_SINFO_SIZE_DEFAULT;
+            fspace->alloc_sect_size = new_size;
+
+            /* Allocate space for the new serialized sections on disk */
+#ifdef QAK
+HDfprintf(stderr, "%s: Allocating space for smaller serialized sections, new_size = %Zu\n", FUNC, new_size);
+#endif /* QAK */
+            if(HADDR_UNDEF == (fspace->sect_addr = H5MF_alloc(f, H5FD_MEM_FSPACE_SINFO, dxpl_id, (hsize_t)fspace->alloc_sect_size)))
+                HGOTO_ERROR(H5E_FSPACE, H5E_NOSPACE, FAIL, "file allocation failed for free space sections")
+
+            /* Move object in cache, if it actually was relocated */
+            if(H5F_addr_ne(fspace->sect_addr, old_addr)) {
+                if(H5AC_rename(f, H5AC_FSPACE_SINFO, old_addr, fspace->sect_addr) < 0)
+                    HGOTO_ERROR(H5E_FSPACE, H5E_CANTRENAME, FAIL, "unable to move free space section info")
+            } /* end if */
+            else {
+                /* Mark free space section as dirty */
+                if(H5AC_mark_pinned_or_protected_entry_dirty(f, fspace->sinfo) < 0)
+                    HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space section info as dirty")
+            } /* end else */
+
+            /* Mark free space header as dirty */
+            if(H5AC_mark_pinned_or_protected_entry_dirty(f, fspace) < 0)
+                HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space header as dirty")
+        } /* end if */
+    } /* end else */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_serialize_size() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_iterate_sect_cb
+ *
+ * Purpose:	Skip list iterator callback to iterate over free space sections
+ *              of a particular size
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Saturday, May 13, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_iterate_sect_cb(void *_item, void UNUSED *key, void *_udata)
+{
+    H5FS_section_info_t *sect_info = (H5FS_section_info_t *)_item;   /* Free space section to work on */
+    H5FS_iter_ud_t *udata = (H5FS_iter_ud_t *)_udata; /* Callback info */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_iterate_sect_cb)
+
+    /* Check arguments. */
+    HDassert(sect_info);
+    HDassert(udata->fspace);
+    HDassert(udata->op);
+
+    /* Make callback for this section */
+    if((*udata->op)(sect_info, udata->op_data) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_BADITER, FAIL, "iteration callback failed")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_iterate_sect_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_iterate_node_cb
+ *
+ * Purpose:	Skip list iterator callback to iterate over free space sections
+ *              in a bin
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Saturday, May 13, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5FS_iterate_node_cb(void *_item, void UNUSED *key, void *_udata)
+{
+    H5FS_node_t *fspace_node = (H5FS_node_t *)_item;   /* Free space size node to work on */
+    H5FS_iter_ud_t *udata = (H5FS_iter_ud_t *)_udata; /* Callback info */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_iterate_node_cb)
+
+    /* Check arguments. */
+    HDassert(fspace_node);
+    HDassert(udata->fspace);
+    HDassert(udata->op);
+
+    /* Iterate through all the sections of this size */
+    HDassert(fspace_node->sect_list);
+    if(H5SL_iterate(fspace_node->sect_list, H5FS_iterate_sect_cb, udata) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_BADITER, FAIL, "can't iterate over section nodes")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_iterate_node_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_iterate
+ *
+ * Purpose:	Iterate over all the sections managed
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Saturday, May 13, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5FS_sect_iterate(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace, H5FS_operator_t op, void *op_data)
+{
+    H5FS_iter_ud_t udata;              /* User data for callbacks */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_iterate)
+
+    /* Check arguments. */
+    HDassert(fspace);
+    HDassert(op);
+
+    /* Check if we need to go get the sections */
+    if(fspace->sinfo == NULL) {
+        if(NULL == (fspace->sinfo = H5FS_sinfo_pin(f, dxpl_id, fspace)))
+            HGOTO_ERROR(H5E_FSPACE, H5E_CANTDECODE, FAIL, "can't pin sections")
+    } /* end if */
+
+#ifdef QAK
+HDfprintf(stderr, "%s: fspace->hdr->sect_count = %Hu\n", FUNC, fspace->hdr->sect_count);
+#endif /* QAK */
+
+    /* Set up user data for iterator */
+    udata.fspace = fspace;
+    udata.op = op;
+    udata.op_data = op_data;
+
+    /* Iterate over sections, if there are any */
+    if(fspace->tot_sect_count) {
+        unsigned bin;           /* Current bin we are on */
+
+        /* Iterate over all the bins */
+#ifdef QAK
+HDfprintf(stderr, "%s: Iterate over section bins\n", FUNC);
+#endif /* QAK */
+        for(bin = 0; bin < fspace->sinfo->nbins; bin++) {
+            /* Check if there are any sections in this bin */
+            if(fspace->sinfo->bins[bin].bin_list) {
+                /* Iterate over list of section size nodes for bin */
+                if(H5SL_iterate(fspace->sinfo->bins[bin].bin_list, H5FS_iterate_node_cb, &udata) < 0)
+                    HGOTO_ERROR(H5E_FSPACE, H5E_BADITER, FAIL, "can't iterate over section size nodes")
+            } /* end if */
+        } /* end for */
+    } /* end if */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_iterate() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_get_sect_count
+ *
+ * Purpose:	Retrieve the number of sections managed
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Tuesday, May 30, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5FS_get_sect_count(const H5FS_t *fspace, hsize_t *nsects)
+{
+    FUNC_ENTER_NOAPI_NOFUNC(H5FS_get_sect_count)
+
+    /* Check arguments. */
+    HDassert(fspace);
+    HDassert(nsects);
+
+    /* Get the section count */
+    *nsects = fspace->tot_sect_count;
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5FS_get_sect_count() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_change_class
+ *
+ * Purpose:	Make appropriate adjustments to internal data structures when
+ *              a section changes class
+ *
+ * Return:	Success:	non-negative
+ *
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Monday, July 10, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5FS_sect_change_class(H5F_t *f, hid_t dxpl_id, H5FS_t *fspace,
+    H5FS_section_info_t *sect, unsigned new_class)
+{
+    const H5FS_section_class_t *old_cls;        /* Old class of section */
+    const H5FS_section_class_t *new_cls;        /* New class of section */
+    unsigned old_class;                         /* Old class ID of section */
+    herr_t ret_value = SUCCEED;                 /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5FS_sect_change_class)
+
+    /* Check arguments. */
+    HDassert(fspace);
+    HDassert(fspace->sinfo);
+    HDassert(sect);
+    HDassert(sect->type < fspace->nclasses);
+    HDassert(new_class < fspace->nclasses);
+
+    /* Get class info */
+    old_class = sect->type;
+    old_cls = &fspace->sect_cls[sect->type];
+    new_cls = &fspace->sect_cls[new_class];
+#ifdef QAK
+HDfprintf(stderr, "%s: old_cls->flags = %x\n", FUNC, old_cls->flags);
+HDfprintf(stderr, "%s: new_cls->flags = %x\n", FUNC, new_cls->flags);
+#endif /* QAK */
+
+    /* Check if the section's class change will affect the # of serializable or ghost sections */
+    if((old_cls->flags & H5FS_CLS_GHOST_OBJ) != (new_cls->flags & H5FS_CLS_GHOST_OBJ)) {
+        H5FS_node_t *fspace_node;       /* Free list size node */
+        unsigned bin;                   /* Bin to put the free space section in */
+        hbool_t to_ghost;       /* Flag if the section is changing to a ghost section */
+
+        /* Determine if this section is becoming a ghost or is becoming serializable */
+        if(old_cls->flags & H5FS_CLS_GHOST_OBJ)
+            to_ghost = FALSE;
+        else
+            to_ghost = TRUE;
+#ifdef QAK
+HDfprintf(stderr, "%s: to_ghost = %u\n", FUNC, to_ghost);
+#endif /* QAK */
+
+        /* Sanity check */
+        HDassert(fspace->sinfo->bins);
+
+        /* Determine correct bin which holds items of at least the section's size */
+        bin = H5V_log2_gen(sect->size);
+        HDassert(bin < fspace->sinfo->nbins);
+        HDassert(fspace->sinfo->bins[bin].bin_list);
+
+        /* Get space node for section's size */
+        fspace_node = H5SL_search(fspace->sinfo->bins[bin].bin_list, &sect->size);
+        HDassert(fspace_node);
+
+        /* Adjust serializable/ghost counts */
+        if(to_ghost) {
+            /* Adjust global section count totals */
+            fspace->serial_sect_count--;
+            fspace->ghost_sect_count++;
+
+            /* Adjust bin's section count totals */
+            fspace->sinfo->bins[bin].serial_sect_count--;
+            fspace->sinfo->bins[bin].ghost_sect_count++;
+
+            /* Adjust section size node's section count totals */
+            fspace_node->serial_count--;
+            fspace_node->ghost_count++;
+
+            /* Check if we switched a section size node's status */
+            if(fspace_node->serial_count == 0)
+                fspace->sinfo->serial_size_count--;
+            if(fspace_node->ghost_count == 1)
+                fspace->sinfo->ghost_size_count++;
+        } /* end if */
+        else {
+            /* Adjust global section count totals */
+            fspace->serial_sect_count++;
+            fspace->ghost_sect_count--;
+
+            /* Adjust bin's section count totals */
+            fspace->sinfo->bins[bin].serial_sect_count++;
+            fspace->sinfo->bins[bin].ghost_sect_count--;
+
+            /* Adjust section size node's section count totals */
+            fspace_node->serial_count++;
+            fspace_node->ghost_count--;
+
+            /* Check if we switched a section size node's status */
+            if(fspace_node->serial_count == 1)
+                fspace->sinfo->serial_size_count++;
+            if(fspace_node->ghost_count == 0)
+                fspace->sinfo->ghost_size_count--;
+        } /* end else */
+    } /* end if */
+
+    /* Check if the section's class change will affect the mergable list */
+    if((old_cls->flags & H5FS_CLS_SEPAR_OBJ) != (new_cls->flags & H5FS_CLS_SEPAR_OBJ)) {
+        hbool_t to_mergable;       /* Flag if the section is changing to a mergable section */
+
+        /* Determine if this section is becoming mergable or is becoming separate */
+        if(old_cls->flags & H5FS_CLS_SEPAR_OBJ)
+            to_mergable = TRUE;
+        else
+            to_mergable = FALSE;
+#ifdef QAK
+HDfprintf(stderr, "%s: to_mergable = %u\n", FUNC, to_mergable);
+#endif /* QAK */
+
+        /* Add or remove section from merge list, as appropriate */
+        if(to_mergable) {
+#ifdef QAK
+HDfprintf(stderr, "%s: inserting object into merge list, sect->type = %u\n", FUNC, (unsigned)sect->type);
+#endif /* QAK */
+            if(fspace->sinfo->merge_list == NULL)
+                if(NULL == (fspace->sinfo->merge_list = H5SL_create(H5SL_TYPE_HADDR, 0.5, H5FS_DEFAULT_SKIPLIST_HEIGHT)))
+                    HGOTO_ERROR(H5E_FSPACE, H5E_CANTCREATE, FAIL, "can't create skip list for merging free space sections")
+            if(H5SL_insert(fspace->sinfo->merge_list, sect, &sect->addr) < 0)
+                HGOTO_ERROR(H5E_FSPACE, H5E_CANTINSERT, FAIL, "can't insert free space node into merging skip list")
+        } /* end if */
+        else {
+            H5FS_section_info_t *tmp_sect_node; /* Temporary section node */
+
+#ifdef QAK
+HDfprintf(stderr, "%s: removing object from merge list, sect->type = %u\n", FUNC, (unsigned)sect->type);
+#endif /* QAK */
+            tmp_sect_node = H5SL_remove(fspace->sinfo->merge_list, &sect->addr);
+            if(tmp_sect_node == NULL || tmp_sect_node != sect)
+                HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "can't find section node on size list")
+        } /* end else */
+    } /* end if */
+
+    /* Change the section's class */
+    sect->type = new_class;
+
+    /* Change the serialized size of sections */
+    fspace->sinfo->serial_size -= fspace->sect_cls[old_class].serial_size;
+    fspace->sinfo->serial_size += fspace->sect_cls[new_class].serial_size;
+
+    /* Update current space used for free space sections */
+    if(H5FS_sect_serialize_size(f, dxpl_id, fspace) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTCOMPUTE, FAIL, "can't adjust free space section size on disk")
+    
+    /* Mark free space sections as dirty */
+    if(H5AC_mark_pinned_or_protected_entry_dirty(f, fspace->sinfo) < 0)
+        HGOTO_ERROR(H5E_FSPACE, H5E_CANTMARKDIRTY, FAIL, "unable to mark free space sections as dirty")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5FS_sect_change_class() */
+
+#ifdef H5FS_DEBUG
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FS_sect_assert
+ *
+ * Purpose:	Verify that the sections managed are mostly sane
+ *
+ * Return:	Non-negative on success, negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *		koziol@hdfgroup.org
+ *		Jul 17 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5FS_sect_assert(const H5FS_t *fspace)
+{
+    hsize_t separate_obj;       /* The number of separate objects managed */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5FS_sect_assert)
+#ifdef QAK
+HDfprintf(stderr, "%s: fspace->hdr->tot_sect_count = %Hu\n", "H5FS_sect_assert", fspace->hdr->tot_sect_count);
+#endif /* QAK */
+
+    /* Initialize state */
+    separate_obj = 0;
+
+    /* Check for bins to work on */
+    if(fspace->bins) {
+        hsize_t acc_tot_sect_count;     /* Accumulated total section count from bins */
+        hsize_t acc_serial_sect_count;  /* Accumulated serializable section count from bins */
+        hsize_t acc_ghost_sect_count;   /* Accumulated ghost section count from bins */
+        size_t acc_tot_size_count;      /* Accumulated total section size count from bins */
+        size_t acc_serial_size_count;   /* Accumulated serializable section size count from bins */
+        size_t acc_ghost_size_count;    /* Accumulated ghost section size count from bins */
+        unsigned u;             /* Local index variable */
+
+        /* Walk through all sections in bins */
+        acc_tot_sect_count = 0;
+        acc_serial_sect_count = 0;
+        acc_ghost_sect_count = 0;
+        acc_tot_size_count = 0;
+        acc_serial_size_count = 0;
+        acc_ghost_size_count = 0;
+        for(u = 0; u < fspace->nbins; u++) {
+            acc_tot_sect_count += fspace->bins[u].tot_sect_count;
+            acc_serial_sect_count += fspace->bins[u].serial_sect_count;
+            acc_ghost_sect_count += fspace->bins[u].ghost_sect_count;
+            if(fspace->bins[u].bin_list) {
+                H5SL_node_t *curr_size_node;    /* Current section size node in skip list */
+                size_t bin_serial_count;        /* # of serializable sections in this bin */
+                size_t bin_ghost_count;         /* # of ghost sections in this bin */
+
+                acc_tot_size_count += H5SL_count(fspace->bins[u].bin_list);
+
+                /* Walk through the sections in this bin */
+                curr_size_node = H5SL_first(fspace->bins[u].bin_list);
+                bin_serial_count = 0;
+                bin_ghost_count = 0;
+                while(curr_size_node != NULL) {
+                    H5FS_node_t *fspace_node;       /* Section size node */
+                    H5SL_node_t *curr_sect_node;    /* Current section node in skip list */
+                    size_t size_serial_count;       /* # of serializable sections of this size */
+                    size_t size_ghost_count;        /* # of ghost sections of this size */
+
+                    /* Get section size node */
+                    fspace_node = H5SL_item(curr_size_node);
+
+                    /* Check sections on list */
+                    curr_sect_node = H5SL_first(fspace_node->sect_list);
+                    size_serial_count = 0;
+                    size_ghost_count = 0;
+                    while(curr_sect_node != NULL) {
+                        H5FS_section_class_t *cls;      /* Class of section */
+                        H5FS_section_info_t *sect;      /* Section */
+
+                        /* Get section node & it's class */
+                        sect = H5SL_item(curr_sect_node);
+                        cls = &fspace->sect_cls[sect->type];
+#ifdef QAK
+HDfprintf(stderr, "%s: sect->size = %Hu, sect->addr = %a, sect->type = %u\n", "H5FS_assert", sect->size, sect->addr, sect->type);
+#endif /* QAK */
+
+                        /* Sanity check section */
+                        HDassert(H5F_addr_defined(sect->addr));
+                        HDassert(fspace_node->sect_size == sect->size);
+                        if(cls->valid)
+                            (*cls->valid)(cls, sect);
+
+                        /* Add to correct count */
+                        if(cls->flags & H5FS_CLS_GHOST_OBJ)
+                            size_ghost_count++;
+                        else
+                            size_serial_count++;
+
+                        /* Count node, if separate */
+                        if(cls->flags & H5FS_CLS_SEPAR_OBJ)
+                            separate_obj++;
+
+                        /* Get the next section node in the list */
+                        curr_sect_node = H5SL_next(curr_sect_node);
+                    } /* end while */
+
+                    /* Check the number of serializable & ghost sections of this size */
+                    HDassert(fspace_node->serial_count == size_serial_count);
+                    HDassert(fspace_node->ghost_count == size_ghost_count);
+
+                    /* Add to global count of serializable & ghost section sizes */
+                    if(fspace_node->serial_count > 0)
+                        acc_serial_size_count++;
+                    if(fspace_node->ghost_count > 0)
+                        acc_ghost_size_count++;
+
+                    /* Add to bin's serializable & ghost counts */
+                    bin_serial_count += size_serial_count;
+                    bin_ghost_count += size_ghost_count;
+
+                    /* Get the next section size node in the list */
+                    curr_size_node = H5SL_next(curr_size_node);
+                } /* end while */
+
+                /* Check the number of serializable & ghost sections in this bin */
+                HDassert(fspace->bins[u].tot_sect_count == (bin_serial_count + bin_ghost_count));
+                HDassert(fspace->bins[u].serial_sect_count == bin_serial_count);
+                HDassert(fspace->bins[u].ghost_sect_count == bin_ghost_count);
+            } /* end if */
+        } /* end for */
+
+        /* Check counts from bins vs. global counts */
+        HDassert(fspace->tot_size_count == acc_tot_size_count);
+        HDassert(fspace->serial_size_count == acc_serial_size_count);
+        HDassert(fspace->ghost_size_count == acc_ghost_size_count);
+        HDassert(fspace->hdr->tot_sect_count == acc_tot_sect_count);
+        HDassert(fspace->hdr->serial_sect_count == acc_serial_sect_count);
+        HDassert(fspace->hdr->ghost_sect_count == acc_ghost_sect_count);
+    } /* end if */
+    else {
+        /* Check counts are zero */
+        HDassert(fspace->hdr->tot_sect_count == 0);
+        HDassert(fspace->hdr->serial_sect_count == 0);
+        HDassert(fspace->hdr->ghost_sect_count == 0);
+    } /* end else */
+
+    /* Make certain that the number of sections on the address list is correct */
+    if(fspace->merge_list)
+        HDassert(fspace->hdr->tot_sect_count == (separate_obj + H5SL_count(fspace->merge_list)));
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5FS_sect_assert() */
+#endif /* H5FS_DEBUG */
+