[svn-r17896] Description:

	Bring r17546:17895 from trunk to revise_chunks branch.  Changes to
fixed and extensible array dataset chunk indexing code to accommodate changes
to private APIs in those interfaces.  Also, other adjustments to source code
and expected output in response to changes on the trunk.

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

1 files changed, 541 insertions, 844 deletions

diff --git a/src/H5B2int.c b/src/H5B2int.c
index 550a5b6..f7312a5 100644
--- a/src/H5B2int.c
+++ b/src/H5B2int.c
@@ -43,15 +43,6 @@
 /* Local Macros */
 /****************/
 
-/* Number of records that fit into internal node */
-/* (accounts for extra node pointer by counting it in with the prefix bytes) */
-#define H5B2_NUM_INT_REC(f, s, d) \
-    (((s)->node_size - (H5B2_INT_PREFIX_SIZE + H5B2_INT_POINTER_SIZE(f, s, d))) / ((s)->rrec_size + H5B2_INT_POINTER_SIZE(f, s, d)))
-
-/* Number of records that fit into leaf node */
-#define H5B2_NUM_LEAF_REC(n, r) \
-    (((n) - H5B2_LEAF_PREFIX_SIZE) / (r))
-
 /* Uncomment this macro to enable extra sanity checking */
 /* #define H5B2_DEBUG */
 
@@ -70,30 +61,29 @@
 /********************/
 
 /* Helper functions */
-static herr_t H5B2_shared_free(void *_shared);
-static herr_t H5B2_create_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
+static herr_t H5B2_create_internal(H5B2_hdr_t *hdr, hid_t dxpl_id,
     H5B2_node_ptr_t *node_ptr, unsigned depth);
