Normalize with vol_integration.

1 files changed, 132 insertions, 129 deletions

diff --git a/src/H5MFaggr.c b/src/H5MFaggr.c
index cd80a10..5ab1834 100644
--- a/src/H5MFaggr.c
+++ b/src/H5MFaggr.c
@@ -59,6 +59,8 @@ static herr_t H5MF__aggr_free(H5F_t *f, H5FD_mem_t type,
     H5F_blk_aggr_t *aggr);
 static haddr_t H5MF__aggr_alloc(H5F_t *f, H5F_blk_aggr_t *aggr,
     H5F_blk_aggr_t *other_aggr, H5FD_mem_t type, hsize_t size);
+static herr_t H5MF__aggr_reset(H5F_t *f, H5F_blk_aggr_t *aggr);
+static htri_t H5MF__aggr_can_shrink_eoa(H5F_t *f, H5FD_mem_t type, H5F_blk_aggr_t *aggr);
 
 
 /*********************/
@@ -179,7 +181,7 @@ HDfprintf(stderr, "%s: type = %u, size = %Hu\n", FUNC, (unsigned)type, size);
     /*
      * If the aggregation feature is enabled for this file and strategy is not H5F_FILE_SPACE_NONE,
      * allocate "generic" space and sub-allocate out of that, if possible.
-     * Otherwise just allocate through H5F_alloc().
+     * Otherwise just allocate through H5F__alloc().
      */
     if((f->shared->feature_flags & aggr->feature_flag) && f->shared->fs_strategy != H5F_FSPACE_STRATEGY_NONE) {
         haddr_t	aggr_frag_addr = HADDR_UNDEF;   /* Address of aggregrator fragment */
@@ -193,18 +195,18 @@ HDfprintf(stderr, "%s: aggr = {%a, %Hu, %Hu}\n", FUNC, aggr->addr, aggr->tot_siz
 #endif /* H5MF_AGGR_DEBUG */
 
         /* Turn off alignment if allocation < threshold */
-	alignment = H5F_ALIGNMENT(f);
-	if(!((alignment > 1) && (size >= H5F_THRESHOLD(f))))
-	    alignment = 0; /* no alignment */
+        alignment = H5F_ALIGNMENT(f);
+        if(!((alignment > 1) && (size >= H5F_THRESHOLD(f))))
+            alignment = 0; /* no alignment */
 
         /* Generate fragment if aggregator is mis-aligned */
-	if(alignment && H5F_addr_gt(aggr->addr, 0) && (aggr_mis_align = (aggr->addr + H5F_BASE_ADDR(f)) % alignment)) {
-	    aggr_frag_addr = aggr->addr;
-	    aggr_frag_size = alignment - aggr_mis_align;
-	} /* end if */
+        if(alignment && H5F_addr_gt(aggr->addr, 0) && (aggr_mis_align = (aggr->addr + H5F_BASE_ADDR(f)) % alignment)) {
+            aggr_frag_addr = aggr->addr;
+            aggr_frag_size = alignment - aggr_mis_align;
+        } /* end if */
 
-	alloc_type = aggr->feature_flag == H5FD_FEAT_AGGREGATE_METADATA ? H5FD_MEM_DEFAULT : H5FD_MEM_DRAW;
-	other_alloc_type = other_aggr->feature_flag == H5FD_FEAT_AGGREGATE_METADATA ? H5FD_MEM_DEFAULT : H5FD_MEM_DRAW;
+        alloc_type = aggr->feature_flag == H5FD_FEAT_AGGREGATE_METADATA ? H5FD_MEM_DEFAULT : H5FD_MEM_DRAW;
+        other_alloc_type = other_aggr->feature_flag == H5FD_FEAT_AGGREGATE_METADATA ? H5FD_MEM_DEFAULT : H5FD_MEM_DRAW;
 
         /* Check if the space requested is larger than the space left in the block */
         if((size + aggr_frag_size) > aggr->size) {
@@ -212,73 +214,74 @@ HDfprintf(stderr, "%s: aggr = {%a, %Hu, %Hu}\n", FUNC, aggr->addr, aggr->tot_siz
 
             /* Check if the block asked for is too large for 'normal' aggregator block */
             if(size >= aggr->alloc_size) {
-		hsize_t ext_size = size + aggr_frag_size;
+                hsize_t ext_size = size + aggr_frag_size;
 
                 /* Check for overlapping into file's temporary allocation space */
                 if(H5F_addr_gt((aggr->addr + aggr->size + ext_size), f->shared->tmp_addr))
                     HGOTO_ERROR(H5E_RESOURCE, H5E_BADRANGE, HADDR_UNDEF, "'normal' file space allocation request will overlap into 'temporary' file space")
 
-		if((aggr->addr > 0) && (extended = H5F__try_extend(f, alloc_type, (aggr->addr + aggr->size), ext_size)) < 0)
-		    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "can't extending space")
-		else if (extended) {
-		    /* aggr->size is unchanged */
-		    ret_value = aggr->addr + aggr_frag_size;
-		    aggr->addr += ext_size;
-		    aggr->tot_size += ext_size;
-		} else {
+                if((aggr->addr > 0) && (extended = H5F__try_extend(f, alloc_type, (aggr->addr + aggr->size), ext_size)) < 0)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "can't extending space")
+                else if(extended) {
+                    /* aggr->size is unchanged */
+                    ret_value = aggr->addr + aggr_frag_size;
+                    aggr->addr += ext_size;
+                    aggr->tot_size += ext_size;
+                }
+                else {
                     /* Release "other" aggregator, if it exists, is at the end of the allocated space,
                      * has allocated more than one block and the unallocated space is greater than its
                      * allocation block size.
                      */
-		    if((other_aggr->size > 0) && (H5F_addr_eq((other_aggr->addr + other_aggr->size), eoa)) &&
-			    (other_aggr->tot_size > other_aggr->size) && ((other_aggr->tot_size - other_aggr->size) >= other_aggr->alloc_size)) {
+                    if((other_aggr->size > 0) && (H5F_addr_eq((other_aggr->addr + other_aggr->size), eoa)) &&
+                            (other_aggr->tot_size > other_aggr->size) && ((other_aggr->tot_size - other_aggr->size) >= other_aggr->alloc_size)) {
                         if(H5MF__aggr_free(f, other_alloc_type, other_aggr) < 0)
                             HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, HADDR_UNDEF, "can't free aggregation block")
-		    } /* end if */
+                    } /* end if */
 
                     /* Allocate space from the VFD (i.e. at the end of the file) */
-		    if(HADDR_UNDEF == (ret_value = H5F__alloc(f, alloc_type, size, &eoa_frag_addr, &eoa_frag_size)))
-			HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "can't allocate file space")
+                    if(HADDR_UNDEF == (ret_value = H5F__alloc(f, alloc_type, size, &eoa_frag_addr, &eoa_frag_size)))
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "can't allocate file space")
                 } /* end else */
             } /* end if */
-	    else {
-		hsize_t ext_size = aggr->alloc_size;
+            else {
+                hsize_t ext_size = aggr->alloc_size;
 
                 /* Allocate another block */
 #ifdef H5MF_AGGR_DEBUG
 HDfprintf(stderr, "%s: Allocating block\n", FUNC);
 #endif /* H5MF_AGGR_DEBUG */
 
-		if(aggr_frag_size > (ext_size - size))
-		    ext_size += (aggr_frag_size - (ext_size - size));
+                if(aggr_frag_size > (ext_size - size))
+                    ext_size += (aggr_frag_size - (ext_size - size));
 
                 /* Check for overlapping into file's temporary allocation space */
                 if(H5F_addr_gt((aggr->addr + aggr->size + ext_size), f->shared->tmp_addr))
                     HGOTO_ERROR(H5E_RESOURCE, H5E_BADRANGE, HADDR_UNDEF, "'normal' file space allocation request will overlap into 'temporary' file space")
 
-		if((aggr->addr > 0) && (extended = H5F__try_extend(f, alloc_type, (aggr->addr + aggr->size), ext_size)) < 0)
-		    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "can't extending space")
-		else if(extended) {
-		    aggr->addr += aggr_frag_size;
-		    aggr->size += (ext_size - aggr_frag_size);
-		    aggr->tot_size += ext_size;
-		} /* end else-if */
-		else {
+                if((aggr->addr > 0) && (extended = H5F__try_extend(f, alloc_type, (aggr->addr + aggr->size), ext_size)) < 0)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "can't extending space")
+                else if(extended) {
+                    aggr->addr += aggr_frag_size;
+                    aggr->size += (ext_size - aggr_frag_size);
+                    aggr->tot_size += ext_size;
+                } /* end else-if */
+                else {
                     haddr_t new_space;          /* Address of new space allocated */
 
                     /* Release "other" aggregator, if it exists, is at the end of the allocated space,
                      * has allocated more than one block and the unallocated space is greater than its
                      * allocation block size.
                      */
-		    if((other_aggr->size > 0) && (H5F_addr_eq((other_aggr->addr + other_aggr->size), eoa)) &&
-			    (other_aggr->tot_size > other_aggr->size) && ((other_aggr->tot_size - other_aggr->size) >= other_aggr->alloc_size)) {
+                    if((other_aggr->size > 0) && (H5F_addr_eq((other_aggr->addr + other_aggr->size), eoa)) &&
+                            (other_aggr->tot_size > other_aggr->size) && ((other_aggr->tot_size - other_aggr->size) >= other_aggr->alloc_size)) {
                         if(H5MF__aggr_free(f, other_alloc_type, other_aggr) < 0)
                             HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, HADDR_UNDEF, "can't free aggregation block")
-		    } /* end if */
+                    } /* end if */
 
                     /* Allocate space from the VFD (i.e. at the end of the file) */
-		    if(HADDR_UNDEF == (new_space = H5F__alloc(f, alloc_type, aggr->alloc_size, &eoa_frag_addr, &eoa_frag_size)))
-			HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "can't allocate file space")
+                    if(HADDR_UNDEF == (new_space = H5F__alloc(f, alloc_type, aggr->alloc_size, &eoa_frag_addr, &eoa_frag_size)))
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "can't allocate file space")
 
                     /* Return the unused portion of the block to a free list */
                     if(aggr->size > 0)