-static herr_t H5B2_split1(H5F_t *f, hid_t dxpl_id, unsigned depth,
+static herr_t H5B2_split1(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     H5B2_node_ptr_t *curr_node_ptr, unsigned *parent_cache_info_flags_ptr,
     H5B2_internal_t *internal, unsigned *internal_flags_ptr, unsigned idx);
-static herr_t H5B2_redistribute2(H5F_t *f, hid_t dxpl_id, unsigned depth,
+static herr_t H5B2_redistribute2(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     H5B2_internal_t *internal, unsigned idx);
-static herr_t H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
+static herr_t H5B2_redistribute3(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     H5B2_internal_t *internal, unsigned *internal_flags_ptr, unsigned idx);
-static herr_t H5B2_merge2(H5F_t *f, hid_t dxpl_id, unsigned depth,
+static herr_t H5B2_merge2(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     H5B2_node_ptr_t *curr_node_ptr, unsigned *parent_cache_info_flags_ptr,
     H5B2_internal_t *internal, unsigned *internal_flags_ptr, unsigned idx);
-static herr_t H5B2_merge3(H5F_t *f, hid_t dxpl_id, unsigned depth,
+static herr_t H5B2_merge3(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     H5B2_node_ptr_t *curr_node_ptr, unsigned *parent_cache_info_flags_ptr,
     H5B2_internal_t *internal, unsigned *internal_flags_ptr, unsigned idx);
-static herr_t H5B2_swap_leaf(H5F_t *f, hid_t dxpl_id, unsigned depth,
+static herr_t H5B2_swap_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     H5B2_internal_t *internal, unsigned *internal_flags_ptr,
     unsigned idx, void *swap_loc);
 #ifdef H5B2_DEBUG
-static herr_t H5B2_assert_leaf(H5B2_shared_t *shared, H5B2_leaf_t *leaf);
-static herr_t H5B2_assert_leaf2(H5B2_shared_t *shared, H5B2_leaf_t *leaf, H5B2_leaf_t *leaf2);
-static herr_t H5B2_assert_internal(hsize_t parent_all_nrec, H5B2_shared_t *shared, H5B2_internal_t *internal);
-static herr_t H5B2_assert_internal2(hsize_t parent_all_nrec, H5B2_shared_t *shared, H5B2_internal_t *internal, H5B2_internal_t *internal2);
+static herr_t H5B2_assert_leaf(H5B2_hdr_t *hdr, H5B2_leaf_t *leaf);
+static herr_t H5B2_assert_leaf2(H5B2_hdr_t *hdr, H5B2_leaf_t *leaf, H5B2_leaf_t *leaf2);
+static herr_t H5B2_assert_internal(hsize_t parent_all_nrec, H5B2_hdr_t *hdr, H5B2_internal_t *internal);
+static herr_t H5B2_assert_internal2(hsize_t parent_all_nrec, H5B2_hdr_t *hdr, H5B2_internal_t *internal, H5B2_internal_t *internal2);
 #endif /* H5B2_DEBUG */
 
 /*********************/
@@ -116,194 +106,12 @@ H5FL_DEFINE(H5B2_leaf_t);
 /* Local Variables */
 /*******************/
 
-/* Declare a free list to manage B-tree node pages to/from disk */
-H5FL_BLK_DEFINE_STATIC(node_page);
-
-/* Declare a free list to manage the 'size_t' sequence information */
-H5FL_SEQ_DEFINE_STATIC(size_t);
-
 /* Declare a free list to manage the 'H5B2_node_info_t' sequence information */
-H5FL_SEQ_DEFINE_STATIC(H5B2_node_info_t);
-
-/* Declare a free list to manage the H5B2_shared_t struct */
-H5FL_DEFINE_STATIC(H5B2_shared_t);
+H5FL_SEQ_EXTERN(H5B2_node_info_t);
 
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5B2_shared_init
- *
- * Purpose:	Allocate & initialize shared B-tree info
- *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
- *		Feb  2 2005
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-H5B2_shared_init (H5F_t *f, H5B2_t *bt2, const H5B2_class_t *type,
-    unsigned depth, size_t node_size, size_t rrec_size,
-    unsigned split_percent, unsigned merge_percent)
-{
-    H5B2_shared_t *shared = NULL;       /* Shared B-tree information */
-    size_t sz_max_nrec;                 /* Temporary variable for range checking */
-    unsigned u_max_nrec_size;           /* Temporary variable for range checking */
-    unsigned u;                         /* Local index variable */
-    herr_t ret_value = SUCCEED;         /* Return value */
-
-    FUNC_ENTER_NOAPI_NOINIT(H5B2_shared_init)
-
-    /* Allocate space for the shared information */
-    if(NULL == (shared = H5FL_CALLOC(H5B2_shared_t)))
-	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree shared information")
-
-    /* Assign dynamic information */
-    shared->depth = depth;
-
-    /* Assign user's information */
-    shared->split_percent = split_percent;
-    shared->merge_percent = merge_percent;
-    shared->node_size = node_size;
-    shared->rrec_size = rrec_size;
-
-    /* Assign common type information */
-    shared->type = type;
-
-    /* Allocate "page" for node I/O */
-    if((shared->page = H5FL_BLK_MALLOC(node_page, shared->node_size)) == NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
-#ifdef H5_CLEAR_MEMORY
-HDmemset(shared->page, 0, shared->node_size);
-#endif /* H5_CLEAR_MEMORY */
-
-    /* Allocate array of node info structs */
-    if((shared->node_info = H5FL_SEQ_MALLOC(H5B2_node_info_t, (size_t)(shared->depth + 1))) == NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
-
-    /* Initialize leaf node info */
-    sz_max_nrec = H5B2_NUM_LEAF_REC(shared->node_size, shared->rrec_size);
-    H5_ASSIGN_OVERFLOW(/* To: */ shared->node_info[0].max_nrec, /* From: */ sz_max_nrec, /* From: */ size_t, /* To: */ unsigned)
-    shared->node_info[0].split_nrec = (shared->node_info[0].max_nrec * shared->split_percent) / 100;
-    shared->node_info[0].merge_nrec = (shared->node_info[0].max_nrec * shared->merge_percent) / 100;
-    shared->node_info[0].cum_max_nrec = shared->node_info[0].max_nrec;
-    shared->node_info[0].cum_max_nrec_size = 0;
-    if((shared->node_info[0].nat_rec_fac = H5FL_fac_init(type->nrec_size * shared->node_info[0].max_nrec)) == NULL)
-	HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't create node native key block factory")
-    shared->node_info[0].node_ptr_fac = NULL;
-
-    /* Allocate array of pointers to internal node native keys */
-    /* (uses leaf # of records because its the largest) */
-    if((shared->nat_off = H5FL_SEQ_MALLOC(size_t, (size_t)shared->node_info[0].max_nrec)) == NULL)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
-
-    /* Initialize offsets in native key block */
-    /* (uses leaf # of records because its the largest) */
-    for(u = 0; u < shared->node_info[0].max_nrec; u++)
-        shared->nat_off[u] = type->nrec_size * u;
-
-    /* Compute size to store # of records in each node */
-    /* (uses leaf # of records because its the largest) */
-    u_max_nrec_size = H5V_limit_enc_size((uint64_t)shared->node_info[0].max_nrec);
-    H5_ASSIGN_OVERFLOW(/* To: */ shared->max_nrec_size, /* From: */ u_max_nrec_size, /* From: */ unsigned, /* To: */ uint8_t)
-    HDassert(shared->max_nrec_size <= H5B2_SIZEOF_RECORDS_PER_NODE);
-
-    /* Initialize internal node info */
-    if(depth > 0) {
-        for(u = 1; u < (depth + 1); u++) {
-            sz_max_nrec = H5B2_NUM_INT_REC(f, shared, u);
-            H5_ASSIGN_OVERFLOW(/* To: */ shared->node_info[u].max_nrec, /* From: */ sz_max_nrec, /* From: */ size_t, /* To: */ unsigned)
-            HDassert(shared->node_info[u].max_nrec <= shared->node_info[u - 1].max_nrec);
-
-            shared->node_info[u].split_nrec = (shared->node_info[u].max_nrec * shared->split_percent) / 100;
-            shared->node_info[u].merge_nrec = (shared->node_info[u].max_nrec * shared->merge_percent) / 100;
-
-            shared->node_info[u].cum_max_nrec = ((shared->node_info[u].max_nrec + 1) *
-                shared->node_info[u - 1].cum_max_nrec) + shared->node_info[u].max_nrec;
-            u_max_nrec_size = H5V_limit_enc_size((uint64_t)shared->node_info[u].cum_max_nrec);
-            H5_ASSIGN_OVERFLOW(/* To: */ shared->node_info[u].cum_max_nrec_size, /* From: */ u_max_nrec_size, /* From: */ unsigned, /* To: */ uint8_t)
-
-            if((shared->node_info[u].nat_rec_fac = H5FL_fac_init(shared->type->nrec_size * shared->node_info[u].max_nrec)) == NULL)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't create node native key block factory")
-            if((shared->node_info[u].node_ptr_fac = H5FL_fac_init(sizeof(H5B2_node_ptr_t) * (shared->node_info[u].max_nrec + 1))) == NULL)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't create internal 'branch' node node pointer block factory")
-        } /* end for */
-    } /* end if */
-
-    /* Make shared B-tree info reference counted */
-    if(NULL == (bt2->shared = H5RC_create(shared, H5B2_shared_free)))
-	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't create ref-count wrapper for shared B-tree info")
-
-done:
-    if(ret_value < 0)
-        if(shared)
-            H5B2_shared_free(shared);
-
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5B2_shared_init() */
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5B2_shared_free
- *
- * Purpose:	Free shared B-tree info
- *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
- *		Feb  2 2005
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5B2_shared_free(void *_shared)
-{
-    H5B2_shared_t *shared = (H5B2_shared_t *)_shared;
-    herr_t ret_value = SUCCEED;
-
-    FUNC_ENTER_NOAPI_NOINIT(H5B2_shared_free)
-
-    /* Sanity check */
-    HDassert(shared);
-
-    /* Free the B-tree node buffer */
-    if(shared->page)
-        (void)H5FL_BLK_FREE(node_page, shared->page);
-
-    /* Free the array of offsets into the native key block */
-    if(shared->nat_off)
-        shared->nat_off = H5FL_SEQ_FREE(size_t, shared->nat_off);
-
-    /* Release the node info */
-    if(shared->node_info) {
-        unsigned u;             /* Local index variable */
-
-        /* Destroy free list factories */
-        for(u = 0; u < (shared->depth + 1); u++) {
-            if(shared->node_info[u].nat_rec_fac)
-                if(H5FL_fac_term(shared->node_info[u].nat_rec_fac) < 0)
-                    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTRELEASE, FAIL, "can't destroy node's native record block factory")
-            if(shared->node_info[u].node_ptr_fac)
-                if(H5FL_fac_term(shared->node_info[u].node_ptr_fac) < 0)
-                    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTRELEASE, FAIL, "can't destroy node's node pointer block factory")
-        } /* end for */
-
-        /* Free the array of node info structs */
-        shared->node_info = H5FL_SEQ_FREE(H5B2_node_info_t, shared->node_info);
-    } /* end if */
-
-    /* Free the shared B-tree info itself */
-    shared = H5FL_FREE(H5B2_shared_t, shared);
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5B2_shared_free() */
-
-
-/*-------------------------------------------------------------------------
  * Function:	H5B2_locate_record
  *
  * Purpose:	Performs a binary search to locate a record in a sorted
@@ -345,7 +153,7 @@ H5B2_locate_record(const H5B2_class_t *type, unsigned nrec, size_t *rec_off,
 
     *idx = my_idx;
 
-    FUNC_LEAVE_NOAPI(cmp);
+    FUNC_LEAVE_NOAPI(cmp)
 } /* end H5B2_locate_record */
 
 
@@ -364,35 +172,30 @@ H5B2_locate_record(const H5B2_class_t *type, unsigned nrec, size_t *rec_off,
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_split1(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_node_ptr_t *curr_node_ptr,
+H5B2_split1(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth, H5B2_node_ptr_t *curr_node_ptr,
     unsigned *parent_cache_info_flags_ptr, H5B2_internal_t *internal,
     unsigned *internal_flags_ptr, unsigned idx)
 {
     const H5AC_class_t *child_class;    /* Pointer to child node's class info */
     haddr_t left_addr, right_addr;      /* Addresses of left & right child nodes */
     void *left_child, *right_child;     /* Pointers to child nodes */
-    unsigned *left_nrec, *right_nrec;   /* Pointers to child # of records */
+    uint16_t *left_nrec, *right_nrec;   /* Pointers to child # of records */
     uint8_t *left_native, *right_native;/* Pointers to childs' native records */
-    H5B2_node_ptr_t *left_node_ptrs=NULL, *right_node_ptrs=NULL;/* Pointers to childs' node pointer info */
-    H5B2_shared_t *shared;              /* B-tree's shared info */
-    unsigned mid_record;                /* Index of "middle" record in current node */
-    unsigned old_node_nrec;             /* Number of records in internal node split */
+    H5B2_node_ptr_t *left_node_ptrs = NULL, *right_node_ptrs = NULL;/* Pointers to childs' node pointer info */
+    uint16_t mid_record;                /* Index of "middle" record in current node */
+    uint16_t old_node_nrec;             /* Number of records in internal node split */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_split1)
 
-    HDassert(f);
-    HDassert(parent_cache_info_flags_ptr);
+    /* Check arguments. */
+    HDassert(hdr);
     HDassert(internal);
     HDassert(internal_flags_ptr);
 
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(internal->shared);
-    HDassert(shared);
-
     /* Slide records in parent node up one space, to make room for promoted record */
     if(idx < internal->nrec) {
-        HDmemmove(H5B2_INT_NREC(internal, shared, idx + 1), H5B2_INT_NREC(internal, shared, idx), shared->type->nrec_size * (internal->nrec - idx));
+        HDmemmove(H5B2_INT_NREC(internal, hdr, idx + 1), H5B2_INT_NREC(internal, hdr, idx), hdr->cls->nrec_size * (internal->nrec - idx));
         HDmemmove(&(internal->node_ptrs[idx + 2]), &(internal->node_ptrs[idx + 1]), sizeof(H5B2_node_ptr_t) * (internal->nrec - idx));
     } /* end if */
 
@@ -402,7 +205,7 @@ H5B2_split1(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_node_ptr_t *curr_node_
 
         /* Create new internal node */
         internal->node_ptrs[idx + 1].all_nrec = internal->node_ptrs[idx + 1].node_nrec = 0;
-        if(H5B2_create_internal(f, dxpl_id, internal->shared, &(internal->node_ptrs[idx + 1]), (depth - 1)) < 0)
+        if(H5B2_create_internal(hdr, dxpl_id, &(internal->node_ptrs[idx + 1]), (depth - 1)) < 0)
 	    HGOTO_ERROR(H5E_BTREE, H5E_CANTINIT, FAIL, "unable to create new internal node")
 
         /* Setup information for unlocking child nodes */
@@ -411,9 +214,9 @@ H5B2_split1(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_node_ptr_t *curr_node_
         right_addr = internal->node_ptrs[idx + 1].addr;
 
         /* Protect both leafs */
-        if(NULL == (left_int = H5B2_protect_internal(f, dxpl_id, internal->shared, left_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (left_int = H5B2_protect_internal(hdr, dxpl_id, left_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
-        if(NULL == (right_int = H5B2_protect_internal(f, dxpl_id, internal->shared, right_addr, internal->node_ptrs[idx + 1].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (right_int = H5B2_protect_internal(hdr, dxpl_id, right_addr, internal->node_ptrs[idx + 1].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
         /* More setup for child nodes */
@@ -431,7 +234,7 @@ H5B2_split1(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_node_ptr_t *curr_node_
 
         /* Create new leaf node */
         internal->node_ptrs[idx + 1].all_nrec = internal->node_ptrs[idx + 1].node_nrec = 0;
-        if(H5B2_create_leaf(f, dxpl_id, internal->shared, &(internal->node_ptrs[idx + 1])) < 0)
+        if(H5B2_create_leaf(hdr, dxpl_id, &(internal->node_ptrs[idx + 1])) < 0)
 	    HGOTO_ERROR(H5E_BTREE, H5E_CANTINIT, FAIL, "unable to create new leaf node")
 
         /* Setup information for unlocking child nodes */
@@ -440,9 +243,9 @@ H5B2_split1(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_node_ptr_t *curr_node_
         right_addr = internal->node_ptrs[idx + 1].addr;
 
         /* Protect both leafs */
-        if(NULL == (left_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, left_addr, &(internal->node_ptrs[idx].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (left_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, left_addr, &(internal->node_ptrs[idx].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
-        if(NULL == (right_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, right_addr, &(internal->node_ptrs[idx + 1].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (right_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, right_addr, &(internal->node_ptrs[idx + 1].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
         /* More setup for child nodes */
@@ -461,21 +264,21 @@ H5B2_split1(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_node_ptr_t *curr_node_
     mid_record = old_node_nrec / 2;
 
     /* Copy "upper half" of records to new child */
-    HDmemcpy(H5B2_NAT_NREC(right_native, shared, 0),
-            H5B2_NAT_NREC(left_native, shared, mid_record + 1),
-            shared->type->nrec_size * (old_node_nrec - (mid_record + 1)));
+    HDmemcpy(H5B2_NAT_NREC(right_native, hdr, 0),
+            H5B2_NAT_NREC(left_native, hdr, mid_record + (unsigned)1),
+            hdr->cls->nrec_size * (old_node_nrec - (mid_record + (unsigned)1)));
 
     /* Copy "upper half" of node pointers, if the node is an internal node */
     if(depth > 1)
-        HDmemcpy(&(right_node_ptrs[0]), &(left_node_ptrs[mid_record + 1]),
+        HDmemcpy(&(right_node_ptrs[0]), &(left_node_ptrs[mid_record + (unsigned)1]),
                 sizeof(H5B2_node_ptr_t) * (old_node_nrec - mid_record));
 
     /* Copy "middle" record to internal node */
-    HDmemcpy(H5B2_INT_NREC(internal, shared, idx), H5B2_NAT_NREC(left_native, shared, mid_record), shared->type->nrec_size);
+    HDmemcpy(H5B2_INT_NREC(internal, hdr, idx), H5B2_NAT_NREC(left_native, hdr, mid_record), hdr->cls->nrec_size);
 
     /* Update record counts in child nodes */
     internal->node_ptrs[idx].node_nrec = *left_nrec = mid_record;
-    internal->node_ptrs[idx + 1].node_nrec = *right_nrec = old_node_nrec - (mid_record + 1);
+    internal->node_ptrs[idx + 1].node_nrec = *right_nrec = old_node_nrec - (mid_record + (unsigned)1);
 
     /* Determine total number of records in new child nodes */
     if(depth > 1) {
@@ -485,11 +288,11 @@ H5B2_split1(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_node_ptr_t *curr_node_
 
         /* Compute total of all records in each child node */
         new_left_all_nrec = internal->node_ptrs[idx].node_nrec;
-        for(u = 0; u < (*left_nrec + 1); u++)
+        for(u = 0; u < (*left_nrec + (unsigned)1); u++)
             new_left_all_nrec += left_node_ptrs[u].all_nrec;
 
         new_right_all_nrec = internal->node_ptrs[idx + 1].node_nrec;
-        for(u = 0; u < (*right_nrec + 1); u++)
+        for(u = 0; u < (*right_nrec + (unsigned)1); u++)
             new_right_all_nrec += right_node_ptrs[u].all_nrec;
 
         internal->node_ptrs[idx].all_nrec = new_left_all_nrec;
@@ -509,29 +312,30 @@ H5B2_split1(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_node_ptr_t *curr_node_
     /* Update grandparent info */
     curr_node_ptr->node_nrec++;
 
-    /* Mark grandparent as dirty */
-    *parent_cache_info_flags_ptr |= H5AC__DIRTIED_FLAG;
+    /* Mark grandparent as dirty, if given */
+    if(parent_cache_info_flags_ptr)
+        *parent_cache_info_flags_ptr |= H5AC__DIRTIED_FLAG;
 
 #ifdef H5B2_DEBUG
-    H5B2_assert_internal((hsize_t)0,shared,internal);
+    H5B2_assert_internal((hsize_t)0, hdr, internal);
     if(depth > 1) {
-        H5B2_assert_internal2(internal->node_ptrs[idx].all_nrec, shared, left_child, right_child);
-        H5B2_assert_internal2(internal->node_ptrs[idx + 1].all_nrec, shared, right_child, left_child);
+        H5B2_assert_internal2(internal->node_ptrs[idx].all_nrec, hdr, left_child, right_child);
+        H5B2_assert_internal2(internal->node_ptrs[idx + 1].all_nrec, hdr, right_child, left_child);
     } /* end if */
     else {
-        H5B2_assert_leaf2(shared, left_child, right_child);
-        H5B2_assert_leaf(shared, right_child);
+        H5B2_assert_leaf2(hdr, left_child, right_child);
+        H5B2_assert_leaf(hdr, right_child);
     } /* end else */
 #endif /* H5B2_DEBUG */
 
     /* Release child nodes (marked as dirty) */
-    if(H5AC_unprotect(f, dxpl_id, child_class, left_addr, left_child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, left_addr, left_child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree leaf node")
-    if(H5AC_unprotect(f, dxpl_id, child_class, right_addr, right_child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, right_addr, right_child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree leaf node")
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5B2_split1 */
 
 
@@ -541,7 +345,6 @@ done:
  * Purpose:	Split the root node
  *
  * Return:	Success:	Non-negative
- *
  *		Failure:	Negative
  *
  * Programmer:	Quincey Koziol
@@ -551,10 +354,9 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_split_root(H5F_t *f, hid_t dxpl_id, H5B2_t *bt2, unsigned *bt2_flags_ptr)
+H5B2_split_root(H5B2_hdr_t *hdr, hid_t dxpl_id)
 {
     H5B2_internal_t *new_root;          /* Pointer to new root node */
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
     unsigned new_root_flags = H5AC__NO_FLAGS_SET;   /* Cache flags for new root node */
     H5B2_node_ptr_t old_root_ptr;       /* Old node pointer to root node in B-tree */
     size_t sz_max_nrec;                 /* Temporary variable for range checking */
@@ -563,61 +365,56 @@ H5B2_split_root(H5F_t *f, hid_t dxpl_id, H5B2_t *bt2, unsigned *bt2_flags_ptr)
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_split_root)
 
-    HDassert(f);
-    HDassert(bt2);
-    HDassert(bt2_flags_ptr);
-
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(bt2->shared);
-    HDassert(shared);
+    /* Check arguments. */
+    HDassert(hdr);
 
     /* Update depth of B-tree */
-    shared->depth++;
+    hdr->depth++;
 
     /* Re-allocate array of node info structs */
-    if((shared->node_info = H5FL_SEQ_REALLOC(H5B2_node_info_t, shared->node_info, (size_t)(shared->depth + 1))) == NULL)
+    if(NULL == (hdr->node_info = H5FL_SEQ_REALLOC(H5B2_node_info_t, hdr->node_info, (size_t)(hdr->depth + 1))))
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
 
     /* Update node info for new depth of tree */
-    sz_max_nrec = H5B2_NUM_INT_REC(f, shared, shared->depth);
-    H5_ASSIGN_OVERFLOW(/* To: */ shared->node_info[shared->depth].max_nrec, /* From: */ sz_max_nrec, /* From: */ size_t, /* To: */ unsigned)
-    shared->node_info[shared->depth].split_nrec = (shared->node_info[shared->depth].max_nrec * shared->split_percent) / 100;
-    shared->node_info[shared->depth].merge_nrec = (shared->node_info[shared->depth].max_nrec * shared->merge_percent) / 100;
-    shared->node_info[shared->depth].cum_max_nrec = ((shared->node_info[shared->depth].max_nrec + 1) *
-        shared->node_info[shared->depth - 1].cum_max_nrec) + shared->node_info[shared->depth].max_nrec;
-    u_max_nrec_size = H5V_limit_enc_size((uint64_t)shared->node_info[shared->depth].cum_max_nrec);
-    H5_ASSIGN_OVERFLOW(/* To: */ shared->node_info[shared->depth].cum_max_nrec_size, /* From: */ u_max_nrec_size, /* From: */ unsigned, /* To: */ uint8_t)
-    if((shared->node_info[shared->depth].nat_rec_fac = H5FL_fac_init(shared->type->nrec_size * shared->node_info[shared->depth].max_nrec)) == NULL)
+    sz_max_nrec = H5B2_NUM_INT_REC(hdr, hdr->depth);
+    H5_ASSIGN_OVERFLOW(/* To: */ hdr->node_info[hdr->depth].max_nrec, /* From: */ sz_max_nrec, /* From: */ size_t, /* To: */ unsigned)
+    hdr->node_info[hdr->depth].split_nrec = (hdr->node_info[hdr->depth].max_nrec * hdr->split_percent) / 100;
+    hdr->node_info[hdr->depth].merge_nrec = (hdr->node_info[hdr->depth].max_nrec * hdr->merge_percent) / 100;
+    hdr->node_info[hdr->depth].cum_max_nrec = ((hdr->node_info[hdr->depth].max_nrec + 1) *
+        hdr->node_info[hdr->depth - 1].cum_max_nrec) + hdr->node_info[hdr->depth].max_nrec;
+    u_max_nrec_size = H5V_limit_enc_size((uint64_t)hdr->node_info[hdr->depth].cum_max_nrec);
+    H5_ASSIGN_OVERFLOW(/* To: */ hdr->node_info[hdr->depth].cum_max_nrec_size, /* From: */ u_max_nrec_size, /* From: */ unsigned, /* To: */ uint8_t)
+    if(NULL == (hdr->node_info[hdr->depth].nat_rec_fac = H5FL_fac_init(hdr->cls->nrec_size * hdr->node_info[hdr->depth].max_nrec)))
 	HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't create node native key block factory")
-    if((shared->node_info[shared->depth].node_ptr_fac = H5FL_fac_init(sizeof(H5B2_node_ptr_t) * (shared->node_info[shared->depth].max_nrec + 1))) == NULL)
+    if(NULL == (hdr->node_info[hdr->depth].node_ptr_fac = H5FL_fac_init(sizeof(H5B2_node_ptr_t) * (hdr->node_info[hdr->depth].max_nrec + 1))))
 	HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't create internal 'branch' node node pointer block factory")
 
     /* Keep old root node pointer info */
-    old_root_ptr = bt2->root;
+    old_root_ptr = hdr->root;
 
     /* Create new internal node to use as root */
-    bt2->root.node_nrec = 0;
-    if(H5B2_create_internal(f, dxpl_id, bt2->shared, &(bt2->root), shared->depth) < 0)
+    hdr->root.node_nrec = 0;
+    if(H5B2_create_internal(hdr, dxpl_id, &(hdr->root), hdr->depth) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTINIT, FAIL, "unable to create new internal node")
 
     /* Protect new root node */
-    if(NULL == (new_root = H5B2_protect_internal(f, dxpl_id, bt2->shared, bt2->root.addr, bt2->root.node_nrec, shared->depth, H5AC_WRITE)))
+    if(NULL == (new_root = H5B2_protect_internal(hdr, dxpl_id, hdr->root.addr, hdr->root.node_nrec, hdr->depth, H5AC_WRITE)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
     /* Set first node pointer in root node to old root node pointer info */
     new_root->node_ptrs[0] = old_root_ptr;
 
     /* Split original root node */
-    if(H5B2_split1(f, dxpl_id, shared->depth, &(bt2->root), bt2_flags_ptr, new_root, &new_root_flags, 0) < 0)
+    if(H5B2_split1(hdr, dxpl_id, hdr->depth, &(hdr->root), NULL, new_root, &new_root_flags, 0) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to split old root node")
 
     /* Release new root node (marked as dirty) */
-    if(H5AC_unprotect(f, dxpl_id, H5AC_BT2_INT, bt2->root.addr, new_root, new_root_flags) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_INT, hdr->root.addr, new_root, new_root_flags) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree internal node")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5B2_split_root */
+} /* end H5B2_split_root() */
 
 
 /*-------------------------------------------------------------------------
@@ -626,7 +423,6 @@ done:
  * Purpose:	Redistribute records between two nodes
  *
  * Return:	Success:	Non-negative
- *
  *		Failure:	Negative
  *
  * Programmer:	Quincey Koziol
@@ -636,27 +432,24 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_redistribute2(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_internal_t *internal, unsigned idx)
+H5B2_redistribute2(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
+    H5B2_internal_t *internal, unsigned idx)
 {
     const H5AC_class_t *child_class;    /* Pointer to child node's class info */
     haddr_t left_addr, right_addr;      /* Addresses of left & right child nodes */
     void *left_child, *right_child;     /* Pointers to child nodes */
-    unsigned *left_nrec, *right_nrec;   /* Pointers to child # of records */
+    uint16_t *left_nrec, *right_nrec;   /* Pointers to child # of records */
     uint8_t *left_native, *right_native;    /* Pointers to childs' native records */
-    H5B2_node_ptr_t *left_node_ptrs=NULL, *right_node_ptrs=NULL;/* Pointers to childs' node pointer info */
-    H5B2_shared_t *shared;              /* B-tree's shared info */
-    hssize_t left_moved_nrec=0, right_moved_nrec=0; /* Number of records moved, for internal redistrib */
-    herr_t ret_value=SUCCEED;           /* Return value */
+    H5B2_node_ptr_t *left_node_ptrs = NULL, *right_node_ptrs = NULL;/* Pointers to childs' node pointer info */
+    hssize_t left_moved_nrec = 0, right_moved_nrec = 0; /* Number of records moved, for internal redistrib */
+    herr_t ret_value = SUCCEED;           /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_redistribute2)
 
-    HDassert(f);
+    /* Check arguments. */
+    HDassert(hdr);
     HDassert(internal);
 
-    /* Get the pointer to the shared B-tree info */
-    shared=(H5B2_shared_t *)H5RC_GET_OBJ(internal->shared);
-    HDassert(shared);
-
     /* Check for the kind of B-tree node to redistribute */
     if(depth > 1) {
         H5B2_internal_t *left_internal;         /* Pointer to left internal node */
@@ -665,12 +458,12 @@ H5B2_redistribute2(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_internal_t *int
         /* Setup information for unlocking child nodes */
         child_class = H5AC_BT2_INT;
         left_addr = internal->node_ptrs[idx].addr;
-        right_addr = internal->node_ptrs[idx+1].addr;
+        right_addr = internal->node_ptrs[idx + 1].addr;
 
         /* Lock left & right B-tree child nodes */
-        if (NULL == (left_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, left_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (left_internal = H5B2_protect_internal(hdr, dxpl_id, left_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
-        if (NULL == (right_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, right_addr, internal->node_ptrs[idx+1].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (right_internal = H5B2_protect_internal(hdr, dxpl_id, right_addr, internal->node_ptrs[idx + 1].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
         /* More setup for child nodes */
@@ -690,12 +483,12 @@ H5B2_redistribute2(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_internal_t *int
         /* Setup information for unlocking child nodes */
         child_class = H5AC_BT2_LEAF;
         left_addr = internal->node_ptrs[idx].addr;
-        right_addr = internal->node_ptrs[idx+1].addr;
+        right_addr = internal->node_ptrs[idx + 1].addr;
 
         /* Lock left & right B-tree child nodes */
-        if (NULL == (left_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, left_addr, &(internal->node_ptrs[idx].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (left_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, left_addr, &(internal->node_ptrs[idx].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
-        if (NULL == (right_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, right_addr, &(internal->node_ptrs[idx+1].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (right_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, right_addr, &(internal->node_ptrs[idx + 1].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
         /* More setup for child nodes */
@@ -708,14 +501,14 @@ H5B2_redistribute2(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_internal_t *int
     } /* end else */
 
 #ifdef H5B2_DEBUG
-    H5B2_assert_internal((hsize_t)0,shared,internal);
-    if(depth>1) {
-        H5B2_assert_internal2(internal->node_ptrs[idx].all_nrec,shared,left_child,right_child);
-        H5B2_assert_internal2(internal->node_ptrs[idx+1].all_nrec,shared,right_child,left_child);
+    H5B2_assert_internal((hsize_t)0, hdr, internal);
+    if(depth > 1) {
+        H5B2_assert_internal2(internal->node_ptrs[idx].all_nrec, hdr, left_child, right_child);
+        H5B2_assert_internal2(internal->node_ptrs[idx + 1].all_nrec, hdr, right_child, left_child);
     } /* end if */
     else {
-        H5B2_assert_leaf2(shared,left_child,right_child);
-        H5B2_assert_leaf(shared,right_child);
+        H5B2_assert_leaf2(hdr, left_child, right_child);
+        H5B2_assert_leaf(hdr, right_child);
     } /* end else */
 #endif /* H5B2_DEBUG */
 
@@ -723,24 +516,24 @@ H5B2_redistribute2(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_internal_t *int
     if(*left_nrec < *right_nrec) {
         /* Moving record from right node to left */
 
-        unsigned new_right_nrec = (*left_nrec + *right_nrec) / 2;             /* New number of records for right child */
-        unsigned move_nrec = *right_nrec - new_right_nrec;      /* Number of records to move from right node to left */
+        uint16_t new_right_nrec = (*left_nrec + *right_nrec) / 2;             /* New number of records for right child */
+        uint16_t move_nrec = *right_nrec - new_right_nrec;      /* Number of records to move from right node to left */
 
         /* Copy record from parent node down into left child */
-        HDmemcpy(H5B2_NAT_NREC(left_native,shared,*left_nrec),H5B2_INT_NREC(internal,shared,idx),shared->type->nrec_size);
+        HDmemcpy(H5B2_NAT_NREC(left_native, hdr, *left_nrec), H5B2_INT_NREC(internal, hdr, idx), hdr->cls->nrec_size);
 
         /* See if we need to move records from right node */
-        if(move_nrec>1)
-            HDmemcpy(H5B2_NAT_NREC(left_native,shared,(*left_nrec+1)),H5B2_NAT_NREC(right_native,shared,0),shared->type->nrec_size*(move_nrec-1));
+        if(move_nrec > 1)
+            HDmemcpy(H5B2_NAT_NREC(left_native, hdr, (*left_nrec + 1)), H5B2_NAT_NREC(right_native, hdr, 0), hdr->cls->nrec_size * (move_nrec - 1));
 
         /* Move record from right node into parent node */
-        HDmemcpy(H5B2_INT_NREC(internal,shared,idx),H5B2_NAT_NREC(right_native,shared,(move_nrec-1)),shared->type->nrec_size);
+        HDmemcpy(H5B2_INT_NREC(internal, hdr, idx), H5B2_NAT_NREC(right_native, hdr, (move_nrec - 1)), hdr->cls->nrec_size);
 
         /* Slide records in right node down */
-        HDmemmove(H5B2_NAT_NREC(right_native,shared,0),H5B2_NAT_NREC(right_native,shared,move_nrec),shared->type->nrec_size*new_right_nrec);
+        HDmemmove(H5B2_NAT_NREC(right_native, hdr, 0), H5B2_NAT_NREC(right_native, hdr, move_nrec), hdr->cls->nrec_size * new_right_nrec);
 
         /* Handle node pointers, if we have an internal node */
-        if(depth>1) {
+        if(depth > 1) {
             hsize_t moved_nrec = move_nrec;   /* Total number of records moved, for internal redistrib */
             unsigned u;             /* Local index variable */
 
@@ -754,7 +547,7 @@ H5B2_redistribute2(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_internal_t *int
             HDmemcpy(&(left_node_ptrs[*left_nrec + 1]), &(right_node_ptrs[0]), sizeof(H5B2_node_ptr_t) * move_nrec);
 
             /* Slide node pointers in right node down */
-            HDmemmove(&(right_node_ptrs[0]), &(right_node_ptrs[move_nrec]), sizeof(H5B2_node_ptr_t) * (new_right_nrec + 1));
+            HDmemmove(&(right_node_ptrs[0]), &(right_node_ptrs[move_nrec]), sizeof(H5B2_node_ptr_t) * (new_right_nrec + (unsigned)1));
         } /* end if */
 
         /* Update number of records in child nodes */
@@ -764,37 +557,37 @@ H5B2_redistribute2(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_internal_t *int
     else {
         /* Moving record from left node to right */
 
-        unsigned new_left_nrec = (*left_nrec + *right_nrec) / 2;    /* New number of records for left child */
-        unsigned move_nrec = *left_nrec - new_left_nrec;        /* Number of records to move from left node to right */
+        uint16_t new_left_nrec = (*left_nrec + *right_nrec) / 2;    /* New number of records for left child */
+        uint16_t move_nrec = *left_nrec - new_left_nrec;        /* Number of records to move from left node to right */
 
         /* Slide records in right node up */
-        HDmemmove(H5B2_NAT_NREC(right_native,shared,move_nrec),
-                H5B2_NAT_NREC(right_native,shared,0),
-                shared->type->nrec_size*(*right_nrec));
+        HDmemmove(H5B2_NAT_NREC(right_native, hdr, move_nrec),
+                H5B2_NAT_NREC(right_native, hdr, 0),
+                hdr->cls->nrec_size * (*right_nrec));
 
         /* Copy record from parent node down into right child */
-        HDmemcpy(H5B2_NAT_NREC(right_native,shared,(move_nrec-1)),H5B2_INT_NREC(internal,shared,idx),shared->type->nrec_size);
+        HDmemcpy(H5B2_NAT_NREC(right_native, hdr, (move_nrec - 1)), H5B2_INT_NREC(internal, hdr, idx), hdr->cls->nrec_size);
 
         /* See if we need to move records from left node */
-        if(move_nrec>1)
-            HDmemcpy(H5B2_NAT_NREC(right_native,shared,0),H5B2_NAT_NREC(left_native,shared,((*left_nrec-move_nrec)+1)),shared->type->nrec_size*(move_nrec-1));
+        if(move_nrec > 1)
+            HDmemcpy(H5B2_NAT_NREC(right_native, hdr, 0), H5B2_NAT_NREC(left_native, hdr, ((*left_nrec - move_nrec) + 1)), hdr->cls->nrec_size * (move_nrec - 1));
 
         /* Move record from left node into parent node */
-        HDmemcpy(H5B2_INT_NREC(internal,shared,idx),H5B2_NAT_NREC(left_native,shared,(*left_nrec-move_nrec)),shared->type->nrec_size);
+        HDmemcpy(H5B2_INT_NREC(internal, hdr, idx), H5B2_NAT_NREC(left_native, hdr, (*left_nrec - move_nrec)), hdr->cls->nrec_size);
 
         /* Handle node pointers, if we have an internal node */
-        if(depth>1) {
-            hsize_t moved_nrec=move_nrec;   /* Total number of records moved, for internal redistrib */
+        if(depth > 1) {
+            hsize_t moved_nrec = move_nrec;   /* Total number of records moved, for internal redistrib */
             unsigned u;             /* Local index variable */
 
             /* Slide node pointers in right node up */
-            HDmemmove(&(right_node_ptrs[move_nrec]),&(right_node_ptrs[0]),sizeof(H5B2_node_ptr_t)*(*right_nrec+1));
+            HDmemmove(&(right_node_ptrs[move_nrec]), &(right_node_ptrs[0]), sizeof(H5B2_node_ptr_t) * (*right_nrec + 1));
 
             /* Copy node pointers from left node to right */
-            HDmemcpy(&(right_node_ptrs[0]),&(left_node_ptrs[new_left_nrec+1]),sizeof(H5B2_node_ptr_t)*move_nrec);
+            HDmemcpy(&(right_node_ptrs[0]), &(left_node_ptrs[new_left_nrec + 1]), sizeof(H5B2_node_ptr_t) * move_nrec);
 
             /* Count the number of records being moved */
-            for(u=0; u<move_nrec; u++)
+            for(u = 0; u < move_nrec; u++)
                 moved_nrec += right_node_ptrs[u].all_nrec;
             left_moved_nrec -= (hssize_t)moved_nrec;
             H5_ASSIGN_OVERFLOW(/* To: */ right_moved_nrec, /* From: */ moved_nrec, /* From: */ hsize_t, /* To: */ hssize_t)
@@ -807,38 +600,38 @@ H5B2_redistribute2(H5F_t *f, hid_t dxpl_id, unsigned depth, H5B2_internal_t *int
 
     /* Update # of records in child nodes */
     internal->node_ptrs[idx].node_nrec = *left_nrec;
-    internal->node_ptrs[idx+1].node_nrec = *right_nrec;
+    internal->node_ptrs[idx + 1].node_nrec = *right_nrec;
 
     /* Update total # of records in child B-trees */
-    if(depth>1) {
+    if(depth > 1) {
         internal->node_ptrs[idx].all_nrec += left_moved_nrec;
-        internal->node_ptrs[idx+1].all_nrec += right_moved_nrec;
+        internal->node_ptrs[idx + 1].all_nrec += right_moved_nrec;
     } /* end if */
     else {
         internal->node_ptrs[idx].all_nrec = internal->node_ptrs[idx].node_nrec;
-        internal->node_ptrs[idx+1].all_nrec = internal->node_ptrs[idx+1].node_nrec;
+        internal->node_ptrs[idx + 1].all_nrec = internal->node_ptrs[idx + 1].node_nrec;
     } /* end else */
 
 #ifdef H5B2_DEBUG
-    H5B2_assert_internal((hsize_t)0,shared,internal);
-    if(depth>1) {
-        H5B2_assert_internal2(internal->node_ptrs[idx].all_nrec,shared,left_child,right_child);
-        H5B2_assert_internal2(internal->node_ptrs[idx+1].all_nrec,shared,right_child,left_child);
+    H5B2_assert_internal((hsize_t)0, hdr, internal);
+    if(depth > 1) {
+        H5B2_assert_internal2(internal->node_ptrs[idx].all_nrec, hdr, left_child, right_child);
+        H5B2_assert_internal2(internal->node_ptrs[idx + 1].all_nrec, hdr, right_child, left_child);
     } /* end if */
     else {
-        H5B2_assert_leaf2(shared,left_child,right_child);
-        H5B2_assert_leaf(shared,right_child);
+        H5B2_assert_leaf2(hdr, left_child, right_child);
+        H5B2_assert_leaf(hdr, right_child);
     } /* end else */
 #endif /* H5B2_DEBUG */
 
     /* Release child nodes (marked as dirty) */
-    if (H5AC_unprotect(f, dxpl_id, child_class, left_addr, left_child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, left_addr, left_child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
-    if (H5AC_unprotect(f, dxpl_id, child_class, right_addr, right_child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, right_addr, right_child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5B2_redistribute2 */
 
 
@@ -848,7 +641,6 @@ done:
  * Purpose:	Redistribute records between three nodes
  *
  * Return:	Success:	Non-negative
- *
  *		Failure:	Negative
  *
  * Programmer:	Quincey Koziol
@@ -858,7 +650,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
+H5B2_redistribute3(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     H5B2_internal_t *internal, unsigned *internal_flags_ptr, unsigned idx)
 {
     const H5AC_class_t *child_class;    /* Pointer to child node's class info */
@@ -866,27 +658,23 @@ H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
     haddr_t middle_addr;                /* Address of middle child node */
     void *left_child, *right_child;     /* Pointers to child nodes */
     void *middle_child;                 /* Pointers to middle child node */
-    unsigned *left_nrec, *right_nrec;   /* Pointers to child # of records */
-    unsigned *middle_nrec;              /* Pointers to middle child # of records */
+    uint16_t *left_nrec, *right_nrec;   /* Pointers to child # of records */
+    uint16_t *middle_nrec;              /* Pointers to middle child # of records */
     uint8_t *left_native, *right_native;    /* Pointers to childs' native records */
     uint8_t *middle_native;             /* Pointers to middle child's native records */
-    H5B2_shared_t *shared;              /* B-tree's shared info */
-    H5B2_node_ptr_t *left_node_ptrs=NULL, *right_node_ptrs=NULL;/* Pointers to childs' node pointer info */
-    H5B2_node_ptr_t *middle_node_ptrs=NULL;/* Pointers to childs' node pointer info */
-    hssize_t left_moved_nrec=0, right_moved_nrec=0; /* Number of records moved, for internal split */
-    hssize_t middle_moved_nrec=0;       /* Number of records moved, for internal split */
-    herr_t ret_value=SUCCEED;           /* Return value */
+    H5B2_node_ptr_t *left_node_ptrs = NULL, *right_node_ptrs = NULL; /* Pointers to childs' node pointer info */
+    H5B2_node_ptr_t *middle_node_ptrs = NULL; /* Pointers to childs' node pointer info */
+    hssize_t left_moved_nrec = 0, right_moved_nrec = 0; /* Number of records moved, for internal split */
+    hssize_t middle_moved_nrec = 0;     /* Number of records moved, for internal split */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_redistribute3)
 
-    HDassert(f);
+    /* Check arguments. */
+    HDassert(hdr);
     HDassert(internal);
     HDassert(internal_flags_ptr);
 
-    /* Get the pointer to the shared B-tree info */
-    shared=(H5B2_shared_t *)H5RC_GET_OBJ(internal->shared);
-    HDassert(shared);
-
     /* Check for the kind of B-tree node to redistribute */
     if(depth > 1) {
         H5B2_internal_t *left_internal;         /* Pointer to left internal node */
@@ -895,16 +683,16 @@ H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
 
         /* Setup information for unlocking child nodes */
         child_class = H5AC_BT2_INT;
-        left_addr = internal->node_ptrs[idx-1].addr;
+        left_addr = internal->node_ptrs[idx - 1].addr;
         middle_addr = internal->node_ptrs[idx].addr;
-        right_addr = internal->node_ptrs[idx+1].addr;
+        right_addr = internal->node_ptrs[idx + 1].addr;
 
         /* Lock B-tree child nodes */
-        if (NULL == (left_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, left_addr, internal->node_ptrs[idx-1].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (left_internal = H5B2_protect_internal(hdr, dxpl_id, left_addr, internal->node_ptrs[idx - 1].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
-        if (NULL == (middle_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, middle_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (middle_internal = H5B2_protect_internal(hdr, dxpl_id, middle_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
-        if (NULL == (right_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, right_addr, internal->node_ptrs[idx+1].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (right_internal = H5B2_protect_internal(hdr, dxpl_id, right_addr, internal->node_ptrs[idx + 1].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
         /* More setup for child nodes */
@@ -928,16 +716,16 @@ H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
 
         /* Setup information for unlocking child nodes */
         child_class = H5AC_BT2_LEAF;
-        left_addr = internal->node_ptrs[idx-1].addr;
+        left_addr = internal->node_ptrs[idx - 1].addr;
         middle_addr = internal->node_ptrs[idx].addr;
-        right_addr = internal->node_ptrs[idx+1].addr;
+        right_addr = internal->node_ptrs[idx + 1].addr;
 
         /* Lock B-tree child nodes */
-        if (NULL == (left_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, left_addr, &(internal->node_ptrs[idx-1].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (left_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, left_addr, &(internal->node_ptrs[idx - 1].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
-        if (NULL == (middle_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, middle_addr, &(internal->node_ptrs[idx].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (middle_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, middle_addr, &(internal->node_ptrs[idx].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
-        if (NULL == (right_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, right_addr, &(internal->node_ptrs[idx+1].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (right_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, right_addr, &(internal->node_ptrs[idx + 1].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
         /* More setup for child nodes */
@@ -956,10 +744,10 @@ H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
     {
         /* Compute new # of records in each node */
         unsigned total_nrec = *left_nrec + *middle_nrec + *right_nrec + 2;
-        unsigned new_middle_nrec = (total_nrec - 2) / 3;
-        unsigned new_left_nrec = ((total_nrec - 2) - new_middle_nrec) / 2;
-        unsigned new_right_nrec = (total_nrec - 2) - (new_left_nrec + new_middle_nrec);
-        unsigned curr_middle_nrec = *middle_nrec;
+        uint16_t new_middle_nrec = (total_nrec - 2) / 3;
+        uint16_t new_left_nrec = ((total_nrec - 2) - new_middle_nrec) / 2;
+        uint16_t new_right_nrec = (total_nrec - 2) - (new_left_nrec + new_middle_nrec);
+        uint16_t curr_middle_nrec = *middle_nrec;
 
         /* Sanity check rounding */
         HDassert(new_middle_nrec <= new_left_nrec);
@@ -967,42 +755,42 @@ H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
 
         /* Move records into left node */
         if(new_left_nrec > *left_nrec) {
-            unsigned moved_middle_nrec = 0;      /* Number of records moved into left node */
+            uint16_t moved_middle_nrec = 0;      /* Number of records moved into left node */
 
             /* Move left parent record down to left node */
-            HDmemcpy(H5B2_NAT_NREC(left_native,shared,*left_nrec),H5B2_INT_NREC(internal,shared,idx-1),shared->type->nrec_size);
+            HDmemcpy(H5B2_NAT_NREC(left_native, hdr, *left_nrec), H5B2_INT_NREC(internal, hdr, idx - 1), hdr->cls->nrec_size);
 
             /* Move records from middle node into left node */
             if((new_left_nrec - 1) > *left_nrec) {
-                moved_middle_nrec = new_left_nrec-(*left_nrec + 1);
-                HDmemcpy(H5B2_NAT_NREC(left_native, shared, *left_nrec + 1),H5B2_NAT_NREC(middle_native, shared, 0), shared->type->nrec_size * moved_middle_nrec);
+                moved_middle_nrec = new_left_nrec - (*left_nrec + 1);
+                HDmemcpy(H5B2_NAT_NREC(left_native, hdr, *left_nrec + 1), H5B2_NAT_NREC(middle_native, hdr, 0), hdr->cls->nrec_size * moved_middle_nrec);
             } /* end if */
 
             /* Move record from middle node up to parent node */
-            HDmemcpy(H5B2_INT_NREC(internal,shared,idx-1),H5B2_NAT_NREC(middle_native,shared,moved_middle_nrec),shared->type->nrec_size);
+            HDmemcpy(H5B2_INT_NREC(internal, hdr, idx - 1), H5B2_NAT_NREC(middle_native, hdr, moved_middle_nrec), hdr->cls->nrec_size);
             moved_middle_nrec++;
 
             /* Slide records in middle node down */
-            HDmemmove(H5B2_NAT_NREC(middle_native,shared,0),H5B2_NAT_NREC(middle_native,shared,moved_middle_nrec),shared->type->nrec_size*(*middle_nrec-moved_middle_nrec));
+            HDmemmove(H5B2_NAT_NREC(middle_native, hdr, 0), H5B2_NAT_NREC(middle_native, hdr, moved_middle_nrec), hdr->cls->nrec_size * (*middle_nrec - moved_middle_nrec));
 
             /* Move node pointers also if this is an internal node */
-            if(depth>1) {
+            if(depth > 1) {
                 hsize_t moved_nrec;         /* Total number of records moved, for internal redistrib */
                 unsigned move_nptrs;    /* Number of node pointers to move */
                 unsigned u;             /* Local index variable */
 
                 /* Move middle node pointers into left node */
                 move_nptrs = new_left_nrec - *left_nrec;
-                HDmemcpy(&(left_node_ptrs[*left_nrec+1]),&(middle_node_ptrs[0]),sizeof(H5B2_node_ptr_t)*move_nptrs);
+                HDmemcpy(&(left_node_ptrs[*left_nrec + 1]), &(middle_node_ptrs[0]), sizeof(H5B2_node_ptr_t)*move_nptrs);
 
                 /* Count the number of records being moved into the left node */
-                for(u=0, moved_nrec=0; u<move_nptrs; u++)
+                for(u = 0, moved_nrec = 0; u < move_nptrs; u++)
                     moved_nrec += middle_node_ptrs[u].all_nrec;
-                left_moved_nrec = moved_nrec+move_nptrs;
-                middle_moved_nrec -= moved_nrec+move_nptrs;
+                left_moved_nrec = moved_nrec + move_nptrs;
+                middle_moved_nrec -= moved_nrec + move_nptrs;
 
                 /* Slide the node pointers in middle node down */
-                HDmemmove(&(middle_node_ptrs[0]),&(middle_node_ptrs[move_nptrs]),sizeof(H5B2_node_ptr_t)*((*middle_nrec-move_nptrs)+1));
+                HDmemmove(&(middle_node_ptrs[0]), &(middle_node_ptrs[move_nptrs]), sizeof(H5B2_node_ptr_t) * ((*middle_nrec - move_nptrs) + 1));
             } /* end if */
 
             /* Update the current number of records in middle node */
@@ -1010,38 +798,38 @@ H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
         } /* end if */
 
         /* Move records into right node */
-        if(new_right_nrec>*right_nrec) {
-            unsigned right_nrec_move = new_right_nrec-*right_nrec; /* Number of records to move out of right node */
+        if(new_right_nrec > *right_nrec) {
+            unsigned right_nrec_move = new_right_nrec - *right_nrec; /* Number of records to move out of right node */
 
             /* Slide records in right node up */
-            HDmemmove(H5B2_NAT_NREC(right_native,shared,right_nrec_move),H5B2_NAT_NREC(right_native,shared,0),shared->type->nrec_size*(*right_nrec));
+            HDmemmove(H5B2_NAT_NREC(right_native, hdr, right_nrec_move), H5B2_NAT_NREC(right_native, hdr, 0), hdr->cls->nrec_size * (*right_nrec));
 
             /* Move right parent record down to right node */
-            HDmemcpy(H5B2_NAT_NREC(right_native,shared,right_nrec_move-1),H5B2_INT_NREC(internal,shared,idx),shared->type->nrec_size);
+            HDmemcpy(H5B2_NAT_NREC(right_native, hdr, right_nrec_move - 1), H5B2_INT_NREC(internal, hdr, idx), hdr->cls->nrec_size);
 
             /* Move records from middle node into right node */
-            if(right_nrec_move>1)
-                HDmemcpy(H5B2_NAT_NREC(right_native,shared,0),H5B2_NAT_NREC(middle_native,shared,((curr_middle_nrec-right_nrec_move)+1)),shared->type->nrec_size*(right_nrec_move-1));
+            if(right_nrec_move > 1)
+                HDmemcpy(H5B2_NAT_NREC(right_native, hdr, 0), H5B2_NAT_NREC(middle_native, hdr, ((curr_middle_nrec - right_nrec_move) + 1)), hdr->cls->nrec_size * (right_nrec_move - 1));
 
             /* Move record from middle node up to parent node */
-            HDmemcpy(H5B2_INT_NREC(internal,shared,idx),H5B2_NAT_NREC(middle_native,shared,(curr_middle_nrec-right_nrec_move)),shared->type->nrec_size);
+            HDmemcpy(H5B2_INT_NREC(internal, hdr, idx), H5B2_NAT_NREC(middle_native, hdr, (curr_middle_nrec - right_nrec_move)), hdr->cls->nrec_size);
 
             /* Move node pointers also if this is an internal node */
-            if(depth>1) {
+            if(depth > 1) {
                 hsize_t moved_nrec;         /* Total number of records moved, for internal redistrib */
                 unsigned u;             /* Local index variable */
 
                 /* Slide the node pointers in right node up */
-                HDmemmove(&(right_node_ptrs[right_nrec_move]),&(right_node_ptrs[0]),sizeof(H5B2_node_ptr_t)*(*right_nrec+1));
+                HDmemmove(&(right_node_ptrs[right_nrec_move]), &(right_node_ptrs[0]), sizeof(H5B2_node_ptr_t) * (*right_nrec + 1));
 
                 /* Move middle node pointers into right node */
-                HDmemcpy(&(right_node_ptrs[0]),&(middle_node_ptrs[(curr_middle_nrec-right_nrec_move)+1]),sizeof(H5B2_node_ptr_t)*right_nrec_move);
+                HDmemcpy(&(right_node_ptrs[0]), &(middle_node_ptrs[(curr_middle_nrec - right_nrec_move) + 1]), sizeof(H5B2_node_ptr_t) * right_nrec_move);
 
                 /* Count the number of records being moved into the right node */
-                for(u=0, moved_nrec=0; u<right_nrec_move; u++)
+                for(u = 0, moved_nrec = 0; u < right_nrec_move; u++)
                     moved_nrec += right_node_ptrs[u].all_nrec;
-                right_moved_nrec = moved_nrec+right_nrec_move;
-                middle_moved_nrec -= moved_nrec+right_nrec_move;
+                right_moved_nrec = moved_nrec + right_nrec_move;
+                middle_moved_nrec -= moved_nrec + right_nrec_move;
             } /* end if */
 
             /* Update the current number of records in middle node */
@@ -1049,38 +837,38 @@ H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
         } /* end if */
 
         /* Move records out of left node */
-        if(new_left_nrec<*left_nrec) {
-            unsigned left_nrec_move = *left_nrec-new_left_nrec; /* Number of records to move out of left node */
+        if(new_left_nrec < *left_nrec) {
+            unsigned left_nrec_move = *left_nrec - new_left_nrec; /* Number of records to move out of left node */
 
             /* Slide middle records up */
-            HDmemmove(H5B2_NAT_NREC(middle_native,shared,left_nrec_move),H5B2_NAT_NREC(middle_native,shared,0),shared->type->nrec_size*curr_middle_nrec);
+            HDmemmove(H5B2_NAT_NREC(middle_native, hdr, left_nrec_move), H5B2_NAT_NREC(middle_native, hdr, 0), hdr->cls->nrec_size * curr_middle_nrec);
 
             /* Move left parent record down to middle node */
-            HDmemcpy(H5B2_NAT_NREC(middle_native,shared,left_nrec_move-1),H5B2_INT_NREC(internal,shared,idx-1),shared->type->nrec_size);
+            HDmemcpy(H5B2_NAT_NREC(middle_native, hdr, left_nrec_move - 1), H5B2_INT_NREC(internal, hdr, idx - 1), hdr->cls->nrec_size);
 
             /* Move left records to middle node */
-            if(left_nrec_move>1)
-                HDmemmove(H5B2_NAT_NREC(middle_native,shared,0),H5B2_NAT_NREC(left_native,shared,new_left_nrec+1),shared->type->nrec_size*(left_nrec_move-1));
+            if(left_nrec_move > 1)
+                HDmemmove(H5B2_NAT_NREC(middle_native, hdr, 0), H5B2_NAT_NREC(left_native, hdr, new_left_nrec + 1), hdr->cls->nrec_size * (left_nrec_move - 1));
 
             /* Move left parent record up from left node */
-            HDmemcpy(H5B2_INT_NREC(internal,shared,idx-1),H5B2_NAT_NREC(left_native,shared,new_left_nrec),shared->type->nrec_size);
+            HDmemcpy(H5B2_INT_NREC(internal, hdr, idx - 1), H5B2_NAT_NREC(left_native, hdr, new_left_nrec), hdr->cls->nrec_size);
 
             /* Move node pointers also if this is an internal node */
-            if(depth>1) {
+            if(depth > 1) {
                 hsize_t moved_nrec;         /* Total number of records moved, for internal redistrib */
                 unsigned u;             /* Local index variable */
 
                 /* Slide the node pointers in middle node up */
-                HDmemmove(&(middle_node_ptrs[left_nrec_move]),&(middle_node_ptrs[0]),sizeof(H5B2_node_ptr_t)*(curr_middle_nrec+1));
+                HDmemmove(&(middle_node_ptrs[left_nrec_move]), &(middle_node_ptrs[0]), sizeof(H5B2_node_ptr_t) * (curr_middle_nrec + 1));
 
                 /* Move left node pointers into middle node */
-                HDmemcpy(&(middle_node_ptrs[0]),&(left_node_ptrs[new_left_nrec+1]),sizeof(H5B2_node_ptr_t)*left_nrec_move);
+                HDmemcpy(&(middle_node_ptrs[0]), &(left_node_ptrs[new_left_nrec + 1]), sizeof(H5B2_node_ptr_t) * left_nrec_move);
 
                 /* Count the number of records being moved into the left node */
-                for(u=0, moved_nrec=0; u<left_nrec_move; u++)
+                for(u = 0, moved_nrec = 0; u < left_nrec_move; u++)
                     moved_nrec += middle_node_ptrs[u].all_nrec;
-                left_moved_nrec -= moved_nrec+left_nrec_move;
-                middle_moved_nrec += moved_nrec+left_nrec_move;
+                left_moved_nrec -= moved_nrec + left_nrec_move;
+                middle_moved_nrec += moved_nrec + left_nrec_move;
             } /* end if */
 
             /* Update the current number of records in middle node */
@@ -1088,37 +876,37 @@ H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
         } /* end if */
 
         /* Move records out of right node */
-        if(new_right_nrec<*right_nrec) {
-            unsigned right_nrec_move = *right_nrec-new_right_nrec; /* Number of records to move out of right node */
+        if(new_right_nrec < *right_nrec) {
+            unsigned right_nrec_move = *right_nrec - new_right_nrec; /* Number of records to move out of right node */
 
             /* Move right parent record down to middle node */
-            HDmemcpy(H5B2_NAT_NREC(middle_native,shared,curr_middle_nrec),H5B2_INT_NREC(internal,shared,idx),shared->type->nrec_size);
+            HDmemcpy(H5B2_NAT_NREC(middle_native, hdr, curr_middle_nrec), H5B2_INT_NREC(internal, hdr, idx), hdr->cls->nrec_size);
 
             /* Move right records to middle node */
-            HDmemmove(H5B2_NAT_NREC(middle_native,shared,(curr_middle_nrec+1)),H5B2_NAT_NREC(right_native,shared,0),shared->type->nrec_size*(right_nrec_move-1));
+            HDmemmove(H5B2_NAT_NREC(middle_native, hdr, (curr_middle_nrec + 1)), H5B2_NAT_NREC(right_native, hdr, 0), hdr->cls->nrec_size * (right_nrec_move - 1));
 
             /* Move right parent record up from right node */
-            HDmemcpy(H5B2_INT_NREC(internal,shared,idx),H5B2_NAT_NREC(right_native,shared,right_nrec_move-1),shared->type->nrec_size);
+            HDmemcpy(H5B2_INT_NREC(internal, hdr, idx), H5B2_NAT_NREC(right_native, hdr, right_nrec_move - 1), hdr->cls->nrec_size);
 
             /* Slide right records down */
-            HDmemmove(H5B2_NAT_NREC(right_native,shared,0),H5B2_NAT_NREC(right_native,shared,right_nrec_move),shared->type->nrec_size*new_right_nrec);
+            HDmemmove(H5B2_NAT_NREC(right_native, hdr, 0), H5B2_NAT_NREC(right_native, hdr, right_nrec_move), hdr->cls->nrec_size * new_right_nrec);
 
             /* Move node pointers also if this is an internal node */
-            if(depth>1) {
+            if(depth > 1) {
                 hsize_t moved_nrec;         /* Total number of records moved, for internal redistrib */
                 unsigned u;             /* Local index variable */
 
                 /* Move right node pointers into middle node */
-                HDmemcpy(&(middle_node_ptrs[curr_middle_nrec+1]),&(right_node_ptrs[0]),sizeof(H5B2_node_ptr_t)*right_nrec_move);
+                HDmemcpy(&(middle_node_ptrs[curr_middle_nrec + 1]), &(right_node_ptrs[0]), sizeof(H5B2_node_ptr_t) * right_nrec_move);
 
                 /* Count the number of records being moved into the right node */
-                for(u=0, moved_nrec=0; u<right_nrec_move; u++)
+                for(u = 0, moved_nrec = 0; u < right_nrec_move; u++)
                     moved_nrec += right_node_ptrs[u].all_nrec;
-                right_moved_nrec -= moved_nrec+right_nrec_move;
-                middle_moved_nrec += moved_nrec+right_nrec_move;
+                right_moved_nrec -= moved_nrec + right_nrec_move;
+                middle_moved_nrec += moved_nrec + right_nrec_move;
 
                 /* Slide the node pointers in right node down */
-                HDmemmove(&(right_node_ptrs[0]),&(right_node_ptrs[right_nrec_move]),sizeof(H5B2_node_ptr_t)*(new_right_nrec+1));
+                HDmemmove(&(right_node_ptrs[0]), &(right_node_ptrs[right_nrec_move]), sizeof(H5B2_node_ptr_t) * (new_right_nrec + 1));
             } /* end if */
         } /* end if */
 
@@ -1129,20 +917,20 @@ H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
     } /* end block */
 
     /* Update # of records in child nodes */
-    internal->node_ptrs[idx-1].node_nrec = *left_nrec;
+    internal->node_ptrs[idx - 1].node_nrec = *left_nrec;
     internal->node_ptrs[idx].node_nrec = *middle_nrec;
-    internal->node_ptrs[idx+1].node_nrec = *right_nrec;
+    internal->node_ptrs[idx + 1].node_nrec = *right_nrec;
 
     /* Update total # of records in child B-trees */
-    if(depth>1) {
-        internal->node_ptrs[idx-1].all_nrec += left_moved_nrec;
+    if(depth > 1) {
+        internal->node_ptrs[idx - 1].all_nrec += left_moved_nrec;
         internal->node_ptrs[idx].all_nrec += middle_moved_nrec;
-        internal->node_ptrs[idx+1].all_nrec += right_moved_nrec;
+        internal->node_ptrs[idx + 1].all_nrec += right_moved_nrec;
     } /* end if */
     else {
-        internal->node_ptrs[idx-1].all_nrec = internal->node_ptrs[idx-1].node_nrec;
+        internal->node_ptrs[idx - 1].all_nrec = internal->node_ptrs[idx - 1].node_nrec;
         internal->node_ptrs[idx].all_nrec = internal->node_ptrs[idx].node_nrec;
-        internal->node_ptrs[idx+1].all_nrec = internal->node_ptrs[idx+1].node_nrec;
+        internal->node_ptrs[idx + 1].all_nrec = internal->node_ptrs[idx + 1].node_nrec;
     } /* end else */
 
     /* Mark parent as dirty */
@@ -1152,67 +940,67 @@ H5B2_redistribute3(H5F_t *f, hid_t dxpl_id, unsigned depth,
 {
     unsigned u;
 
-    HDfprintf(stderr,"%s: Internal records:\n",FUNC);
-    for(u=0; u<internal->nrec; u++) {
-        HDfprintf(stderr,"%s: u=%u\n",FUNC,u);
-        (shared->type->debug)(stderr,f,dxpl_id,3,4,H5B2_INT_NREC(internal,shared,u),NULL);
+    HDfprintf(stderr, "%s: Internal records:\n", FUNC);
+    for(u = 0; u < internal->nrec; u++) {
+        HDfprintf(stderr, "%s: u = %u\n", FUNC, u);
+        (hdr->cls->debug)(stderr, hdr->f, dxpl_id, 3, 4, H5B2_INT_NREC(internal, hdr, u), NULL);
     } /* end for */
 
-    HDfprintf(stderr,"%s: Left Child records:\n",FUNC);
-    for(u=0; u<*left_nrec; u++) {
-        HDfprintf(stderr,"%s: u=%u\n",FUNC,u);
-        (shared->type->debug)(stderr,f,dxpl_id,3,4,H5B2_NAT_NREC(left_native,shared,u),NULL);
+    HDfprintf(stderr, "%s: Left Child records:\n", FUNC);
+    for(u = 0; u < *left_nrec; u++) {
+        HDfprintf(stderr, "%s: u = %u\n", FUNC, u);
+        (hdr->cls->debug)(stderr, hdr->f, dxpl_id, 3, 4, H5B2_NAT_NREC(left_native, hdr, u), NULL);
     } /* end for */
 
-    HDfprintf(stderr,"%s: Middle Child records:\n",FUNC);
-    for(u=0; u<*middle_nrec; u++) {
-        HDfprintf(stderr,"%s: u=%u\n",FUNC,u);
-        (shared->type->debug)(stderr,f,dxpl_id,3,4,H5B2_NAT_NREC(middle_native,shared,u),NULL);
+    HDfprintf(stderr, "%s: Middle Child records:\n", FUNC);
+    for(u = 0; u < *middle_nrec; u++) {
+        HDfprintf(stderr, "%s: u = %u\n", FUNC, u);
+        (hdr->cls->debug)(stderr, hdr->f, dxpl_id, 3, 4, H5B2_NAT_NREC(middle_native, hdr, u), NULL);
     } /* end for */
 
-    HDfprintf(stderr,"%s: Right Child records:\n",FUNC);
-    for(u=0; u<*right_nrec; u++) {
-        HDfprintf(stderr,"%s: u=%u\n",FUNC,u);
-        (shared->type->debug)(stderr,f,dxpl_id,3,4,H5B2_NAT_NREC(right_native,shared,u),NULL);
+    HDfprintf(stderr, "%s: Right Child records:\n", FUNC);
+    for(u = 0; u < *right_nrec; u++) {
+        HDfprintf(stderr, "%s: u = %u\n", FUNC, u);
+        (hdr->cls->debug)(stderr, hdr->f, dxpl_id, 3, 4, H5B2_NAT_NREC(right_native, hdr, u), NULL);
     } /* end for */
 
-    for(u=0; u<internal->nrec+1; u++)
-        HDfprintf(stderr,"%s: internal->node_ptrs[%u]=(%Hu/%u/%a)\n",FUNC,u,internal->node_ptrs[u].all_nrec,internal->node_ptrs[u].node_nrec,internal->node_ptrs[u].addr);
-    if(depth>1) {
-        for(u=0; u<*left_nrec+1; u++)
-            HDfprintf(stderr,"%s: left_node_ptr[%u]=(%Hu/%u/%a)\n",FUNC,u,left_node_ptrs[u].all_nrec,left_node_ptrs[u].node_nrec,left_node_ptrs[u].addr);
-        for(u=0; u<*middle_nrec+1; u++)
-            HDfprintf(stderr,"%s: middle_node_ptr[%u]=(%Hu/%u/%a)\n",FUNC,u,middle_node_ptrs[u].all_nrec,middle_node_ptrs[u].node_nrec,middle_node_ptrs[u].addr);
-        for(u=0; u<*right_nrec+1; u++)
-            HDfprintf(stderr,"%s: right_node_ptr[%u]=(%Hu/%u/%a)\n",FUNC,u,right_node_ptrs[u].all_nrec,right_node_ptrs[u].node_nrec,right_node_ptrs[u].addr);
+    for(u = 0; u < internal->nrec + 1; u++)
+        HDfprintf(stderr, "%s: internal->node_ptrs[%u] = (%Hu/%u/%a)\n", FUNC, u, internal->node_ptrs[u].all_nrec, internal->node_ptrs[u].node_nrec, internal->node_ptrs[u].addr);
+    if(depth > 1) {
+        for(u = 0; u < *left_nrec + 1; u++)
+            HDfprintf(stderr, "%s: left_node_ptr[%u] = (%Hu/%u/%a)\n", FUNC, u, left_node_ptrs[u].all_nrec, left_node_ptrs[u].node_nrec, left_node_ptrs[u].addr);
+        for(u = 0; u < *middle_nrec + 1; u++)
+            HDfprintf(stderr, "%s: middle_node_ptr[%u] = (%Hu/%u/%a)\n", FUNC, u, middle_node_ptrs[u].all_nrec, middle_node_ptrs[u].node_nrec, middle_node_ptrs[u].addr);
+        for(u = 0; u < *right_nrec + 1; u++)
+            HDfprintf(stderr, "%s: right_node_ptr[%u] = (%Hu/%u/%a)\n", FUNC, u, right_node_ptrs[u].all_nrec, right_node_ptrs[u].node_nrec, right_node_ptrs[u].addr);
     } /* end if */
 }
 #endif /* QAK */
 #ifdef H5B2_DEBUG
-    H5B2_assert_internal((hsize_t)0,shared,internal);
-    if(depth>1) {
-        H5B2_assert_internal2(internal->node_ptrs[idx-1].all_nrec,shared,left_child,middle_child);
-        H5B2_assert_internal2(internal->node_ptrs[idx].all_nrec,shared,middle_child,left_child);
-        H5B2_assert_internal2(internal->node_ptrs[idx].all_nrec,shared,middle_child,right_child);
-        H5B2_assert_internal2(internal->node_ptrs[idx+1].all_nrec,shared,right_child,middle_child);
+    H5B2_assert_internal((hsize_t)0, hdr, internal);
+    if(depth > 1) {
+        H5B2_assert_internal2(internal->node_ptrs[idx - 1].all_nrec, hdr, left_child, middle_child);
+        H5B2_assert_internal2(internal->node_ptrs[idx].all_nrec, hdr, middle_child, left_child);
+        H5B2_assert_internal2(internal->node_ptrs[idx].all_nrec, hdr, middle_child, right_child);
+        H5B2_assert_internal2(internal->node_ptrs[idx + 1].all_nrec, hdr, right_child, middle_child);
     } /* end if */
     else {
-        H5B2_assert_leaf2(shared,left_child,middle_child);
-        H5B2_assert_leaf2(shared,middle_child,right_child);
-        H5B2_assert_leaf(shared,right_child);
+        H5B2_assert_leaf2(hdr, left_child, middle_child);
+        H5B2_assert_leaf2(hdr, middle_child, right_child);
+        H5B2_assert_leaf(hdr, right_child);
     } /* end else */
 #endif /* H5B2_DEBUG */
 
     /* Unlock child nodes (marked as dirty) */
-    if (H5AC_unprotect(f, dxpl_id, child_class, left_addr, left_child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, left_addr, left_child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
-    if (H5AC_unprotect(f, dxpl_id, child_class, middle_addr, middle_child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, middle_addr, middle_child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
-    if (H5AC_unprotect(f, dxpl_id, child_class, right_addr, right_child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, right_addr, right_child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5B2_redistribute3 */
 
 
@@ -1232,31 +1020,26 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_merge2(H5F_t *f, hid_t dxpl_id, unsigned depth,
+H5B2_merge2(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     H5B2_node_ptr_t *curr_node_ptr, unsigned *parent_cache_info_flags_ptr,
     H5B2_internal_t *internal, unsigned *internal_flags_ptr, unsigned idx)
 {
     const H5AC_class_t *child_class;    /* Pointer to child node's class info */
     haddr_t left_addr, right_addr;      /* Addresses of left & right child nodes */
     void *left_child, *right_child;     /* Pointers to left & right child nodes */
-    unsigned *left_nrec, *right_nrec;   /* Pointers to left & right child # of records */
+    uint16_t *left_nrec, *right_nrec;   /* Pointers to left & right child # of records */
     uint8_t *left_native, *right_native;    /* Pointers to left & right children's native records */
-    H5B2_node_ptr_t *left_node_ptrs=NULL, *right_node_ptrs=NULL;/* Pointers to childs' node pointer info */
-    H5B2_shared_t *shared;              /* B-tree's shared info */
-    herr_t ret_value=SUCCEED;           /* Return value */
+    H5B2_node_ptr_t *left_node_ptrs = NULL, *right_node_ptrs = NULL;/* Pointers to childs' node pointer info */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_merge2)
 
-    HDassert(f);
+    /* Check arguments. */
+    HDassert(hdr);
     HDassert(curr_node_ptr);
-    HDassert(parent_cache_info_flags_ptr);
     HDassert(internal);
     HDassert(internal_flags_ptr);
 
-    /* Get the pointer to the shared B-tree info */
-    shared=(H5B2_shared_t *)H5RC_GET_OBJ(internal->shared);
-    HDassert(shared);
-
     /* Check for the kind of B-tree node to split */
     if(depth > 1) {
         H5B2_internal_t *left_internal;         /* Pointer to left internal node */
@@ -1265,12 +1048,12 @@ H5B2_merge2(H5F_t *f, hid_t dxpl_id, unsigned depth,
         /* Setup information for unlocking child nodes */
         child_class = H5AC_BT2_INT;
         left_addr = internal->node_ptrs[idx].addr;
-        right_addr = internal->node_ptrs[idx+1].addr;
+        right_addr = internal->node_ptrs[idx + 1].addr;
 
         /* Lock left & right B-tree child nodes */
-        if(NULL == (left_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, left_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (left_internal = H5B2_protect_internal(hdr, dxpl_id, left_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
-        if(NULL == (right_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, right_addr, internal->node_ptrs[idx+1].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (right_internal = H5B2_protect_internal(hdr, dxpl_id, right_addr, internal->node_ptrs[idx + 1].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
         /* More setup for accessing child node information */
@@ -1290,12 +1073,12 @@ H5B2_merge2(H5F_t *f, hid_t dxpl_id, unsigned depth,
         /* Setup information for unlocking child nodes */
         child_class = H5AC_BT2_LEAF;
         left_addr = internal->node_ptrs[idx].addr;
-        right_addr = internal->node_ptrs[idx+1].addr;
+        right_addr = internal->node_ptrs[idx + 1].addr;
 
         /* Lock left & right B-tree child nodes */
-        if(NULL == (left_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, left_addr, &(internal->node_ptrs[idx].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (left_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, left_addr, &(internal->node_ptrs[idx].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
-        if(NULL == (right_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, right_addr, &(internal->node_ptrs[idx+1].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (right_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, right_addr, &(internal->node_ptrs[idx + 1].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
         /* More setup for accessing child node information */
@@ -1310,14 +1093,14 @@ H5B2_merge2(H5F_t *f, hid_t dxpl_id, unsigned depth,
     /* Redistribute records into left node */
     {
         /* Copy record from parent node to proper location */
-        HDmemcpy(H5B2_NAT_NREC(left_native,shared,*left_nrec),H5B2_INT_NREC(internal,shared,idx),shared->type->nrec_size);
+        HDmemcpy(H5B2_NAT_NREC(left_native, hdr, *left_nrec), H5B2_INT_NREC(internal, hdr, idx), hdr->cls->nrec_size);
 
         /* Copy records from right node to left node */
-        HDmemcpy(H5B2_NAT_NREC(left_native,shared,*left_nrec+1),H5B2_NAT_NREC(right_native,shared,0),shared->type->nrec_size*(*right_nrec));
+        HDmemcpy(H5B2_NAT_NREC(left_native, hdr, *left_nrec + 1), H5B2_NAT_NREC(right_native, hdr, 0), hdr->cls->nrec_size * (*right_nrec));
 
         /* Copy node pointers from right node into left node */
-        if(depth>1)
-            HDmemcpy(&(left_node_ptrs[*left_nrec+1]),&(right_node_ptrs[0]),sizeof(H5B2_node_ptr_t)*(*right_nrec+1));
+        if(depth > 1)
+            HDmemcpy(&(left_node_ptrs[*left_nrec + 1]), &(right_node_ptrs[0]), sizeof(H5B2_node_ptr_t) * (*right_nrec + 1));
 
         /* Update # of records in left node */
         *left_nrec += *right_nrec + 1;
@@ -1327,12 +1110,12 @@ H5B2_merge2(H5F_t *f, hid_t dxpl_id, unsigned depth,
     internal->node_ptrs[idx].node_nrec = *left_nrec;
 
     /* Update total # of records in child B-trees */
-    internal->node_ptrs[idx].all_nrec += internal->node_ptrs[idx+1].all_nrec + 1;
+    internal->node_ptrs[idx].all_nrec += internal->node_ptrs[idx + 1].all_nrec + 1;
 
     /* Slide records in parent node down, to eliminate demoted record */
-    if((idx+1) < internal->nrec) {
-        HDmemmove(H5B2_INT_NREC(internal,shared,idx),H5B2_INT_NREC(internal,shared,idx+1),shared->type->nrec_size*(internal->nrec-(idx+1)));
-        HDmemmove(&(internal->node_ptrs[idx+1]),&(internal->node_ptrs[idx+2]),sizeof(H5B2_node_ptr_t)*(internal->nrec-(idx+1)));
+    if((idx + 1) < internal->nrec) {
+        HDmemmove(H5B2_INT_NREC(internal, hdr, idx), H5B2_INT_NREC(internal, hdr, idx + 1), hdr->cls->nrec_size * (internal->nrec - (idx + 1)));
+        HDmemmove(&(internal->node_ptrs[idx + 1]), &(internal->node_ptrs[idx + 2]), sizeof(H5B2_node_ptr_t) * (internal->nrec - (idx + 1)));
     } /* end if */
 
     /* Update # of records in parent node */
@@ -1344,28 +1127,29 @@ H5B2_merge2(H5F_t *f, hid_t dxpl_id, unsigned depth,
     /* Update grandparent info */
     curr_node_ptr->node_nrec--;
 
-    /* Mark grandparent as dirty */
-    *parent_cache_info_flags_ptr |= H5AC__DIRTIED_FLAG;
+    /* Mark grandparent as dirty, if given */
+    if(parent_cache_info_flags_ptr)
+        *parent_cache_info_flags_ptr |= H5AC__DIRTIED_FLAG;
 
 #ifdef H5B2_DEBUG
-    H5B2_assert_internal((hsize_t)0,shared,internal);
-    if(depth>1)
-        H5B2_assert_internal(internal->node_ptrs[idx].all_nrec,shared,left_child);
+    H5B2_assert_internal((hsize_t)0, hdr, internal);
+    if(depth > 1)
+        H5B2_assert_internal(internal->node_ptrs[idx].all_nrec, hdr, left_child);
     else
-        H5B2_assert_leaf(shared,left_child);
+        H5B2_assert_leaf(hdr, left_child);
 #endif /* H5B2_DEBUG */
 
     /* Unlock left node (marked as dirty) */
-    if(H5AC_unprotect(f, dxpl_id, child_class, left_addr, left_child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, left_addr, left_child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
 
     /* Delete right node & remove from cache (marked as dirty) */
-    if(H5AC_unprotect(f, dxpl_id, child_class, right_addr, right_child, H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, right_addr, right_child, H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5B2_merge2 */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5B2_merge2() */
 
 
 /*-------------------------------------------------------------------------
@@ -1384,7 +1168,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_merge3(H5F_t *f, hid_t dxpl_id, unsigned depth,
+H5B2_merge3(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     H5B2_node_ptr_t *curr_node_ptr, unsigned *parent_cache_info_flags_ptr,
     H5B2_internal_t *internal, unsigned *internal_flags_ptr, unsigned idx)
 {
@@ -1393,28 +1177,23 @@ H5B2_merge3(H5F_t *f, hid_t dxpl_id, unsigned depth,
     haddr_t middle_addr;                /* Address of middle child node */
     void *left_child, *right_child;     /* Pointers to left & right child nodes */
     void *middle_child;                 /* Pointer to middle child node */
-    unsigned *left_nrec, *right_nrec;   /* Pointers to left & right child # of records */
-    unsigned *middle_nrec;              /* Pointer to middle child # of records */
+    uint16_t *left_nrec, *right_nrec;   /* Pointers to left & right child # of records */
+    uint16_t *middle_nrec;              /* Pointer to middle child # of records */
     uint8_t *left_native, *right_native;    /* Pointers to left & right children's native records */
     uint8_t *middle_native;             /* Pointer to middle child's native records */
-    H5B2_node_ptr_t *left_node_ptrs=NULL, *right_node_ptrs=NULL;/* Pointers to childs' node pointer info */
-    H5B2_node_ptr_t *middle_node_ptrs=NULL;/* Pointer to child's node pointer info */
-    H5B2_shared_t *shared;              /* B-tree's shared info */
+    H5B2_node_ptr_t *left_node_ptrs = NULL, *right_node_ptrs = NULL;/* Pointers to childs' node pointer info */
+    H5B2_node_ptr_t *middle_node_ptrs = NULL;/* Pointer to child's node pointer info */
     hsize_t middle_moved_nrec;          /* Number of records moved, for internal split */
-    herr_t ret_value=SUCCEED;           /* Return value */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_merge3)
 
-    HDassert(f);
+    /* Check arguments. */
+    HDassert(hdr);
     HDassert(curr_node_ptr);
-    HDassert(parent_cache_info_flags_ptr);
     HDassert(internal);
     HDassert(internal_flags_ptr);
 
-    /* Get the pointer to the shared B-tree info */
-    shared=(H5B2_shared_t *)H5RC_GET_OBJ(internal->shared);
-    HDassert(shared);
-
     /* Check for the kind of B-tree node to split */
     if(depth > 1) {
         H5B2_internal_t *left_internal;         /* Pointer to left internal node */
@@ -1423,16 +1202,16 @@ H5B2_merge3(H5F_t *f, hid_t dxpl_id, unsigned depth,
 
         /* Setup information for unlocking child nodes */
         child_class = H5AC_BT2_INT;
-        left_addr = internal->node_ptrs[idx-1].addr;
+        left_addr = internal->node_ptrs[idx - 1].addr;
         middle_addr = internal->node_ptrs[idx].addr;
-        right_addr = internal->node_ptrs[idx+1].addr;
+        right_addr = internal->node_ptrs[idx + 1].addr;
 
         /* Lock B-tree child nodes */
-        if (NULL == (left_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, left_addr, internal->node_ptrs[idx-1].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (left_internal = H5B2_protect_internal(hdr, dxpl_id, left_addr, internal->node_ptrs[idx - 1].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
-        if (NULL == (middle_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, middle_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (middle_internal = H5B2_protect_internal(hdr, dxpl_id, middle_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
-        if (NULL == (right_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, right_addr, internal->node_ptrs[idx+1].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (right_internal = H5B2_protect_internal(hdr, dxpl_id, right_addr, internal->node_ptrs[idx + 1].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
         /* More setup for accessing child node information */
@@ -1456,16 +1235,16 @@ H5B2_merge3(H5F_t *f, hid_t dxpl_id, unsigned depth,
 
         /* Setup information for unlocking child nodes */
         child_class = H5AC_BT2_LEAF;
-        left_addr = internal->node_ptrs[idx-1].addr;
+        left_addr = internal->node_ptrs[idx - 1].addr;
         middle_addr = internal->node_ptrs[idx].addr;
-        right_addr = internal->node_ptrs[idx+1].addr;
+        right_addr = internal->node_ptrs[idx + 1].addr;
 
         /* Lock B-tree child nodes */
-        if (NULL == (left_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, left_addr, &(internal->node_ptrs[idx-1].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (left_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, left_addr, &(internal->node_ptrs[idx - 1].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
-        if (NULL == (middle_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, middle_addr, &(internal->node_ptrs[idx].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (middle_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, middle_addr, &(internal->node_ptrs[idx].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
-        if (NULL == (right_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, right_addr, &(internal->node_ptrs[idx+1].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (right_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, right_addr, &(internal->node_ptrs[idx + 1].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
         /* More setup for accessing child node information */
@@ -1489,30 +1268,30 @@ H5B2_merge3(H5F_t *f, hid_t dxpl_id, unsigned depth,
         middle_moved_nrec = middle_nrec_move;
 
         /* Copy record from parent node to proper location in left node */
-        HDmemcpy(H5B2_NAT_NREC(left_native,shared,*left_nrec),H5B2_INT_NREC(internal,shared,idx-1),shared->type->nrec_size);
+        HDmemcpy(H5B2_NAT_NREC(left_native, hdr, *left_nrec), H5B2_INT_NREC(internal, hdr, idx - 1), hdr->cls->nrec_size);
 
         /* Copy records from middle node to left node */
-        HDmemcpy(H5B2_NAT_NREC(left_native,shared,*left_nrec+1),H5B2_NAT_NREC(middle_native,shared,0),shared->type->nrec_size*(middle_nrec_move-1));
+        HDmemcpy(H5B2_NAT_NREC(left_native, hdr, *left_nrec + 1), H5B2_NAT_NREC(middle_native, hdr, 0), hdr->cls->nrec_size * (middle_nrec_move - 1));
 
         /* Copy record from middle node to proper location in parent node */
-        HDmemcpy(H5B2_INT_NREC(internal,shared,idx-1),H5B2_NAT_NREC(middle_native,shared,(middle_nrec_move-1)),shared->type->nrec_size);
+        HDmemcpy(H5B2_INT_NREC(internal, hdr, idx - 1), H5B2_NAT_NREC(middle_native, hdr, (middle_nrec_move - 1)), hdr->cls->nrec_size);
 
         /* Slide records in middle node down */
-        HDmemmove(H5B2_NAT_NREC(middle_native,shared,0),H5B2_NAT_NREC(middle_native,shared,middle_nrec_move),shared->type->nrec_size*(*middle_nrec-middle_nrec_move));
+        HDmemmove(H5B2_NAT_NREC(middle_native, hdr, 0), H5B2_NAT_NREC(middle_native, hdr, middle_nrec_move), hdr->cls->nrec_size * (*middle_nrec - middle_nrec_move));
 
         /* Move node pointers also if this is an internal node */
-        if(depth>1) {
+        if(depth > 1) {
             unsigned u;         /* Local index variable */
 
             /* Copy node pointers from middle node into left node */
-            HDmemcpy(&(left_node_ptrs[*left_nrec+1]),&(middle_node_ptrs[0]),sizeof(H5B2_node_ptr_t)*middle_nrec_move);
+            HDmemcpy(&(left_node_ptrs[*left_nrec + 1]), &(middle_node_ptrs[0]), sizeof(H5B2_node_ptr_t) * middle_nrec_move);
 
             /* Count the number of records being moved into the left node */
-            for(u=0; u<middle_nrec_move; u++)
+            for(u = 0; u < middle_nrec_move; u++)
                 middle_moved_nrec += middle_node_ptrs[u].all_nrec;
 
             /* Slide the node pointers in right node down */
-            HDmemmove(&(middle_node_ptrs[0]),&(middle_node_ptrs[middle_nrec_move]),sizeof(H5B2_node_ptr_t)*((*middle_nrec+1)-middle_nrec_move));
+            HDmemmove(&(middle_node_ptrs[0]), &(middle_node_ptrs[middle_nrec_move]), sizeof(H5B2_node_ptr_t) * ((*middle_nrec + 1) - middle_nrec_move));
         } /* end if */
 
         /* Update # of records in left & middle nodes */
@@ -1523,32 +1302,32 @@ H5B2_merge3(H5F_t *f, hid_t dxpl_id, unsigned depth,
     /* Redistribute records into middle node */
     {
         /* Copy record from parent node to proper location in middle node */
-        HDmemcpy(H5B2_NAT_NREC(middle_native,shared,*middle_nrec),H5B2_INT_NREC(internal,shared,idx),shared->type->nrec_size);
+        HDmemcpy(H5B2_NAT_NREC(middle_native, hdr, *middle_nrec), H5B2_INT_NREC(internal, hdr, idx), hdr->cls->nrec_size);
 
         /* Copy records from right node to middle node */
-        HDmemcpy(H5B2_NAT_NREC(middle_native,shared,*middle_nrec+1),H5B2_NAT_NREC(right_native,shared,0),shared->type->nrec_size*(*right_nrec));
+        HDmemcpy(H5B2_NAT_NREC(middle_native, hdr, *middle_nrec + 1), H5B2_NAT_NREC(right_native, hdr, 0), hdr->cls->nrec_size * (*right_nrec));
 
         /* Move node pointers also if this is an internal node */
-        if(depth>1)
+        if(depth > 1)
             /* Copy node pointers from middle node into left node */
-            HDmemcpy(&(middle_node_ptrs[*middle_nrec+1]),&(right_node_ptrs[0]),sizeof(H5B2_node_ptr_t)*(*right_nrec+1));
+            HDmemcpy(&(middle_node_ptrs[*middle_nrec + 1]), &(right_node_ptrs[0]), sizeof(H5B2_node_ptr_t) * (*right_nrec + 1));
 
         /* Update # of records in middle node */
         *middle_nrec += *right_nrec + 1;
     } /* end block */
 
     /* Update # of records in child nodes */
-    internal->node_ptrs[idx-1].node_nrec = *left_nrec;
+    internal->node_ptrs[idx - 1].node_nrec = *left_nrec;
     internal->node_ptrs[idx].node_nrec = *middle_nrec;
 
     /* Update total # of records in child B-trees */
-    internal->node_ptrs[idx-1].all_nrec += middle_moved_nrec;
-    internal->node_ptrs[idx].all_nrec += (internal->node_ptrs[idx+1].all_nrec + 1) - middle_moved_nrec;
+    internal->node_ptrs[idx - 1].all_nrec += middle_moved_nrec;
+    internal->node_ptrs[idx].all_nrec += (internal->node_ptrs[idx + 1].all_nrec + 1) - middle_moved_nrec;
 
     /* Slide records in parent node down, to eliminate demoted record */
-    if((idx+1) < internal->nrec) {
-        HDmemmove(H5B2_INT_NREC(internal,shared,idx),H5B2_INT_NREC(internal,shared,idx+1),shared->type->nrec_size*(internal->nrec-(idx+1)));
-        HDmemmove(&(internal->node_ptrs[idx+1]),&(internal->node_ptrs[idx+2]),sizeof(H5B2_node_ptr_t)*(internal->nrec-(idx+1)));
+    if((idx + 1) < internal->nrec) {
+        HDmemmove(H5B2_INT_NREC(internal, hdr, idx), H5B2_INT_NREC(internal, hdr, idx + 1), hdr->cls->nrec_size * (internal->nrec - (idx + 1)));
+        HDmemmove(&(internal->node_ptrs[idx + 1]), &(internal->node_ptrs[idx + 2]), sizeof(H5B2_node_ptr_t) * (internal->nrec - (idx + 1)));
     } /* end if */
 
     /* Update # of records in parent node */
@@ -1560,34 +1339,35 @@ H5B2_merge3(H5F_t *f, hid_t dxpl_id, unsigned depth,
     /* Update grandparent info */
     curr_node_ptr->node_nrec--;
 
-    /* Mark grandparent as dirty */
-    *parent_cache_info_flags_ptr |= H5AC__DIRTIED_FLAG;
+    /* Mark grandparent as dirty, if given */
+    if(parent_cache_info_flags_ptr)
+        *parent_cache_info_flags_ptr |= H5AC__DIRTIED_FLAG;
 
 #ifdef H5B2_DEBUG
-    H5B2_assert_internal((hsize_t)0,shared,internal);
-    if(depth>1) {
-        H5B2_assert_internal2(internal->node_ptrs[idx-1].all_nrec,shared,left_child,middle_child);
-        H5B2_assert_internal(internal->node_ptrs[idx].all_nrec,shared,middle_child);
+    H5B2_assert_internal((hsize_t)0, hdr, internal);
+    if(depth > 1) {
+        H5B2_assert_internal2(internal->node_ptrs[idx - 1].all_nrec, hdr, left_child, middle_child);
+        H5B2_assert_internal(internal->node_ptrs[idx].all_nrec, hdr, middle_child);
     } /* end if */
     else {
-        H5B2_assert_leaf2(shared,left_child,middle_child);
-        H5B2_assert_leaf(shared,middle_child);
+        H5B2_assert_leaf2(hdr, left_child, middle_child);
+        H5B2_assert_leaf(hdr, middle_child);
     } /* end else */
 #endif /* H5B2_DEBUG */
 
     /* Unlock left & middle nodes (marked as dirty) */
-    if (H5AC_unprotect(f, dxpl_id, child_class, left_addr, left_child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, left_addr, left_child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
-    if (H5AC_unprotect(f, dxpl_id, child_class, middle_addr, middle_child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, middle_addr, middle_child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
 
     /* Delete right node & remove from cache (marked as dirty) */
-    if(H5AC_unprotect(f, dxpl_id, child_class, right_addr, right_child, H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, right_addr, right_child, H5AC__DIRTIED_FLAG | H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
-} /* end H5B2_merge3 */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5B2_merge3() */
 
 
 /*-------------------------------------------------------------------------
@@ -1606,7 +1386,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_swap_leaf(H5F_t *f, hid_t dxpl_id, unsigned depth,
+H5B2_swap_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     H5B2_internal_t *internal, unsigned *internal_flags_ptr,
     unsigned idx, void *swap_loc)
 {
@@ -1614,20 +1394,16 @@ H5B2_swap_leaf(H5F_t *f, hid_t dxpl_id, unsigned depth,
     haddr_t child_addr;                 /* Address of child node */
     void *child;                        /* Pointer to child node */
     uint8_t *child_native;              /* Pointer to child's native records */
-    H5B2_shared_t *shared;              /* B-tree's shared info */
-    herr_t ret_value=SUCCEED;           /* Return value */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_swap_leaf)
 
-    HDassert(f);
+    /* Check arguments. */
+    HDassert(hdr);
     HDassert(internal);
     HDassert(internal_flags_ptr);
     HDassert(idx <= internal->nrec);
 
-    /* Get the pointer to the shared B-tree info */
-    shared=(H5B2_shared_t *)H5RC_GET_OBJ(internal->shared);
-    HDassert(shared);
-
     /* Check for the kind of B-tree node to swap */
     if(depth > 1) {
         H5B2_internal_t *child_internal;        /* Pointer to internal node */
@@ -1637,7 +1413,7 @@ H5B2_swap_leaf(H5F_t *f, hid_t dxpl_id, unsigned depth,
         child_addr = internal->node_ptrs[idx].addr;
 
         /* Lock B-tree child nodes */
-        if(NULL == (child_internal = H5B2_protect_internal(f, dxpl_id, internal->shared, child_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
+        if(NULL == (child_internal = H5B2_protect_internal(hdr, dxpl_id, child_addr, internal->node_ptrs[idx].node_nrec, (depth - 1), H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
         /* More setup for accessing child node information */
@@ -1652,7 +1428,7 @@ H5B2_swap_leaf(H5F_t *f, hid_t dxpl_id, unsigned depth,
         child_addr = internal->node_ptrs[idx].addr;
 
         /* Lock B-tree child node */
-        if (NULL == (child_leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, child_class, child_addr, &(internal->node_ptrs[idx].node_nrec), internal->shared, H5AC_WRITE)))
+        if(NULL == (child_leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, child_class, child_addr, &(internal->node_ptrs[idx].node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
         /* More setup for accessing child node information */
@@ -1661,27 +1437,27 @@ H5B2_swap_leaf(H5F_t *f, hid_t dxpl_id, unsigned depth,
     } /* end else */
 
     /* Swap records (use disk page as temporary buffer) */
-    HDmemcpy(shared->page, H5B2_NAT_NREC(child_native,shared,0), shared->type->nrec_size);
-    HDmemcpy(H5B2_NAT_NREC(child_native,shared,0), swap_loc, shared->type->nrec_size);
-    HDmemcpy(swap_loc, shared->page, shared->type->nrec_size);
+    HDmemcpy(hdr->page, H5B2_NAT_NREC(child_native, hdr, 0), hdr->cls->nrec_size);
+    HDmemcpy(H5B2_NAT_NREC(child_native, hdr, 0), swap_loc, hdr->cls->nrec_size);
+    HDmemcpy(swap_loc, hdr->page, hdr->cls->nrec_size);
 
     /* Mark parent as dirty */
     *internal_flags_ptr |= H5AC__DIRTIED_FLAG;
 
 #ifdef H5B2_DEBUG
-    H5B2_assert_internal((hsize_t)0,shared,internal);
-    if(depth>1)
-        H5B2_assert_internal(internal->node_ptrs[idx].all_nrec,shared,child);
+    H5B2_assert_internal((hsize_t)0, hdr, internal);
+    if(depth > 1)
+        H5B2_assert_internal(internal->node_ptrs[idx].all_nrec, hdr, child);
     else
-        H5B2_assert_leaf(shared,child);
+        H5B2_assert_leaf(hdr, child);
 #endif /* H5B2_DEBUG */
 
     /* Unlock child node */
-    if (H5AC_unprotect(f, dxpl_id, child_class, child_addr, child, H5AC__DIRTIED_FLAG) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, child_class, child_addr, child, H5AC__DIRTIED_FLAG) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree child node")
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5B2_swap_leaf */
 
 
@@ -1699,11 +1475,10 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_insert_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
-    H5B2_node_ptr_t *curr_node_ptr, void *udata)
+H5B2_insert_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id, H5B2_node_ptr_t *curr_node_ptr,
+    void *udata)
 {
     H5B2_leaf_t *leaf;                  /* Pointer to leaf node */
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
     int         cmp;                    /* Comparison value of records */
     unsigned    idx;                    /* Location of record which matches key */
     herr_t	ret_value = SUCCEED;
@@ -1711,21 +1486,16 @@ H5B2_insert_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     FUNC_ENTER_NOAPI_NOINIT(H5B2_insert_leaf)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(curr_node_ptr);
     HDassert(H5F_addr_defined(curr_node_ptr->addr));
 
     /* Lock current B-tree node */
-    if (NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_LEAF, curr_node_ptr->addr, &(curr_node_ptr->node_nrec), bt2_shared, H5AC_WRITE)))
+    if(NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, H5AC_BT2_LEAF, curr_node_ptr->addr, &(curr_node_ptr->node_nrec), hdr, H5AC_WRITE)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
-    /* Get the pointer to the shared B-tree info */
-    shared=(H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-
     /* Must have a leaf node with enough space to insert a record now */
-    HDassert(curr_node_ptr->node_nrec < shared->node_info[0].max_nrec);
+    HDassert(curr_node_ptr->node_nrec < hdr->node_info[0].max_nrec);
 
     /* Sanity check number of records */
     HDassert(curr_node_ptr->all_nrec == curr_node_ptr->node_nrec);
@@ -1736,18 +1506,18 @@ H5B2_insert_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
         idx = 0;
     else {
         /* Find correct location to insert this record */
-        if((cmp = H5B2_locate_record(shared->type, leaf->nrec, shared->nat_off, leaf->leaf_native, udata, &idx)) == 0)
+        if((cmp = H5B2_locate_record(hdr->cls, leaf->nrec, hdr->nat_off, leaf->leaf_native, udata, &idx)) == 0)
             HGOTO_ERROR(H5E_BTREE, H5E_EXISTS, FAIL, "record is already in B-tree")
         if(cmp > 0)
             idx++;
 
         /* Make room for new record */
         if(idx < leaf->nrec)
-            HDmemmove(H5B2_LEAF_NREC(leaf, shared, idx + 1), H5B2_LEAF_NREC(leaf, shared, idx), shared->type->nrec_size * (leaf->nrec-idx));
+            HDmemmove(H5B2_LEAF_NREC(leaf, hdr, idx + 1), H5B2_LEAF_NREC(leaf, hdr, idx), hdr->cls->nrec_size * (leaf->nrec - idx));
     } /* end else */
 
     /* Make callback to store record in native form */
-    if((shared->type->store)(H5B2_LEAF_NREC(leaf, shared, idx), udata) < 0)
+    if((hdr->cls->store)(H5B2_LEAF_NREC(leaf, hdr, idx), udata) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into leaf node")
 
     /* Update record count for node pointer to current node */
@@ -1759,7 +1529,7 @@ H5B2_insert_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
 done:
     /* Release the B-tree leaf node (marked as dirty) */
-    if(leaf && H5AC_unprotect(f, dxpl_id, H5AC_BT2_LEAF, curr_node_ptr->addr, leaf, H5AC__DIRTIED_FLAG) < 0)
+    if(leaf && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_LEAF, curr_node_ptr->addr, leaf, H5AC__DIRTIED_FLAG) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1780,34 +1550,27 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_insert_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
-    unsigned depth, unsigned *parent_cache_info_flags_ptr,
-    H5B2_node_ptr_t *curr_node_ptr, void *udata)
+H5B2_insert_internal(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
+    unsigned *parent_cache_info_flags_ptr, H5B2_node_ptr_t *curr_node_ptr,
+    void *udata)
 {
     H5B2_internal_t *internal;          /* Pointer to internal node */
     unsigned internal_flags = H5AC__NO_FLAGS_SET;
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
     unsigned    idx;                    /* Location of record which matches key */
     herr_t	ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_insert_internal)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(depth > 0);
-    HDassert(parent_cache_info_flags_ptr);
     HDassert(curr_node_ptr);
     HDassert(H5F_addr_defined(curr_node_ptr->addr));
 
     /* Lock current B-tree node */
-    if(NULL == (internal = H5B2_protect_internal(f, dxpl_id, bt2_shared, curr_node_ptr->addr, curr_node_ptr->node_nrec, depth, H5AC_WRITE)))
+    if(NULL == (internal = H5B2_protect_internal(hdr, dxpl_id, curr_node_ptr->addr, curr_node_ptr->node_nrec, depth, H5AC_WRITE)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
-    /* Get the pointer to the shared B-tree info */
-    shared=(H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-
 /* Split or redistribute child node pointers, if necessary */
     {
         int         cmp;        /* Comparison value of records */
@@ -1815,7 +1578,7 @@ H5B2_insert_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
         size_t      split_nrec; /* Number of records to split node at */
 
         /* Locate node pointer for child */
-        if((cmp = H5B2_locate_record(shared->type, internal->nrec, shared->nat_off, internal->int_native, udata, &idx)) == 0)
+        if((cmp = H5B2_locate_record(hdr->cls, internal->nrec, hdr->nat_off, internal->int_native, udata, &idx)) == 0)
             HGOTO_ERROR(H5E_BTREE, H5E_EXISTS, FAIL, "record is already in B-tree")
         if(cmp > 0)
             idx++;
@@ -1829,29 +1592,29 @@ H5B2_insert_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
         retries = 2;
 
         /* Determine the correct number of records to split child node at */
-        split_nrec = shared->node_info[depth - 1].split_nrec;
+        split_nrec = hdr->node_info[depth - 1].split_nrec;
 
         /* Preemptively split/redistribute a node we will enter */
         while(internal->node_ptrs[idx].node_nrec == split_nrec) {
             /* Attempt to redistribute records among children */
             if(idx == 0) {    /* Left-most child */
-                if(retries > 0 && (internal->node_ptrs[idx+1].node_nrec < split_nrec)) {
-                    if(H5B2_redistribute2(f, dxpl_id, depth, internal, idx) < 0)
+                if(retries > 0 && (internal->node_ptrs[idx + 1].node_nrec < split_nrec)) {
+                    if(H5B2_redistribute2(hdr, dxpl_id, depth, internal, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTREDISTRIBUTE, FAIL, "unable to redistribute child node records")
                 } /* end if */
                 else {
-                    if(H5B2_split1(f, dxpl_id, depth, curr_node_ptr,
+                    if(H5B2_split1(hdr, dxpl_id, depth, curr_node_ptr,
                            parent_cache_info_flags_ptr, internal, &internal_flags, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to split child node")
                 } /* end else */
             } /* end if */
             else if(idx == internal->nrec) { /* Right-most child */
                 if(retries > 0 && (internal->node_ptrs[idx - 1].node_nrec < split_nrec)) {
-                    if(H5B2_redistribute2(f, dxpl_id, depth, internal, (idx - 1)) < 0)
+                    if(H5B2_redistribute2(hdr, dxpl_id, depth, internal, (idx - 1)) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTREDISTRIBUTE, FAIL, "unable to redistribute child node records")
                 } /* end if */
                 else {
-                    if(H5B2_split1(f, dxpl_id, depth, curr_node_ptr,
+                    if(H5B2_split1(hdr, dxpl_id, depth, curr_node_ptr,
                            parent_cache_info_flags_ptr, internal, &internal_flags, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to split child node")
                 } /* end else */
@@ -1859,11 +1622,11 @@ H5B2_insert_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
             else { /* Middle child */
                 if(retries > 0 && ((internal->node_ptrs[idx + 1].node_nrec < split_nrec) ||
                             (internal->node_ptrs[idx - 1].node_nrec < split_nrec))) {
-                    if(H5B2_redistribute3(f, dxpl_id, depth, internal, &internal_flags, idx) < 0)
+                    if(H5B2_redistribute3(hdr, dxpl_id, depth, internal, &internal_flags, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTREDISTRIBUTE, FAIL, "unable to redistribute child node records")
                 } /* end if */
                 else {
-                    if(H5B2_split1(f, dxpl_id, depth, curr_node_ptr,
+                    if(H5B2_split1(hdr, dxpl_id, depth, curr_node_ptr,
                            parent_cache_info_flags_ptr, internal, &internal_flags, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to split child node")
                 } /* end else */
@@ -1871,7 +1634,7 @@ H5B2_insert_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
             /* Locate node pointer for child (after split/redistribute) */
 /* Actually, this can be easily updated (for 2-node redistrib.) and shouldn't require re-searching */
-            if((cmp = H5B2_locate_record(shared->type, internal->nrec, shared->nat_off, internal->int_native, udata, &idx)) == 0)
+            if((cmp = H5B2_locate_record(hdr->cls, internal->nrec, hdr->nat_off, internal->int_native, udata, &idx)) == 0)
                 HGOTO_ERROR(H5E_BTREE, H5E_EXISTS, FAIL, "record is already in B-tree")
             if(cmp > 0)
                 idx++;
@@ -1883,11 +1646,11 @@ H5B2_insert_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
     /* Attempt to insert node */
     if(depth > 1) {
-        if(H5B2_insert_internal(f, dxpl_id, bt2_shared, (depth - 1), &internal_flags, &internal->node_ptrs[idx], udata) < 0)
+        if(H5B2_insert_internal(hdr, dxpl_id, (depth - 1), &internal_flags, &internal->node_ptrs[idx], udata) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into B-tree internal node")
     } /* end if */
     else {
-        if(H5B2_insert_leaf(f, dxpl_id, bt2_shared, &internal->node_ptrs[idx], udata) < 0)
+        if(H5B2_insert_leaf(hdr, dxpl_id, &internal->node_ptrs[idx], udata) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into B-tree leaf node")
     } /* end else */
 
@@ -1899,7 +1662,7 @@ H5B2_insert_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
 done:
     /* Release the B-tree internal node */
-    if (internal && H5AC_unprotect(f, dxpl_id, H5AC_BT2_INT, curr_node_ptr->addr, internal, internal_flags) < 0)
+    if(internal && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_INT, curr_node_ptr->addr, internal, internal_flags) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1921,56 +1684,53 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_create_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, H5B2_node_ptr_t *node_ptr)
+H5B2_create_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id, H5B2_node_ptr_t *node_ptr)
 {
     H5B2_leaf_t *leaf = NULL;     /* Pointer to new leaf node created */
-    H5B2_shared_t *shared;      /* Shared B-tree information */
     herr_t	ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_create_leaf)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(node_ptr);
 
     /* Allocate memory for leaf information */
     if(NULL == (leaf = H5FL_MALLOC(H5B2_leaf_t)))
-	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree leaf info")
+	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree leaf info")
 
     /* Set metadata cache info */
     HDmemset(&leaf->cache_info, 0, sizeof(H5AC_info_t));
 
-    /* Share common B-tree information */
-    leaf->shared = bt2_shared;
-    H5RC_INC(leaf->shared);
+    /* Increment ref. count on B-tree header */
+    if(H5B2_hdr_incr(hdr) < 0)
+	HGOTO_ERROR(H5E_BTREE, H5E_CANTINC, FAIL, "can't increment ref. count on B-tree header")
 
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(leaf->shared);
-    HDassert(shared);
+    /* Share B-tree header information */
+    leaf->hdr = hdr;
 
     /* Allocate space for the native keys in memory */
-    if((leaf->leaf_native = (uint8_t *)H5FL_FAC_MALLOC(shared->node_info[0].nat_rec_fac)) == NULL)
-	HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree leaf native keys")
+    if(NULL == (leaf->leaf_native = (uint8_t *)H5FL_FAC_MALLOC(hdr->node_info[0].nat_rec_fac)))
+	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree leaf native keys")
 #ifdef H5_CLEAR_MEMORY
-HDmemset(leaf->leaf_native, 0, shared->type->nrec_size * shared->node_info[0].max_nrec);
+HDmemset(leaf->leaf_native, 0, hdr->cls->nrec_size * hdr->node_info[0].max_nrec);
 #endif /* H5_CLEAR_MEMORY */
 
     /* Set number of records */
     leaf->nrec = 0;
 
     /* Allocate space on disk for the leaf */
-    if(HADDR_UNDEF == (node_ptr->addr=H5MF_alloc(f, H5FD_MEM_BTREE, dxpl_id, (hsize_t)shared->node_size)))
+    if(HADDR_UNDEF == (node_ptr->addr = H5MF_alloc(hdr->f, H5FD_MEM_BTREE, dxpl_id, (hsize_t)hdr->node_size)))
 	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for B-tree leaf node")
 
     /* Cache the new B-tree node */
-    if(H5AC_set(f, dxpl_id, H5AC_BT2_LEAF, node_ptr->addr, leaf, H5AC__NO_FLAGS_SET) < 0)
+    if(H5AC_set(hdr->f, dxpl_id, H5AC_BT2_LEAF, node_ptr->addr, leaf, H5AC__NO_FLAGS_SET) < 0)
 	HGOTO_ERROR(H5E_BTREE, H5E_CANTINIT, FAIL, "can't add B-tree leaf to cache")
 
 done:
     if(ret_value < 0) {
 	if(leaf)
-            (void)H5B2_cache_leaf_dest(f,leaf);
+            (void)H5B2_cache_leaf_dest(hdr->f, leaf);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1992,18 +1752,16 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_create_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
-    H5B2_node_ptr_t *node_ptr, unsigned depth)
+H5B2_create_internal(H5B2_hdr_t *hdr, hid_t dxpl_id, H5B2_node_ptr_t *node_ptr,
+    unsigned depth)
 {
-    H5B2_internal_t *internal=NULL;     /* Pointer to new internal node created */
-    H5B2_shared_t *shared;              /* Shared B-tree information */
+    H5B2_internal_t *internal = NULL;     /* Pointer to new internal node created */
     herr_t	ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_create_internal)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(node_ptr);
     HDassert(depth > 0);
 
@@ -2014,26 +1772,25 @@ H5B2_create_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     /* Set metadata cache info */
     HDmemset(&internal->cache_info, 0, sizeof(H5AC_info_t));
 
-    /* Share common B-tree information */
-    internal->shared = bt2_shared;
-    H5RC_INC(internal->shared);
+    /* Increment ref. count on B-tree header */
+    if(H5B2_hdr_incr(hdr) < 0)
+	HGOTO_ERROR(H5E_BTREE, H5E_CANTINC, FAIL, "can't increment ref. count on B-tree header")
 
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(internal->shared);
-    HDassert(shared);
+    /* Share B-tree header information */
+    internal->hdr = hdr;
 
     /* Allocate space for the native keys in memory */
-    if((internal->int_native = (uint8_t *)H5FL_FAC_MALLOC(shared->node_info[depth].nat_rec_fac)) == NULL)
-        HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree internal native keys")
+    if(NULL == (internal->int_native = (uint8_t *)H5FL_FAC_MALLOC(hdr->node_info[depth].nat_rec_fac)))
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree internal native keys")
 #ifdef H5_CLEAR_MEMORY
-HDmemset(internal->int_native, 0, shared->type->nrec_size * shared->node_info[depth].max_nrec);
+HDmemset(internal->int_native, 0, hdr->cls->nrec_size * hdr->node_info[depth].max_nrec);
 #endif /* H5_CLEAR_MEMORY */
 
     /* Allocate space for the node pointers in memory */
-    if((internal->node_ptrs = (H5B2_node_ptr_t *)H5FL_FAC_MALLOC(shared->node_info[depth].node_ptr_fac)) == NULL)
-        HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree internal node pointers")
+    if(NULL == (internal->node_ptrs = (H5B2_node_ptr_t *)H5FL_FAC_MALLOC(hdr->node_info[depth].node_ptr_fac)))
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree internal node pointers")
 #ifdef H5_CLEAR_MEMORY
-HDmemset(internal->node_ptrs, 0, sizeof(H5B2_node_ptr_t) * (shared->node_info[depth].max_nrec + 1));
+HDmemset(internal->node_ptrs, 0, sizeof(H5B2_node_ptr_t) * (hdr->node_info[depth].max_nrec + 1));
 #endif /* H5_CLEAR_MEMORY */
 
     /* Set number of records & depth of the node */
@@ -2041,17 +1798,17 @@ HDmemset(internal->node_ptrs, 0, sizeof(H5B2_node_ptr_t) * (shared->node_info[de
     internal->depth = depth;
 
     /* Allocate space on disk for the internal node */
-    if(HADDR_UNDEF == (node_ptr->addr = H5MF_alloc(f, H5FD_MEM_BTREE, dxpl_id, (hsize_t)shared->node_size)))
+    if(HADDR_UNDEF == (node_ptr->addr = H5MF_alloc(hdr->f, H5FD_MEM_BTREE, dxpl_id, (hsize_t)hdr->node_size)))
 	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for B-tree internal node")
 
     /* Cache the new B-tree node */
-    if(H5AC_set(f, dxpl_id, H5AC_BT2_INT, node_ptr->addr, internal, H5AC__NO_FLAGS_SET) < 0)
+    if(H5AC_set(hdr->f, dxpl_id, H5AC_BT2_INT, node_ptr->addr, internal, H5AC__NO_FLAGS_SET) < 0)
 	HGOTO_ERROR(H5E_BTREE, H5E_CANTINIT, FAIL, "can't add B-tree internal node to cache")
 
 done:
     if(ret_value < 0) {
 	if(internal)
-            (void)H5B2_cache_internal_dest(f,internal);
+            (void)H5B2_cache_internal_dest(hdr->f, internal);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2072,7 +1829,7 @@ done:
  *-------------------------------------------------------------------------
  */
 H5B2_internal_t *
-H5B2_protect_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, haddr_t addr,
+H5B2_protect_internal(H5B2_hdr_t *hdr, hid_t dxpl_id, haddr_t addr,
     unsigned nrec, unsigned depth, H5AC_protect_t rw)
 {
     H5B2_int_load_ud1_t udata;          /* User data to pass through to cache 'load' callback */
@@ -2081,18 +1838,17 @@ H5B2_protect_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, haddr_t addr,
     FUNC_ENTER_NOAPI_NOINIT(H5B2_protect_internal)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(H5F_addr_defined(addr));
     HDassert(depth > 0);
 
     /* Set up user data for callback */
-    udata.bt2_shared = bt2_shared;
+    udata.hdr = hdr;
     udata.nrec = nrec;
     udata.depth = depth;
 
     /* Protect the internal node */
-    if(NULL == (ret_value = (H5B2_internal_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_INT, addr, &udata, NULL, rw)))
+    if(NULL == (ret_value = (H5B2_internal_t *)H5AC_protect(hdr->f, dxpl_id, H5AC_BT2_INT, addr, &udata, NULL, rw)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, NULL, "unable to load B-tree internal node")
 
 done:
@@ -2118,10 +1874,9 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_iterate_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned depth,
+H5B2_iterate_node(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     const H5B2_node_ptr_t *curr_node, H5B2_operator_t op, void *op_data)
 {
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
     const H5AC_class_t *curr_node_class = NULL; /* Pointer to current node's class info */
     void *node = NULL;                  /* Pointers to current node */
     uint8_t *node_native;               /* Pointers to node's native records */
@@ -2133,21 +1888,16 @@ H5B2_iterate_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned depth,
     FUNC_ENTER_NOAPI_NOINIT(H5B2_iterate_node)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(curr_node);
     HDassert(op);
 
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-
     /* Protect current node & set up variables */
     if(depth > 0) {
         H5B2_internal_t *internal;     /* Pointer to internal node */
 
         /* Lock the current B-tree node */
-        if(NULL == (internal = H5B2_protect_internal(f, dxpl_id, bt2_shared, curr_node->addr, curr_node->node_nrec, depth, H5AC_READ)))
+        if(NULL == (internal = H5B2_protect_internal(hdr, dxpl_id, curr_node->addr, curr_node->node_nrec, depth, H5AC_READ)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
         /* Set up information about current node */
@@ -2156,8 +1906,8 @@ H5B2_iterate_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned depth,
         node_native = internal->int_native;
 
         /* Allocate space for the node pointers in memory */
-        if((node_ptrs = (H5B2_node_ptr_t *)H5FL_FAC_MALLOC(shared->node_info[depth].node_ptr_fac)) == NULL)
-            HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree internal node pointers")
+        if(NULL == (node_ptrs = (H5B2_node_ptr_t *)H5FL_FAC_MALLOC(hdr->node_info[depth].node_ptr_fac)))
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree internal node pointers")
 
         /* Copy the node pointers */
         HDmemcpy(node_ptrs, internal->node_ptrs, (sizeof(H5B2_node_ptr_t) * (curr_node->node_nrec + 1)));
@@ -2166,7 +1916,7 @@ H5B2_iterate_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned depth,
         H5B2_leaf_t *leaf;             /* Pointer to leaf node */
 
         /* Lock the current B-tree node */
-        if (NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_LEAF, curr_node->addr, &(curr_node->node_nrec), bt2_shared, H5AC_READ)))
+        if(NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, H5AC_BT2_LEAF, curr_node->addr, &(curr_node->node_nrec), hdr, H5AC_READ)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
         /* Set up information about current node */
@@ -2176,14 +1926,14 @@ H5B2_iterate_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned depth,
     } /* end else */
 
     /* Allocate space for the native keys in memory */
-    if((native = (uint8_t *)H5FL_FAC_MALLOC(shared->node_info[depth].nat_rec_fac)) == NULL)
+    if(NULL == (native = (uint8_t *)H5FL_FAC_MALLOC(hdr->node_info[depth].nat_rec_fac)))
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for B-tree internal native keys")
 
     /* Copy the native keys */
-    HDmemcpy(native, node_native, (shared->type->nrec_size * curr_node->node_nrec));
+    HDmemcpy(native, node_native, (hdr->cls->nrec_size * curr_node->node_nrec));
 
     /* Unlock the node */
-    if(H5AC_unprotect(f, dxpl_id, curr_node_class, curr_node->addr, node, H5AC__NO_FLAGS_SET) < 0)
+    if(H5AC_unprotect(hdr->f, dxpl_id, curr_node_class, curr_node->addr, node, H5AC__NO_FLAGS_SET) < 0)
         HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
     node = NULL;
 
@@ -2191,29 +1941,29 @@ H5B2_iterate_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned depth,
     for(u = 0; u < curr_node->node_nrec && !ret_value; u++) {
         /* Descend into child node, if current node is an internal node */
         if(depth > 0) {
-            if((ret_value = H5B2_iterate_node(f, dxpl_id, bt2_shared, (depth - 1), &(node_ptrs[u]), op, op_data)) < 0)
+            if((ret_value = H5B2_iterate_node(hdr, dxpl_id, (depth - 1), &(node_ptrs[u]), op, op_data)) < 0)
                 HERROR(H5E_BTREE, H5E_CANTLIST, "node iteration failed");
         } /* end if */
 
         /* Make callback for current record */
         if(!ret_value) {
-            if((ret_value = (op)(H5B2_NAT_NREC(native, shared, u), op_data)) < 0)
+            if((ret_value = (op)(H5B2_NAT_NREC(native, hdr, u), op_data)) < 0)
                 HERROR(H5E_BTREE, H5E_CANTLIST, "iterator function failed");
         } /* end if */
     } /* end for */
 
     /* Descend into last child node, if current node is an internal node */
     if(!ret_value && depth > 0) {
-        if((ret_value = H5B2_iterate_node(f, dxpl_id, bt2_shared, (depth - 1), &(node_ptrs[u]), op, op_data)) < 0)
+        if((ret_value = H5B2_iterate_node(hdr, dxpl_id, (depth - 1), &(node_ptrs[u]), op, op_data)) < 0)
             HERROR(H5E_BTREE, H5E_CANTLIST, "node iteration failed");
     } /* end if */
 
 done:
     /* Release the node pointers & native records, if they were copied */
     if(node_ptrs)
-        H5FL_FAC_FREE(shared->node_info[depth].node_ptr_fac, node_ptrs);
+        H5FL_FAC_FREE(hdr->node_info[depth].node_ptr_fac, node_ptrs);
     if(native)
-        H5FL_FAC_FREE(shared->node_info[depth].nat_rec_fac, native);
+        H5FL_FAC_FREE(hdr->node_info[depth].nat_rec_fac, native);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5B2_iterate_node() */
@@ -2233,45 +1983,38 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_remove_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
-    H5B2_node_ptr_t *curr_node_ptr, void *udata, H5B2_remove_t op,
-    void *op_data)
+H5B2_remove_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id, H5B2_node_ptr_t *curr_node_ptr,
+    void *udata, H5B2_remove_t op, void *op_data)
 {
     H5B2_leaf_t *leaf;                  /* Pointer to leaf node */
     haddr_t     leaf_addr = HADDR_UNDEF;  /* Leaf address on disk */
     unsigned    leaf_flags = H5AC__NO_FLAGS_SET; /* Flags for unprotecting leaf node */
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
     unsigned    idx;                    /* Location of record which matches key */
     herr_t	ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_remove_leaf)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(curr_node_ptr);
     HDassert(H5F_addr_defined(curr_node_ptr->addr));
 
     /* Lock current B-tree node */
     leaf_addr = curr_node_ptr->addr;
-    if(NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_LEAF, leaf_addr, &(curr_node_ptr->node_nrec), bt2_shared, H5AC_WRITE)))
+    if(NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, H5AC_BT2_LEAF, leaf_addr, &(curr_node_ptr->node_nrec), hdr, H5AC_WRITE)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-
     /* Sanity check number of records */
     HDassert(curr_node_ptr->all_nrec == curr_node_ptr->node_nrec);
     HDassert(leaf->nrec == curr_node_ptr->node_nrec);
 
     /* Find correct location to remove this record */
-    if(H5B2_locate_record(shared->type, leaf->nrec, shared->nat_off, leaf->leaf_native, udata, &idx) != 0)
+    if(H5B2_locate_record(hdr->cls, leaf->nrec, hdr->nat_off, leaf->leaf_native, udata, &idx) != 0)
         HGOTO_ERROR(H5E_BTREE, H5E_NOTFOUND, FAIL, "record is not in B-tree")
 
     /* Make 'remove' callback if there is one */
     if(op)
-        if((op)(H5B2_LEAF_NREC(leaf, shared, idx), op_data) < 0)
+        if((op)(H5B2_LEAF_NREC(leaf, hdr, idx), op_data) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTDELETE, FAIL, "unable to remove record into leaf node")
 
     /* Update number of records in node */
@@ -2283,7 +2026,7 @@ H5B2_remove_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     if(leaf->nrec > 0) {
         /* Pack record out of leaf */
         if(idx < leaf->nrec)
-            HDmemmove(H5B2_LEAF_NREC(leaf, shared, idx), H5B2_LEAF_NREC(leaf, shared, (idx + 1)), shared->type->nrec_size * (leaf->nrec-idx));
+            HDmemmove(H5B2_LEAF_NREC(leaf, hdr, idx), H5B2_LEAF_NREC(leaf, hdr, (idx + 1)), hdr->cls->nrec_size * (leaf->nrec - idx));
     } /* end if */
     else {
         /* Let the cache know that the object is deleted */
@@ -2298,7 +2041,7 @@ H5B2_remove_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
 done:
     /* Release the B-tree leaf node */
-    if(leaf && H5AC_unprotect(f, dxpl_id, H5AC_BT2_LEAF, leaf_addr, leaf, leaf_flags) < 0)
+    if(leaf && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_LEAF, leaf_addr, leaf, leaf_flags) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2319,11 +2062,10 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
-    hbool_t *depth_decreased, void *swap_loc, unsigned depth,
-    H5AC_info_t *parent_cache_info, unsigned *parent_cache_info_flags_ptr,
-    H5B2_node_ptr_t *curr_node_ptr, void *udata, H5B2_remove_t op,
-    void *op_data)
+H5B2_remove_internal(H5B2_hdr_t *hdr, hid_t dxpl_id, hbool_t *depth_decreased,
+    void *swap_loc, unsigned depth, H5AC_info_t *parent_cache_info,
+    unsigned *parent_cache_info_flags_ptr, H5B2_node_ptr_t *curr_node_ptr,
+    void *udata, H5B2_remove_t op, void *op_data)
 {
     H5AC_info_t *new_cache_info;        /* Pointer to new cache info */
     unsigned *new_cache_info_flags_ptr = NULL;
@@ -2331,7 +2073,6 @@ H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     H5B2_internal_t *internal;          /* Pointer to internal node */
     unsigned internal_flags = H5AC__NO_FLAGS_SET;
     haddr_t internal_addr;              /* Address of internal node */
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
     size_t      merge_nrec;             /* Number of records to merge node at */
     hbool_t     collapsed_root = FALSE; /* Whether the root was collapsed */
     herr_t	ret_value = SUCCEED;
@@ -2339,25 +2080,19 @@ H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     FUNC_ENTER_NOAPI_NOINIT(H5B2_remove_internal)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(depth > 0);
     HDassert(parent_cache_info);
-    HDassert(parent_cache_info_flags_ptr);
     HDassert(curr_node_ptr);
     HDassert(H5F_addr_defined(curr_node_ptr->addr));
 
     /* Lock current B-tree node */
     internal_addr = curr_node_ptr->addr;
-    if(NULL == (internal = H5B2_protect_internal(f, dxpl_id, bt2_shared, internal_addr, curr_node_ptr->node_nrec, depth, H5AC_WRITE)))
+    if(NULL == (internal = H5B2_protect_internal(hdr, dxpl_id, internal_addr, curr_node_ptr->node_nrec, depth, H5AC_WRITE)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-
     /* Determine the correct number of records to merge at */
-    merge_nrec = shared->node_info[depth - 1].merge_nrec;
+    merge_nrec = hdr->node_info[depth - 1].merge_nrec;
 
     /* Check for needing to collapse the root node */
     /* (The root node is the only internal node allowed to have 1 record) */
@@ -2365,7 +2100,7 @@ H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
             ((internal->node_ptrs[0].node_nrec + internal->node_ptrs[1].node_nrec) <= ((merge_nrec * 2) + 1))) {
 
         /* Merge children of root node */
-        if(H5B2_merge2(f, dxpl_id, depth, curr_node_ptr,
+        if(H5B2_merge2(hdr, dxpl_id, depth, curr_node_ptr,
                 parent_cache_info_flags_ptr, internal, &internal_flags, 0) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to merge child node")
 
@@ -2397,7 +2132,7 @@ H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
         if(swap_loc)
             idx = 0;
         else {
-            cmp = H5B2_locate_record(shared->type, internal->nrec, shared->nat_off, internal->int_native, udata, &idx);
+            cmp = H5B2_locate_record(hdr->cls, internal->nrec, hdr->nat_off, internal->int_native, udata, &idx);
             if(cmp >= 0)
                 idx++;
         } /* end else */
@@ -2421,22 +2156,22 @@ H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
              */
             if(idx == 0) {    /* Left-most child */
                 if(retries > 0 && (internal->node_ptrs[idx + 1].node_nrec > merge_nrec)) {
-                    if(H5B2_redistribute2(f, dxpl_id, depth, internal, idx) < 0)
+                    if(H5B2_redistribute2(hdr, dxpl_id, depth, internal, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTREDISTRIBUTE, FAIL, "unable to redistribute child node records")
                 } /* end if */
                 else {
-                    if(H5B2_merge2(f, dxpl_id, depth, curr_node_ptr,
+                    if(H5B2_merge2(hdr, dxpl_id, depth, curr_node_ptr,
                            parent_cache_info_flags_ptr, internal, &internal_flags, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to merge child node")
                 } /* end else */
             } /* end if */
             else if(idx == internal->nrec) { /* Right-most child */
                 if(retries > 0 && (internal->node_ptrs[idx - 1].node_nrec > merge_nrec)) {
-                    if(H5B2_redistribute2(f, dxpl_id, depth, internal, (idx - 1)) < 0)
+                    if(H5B2_redistribute2(hdr, dxpl_id, depth, internal, (idx - 1)) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTREDISTRIBUTE, FAIL, "unable to redistribute child node records")
                 } /* end if */
                 else {
-                    if(H5B2_merge2(f, dxpl_id, depth, curr_node_ptr,
+                    if(H5B2_merge2(hdr, dxpl_id, depth, curr_node_ptr,
                            parent_cache_info_flags_ptr, internal, &internal_flags, (idx - 1)) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to merge child node")
                 } /* end else */
@@ -2444,11 +2179,11 @@ H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
             else { /* Middle child */
                 if(retries > 0 && ((internal->node_ptrs[idx + 1].node_nrec > merge_nrec) ||
                             (internal->node_ptrs[idx - 1].node_nrec > merge_nrec))) {
-                    if(H5B2_redistribute3(f, dxpl_id, depth, internal, &internal_flags, idx) < 0)
+                    if(H5B2_redistribute3(hdr, dxpl_id, depth, internal, &internal_flags, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTREDISTRIBUTE, FAIL, "unable to redistribute child node records")
                 } /* end if */
                 else {
-                    if(H5B2_merge3(f, dxpl_id, depth, curr_node_ptr,
+                    if(H5B2_merge3(hdr, dxpl_id, depth, curr_node_ptr,
                            parent_cache_info_flags_ptr, internal, &internal_flags, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to merge child node")
                 } /* end else */
@@ -2459,7 +2194,7 @@ H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
                 idx = 0;
             else {
 /* Actually, this can be easily updated (for 2-node redistrib.) and shouldn't require re-searching */
-                cmp = H5B2_locate_record(shared->type, internal->nrec, shared->nat_off, internal->int_native, udata, &idx);
+                cmp = H5B2_locate_record(hdr->cls, internal->nrec, hdr->nat_off, internal->int_native, udata, &idx);
                 if(cmp >= 0)
                     idx++;
             } /* end else */
@@ -2470,11 +2205,11 @@ H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
         /* Handle deleting a record from an internal node */
         if(!swap_loc && cmp == 0)
-            swap_loc = H5B2_INT_NREC(internal, shared, idx - 1);
+            swap_loc = H5B2_INT_NREC(internal, hdr, idx - 1);
 
         /* Swap record to delete with record from leaf, if we are the last internal node */
         if(swap_loc && depth == 1)
-            if(H5B2_swap_leaf(f, dxpl_id, depth, internal, &internal_flags, idx, swap_loc) < 0)
+            if(H5B2_swap_leaf(hdr, dxpl_id, depth, internal, &internal_flags, idx, swap_loc) < 0)
                 HGOTO_ERROR(H5E_BTREE, H5E_CANTSWAP, FAIL, "Can't swap records in B-tree")
 
         /* Set pointers for advancing to child node */
@@ -2485,12 +2220,12 @@ H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
     /* Attempt to remove record from child node */
     if(depth > 1) {
-        if(H5B2_remove_internal(f, dxpl_id, bt2_shared, depth_decreased, swap_loc, depth - 1,
+        if(H5B2_remove_internal(hdr, dxpl_id, depth_decreased, swap_loc, depth - 1,
                 new_cache_info, new_cache_info_flags_ptr, new_node_ptr, udata, op, op_data) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTDELETE, FAIL, "unable to remove record from B-tree internal node")
     } /* end if */
     else {
-        if(H5B2_remove_leaf(f, dxpl_id, bt2_shared, new_node_ptr, udata, op, op_data) < 0)
+        if(H5B2_remove_leaf(hdr, dxpl_id, new_node_ptr, udata, op, op_data) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTDELETE, FAIL, "unable to remove record from B-tree leaf node")
     } /* end else */
 
@@ -2502,12 +2237,12 @@ H5B2_remove_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     internal_flags |= H5AC__DIRTIED_FLAG;
 
 #ifdef H5B2_DEBUG
-    H5B2_assert_internal((!collapsed_root ? (curr_node_ptr->all_nrec-1) : new_node_ptr->all_nrec),shared,internal);
+    H5B2_assert_internal((!collapsed_root ? (curr_node_ptr->all_nrec - 1) : new_node_ptr->all_nrec), hdr, internal);
 #endif /* H5B2_DEBUG */
 
 done:
     /* Release the B-tree internal node */
-    if(internal && H5AC_unprotect(f, dxpl_id, H5AC_BT2_INT, internal_addr, internal, internal_flags) < 0)
+    if(internal && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_INT, internal_addr, internal, internal_flags) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2529,33 +2264,27 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_remove_leaf_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
+H5B2_remove_leaf_by_idx(H5B2_hdr_t *hdr, hid_t dxpl_id,
     H5B2_node_ptr_t *curr_node_ptr, unsigned idx, H5B2_remove_t op,
     void *op_data)
 {
     H5B2_leaf_t *leaf;                  /* Pointer to leaf node */
     haddr_t     leaf_addr = HADDR_UNDEF;  /* Leaf address on disk */
     unsigned    leaf_flags = H5AC__NO_FLAGS_SET; /* Flags for unprotecting leaf node */
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
     herr_t	ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_remove_leaf_by_idx)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(curr_node_ptr);
     HDassert(H5F_addr_defined(curr_node_ptr->addr));
 
     /* Lock B-tree leaf node */
     leaf_addr = curr_node_ptr->addr;
-    if(NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_LEAF, leaf_addr, &(curr_node_ptr->node_nrec), bt2_shared, H5AC_WRITE)))
+    if(NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, H5AC_BT2_LEAF, leaf_addr, &(curr_node_ptr->node_nrec), hdr, H5AC_WRITE)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-
     /* Sanity check number of records */
     HDassert(curr_node_ptr->all_nrec == curr_node_ptr->node_nrec);
     HDassert(leaf->nrec == curr_node_ptr->node_nrec);
@@ -2563,7 +2292,7 @@ H5B2_remove_leaf_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
     /* Make 'remove' callback if there is one */
     if(op)
-        if((op)(H5B2_LEAF_NREC(leaf, shared, idx), op_data) < 0)
+        if((op)(H5B2_LEAF_NREC(leaf, hdr, idx), op_data) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTDELETE, FAIL, "unable to remove record into leaf node")
 
     /* Update number of records in node */
@@ -2575,7 +2304,7 @@ H5B2_remove_leaf_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     if(leaf->nrec > 0) {
         /* Pack record out of leaf */
         if(idx < leaf->nrec)
-            HDmemmove(H5B2_LEAF_NREC(leaf, shared, idx), H5B2_LEAF_NREC(leaf, shared, (idx + 1)), shared->type->nrec_size * (leaf->nrec-idx));
+            HDmemmove(H5B2_LEAF_NREC(leaf, hdr, idx), H5B2_LEAF_NREC(leaf, hdr, (idx + 1)), hdr->cls->nrec_size * (leaf->nrec - idx));
     } /* end if */
     else {
         /* Let the cache know that the object is deleted */
@@ -2590,7 +2319,7 @@ H5B2_remove_leaf_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
 done:
     /* Release the B-tree leaf node */
-    if(leaf && H5AC_unprotect(f, dxpl_id, H5AC_BT2_LEAF, leaf_addr, leaf, leaf_flags) < 0)
+    if(leaf && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_LEAF, leaf_addr, leaf, leaf_flags) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2612,7 +2341,7 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_remove_internal_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
+H5B2_remove_internal_by_idx(H5B2_hdr_t *hdr, hid_t dxpl_id,
     hbool_t *depth_decreased, void *swap_loc, unsigned depth,
     H5AC_info_t *parent_cache_info, unsigned *parent_cache_info_flags_ptr,
     H5B2_node_ptr_t *curr_node_ptr, hsize_t n, H5B2_remove_t op,
@@ -2624,7 +2353,6 @@ H5B2_remove_internal_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     H5B2_internal_t *internal;          /* Pointer to internal node */
     unsigned internal_flags = H5AC__NO_FLAGS_SET;
     haddr_t internal_addr;              /* Address of internal node */
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
     size_t      merge_nrec;             /* Number of records to merge node at */
     hbool_t     collapsed_root = FALSE; /* Whether the root was collapsed */
     herr_t	ret_value = SUCCEED;
@@ -2632,36 +2360,30 @@ H5B2_remove_internal_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     FUNC_ENTER_NOAPI_NOINIT(H5B2_remove_internal_by_idx)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(depth > 0);
     HDassert(parent_cache_info);
-    HDassert(parent_cache_info_flags_ptr);
     HDassert(curr_node_ptr);
     HDassert(H5F_addr_defined(curr_node_ptr->addr));
 
     /* Lock current B-tree node */
     internal_addr = curr_node_ptr->addr;
-    if(NULL == (internal = H5B2_protect_internal(f, dxpl_id, bt2_shared, internal_addr, curr_node_ptr->node_nrec, depth, H5AC_WRITE)))
+    if(NULL == (internal = H5B2_protect_internal(hdr, dxpl_id, internal_addr, curr_node_ptr->node_nrec, depth, H5AC_WRITE)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
     HDassert(internal->nrec == curr_node_ptr->node_nrec);
-
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-    HDassert(depth == shared->depth || internal->nrec > 1);
+    HDassert(depth == hdr->depth || internal->nrec > 1);
 
     /* Determine the correct number of records to merge at */
-    merge_nrec = shared->node_info[depth - 1].merge_nrec;
+    merge_nrec = hdr->node_info[depth - 1].merge_nrec;
 
     /* Check for needing to collapse the root node */
     /* (The root node is the only internal node allowed to have 1 record) */
     if(internal->nrec == 1 &&
             ((internal->node_ptrs[0].node_nrec + internal->node_ptrs[1].node_nrec) <= ((merge_nrec * 2) + 1))) {
-        HDassert(depth == shared->depth);
+        HDassert(depth == hdr->depth);
 
         /* Merge children of root node */
-        if(H5B2_merge2(f, dxpl_id, depth, curr_node_ptr,
+        if(H5B2_merge2(hdr, dxpl_id, depth, curr_node_ptr,
                 parent_cache_info_flags_ptr, internal, &internal_flags, 0) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to merge child node")
 
@@ -2740,22 +2462,22 @@ H5B2_remove_internal_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
              */
             if(idx == 0) {    /* Left-most child */
                 if(retries > 0 && (internal->node_ptrs[idx + 1].node_nrec > merge_nrec)) {
-                    if(H5B2_redistribute2(f, dxpl_id, depth, internal, idx) < 0)
+                    if(H5B2_redistribute2(hdr, dxpl_id, depth, internal, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTREDISTRIBUTE, FAIL, "unable to redistribute child node records")
                 } /* end if */
                 else {
-                    if(H5B2_merge2(f, dxpl_id, depth, curr_node_ptr,
+                    if(H5B2_merge2(hdr, dxpl_id, depth, curr_node_ptr,
                            parent_cache_info_flags_ptr, internal, &internal_flags, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to merge child node")
                 } /* end else */
             } /* end if */
             else if(idx == internal->nrec) { /* Right-most child */
                 if(retries > 0 && (internal->node_ptrs[idx - 1].node_nrec > merge_nrec)) {
-                    if(H5B2_redistribute2(f, dxpl_id, depth, internal, (idx - 1)) < 0)
+                    if(H5B2_redistribute2(hdr, dxpl_id, depth, internal, (idx - 1)) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTREDISTRIBUTE, FAIL, "unable to redistribute child node records")
                 } /* end if */
                 else {
-                    if(H5B2_merge2(f, dxpl_id, depth, curr_node_ptr,
+                    if(H5B2_merge2(hdr, dxpl_id, depth, curr_node_ptr,
                            parent_cache_info_flags_ptr, internal, &internal_flags, (idx - 1)) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to merge child node")
                 } /* end else */
@@ -2763,11 +2485,11 @@ H5B2_remove_internal_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
             else { /* Middle child */
                 if(retries > 0 && ((internal->node_ptrs[idx + 1].node_nrec > merge_nrec) ||
                             (internal->node_ptrs[idx - 1].node_nrec > merge_nrec))) {
-                    if(H5B2_redistribute3(f, dxpl_id, depth, internal, &internal_flags, idx) < 0)
+                    if(H5B2_redistribute3(hdr, dxpl_id, depth, internal, &internal_flags, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTREDISTRIBUTE, FAIL, "unable to redistribute child node records")
                 } /* end if */
                 else {
-                    if(H5B2_merge3(f, dxpl_id, depth, curr_node_ptr,
+                    if(H5B2_merge3(hdr, dxpl_id, depth, curr_node_ptr,
                            parent_cache_info_flags_ptr, internal, &internal_flags, idx) < 0)
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to merge child node")
                 } /* end else */
@@ -2818,11 +2540,11 @@ H5B2_remove_internal_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
         /* Handle deleting a record from an internal node */
         if(!swap_loc && found)
-            swap_loc = H5B2_INT_NREC(internal, shared, idx - 1);
+            swap_loc = H5B2_INT_NREC(internal, hdr, idx - 1);
 
         /* Swap record to delete with record from leaf, if we are the last internal node */
         if(swap_loc && depth == 1)
-            if(H5B2_swap_leaf(f, dxpl_id, depth, internal, &internal_flags, idx, swap_loc) < 0)
+            if(H5B2_swap_leaf(hdr, dxpl_id, depth, internal, &internal_flags, idx, swap_loc) < 0)
                 HGOTO_ERROR(H5E_BTREE, H5E_CANTSWAP, FAIL, "can't swap records in B-tree")
 
         /* Set pointers for advancing to child node */
@@ -2833,12 +2555,12 @@ H5B2_remove_internal_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
     /* Attempt to remove record from child node */
     if(depth > 1) {
-        if(H5B2_remove_internal_by_idx(f, dxpl_id, bt2_shared, depth_decreased, swap_loc, depth - 1,
+        if(H5B2_remove_internal_by_idx(hdr, dxpl_id, depth_decreased, swap_loc, depth - 1,
                 new_cache_info, new_cache_info_flags_ptr, new_node_ptr, n, op, op_data) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTDELETE, FAIL, "unable to remove record from B-tree internal node")
     } /* end if */
     else {
-        if(H5B2_remove_leaf_by_idx(f, dxpl_id, bt2_shared, new_node_ptr, (unsigned)n, op, op_data) < 0)
+        if(H5B2_remove_leaf_by_idx(hdr, dxpl_id, new_node_ptr, (unsigned)n, op, op_data) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTDELETE, FAIL, "unable to remove record from B-tree leaf node")
     } /* end else */
 
@@ -2850,12 +2572,12 @@ H5B2_remove_internal_by_idx(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     internal_flags |= H5AC__DIRTIED_FLAG;
 
 #ifdef H5B2_DEBUG
-    H5B2_assert_internal((!collapsed_root ? (curr_node_ptr->all_nrec-1) : new_node_ptr->all_nrec),shared,internal);
+    H5B2_assert_internal((!collapsed_root ? (curr_node_ptr->all_nrec - 1) : new_node_ptr->all_nrec), hdr, internal);
 #endif /* H5B2_DEBUG */
 
 done:
     /* Release the B-tree internal node */
-    if(internal && H5AC_unprotect(f, dxpl_id, H5AC_BT2_INT, internal_addr, internal, internal_flags) < 0)
+    if(internal && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_INT, internal_addr, internal, internal_flags) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2889,36 +2611,29 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_neighbor_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
-    H5B2_node_ptr_t *curr_node_ptr, void *neighbor_loc,
-    H5B2_compare_t comp, void *udata, H5B2_found_t op, void *op_data)
+H5B2_neighbor_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id, H5B2_node_ptr_t *curr_node_ptr,
+    void *neighbor_loc, H5B2_compare_t comp, void *udata, H5B2_found_t op,
+    void *op_data)
 {
     H5B2_leaf_t *leaf;                  /* Pointer to leaf node */
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
     unsigned    idx;                    /* Location of record which matches key */
-    int         cmp=0;                  /* Comparison value of records */
+    int         cmp = 0;                  /* Comparison value of records */
     herr_t	ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_neighbor_leaf)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(curr_node_ptr);
     HDassert(H5F_addr_defined(curr_node_ptr->addr));
     HDassert(op);
 
     /* Lock current B-tree node */
-    if (NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_LEAF, curr_node_ptr->addr, &(curr_node_ptr->node_nrec), bt2_shared, H5AC_READ)))
+    if(NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, H5AC_BT2_LEAF, curr_node_ptr->addr, &(curr_node_ptr->node_nrec), hdr, H5AC_READ)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
-    /* Get the pointer to the shared B-tree info */
-    shared=(H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-
-
     /* Locate node pointer for child */
-    cmp = H5B2_locate_record(shared->type, leaf->nrec, shared->nat_off, leaf->leaf_native, udata, &idx);
+    cmp = H5B2_locate_record(hdr->cls, leaf->nrec, hdr->nat_off, leaf->leaf_native, udata, &idx);
     if(cmp > 0)
         idx++;
     else
@@ -2928,19 +2643,19 @@ H5B2_neighbor_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
     /* Set the neighbor location, if appropriate */
     if(comp == H5B2_COMPARE_LESS) {
         if(idx > 0)
-            neighbor_loc = H5B2_LEAF_NREC(leaf,shared,idx-1);
+            neighbor_loc = H5B2_LEAF_NREC(leaf, hdr, idx - 1);
     } /* end if */
     else {
         HDassert(comp == H5B2_COMPARE_GREATER);
 
         if(idx < leaf->nrec)
-            neighbor_loc = H5B2_LEAF_NREC(leaf,shared,idx);
+            neighbor_loc = H5B2_LEAF_NREC(leaf, hdr, idx);
     } /* end else */
 
     /* Make callback if neighbor record has been found */
     if(neighbor_loc) {
         /* Make callback for current record */
-        if ((op)(neighbor_loc, op_data) < 0)
+        if((op)(neighbor_loc, op_data) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_NOTFOUND, FAIL, "'found' callback failed for B-tree neighbor operation")
     } /* end if */
     else
@@ -2948,7 +2663,7 @@ H5B2_neighbor_leaf(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
 
 done:
     /* Release the B-tree internal node */
-    if (leaf && H5AC_unprotect(f, dxpl_id, H5AC_BT2_LEAF, curr_node_ptr->addr, leaf, H5AC__NO_FLAGS_SET) < 0)
+    if(leaf && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_LEAF, curr_node_ptr->addr, leaf, H5AC__NO_FLAGS_SET) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree leaf node")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2982,64 +2697,58 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_neighbor_internal(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared,
-    unsigned depth, H5B2_node_ptr_t *curr_node_ptr, void *neighbor_loc,
-    H5B2_compare_t comp, void *udata, H5B2_found_t op, void *op_data)
+H5B2_neighbor_internal(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
+    H5B2_node_ptr_t *curr_node_ptr, void *neighbor_loc, H5B2_compare_t comp,
+    void *udata, H5B2_found_t op, void *op_data)
 {
     H5B2_internal_t *internal;          /* Pointer to internal node */
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
     unsigned    idx;                    /* Location of record which matches key */
-    int         cmp=0;                  /* Comparison value of records */
+    int         cmp = 0;                /* Comparison value of records */
     herr_t	ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_neighbor_internal)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
-    HDassert(depth>0);
+    HDassert(hdr);
+    HDassert(depth > 0);
     HDassert(curr_node_ptr);
     HDassert(H5F_addr_defined(curr_node_ptr->addr));
     HDassert(op);
 
     /* Lock current B-tree node */
-    if(NULL == (internal = H5B2_protect_internal(f, dxpl_id, bt2_shared, curr_node_ptr->addr, curr_node_ptr->node_nrec, depth, H5AC_READ)))
+    if(NULL == (internal = H5B2_protect_internal(hdr, dxpl_id, curr_node_ptr->addr, curr_node_ptr->node_nrec, depth, H5AC_READ)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-
     /* Locate node pointer for child */
-    cmp = H5B2_locate_record(shared->type, internal->nrec, shared->nat_off, internal->int_native, udata, &idx);
+    cmp = H5B2_locate_record(hdr->cls, internal->nrec, hdr->nat_off, internal->int_native, udata, &idx);
     if(cmp > 0)
         idx++;
 
     /* Set the neighbor location, if appropriate */
     if(comp == H5B2_COMPARE_LESS) {
         if(idx > 0)
-            neighbor_loc = H5B2_INT_NREC(internal,shared,idx-1);
+            neighbor_loc = H5B2_INT_NREC(internal, hdr, idx - 1);
     } /* end if */
     else {
         HDassert(comp == H5B2_COMPARE_GREATER);
 
         if(idx < internal->nrec)
-            neighbor_loc = H5B2_INT_NREC(internal,shared,idx);
+            neighbor_loc = H5B2_INT_NREC(internal, hdr, idx);
     } /* end else */
 
     /* Attempt to find neighboring record */
-    if(depth>1) {
-        if(H5B2_neighbor_internal(f, dxpl_id, bt2_shared, depth-1, &internal->node_ptrs[idx], neighbor_loc, comp, udata, op, op_data) < 0)
+    if(depth > 1) {
+        if(H5B2_neighbor_internal(hdr, dxpl_id, depth - 1, &internal->node_ptrs[idx], neighbor_loc, comp, udata, op, op_data) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_NOTFOUND, FAIL, "unable to find neighbor record in B-tree internal node")
     } /* end if */
     else {
-        if(H5B2_neighbor_leaf(f, dxpl_id, bt2_shared, &internal->node_ptrs[idx], neighbor_loc, comp, udata, op, op_data) < 0)
+        if(H5B2_neighbor_leaf(hdr, dxpl_id, &internal->node_ptrs[idx], neighbor_loc, comp, udata, op, op_data) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_NOTFOUND, FAIL, "unable to find neighbor record in B-tree leaf node")
     } /* end else */
 
 done:
     /* Release the B-tree internal node */
-    if (internal && H5AC_unprotect(f, dxpl_id, H5AC_BT2_INT, curr_node_ptr->addr, internal, H5AC__NO_FLAGS_SET) < 0)
+    if(internal && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_INT, curr_node_ptr->addr, internal, H5AC__NO_FLAGS_SET) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -3061,32 +2770,26 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_delete_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned depth,
+H5B2_delete_node(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     const H5B2_node_ptr_t *curr_node, H5B2_remove_t op, void *op_data)
 {
-    H5B2_shared_t *shared;              /* Pointer to B-tree's shared information */
-    const H5AC_class_t *curr_node_class=NULL; /* Pointer to current node's class info */
-    void *node=NULL;                    /* Pointers to current node */
+    const H5AC_class_t *curr_node_class = NULL; /* Pointer to current node's class info */
+    void *node = NULL;                    /* Pointers to current node */
     uint8_t *native;                    /* Pointers to node's native records */
     herr_t	ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT(H5B2_delete_node)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(curr_node);
 
-    /* Get the pointer to the shared B-tree info */
-    shared=(H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-
-    if(depth>0) {
+    if(depth > 0) {
         H5B2_internal_t *internal;     /* Pointer to internal node */
         unsigned u;                    /* Local index */
 
         /* Lock the current B-tree node */
-        if (NULL == (internal = H5B2_protect_internal(f, dxpl_id, bt2_shared, curr_node->addr, curr_node->node_nrec, depth, H5AC_WRITE)))
+        if(NULL == (internal = H5B2_protect_internal(hdr, dxpl_id, curr_node->addr, curr_node->node_nrec, depth, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
         /* Set up information about current node */
@@ -3095,15 +2798,15 @@ H5B2_delete_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned depth,
         native = internal->int_native;
 
         /* Descend into children */
-        for(u=0; u<internal->nrec+1; u++)
-            if(H5B2_delete_node(f, dxpl_id, bt2_shared, depth-1, &(internal->node_ptrs[u]), op, op_data) < 0)
+        for(u = 0; u < internal->nrec + 1; u++)
+            if(H5B2_delete_node(hdr, dxpl_id, depth - 1, &(internal->node_ptrs[u]), op, op_data) < 0)
                 HGOTO_ERROR(H5E_BTREE, H5E_CANTLIST, FAIL, "node descent failed")
     } /* end if */
     else {
         H5B2_leaf_t *leaf;             /* Pointer to leaf node */
 
         /* Lock the current B-tree node */
-        if (NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_LEAF, curr_node->addr, &(curr_node->node_nrec), bt2_shared, H5AC_WRITE)))
+        if(NULL == (leaf = (H5B2_leaf_t *)H5AC_protect(hdr->f, dxpl_id, H5AC_BT2_LEAF, curr_node->addr, &(curr_node->node_nrec), hdr, H5AC_WRITE)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree leaf node")
 
         /* Set up information about current node */
@@ -3119,14 +2822,14 @@ H5B2_delete_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned depth,
         /* Iterate through records in this node */
         for(u = 0; u < curr_node->node_nrec; u++) {
             /* Make callback for each record */
-            if((op)(H5B2_NAT_NREC(native, shared, u), op_data) < 0)
+            if((op)(H5B2_NAT_NREC(native, hdr, u), op_data) < 0)
                 HGOTO_ERROR(H5E_BTREE, H5E_CANTLIST, FAIL, "iterator function failed")
         } /* end for */
     } /* end if */
 
 done:
     /* Unlock & delete current node */
-    if(node && H5AC_unprotect(f, dxpl_id, curr_node_class, curr_node->addr, node, H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG) < 0)
+    if(node && H5AC_unprotect(hdr->f, dxpl_id, curr_node_class, curr_node->addr, node, H5AC__DELETED_FLAG | H5AC__FREE_FILE_SPACE_FLAG) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -3134,7 +2837,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5B2_iterate_size_node
+ * Function:    H5B2_node_size
  *
  * Purpose:     Iterate over all the records from a B-tree node, collecting
  *		btree storage info.
@@ -3147,28 +2850,22 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B2_iterate_size_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned depth,
+H5B2_node_size(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
     const H5B2_node_ptr_t *curr_node, hsize_t *btree_size)
 {
-    H5B2_shared_t 	*shared;        	/* Pointer to B-tree's shared information */
     H5B2_internal_t 	*internal = NULL;     	/* Pointer to internal node */
     herr_t 		ret_value = SUCCEED;  	/* Iterator return value */
 
-    FUNC_ENTER_NOAPI(H5B2_iterate_size_node, FAIL)
+    FUNC_ENTER_NOAPI(H5B2_node_size, FAIL)
 
     /* Check arguments. */
-    HDassert(f);
-    HDassert(bt2_shared);
+    HDassert(hdr);
     HDassert(curr_node);
     HDassert(btree_size);
     HDassert(depth > 0);
 
-    /* Get the pointer to the shared B-tree info */
-    shared = (H5B2_shared_t *)H5RC_GET_OBJ(bt2_shared);
-    HDassert(shared);
-
     /* Lock the current B-tree node */
-    if(NULL == (internal = H5B2_protect_internal(f, dxpl_id, bt2_shared, curr_node->addr, curr_node->node_nrec, depth, H5AC_READ)))
+    if(NULL == (internal = H5B2_protect_internal(hdr, dxpl_id, curr_node->addr, curr_node->node_nrec, depth, H5AC_READ)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree internal node")
 
     /* Recursively descend into child nodes, if we are above the "twig" level in the B-tree */
@@ -3177,21 +2874,21 @@ H5B2_iterate_size_node(H5F_t *f, hid_t dxpl_id, H5RC_t *bt2_shared, unsigned dep
 
         /* Descend into children */
         for(u = 0; u < internal->nrec + 1; u++)
-            if(H5B2_iterate_size_node(f, dxpl_id, bt2_shared, (depth - 1), &(internal->node_ptrs[u]), btree_size) < 0)
+            if(H5B2_node_size(hdr, dxpl_id, (depth - 1), &(internal->node_ptrs[u]), btree_size) < 0)
                 HGOTO_ERROR(H5E_BTREE, H5E_CANTLIST, FAIL, "node iteration failed")
     } /* end if */
     else /* depth is 1: count all the leaf nodes from this node */
-        *btree_size += (internal->nrec + 1) * shared->node_size;
+        *btree_size += (internal->nrec + 1) * hdr->node_size;
 
     /* Count this node */
-    *btree_size += shared->node_size;
+    *btree_size += hdr->node_size;
 
 done:
-    if(internal && H5AC_unprotect(f, dxpl_id, H5AC_BT2_INT, curr_node->addr, internal, H5AC__NO_FLAGS_SET) < 0)
+    if(internal && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_INT, curr_node->addr, internal, H5AC__NO_FLAGS_SET) < 0)
 	HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5B2_iterate_size_node() */
+} /* H5B2_node_size() */
 
 #ifdef H5B2_DEBUG
 
@@ -3209,10 +2906,10 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_assert_leaf(H5B2_shared_t *shared, H5B2_leaf_t *leaf)
+H5B2_assert_leaf(H5B2_hdr_t *hdr, H5B2_leaf_t *leaf)
 {
     /* General sanity checking on node */
-    HDassert(leaf->nrec<=shared->node_info->split_nrec);
+    HDassert(leaf->nrec <= hdr->node_info->split_nrec);
 
     return(0);
 } /* end H5B2_assert_leaf() */
@@ -3232,10 +2929,10 @@ H5B2_assert_leaf(H5B2_shared_t *shared, H5B2_leaf_t *leaf)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_assert_leaf2(H5B2_shared_t *shared, H5B2_leaf_t *leaf, H5B2_leaf_t *leaf2)
+H5B2_assert_leaf2(H5B2_hdr_t *hdr, H5B2_leaf_t *leaf, H5B2_leaf_t *leaf2)
 {
     /* General sanity checking on node */
-    HDassert(leaf->nrec<=shared->node_info->split_nrec);
+    HDassert(leaf->nrec <= hdr->node_info->split_nrec);
 
     return(0);
 } /* end H5B2_assert_leaf() */
@@ -3255,27 +2952,27 @@ H5B2_assert_leaf2(H5B2_shared_t *shared, H5B2_leaf_t *leaf, H5B2_leaf_t *leaf2)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_assert_internal(hsize_t parent_all_nrec, H5B2_shared_t *shared, H5B2_internal_t *internal)
+H5B2_assert_internal(hsize_t parent_all_nrec, H5B2_hdr_t *hdr, H5B2_internal_t *internal)
 {
     hsize_t tot_all_nrec;       /* Total number of records at or below this node */
-    unsigned u,v;               /* Local index variables */
+    unsigned u, v;               /* Local index variables */
 
     /* General sanity checking on node */
-    HDassert(internal->nrec<=shared->node_info->split_nrec);
+    HDassert(internal->nrec <= hdr->node_info->split_nrec);
 
     /* Sanity checking on node pointers */
-    tot_all_nrec=internal->nrec;
-    for(u=0; u<internal->nrec+1; u++) {
+    tot_all_nrec = internal->nrec;
+    for(u = 0; u < internal->nrec + 1; u++) {
         tot_all_nrec += internal->node_ptrs[u].all_nrec;
 
         HDassert(H5F_addr_defined(internal->node_ptrs[u].addr));
-        HDassert(internal->node_ptrs[u].addr>0);
-        for(v=0; v<u; v++)
-            HDassert(internal->node_ptrs[u].addr!=internal->node_ptrs[v].addr);
+        HDassert(internal->node_ptrs[u].addr > 0);
+        for(v = 0; v < u; v++)
+            HDassert(internal->node_ptrs[u].addr != internal->node_ptrs[v].addr);
     } /* end for */
 
     /* Sanity check all_nrec total in parent */
-    if(parent_all_nrec>0)
+    if(parent_all_nrec > 0)
         HDassert(tot_all_nrec == parent_all_nrec);
 
     return(0);
@@ -3296,29 +2993,29 @@ H5B2_assert_internal(hsize_t parent_all_nrec, H5B2_shared_t *shared, H5B2_intern
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5B2_assert_internal2(hsize_t parent_all_nrec, H5B2_shared_t *shared, H5B2_internal_t *internal, H5B2_internal_t *internal2)
+H5B2_assert_internal2(hsize_t parent_all_nrec, H5B2_hdr_t *hdr, H5B2_internal_t *internal, H5B2_internal_t *internal2)
 {
     hsize_t tot_all_nrec;       /* Total number of records at or below this node */
-    unsigned u,v;       /* Local index variables */
+    unsigned u, v;       /* Local index variables */
 
     /* General sanity checking on node */
-    HDassert(internal->nrec<=shared->node_info->split_nrec);
+    HDassert(internal->nrec <= hdr->node_info->split_nrec);
 
     /* Sanity checking on node pointers */
-    tot_all_nrec=internal->nrec;
-    for(u=0; u<internal->nrec+1; u++) {
+    tot_all_nrec =internal->nrec;
+    for(u =0; u < internal->nrec + 1; u++) {
         tot_all_nrec += internal->node_ptrs[u].all_nrec;
 
         HDassert(H5F_addr_defined(internal->node_ptrs[u].addr));
-        HDassert(internal->node_ptrs[u].addr>0);
-        for(v=0; v<u; v++)
-            HDassert(internal->node_ptrs[u].addr!=internal->node_ptrs[v].addr);
-        for(v=0; v<internal2->nrec+1; v++)
-            HDassert(internal->node_ptrs[u].addr!=internal2->node_ptrs[v].addr);
+        HDassert(internal->node_ptrs[u].addr > 0);
+        for(v = 0; v < u; v++)
+            HDassert(internal->node_ptrs[u].addr != internal->node_ptrs[v].addr);
+        for(v = 0; v < internal2->nrec + 1; v++)
+            HDassert(internal->node_ptrs[u].addr != internal2->node_ptrs[v].addr);
     } /* end for */
 
     /* Sanity check all_nrec total in parent */
-    if(parent_all_nrec>0)
+    if(parent_all_nrec > 0)
         HDassert(tot_all_nrec == parent_all_nrec);
 
     return(0);