@@ -307,32 +310,32 @@ HDfprintf(stderr, "%s: Allocating block\n", FUNC);
                     } /* end else */
                 } /* end else */
 
-		/* Allocate space out of the metadata block */
-		ret_value = aggr->addr;
-		aggr->size -= size;
-		aggr->addr += size;
+                /* Allocate space out of the metadata block */
+                ret_value = aggr->addr;
+                aggr->size -= size;
+                aggr->addr += size;
             } /* end else */
 
-	    /* Freeing any possible fragment due to file allocation */
-	    if(eoa_frag_size)
-		if(H5MF_xfree(f, alloc_type, eoa_frag_addr, eoa_frag_size) < 0)
-		    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, HADDR_UNDEF, "can't free eoa fragment")
+            /* Freeing any possible fragment due to file allocation */
+            if(eoa_frag_size)
+                if(H5MF_xfree(f, alloc_type, eoa_frag_addr, eoa_frag_size) < 0)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, HADDR_UNDEF, "can't free eoa fragment")
 
-	    /* Freeing any possible fragment due to alignment in the block after extension */
+            /* Freeing any possible fragment due to alignment in the block after extension */
             if(extended && aggr_frag_size)
-		if(H5MF_xfree(f, alloc_type, aggr_frag_addr, aggr_frag_size) < 0)
-		    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, HADDR_UNDEF, "can't free aggregation fragment")
+                if(H5MF_xfree(f, alloc_type, aggr_frag_addr, aggr_frag_size) < 0)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, HADDR_UNDEF, "can't free aggregation fragment")
         } /* end if */
         else {
             /* Allocate space out of the block */
-	    ret_value = aggr->addr + aggr_frag_size;
-	    aggr->size -= (size + aggr_frag_size);
-	    aggr->addr += (size + aggr_frag_size);
-
-	    /* free any possible fragment */
-	    if(aggr_frag_size)
-		if(H5MF_xfree(f, alloc_type, aggr_frag_addr, aggr_frag_size) < 0)
-		    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, HADDR_UNDEF, "can't free aggregation fragment")
+            ret_value = aggr->addr + aggr_frag_size;
+            aggr->size -= (size + aggr_frag_size);
+            aggr->addr += (size + aggr_frag_size);
+
+            /* free any possible fragment */
+            if(aggr_frag_size)
+                if(H5MF_xfree(f, alloc_type, aggr_frag_addr, aggr_frag_size) < 0)
+                    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, HADDR_UNDEF, "can't free aggregation fragment")
         } /* end else */
     } /* end if */
     else {
@@ -341,10 +344,10 @@ HDfprintf(stderr, "%s: Allocating block\n", FUNC);
             HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, HADDR_UNDEF, "can't allocate file space")
 
         /* Check if fragment was generated */
-	if(eoa_frag_size)
+        if(eoa_frag_size)
             /* Put fragment on the free list */
-	    if(H5MF_xfree(f, type, eoa_frag_addr, eoa_frag_size) < 0)
-		HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, HADDR_UNDEF, "can't free eoa fragment")
+            if(H5MF_xfree(f, type, eoa_frag_addr, eoa_frag_size) < 0)
+                HGOTO_ERROR(H5E_RESOURCE, H5E_CANTFREE, HADDR_UNDEF, "can't free eoa fragment")
     } /* end else */
 
     /* Sanity check for overlapping into file's temporary allocation space */
@@ -403,53 +406,53 @@ H5MF__aggr_try_extend(H5F_t *f, H5F_blk_aggr_t *aggr,
     /* Check if this aggregator is active */
     if(f->shared->feature_flags & aggr->feature_flag) {
         /* 
-	 * If the block being tested adjoins the beginning of the aggregator
+         * If the block being tested adjoins the beginning of the aggregator
          *      block, check if the aggregator can accomodate the extension.
          */
         if(H5F_addr_eq(blk_end, aggr->addr)) {
-	    haddr_t eoa;      /* EOA for the file */
-
-	    /* Get the EOA for the file */
-	    if(HADDR_UNDEF == (eoa = H5F_get_eoa(f, type)))
-		HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "Unable to get eoa")
-
-	    /* If the aggregator is at the end of file: */
-	    if(H5F_addr_eq(eoa, aggr->addr + aggr->size)) {
-		/* If extra_requested is below percentage threshold, extend block into the aggregator. */
-		if(extra_requested <= (hsize_t)(EXTEND_THRESHOLD * (float)aggr->size)) {
-		    aggr->size -= extra_requested;
-		    aggr->addr += extra_requested;
-
-		    /* Indicate success */
-		    HGOTO_DONE(TRUE);
-		} /* end if */
-		/*
-		 * If extra_requested is above percentage threshold:
-		 * 1) "bubble" up the aggregator by aggr->alloc_size or extra_requested
-		 * 2) extend the block into the aggregator 
-		 */
-		else {
-		    hsize_t extra = (extra_requested < aggr->alloc_size) ? aggr->alloc_size : extra_requested;
+            haddr_t eoa;      /* EOA for the file */
+
+            /* Get the EOA for the file */
+            if(HADDR_UNDEF == (eoa = H5F_get_eoa(f, type)))
+                HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "Unable to get eoa")
+
+            /* If the aggregator is at the end of file: */
+            if(H5F_addr_eq(eoa, aggr->addr + aggr->size)) {
+                /* If extra_requested is below percentage threshold, extend block into the aggregator. */
+                if(extra_requested <= (hsize_t)(EXTEND_THRESHOLD * (float)aggr->size)) {
+                    aggr->size -= extra_requested;
+                    aggr->addr += extra_requested;
+
+                    /* Indicate success */
+                    HGOTO_DONE(TRUE);
+                } /* end if */
+                /*
+                 * If extra_requested is above percentage threshold:
+                 * 1) "bubble" up the aggregator by aggr->alloc_size or extra_requested
+                 * 2) extend the block into the aggregator 
+                 */
+                else {
+                    hsize_t extra = (extra_requested < aggr->alloc_size) ? aggr->alloc_size : extra_requested;
 
                     if((ret_value = H5F__try_extend(f, type, (aggr->addr + aggr->size), extra)) < 0)
-			HGOTO_ERROR(H5E_RESOURCE, H5E_CANTEXTEND, FAIL, "error extending file")
-		    else if(ret_value == TRUE) {
-			/* Shift the aggregator block by the extra requested */
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_CANTEXTEND, FAIL, "error extending file")
+                    else if(ret_value == TRUE) {
+                        /* Shift the aggregator block by the extra requested */
                         /* (allocates the space for the extra_requested) */
-			aggr->addr += extra_requested;
+                        aggr->addr += extra_requested;
 
-			/* Add extra to the aggregator's total allocated amount */
-			aggr->tot_size += extra;
+                        /* Add extra to the aggregator's total allocated amount */
+                        aggr->tot_size += extra;
 
                         /* Account for any space added to the aggregator */
                         /* (either 0 (if extra_requested > aggr->alloc_size) or
                          *      (aggr->alloc_size - extra_requested) -QAK
                          */
-			aggr->size += extra;
-			aggr->size -= extra_requested;
-		    } /* end else-if */
-		} /* end else */
-	    } /* end if */
+                        aggr->size += extra;
+                        aggr->size -= extra_requested;
+                    } /* end else-if */
+                } /* end else */
+            } /* end if */
             else {
                 /* The aggreator is not at end of file */
                 /* Check if aggregator has enough internal space to satisfy the extension. */
@@ -461,8 +464,8 @@ H5MF__aggr_try_extend(H5F_t *f, H5F_blk_aggr_t *aggr,
                     /* Indicate success */
                     HGOTO_DONE(TRUE);
                  } /* end if */
-	    } /* end else */
-	} /* end if */
+            } /* end else */
+        } /* end if */
     } /* end if */
 
 done:
@@ -471,7 +474,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5MF_aggr_can_absorb
+ * Function:    H5MF__aggr_can_absorb
  *
  * Purpose:	Check if a section adjoins an aggregator block and one can
  *              absorb the other.
@@ -486,12 +489,12 @@ done:
  *-------------------------------------------------------------------------
  */
 htri_t
-H5MF_aggr_can_absorb(const H5F_t *f, const H5F_blk_aggr_t *aggr,
+H5MF__aggr_can_absorb(const H5F_t *f, const H5F_blk_aggr_t *aggr,
     const H5MF_free_section_t *sect, H5MF_shrink_type_t *shrink)
 {
     htri_t ret_value = FALSE;           /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
     /* Check args */
     HDassert(f);
@@ -506,7 +509,7 @@ H5MF_aggr_can_absorb(const H5F_t *f, const H5F_blk_aggr_t *aggr,
         if(H5F_addr_eq((sect->sect_info.addr + sect->sect_info.size), aggr->addr)
                 || H5F_addr_eq((aggr->addr + aggr->size), sect->sect_info.addr)) {
 #ifdef H5MF_AGGR_DEBUG
-HDfprintf(stderr, "%s: section {%a, %Hu} adjoins aggr = {%a, %Hu}\n", "H5MF_aggr_can_absorb", sect->sect_info.addr, sect->sect_info.size, aggr->addr, aggr->size);
+HDfprintf(stderr, "%s: section {%a, %Hu} adjoins aggr = {%a, %Hu}\n", "H5MF__aggr_can_absorb", sect->sect_info.addr, sect->sect_info.size, aggr->addr, aggr->size);
 #endif /* H5MF_AGGR_DEBUG */
             /* Check if aggregator would get too large and should be absorbed into section */
             if((aggr->size + sect->sect_info.size) >= aggr->alloc_size)
@@ -521,11 +524,11 @@ HDfprintf(stderr, "%s: section {%a, %Hu} adjoins aggr = {%a, %Hu}\n", "H5MF_aggr
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5MF_aggr_can_absorb() */
+} /* end H5MF__aggr_can_absorb() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5MF_aggr_absorb
+ * Function:    H5MF__aggr_absorb
  *
  * Purpose:	Absorb a free space section into an aggregator block or
  *              vice versa.
@@ -539,10 +542,10 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5MF_aggr_absorb(const H5F_t H5_ATTR_UNUSED *f, H5F_blk_aggr_t *aggr, H5MF_free_section_t *sect,
+H5MF__aggr_absorb(const H5F_t H5_ATTR_UNUSED *f, H5F_blk_aggr_t *aggr, H5MF_free_section_t *sect,
     hbool_t allow_sect_absorb)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
     /* Check args */
     HDassert(f);
@@ -556,7 +559,7 @@ H5MF_aggr_absorb(const H5F_t H5_ATTR_UNUSED *f, H5F_blk_aggr_t *aggr, H5MF_free_
         /* Check if the section adjoins the beginning or end of the aggregator */
         if(H5F_addr_eq((sect->sect_info.addr + sect->sect_info.size), aggr->addr)) {
 #ifdef H5MF_AGGR_DEBUG
-HDfprintf(stderr, "%s: aggr {%a, %Hu} adjoins front of section = {%a, %Hu}\n", "H5MF_aggr_absorb", aggr->addr, aggr->size, sect->sect_info.addr, sect->sect_info.size);
+HDfprintf(stderr, "%s: aggr {%a, %Hu} adjoins front of section = {%a, %Hu}\n", "H5MF__aggr_absorb", aggr->addr, aggr->size, sect->sect_info.addr, sect->sect_info.size);
 #endif /* H5MF_AGGR_DEBUG */
             /* Absorb aggregator onto end of section */
             sect->sect_info.size += aggr->size;
@@ -566,7 +569,7 @@ HDfprintf(stderr, "%s: aggr {%a, %Hu} adjoins front of section = {%a, %Hu}\n", "
             HDassert(H5F_addr_eq((aggr->addr + aggr->size), sect->sect_info.addr));
 
 #ifdef H5MF_AGGR_DEBUG
-HDfprintf(stderr, "%s: aggr {%a, %Hu} adjoins end of section = {%a, %Hu}\n", "H5MF_aggr_absorb", aggr->addr, aggr->size, sect->sect_info.addr, sect->sect_info.size);
+HDfprintf(stderr, "%s: aggr {%a, %Hu} adjoins end of section = {%a, %Hu}\n", "H5MF__aggr_absorb", aggr->addr, aggr->size, sect->sect_info.addr, sect->sect_info.size);
 #endif /* H5MF_AGGR_DEBUG */
             /* Absorb aggregator onto beginning of section */
             sect->sect_info.addr -= aggr->size;
@@ -582,7 +585,7 @@ HDfprintf(stderr, "%s: aggr {%a, %Hu} adjoins end of section = {%a, %Hu}\n", "H5
         /* Check if the section adjoins the beginning or end of the aggregator */
         if(H5F_addr_eq((sect->sect_info.addr + sect->sect_info.size), aggr->addr)) {
 #ifdef H5MF_AGGR_DEBUG
-HDfprintf(stderr, "%s: section {%a, %Hu} adjoins front of aggr = {%a, %Hu}\n", "H5MF_aggr_absorb", sect->sect_info.addr, sect->sect_info.size, aggr->addr, aggr->size);
+HDfprintf(stderr, "%s: section {%a, %Hu} adjoins front of aggr = {%a, %Hu}\n", "H5MF__aggr_absorb", sect->sect_info.addr, sect->sect_info.size, aggr->addr, aggr->size);
 #endif /* H5MF_AGGR_DEBUG */
             /* Absorb section onto front of aggregator */
             aggr->addr -= sect->sect_info.size;
@@ -598,7 +601,7 @@ HDfprintf(stderr, "%s: section {%a, %Hu} adjoins front of aggr = {%a, %Hu}\n", "
             HDassert(H5F_addr_eq((aggr->addr + aggr->size), sect->sect_info.addr));
 
 #ifdef H5MF_AGGR_DEBUG
-HDfprintf(stderr, "%s: section {%a, %Hu} adjoins end of aggr = {%a, %Hu}\n", "H5MF_aggr_absorb", sect->sect_info.addr, sect->sect_info.size, aggr->addr, aggr->size);
+HDfprintf(stderr, "%s: section {%a, %Hu} adjoins end of aggr = {%a, %Hu}\n", "H5MF__aggr_absorb", sect->sect_info.addr, sect->sect_info.size, aggr->addr, aggr->size);
 #endif /* H5MF_AGGR_DEBUG */
             /* Absorb section onto end of aggregator */
             aggr->size += sect->sect_info.size;
@@ -608,11 +611,11 @@ HDfprintf(stderr, "%s: section {%a, %Hu} adjoins end of aggr = {%a, %Hu}\n", "H5
     } /* end else */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5MF_aggr_absorb() */
+} /* end H5MF__aggr_absorb() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5MF_aggr_query
+ * Function:    H5MF__aggr_query
  *
  * Purpose:     Query a block aggregator's current address & size info
  *
@@ -625,10 +628,10 @@ HDfprintf(stderr, "%s: section {%a, %Hu} adjoins end of aggr = {%a, %Hu}\n", "H5
  *-------------------------------------------------------------------------
  */
 herr_t
-H5MF_aggr_query(const H5F_t *f, const H5F_blk_aggr_t *aggr, haddr_t *addr,
+H5MF__aggr_query(const H5F_t *f, const H5F_blk_aggr_t *aggr, haddr_t *addr,
     hsize_t *size)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
     /* Check args */
     HDassert(f);
@@ -644,7 +647,7 @@ H5MF_aggr_query(const H5F_t *f, const H5F_blk_aggr_t *aggr, haddr_t *addr,
     } /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5MF_aggr_query() */
+} /* end H5MF__aggr_query() */
 
 
 /*-------------------------------------------------------------------------
@@ -737,11 +740,11 @@ H5MF_free_aggrs(H5F_t *f)
     HDassert(f->shared->lf);
 
     /* Retrieve metadata aggregator info, if available */
-    if(H5MF_aggr_query(f, &(f->shared->meta_aggr), &ma_addr, &ma_size) < 0)
+    if(H5MF__aggr_query(f, &(f->shared->meta_aggr), &ma_addr, &ma_size) < 0)
         HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't query metadata aggregator stats")
 
     /* Retrieve 'small data' aggregator info, if available */
-    if(H5MF_aggr_query(f, &(f->shared->sdata_aggr), &sda_addr, &sda_size) < 0)
+    if(H5MF__aggr_query(f, &(f->shared->sdata_aggr), &sda_addr, &sda_size) < 0)
         HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't query small data aggregator stats")
 
     /* Make certain we release the aggregator that's later in the file first */
@@ -774,7 +777,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5MF_aggr_can_shrink_eoa
+ * Function:    H5MF__aggr_can_shrink_eoa
  *
  * Purpose:     Check if the remaining space in the aggregator is at EOA
  *
@@ -786,12 +789,12 @@ done:
  *-------------------------------------------------------------------------
  */
 static htri_t
-H5MF_aggr_can_shrink_eoa(H5F_t *f, H5FD_mem_t type, H5F_blk_aggr_t *aggr)
+H5MF__aggr_can_shrink_eoa(H5F_t *f, H5FD_mem_t type, H5F_blk_aggr_t *aggr)
 {
     haddr_t eoa = HADDR_UNDEF;      	/* EOA for the file */
     htri_t ret_value = FALSE;   	/* Return value */
 
-    FUNC_ENTER_NOAPI(FAIL)
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(f);
@@ -808,7 +811,7 @@ H5MF_aggr_can_shrink_eoa(H5F_t *f, H5FD_mem_t type, H5F_blk_aggr_t *aggr)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5MF_aggr_can_shrink_eoa() */
+} /* H5MF__aggr_can_shrink_eoa() */
 
 
 /*-------------------------------------------------------------------------
@@ -882,17 +885,17 @@ H5MF_aggrs_try_shrink_eoa(H5F_t *f)
     HDassert(f);
     HDassert(f->shared);
 
-    if((ma_status = H5MF_aggr_can_shrink_eoa(f, H5FD_MEM_DEFAULT, &(f->shared->meta_aggr))) < 0)
+    if((ma_status = H5MF__aggr_can_shrink_eoa(f, H5FD_MEM_DEFAULT, &(f->shared->meta_aggr))) < 0)
         HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't query metadata aggregator stats")
     if(ma_status > 0)
-	if(H5MF__aggr_free(f, H5FD_MEM_DEFAULT, &(f->shared->meta_aggr)) < 0)
-	    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTSHRINK, FAIL, "can't check for shrinking eoa")
+        if(H5MF__aggr_free(f, H5FD_MEM_DEFAULT, &(f->shared->meta_aggr)) < 0)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_CANTSHRINK, FAIL, "can't check for shrinking eoa")
 
-    if((sda_status = H5MF_aggr_can_shrink_eoa(f, H5FD_MEM_DRAW, &(f->shared->sdata_aggr))) < 0)
+    if((sda_status = H5MF__aggr_can_shrink_eoa(f, H5FD_MEM_DRAW, &(f->shared->sdata_aggr))) < 0)
         HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't query small data aggregator stats")
     if(sda_status > 0)
-	if(H5MF__aggr_free(f, H5FD_MEM_DRAW, &(f->shared->sdata_aggr)) < 0)
-	    HGOTO_ERROR(H5E_RESOURCE, H5E_CANTSHRINK, FAIL, "can't check for shrinking eoa")
+        if(H5MF__aggr_free(f, H5FD_MEM_DRAW, &(f->shared->sdata_aggr)) < 0)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_CANTSHRINK, FAIL, "can't check for shrinking eoa")
 
     ret_value = (ma_status || sda_status);