summaryrefslogtreecommitdiffstats
path: root/src/H5HFcache.c
diff options
context:
space:
mode:
authorQuincey Koziol <koziol@koziol.gov>2020-04-20 23:12:00 (GMT)
committerQuincey Koziol <koziol@koziol.gov>2020-04-20 23:12:00 (GMT)
commit9e5dbf69062d4d2cb40ba8f68edb355477fc9b67 (patch)
treeab184e76824e8b4250ad9bf38286a65227fe2407 /src/H5HFcache.c
parent7ba692badf9a1bafb9d3b2f72efbbdf773b5932a (diff)
downloadhdf5-9e5dbf69062d4d2cb40ba8f68edb355477fc9b67.zip
hdf5-9e5dbf69062d4d2cb40ba8f68edb355477fc9b67.tar.gz
hdf5-9e5dbf69062d4d2cb40ba8f68edb355477fc9b67.tar.bz2
Trim trailing whitespace
Diffstat (limited to 'src/H5HFcache.c')
-rw-r--r--src/H5HFcache.c616
1 files changed, 308 insertions, 308 deletions
diff --git a/src/H5HFcache.c b/src/H5HFcache.c
index 4a2ff91..8dbdf25 100644
--- a/src/H5HFcache.c
+++ b/src/H5HFcache.c
@@ -77,35 +77,35 @@ static herr_t H5HF__cache_hdr_get_final_load_size(const void *image_ptr,
size_t image_len, void *udata, size_t *actual_len);
static htri_t H5HF__cache_hdr_verify_chksum(const void *image_ptr, size_t len, void *udata_ptr);
static void *H5HF__cache_hdr_deserialize(const void *image, size_t len,
- void *udata, hbool_t *dirty);
+ void *udata, hbool_t *dirty);
static herr_t H5HF__cache_hdr_image_len(const void *thing, size_t *image_len);
static herr_t H5HF__cache_hdr_pre_serialize(H5F_t *f, void *thing, haddr_t addr,
- size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags);
+ size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags);
static herr_t H5HF__cache_hdr_serialize(const H5F_t *f, void *image,
- size_t len, void *thing);
+ size_t len, void *thing);
static herr_t H5HF__cache_hdr_free_icr(void *thing);
static herr_t H5HF__cache_iblock_get_initial_load_size(void *udata, size_t *image_len);
static htri_t H5HF__cache_iblock_verify_chksum(const void *image_ptr, size_t len, void *udata_ptr);
static void *H5HF__cache_iblock_deserialize(const void *image, size_t len,
- void *udata, hbool_t *dirty);
+ void *udata, hbool_t *dirty);
static herr_t H5HF__cache_iblock_image_len(const void *thing, size_t *image_len);
static herr_t H5HF__cache_iblock_pre_serialize(H5F_t *f, void *thing,
- haddr_t addr, size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags);
+ haddr_t addr, size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags);
static herr_t H5HF__cache_iblock_serialize(const H5F_t *f, void *image,
- size_t len, void *thing);
-static herr_t H5HF__cache_iblock_notify(H5AC_notify_action_t action, void *thing);
+ size_t len, void *thing);
+static herr_t H5HF__cache_iblock_notify(H5AC_notify_action_t action, void *thing);
static herr_t H5HF__cache_iblock_free_icr(void *thing);
static herr_t H5HF__cache_dblock_get_initial_load_size(void *udata, size_t *image_len);
static htri_t H5HF__cache_dblock_verify_chksum(const void *image_ptr, size_t len, void *udata_ptr);
static void *H5HF__cache_dblock_deserialize(const void *image, size_t len,
- void *udata, hbool_t *dirty);
+ void *udata, hbool_t *dirty);
static herr_t H5HF__cache_dblock_image_len(const void *thing, size_t *image_len);
static herr_t H5HF__cache_dblock_pre_serialize(H5F_t *f, void *thing, haddr_t addr,
- size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags);
+ size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags);
static herr_t H5HF__cache_dblock_serialize(const H5F_t *f, void *image,
- size_t len, void *thing);
+ size_t len, void *thing);
static herr_t H5HF__cache_dblock_notify(H5AC_notify_action_t action, void *thing);
static herr_t H5HF__cache_dblock_free_icr(void *thing);
static herr_t H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size);
@@ -114,14 +114,14 @@ static herr_t H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
#ifndef NDEBUG
static herr_t H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
hbool_t *fd_clean, hbool_t *clean);
-static herr_t H5HF__cache_verify_iblock_descendants_clean(H5F_t *f,
+static herr_t H5HF__cache_verify_iblock_descendants_clean(H5F_t *f,
haddr_t fd_parent_addr, H5HF_indirect_t *iblock, unsigned *iblock_status,
hbool_t *fd_clean, hbool_t *clean);
-static herr_t H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f,
- haddr_t fd_parent_addr, H5HF_indirect_t *iblock, hbool_t *fd_clean,
+static herr_t H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f,
+ haddr_t fd_parent_addr, H5HF_indirect_t *iblock, hbool_t *fd_clean,
hbool_t *clean, hbool_t *has_dblocks);
-static herr_t H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f,
- haddr_t fd_parent_addr, H5HF_indirect_t *iblock,
+static herr_t H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f,
+ haddr_t fd_parent_addr, H5HF_indirect_t *iblock,
hbool_t *fd_clean, hbool_t *clean, hbool_t *has_iblocks);
#endif /* NDEBUG */
@@ -212,7 +212,7 @@ H5FL_BLK_DEFINE(direct_block);
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__hdr_prefix_decode(H5HF_hdr_t *hdr, const uint8_t **image_ref)
{
const uint8_t *image = *image_ref; /* Pointer into into supplied image */
@@ -351,8 +351,8 @@ H5HF__dtable_encode(H5F_t *f, uint8_t **pp, const H5HF_dtable_t *dtable)
* Purpose: Determine the size of the fractal heap header on disk,
* and set *image_len to this value.
*
- * Note also that the value returned by this function presumes that
- * there is no I/O filtering data in the header. If there is, the
+ * Note also that the value returned by this function presumes that
+ * there is no I/O filtering data in the header. If there is, the
* size reported will be too small, and H5C_load_entry()
* will have to make two tries to load the fractal heap header.
*
@@ -364,7 +364,7 @@ H5HF__dtable_encode(H5F_t *f, uint8_t **pp, const H5HF_dtable_t *dtable)
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_hdr_get_initial_load_size(void *_udata, size_t *image_len)
{
H5HF_hdr_cache_ud_t *udata = (H5HF_hdr_cache_ud_t *)_udata; /* Pointer to user data */
@@ -402,7 +402,7 @@ H5HF__cache_hdr_get_initial_load_size(void *_udata, size_t *image_len)
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_hdr_get_final_load_size(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED image_len,
void *_udata, size_t *actual_len)
{
@@ -609,11 +609,11 @@ done:
/*-------------------------------------------------------------------------
* Function: H5HF__cache_hdr_image_len
*
- * Purpose: Return the actual size of the fractal heap header on
- * disk image.
+ * Purpose: Return the actual size of the fractal heap header on
+ * disk image.
*
- * If the header contains filter information, this size will be
- * larger than the value returned by H5HF__cache_hdr_get_initial_load_size().
+ * If the header contains filter information, this size will be
+ * larger than the value returned by H5HF__cache_hdr_get_initial_load_size().
*
* Return: Success: SUCCEED
* Failure: FAIL
@@ -623,7 +623,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_hdr_image_len(const void *_thing, size_t *image_len)
{
const H5HF_hdr_t *hdr = (const H5HF_hdr_t *)_thing; /* Fractal heap info */
@@ -645,13 +645,13 @@ H5HF__cache_hdr_image_len(const void *_thing, size_t *image_len)
/*-------------------------------------------------------------------------
* Function: H5HF__cache_hdr_pre_serialize
*
- * Purpose: As best I can tell, fractal heap header blocks are always
+ * Purpose: As best I can tell, fractal heap header blocks are always
* allocated in real file space. Thus this routine simply verifies
* this, verifies that the len parameter contains the expected
* value, and returns an error if either of these checks fail.
*
* When compiled in debug mode, the function also verifies that all
- * indirect and direct blocks that are children of the header are
+ * indirect and direct blocks that are children of the header are
* either clean, or not in the metadata cache.
*
* Return: Success: SUCCEED
@@ -662,7 +662,7 @@ H5HF__cache_hdr_image_len(const void *_thing, size_t *image_len)
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t len,
haddr_t H5_ATTR_UNUSED *new_addr, size_t H5_ATTR_UNUSED *new_len,
unsigned *flags)
@@ -706,8 +706,8 @@ H5HF__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t len,
* is made during a cache serialization instead of an entry or cache
* flush.
*
- * Note also that with the recent change in the definition of flush
- * dependency, not all descendants need be clean -- only direct flush
+ * Note also that with the recent change in the definition of flush
+ * dependency, not all descendants need be clean -- only direct flush
* dependency children.
*
* Finally, observe that the H5HF__cache_verify_hdr_descendants_clean()
@@ -736,7 +736,7 @@ done:
/*-------------------------------------------------------------------------
* Function: H5HF__cache_hdr_serialize
*
- * Purpose: Construct the on disk image of the header, and place it in
+ * Purpose: Construct the on disk image of the header, and place it in
* the buffer pointed to by image. Return SUCCEED on success,
* and FAIL on failure.
*
@@ -748,7 +748,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_UNUSED len,
void *_thing)
{
@@ -846,7 +846,7 @@ done:
*
* Purpose: Free the in core representation of the fractal heap header.
*
- * This routine frees just the header itself, not the
+ * This routine frees just the header itself, not the
* associated version 2 B-Tree, the associated Free Space Manager,
* nor the indirect/direct block tree that is rooted in the header.
*
@@ -865,7 +865,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_hdr_free_icr(void *_thing)
{
H5HF_hdr_t *hdr = (H5HF_hdr_t *)_thing; /* Fractal heap info */
@@ -890,7 +890,7 @@ done:
/*-------------------------------------------------------------------------
* Function: H5HF__cache_iblock_get_initial_load_size()
*
- * Purpose: Compute the size of the on disk image of the indirect
+ * Purpose: Compute the size of the on disk image of the indirect
* block, and place this value in *image_len.
*
* Return: Success: SUCCEED
@@ -901,7 +901,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_iblock_get_initial_load_size(void *_udata, size_t *image_len)
{
H5HF_iblock_cache_ud_t *udata = (H5HF_iblock_cache_ud_t *)_udata; /* User data for callback */
@@ -913,7 +913,7 @@ H5HF__cache_iblock_get_initial_load_size(void *_udata, size_t *image_len)
HDassert(udata->par_info);
HDassert(udata->par_info->hdr);
HDassert(image_len);
-
+
/* Set the image length size */
*image_len = (size_t)H5HF_MAN_INDIRECT_SIZE(udata->par_info->hdr, *udata->nrows);
@@ -961,9 +961,9 @@ H5HF__cache_iblock_verify_chksum(const void *_image, size_t len, void H5_ATTR_UN
/*-------------------------------------------------------------------------
* Function: H5HF__cache_iblock_deserialize
*
- * Purpose: Given a buffer containing the on disk image of the indirect
- * block, allocate an instance of H5HF_indirect_t, load the data
- * in the buffer into this new instance, and return a pointer to
+ * Purpose: Given a buffer containing the on disk image of the indirect
+ * block, allocate an instance of H5HF_indirect_t, load the data
+ * in the buffer into this new instance, and return a pointer to
* it.
*
* As best I can tell, the size of the indirect block image is fully
@@ -979,7 +979,7 @@ H5HF__cache_iblock_verify_chksum(const void *_image, size_t len, void H5_ATTR_UN
*-------------------------------------------------------------------------
*/
static void *
-H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len,
+H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len,
void *_udata, hbool_t H5_ATTR_UNUSED *dirty)
{
H5HF_hdr_t *hdr; /* Shared fractal heap information */
@@ -1164,7 +1164,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_iblock_image_len(const void *_thing, size_t *image_len)
{
const H5HF_indirect_t *iblock = (const H5HF_indirect_t *)_thing; /* Indirect block info */
@@ -1188,11 +1188,11 @@ H5HF__cache_iblock_image_len(const void *_thing, size_t *image_len)
*
* Purpose: The primary objective of this function is to determine if the
* indirect block is currently allocated in temporary file space,
- * and if so, to move it to real file space before the entry is
+ * and if so, to move it to real file space before the entry is
* serialized.
*
- * In debug compiles, this function also verifies that all
- * immediate flush dependency children of this indirect block
+ * In debug compiles, this function also verifies that all
+ * immediate flush dependency children of this indirect block
* are either clean or are not in cache.
*
* Return: Success: SUCCEED
@@ -1203,7 +1203,7 @@ H5HF__cache_iblock_image_len(const void *_thing, size_t *image_len)
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr,
size_t H5_ATTR_UNUSED len, haddr_t *new_addr, size_t H5_ATTR_UNUSED *new_len,
unsigned *flags)
@@ -1237,7 +1237,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr,
unsigned iblock_status = 0;
/* verify that flush dependencies are working correctly. Do this
- * by verifying that all immediate flush dependency children of this
+ * by verifying that all immediate flush dependency children of this
* iblock are clean.
*/
if(H5AC_get_entry_status(f, iblock->addr, &iblock_status) < 0)
@@ -1254,7 +1254,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr,
}
#endif /* NDEBUG */
- /* Check to see if we must re-allocate the iblock from temporary to
+ /* Check to see if we must re-allocate the iblock from temporary to
* normal (AKA real) file space.
*/
if(H5F_IS_TMP_ADDR(f, addr)) {
@@ -1302,7 +1302,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr,
*new_addr = iblock_addr;
*flags = H5AC__SERIALIZE_MOVED_FLAG;
} /* end if */
- else
+ else
*flags = 0;
done:
@@ -1313,8 +1313,8 @@ done:
/*-------------------------------------------------------------------------
* Function: H5HF__cache_iblock_serialize
*
- * Purpose: Given a pointer to an iblock, and a pointer to a buffer of
- * the appropriate size, write the contents of the iblock to the
+ * Purpose: Given a pointer to an iblock, and a pointer to a buffer of
+ * the appropriate size, write the contents of the iblock to the
* buffer in format appropriate for writing to disk.
*
* Return: Success: SUCCEED
@@ -1325,7 +1325,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_UNUSED len,
void *_thing)
{
@@ -1390,7 +1390,7 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG
/* (either both the address & size are defined or both are
* not defined)
*/
- HDassert((H5F_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size)
+ HDassert((H5F_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size)
|| (!H5F_addr_defined(iblock->ents[u].addr) && iblock->filt_ents[u].size == 0));
/* Size of filtered direct block */
@@ -1431,11 +1431,11 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG
/*-------------------------------------------------------------------------
* Function: H5HF__cache_iblock_notify
*
- * Purpose: This function is used to create and destroy flush dependency
+ * Purpose: This function is used to create and destroy flush dependency
* relationships between iblocks and their parents as indirect blocks
* are loaded / inserted and evicted from the metadata cache.
*
- * In general, the parent will be another iblock, but it may be the
+ * In general, the parent will be another iblock, but it may be the
* header if the iblock in question is the root iblock.
*
* Return: Success: SUCCEED
@@ -1446,7 +1446,7 @@ H5HF__cache_iblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_iblock_notify(H5AC_notify_action_t action, void *_thing)
{
H5HF_indirect_t *iblock = (H5HF_indirect_t *)_thing; /* Indirect block info */
@@ -1528,7 +1528,7 @@ done:
/*-------------------------------------------------------------------------
* Function: H5HF__cache_iblock_free_icr
*
- * Purpose: Unlink the supplied instance of H5HF_indirect_t from the
+ * Purpose: Unlink the supplied instance of H5HF_indirect_t from the
* fractal heap and free its memory.
*
* Note: The metadata cache sets the object's cache_info.magic to
@@ -1543,7 +1543,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_iblock_free_icr(void *thing)
{
H5HF_indirect_t *iblock = (H5HF_indirect_t *)thing; /* Fractal heap indirect block to free */
@@ -1570,7 +1570,7 @@ done:
/*-------------------------------------------------------------------------
* Function: H5HF__cache_dblock_get_initial_load_size()
*
- * Purpose: Determine the size of the direct block on disk image, and
+ * Purpose: Determine the size of the direct block on disk image, and
* return it in *image_len.
*
* Return: Success: SUCCEED
@@ -1581,7 +1581,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_dblock_get_initial_load_size(void *_udata, size_t *image_len)
{
const H5HF_dblock_cache_ud_t *udata = (const H5HF_dblock_cache_ud_t *)_udata; /* User data for callback */
@@ -1612,7 +1612,7 @@ H5HF__cache_dblock_get_initial_load_size(void *_udata, size_t *image_len)
} /* end if */
else
*image_len = udata->dblock_size;
-
+
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5HF__cache_dblock_get_initial_load_size() */
@@ -1668,7 +1668,7 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
filter_cb.func = NULL; /* no callback function when failed */
/* Allocate buffer to perform I/O filtering on and copy image into
- * it. Must do this as H5Z_pipeline() may re-size the buffer
+ * it. Must do this as H5Z_pipeline() may re-size the buffer
* provided to it.
*/
if(NULL == (read_buf = H5MM_malloc(len)))
@@ -1801,7 +1801,7 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata,
/* Check for I/O filters on this heap */
if(hdr->filter_len > 0) {
/* Direct block is already decompressed in verify_chksum callback */
- if(udata->decompressed) {
+ if(udata->decompressed) {
/* Sanity check */
HDassert(udata->dblk);
@@ -1822,7 +1822,7 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata,
filter_cb.func = NULL; /* no callback function when failed */
/* Allocate buffer to perform I/O filtering on and copy image into
- * it. Must do this as H5Z_pipeline() may resize the buffer
+ * it. Must do this as H5Z_pipeline() may resize the buffer
* provided to it.
*/
if (NULL == (read_buf = H5MM_malloc(len)))
@@ -1926,7 +1926,7 @@ done:
* Function: H5HF__cache_dblock_image_len
*
* Purpose: Report the actual size of the direct block image on disk.
- * Note that this value will probably be incorrect if compression
+ * Note that this value will probably be incorrect if compression
* is enabled and the entry is dirty.
*
* Return: Success: SUCCEED
@@ -1937,7 +1937,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_dblock_image_len(const void *_thing, size_t *image_len)
{
const H5HF_direct_t *dblock = (const H5HF_direct_t *)_thing; /* Direct block info */
@@ -1958,32 +1958,32 @@ H5HF__cache_dblock_image_len(const void *_thing, size_t *image_len)
/* Check for I/O filters on this heap */
if(hdr->filter_len > 0) {
- /*
+ /*
* If the data is available, set to the compressed
- * size of the direct block -- otherwise set it equal to the
- * uncompressed size.
+ * size of the direct block -- otherwise set it equal to the
+ * uncompressed size.
*
* We have three possible scenarios here.
*
* First, the block may never have been flushed. In this
- * case, both dblock->file_size and the size stored in the
- * parent (either the header or the parent iblock) will all
- * be zero. In this case, return the uncompressed size
+ * case, both dblock->file_size and the size stored in the
+ * parent (either the header or the parent iblock) will all
+ * be zero. In this case, return the uncompressed size
* stored in dblock->size as the size.
*
* Second, the block may have just been serialized, in which
- * case, dblock->file_size should be zero, and the correct
+ * case, dblock->file_size should be zero, and the correct
* on disk size should be stored in the parent (again, either
* the header or the parent iblock as case may be).
- *
- * Third, we may be in the process of discarding this
+ *
+ * Third, we may be in the process of discarding this
* dblock without writing it. In this case, dblock->file_size
- * should be non-zero and have the correct size. Note that
+ * should be non-zero and have the correct size. Note that
* in this case, the direct block will have been detached,
* and thus looking up the parent will likely return incorrect
* data.
*/
- if(dblock->file_size != 0)
+ if(dblock->file_size != 0)
size = dblock->file_size;
else {
const H5HF_indirect_t *par_iblock = dblock->parent; /* Parent iblock */
@@ -2012,54 +2012,54 @@ H5HF__cache_dblock_image_len(const void *_thing, size_t *image_len)
* Function: H5HF__cache_dblock_pre_serialize
*
* Purpose: In principle, the purpose of this function is to determine
- * the size and location of the disk image of the target direct
+ * the size and location of the disk image of the target direct
* block. In this case, the uncompressed size of the block is
- * fixed, but since the direct block could be compressed,
+ * fixed, but since the direct block could be compressed,
* we may need to compute and report the compressed size.
*
- * This is a bit sticky in the case of a direct block when I/O
+ * This is a bit sticky in the case of a direct block when I/O
* filters are enabled, as the size of the compressed version
- * of the on disk image is not known until the direct block has
- * been run through the filters. Further, the location of the
- * on disk image may change if the compressed size of the image
+ * of the on disk image is not known until the direct block has
+ * been run through the filters. Further, the location of the
+ * on disk image may change if the compressed size of the image
* changes as well.
*
- * To complicate matters further, the direct block may have been
- * initially allocated in temporary (AKA imaginary) file space.
- * In this case, we must relocate the direct block's on-disk
- * image to "real" file space regardless of whether it has changed
+ * To complicate matters further, the direct block may have been
+ * initially allocated in temporary (AKA imaginary) file space.
+ * In this case, we must relocate the direct block's on-disk
+ * image to "real" file space regardless of whether it has changed
* size.
*
- * One simplifying factor is the direct block's "blk" field,
+ * One simplifying factor is the direct block's "blk" field,
* which contains a pointer to a buffer which (with the exception
- * of a small header) contains the on disk image in uncompressed
+ * of a small header) contains the on disk image in uncompressed
* form.
*
- * To square this particular circle, this function does
- * everything the serialize function usually does, with the
- * exception of copying the image into the image buffer provided
- * to the serialize function by the metadata cache. The data to
+ * To square this particular circle, this function does
+ * everything the serialize function usually does, with the
+ * exception of copying the image into the image buffer provided
+ * to the serialize function by the metadata cache. The data to
* copy is provided to the serialize function in a buffer pointed
* to by the write_buf field.
*
- * If I/O filters are enabled, on exit,
- * H5HF__cache_dblock_pre_serialize() sets the write_buf field to
+ * If I/O filters are enabled, on exit,
+ * H5HF__cache_dblock_pre_serialize() sets the write_buf field to
* point to a buffer containing the filtered image of the direct
* block. The serialize function should free this block, and set
- * the write_buf field to NULL after copying it into the image
+ * the write_buf field to NULL after copying it into the image
* buffer provided by the metadata cache.
*
- * If I/O filters are not enabled, this function prepares
- * the buffer pointed to by the blk field for copying to the
- * image buffer provided by the metadata cache, and sets the
- * write_buf field equal to the blk field. In this case, the
- * serialize function should simply set the write_buf field to
- * NULL after copying the direct block image into the image
+ * If I/O filters are not enabled, this function prepares
+ * the buffer pointed to by the blk field for copying to the
+ * image buffer provided by the metadata cache, and sets the
+ * write_buf field equal to the blk field. In this case, the
+ * serialize function should simply set the write_buf field to
+ * NULL after copying the direct block image into the image
* buffer.
*
- * In both of the above cases, the length of the buffer pointed
- * to by write_buf is provided in the write_len field. This
- * field must contain 0 on entry to this function, and should
+ * In both of the above cases, the length of the buffer pointed
+ * to by write_buf is provided in the write_len field. This
+ * field must contain 0 on entry to this function, and should
* be set back to 0 at the end of the serialize function.
*
* Return: Success: SUCCEED
@@ -2070,7 +2070,7 @@ H5HF__cache_dblock_image_len(const void *_thing, size_t *image_len)
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
haddr_t addr, size_t len, haddr_t *new_addr, size_t *new_len, unsigned *flags)
{
@@ -2114,10 +2114,10 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
HDassert(hdr->cache_info.type == H5AC_FHEAP_HDR);
if(dblock->parent) {
- /* this is the common case, in which the direct block is the child
+ /* this is the common case, in which the direct block is the child
* of an indirect block. Set up the convenience variables we will
- * need if the address and/or compressed size of the on disk image
- * of the direct block changes, and do some sanity checking in
+ * need if the address and/or compressed size of the on disk image
+ * of the direct block changes, and do some sanity checking in
* passing.
*/
par_iblock = dblock->parent;
@@ -2137,8 +2137,8 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
at_tmp_addr = H5F_IS_TMP_ADDR(f, addr);
/* Begin by preping the direct block to be written to disk. Do
- * this by writing the correct magic number, the dblock version,
- * the address of the header, the offset of the block in the heap,
+ * this by writing the correct magic number, the dblock version,
+ * the address of the header, the offset of the block in the heap,
* and the checksum at the beginning of the block.
*/
@@ -2172,7 +2172,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
UINT32ENCODE(image, metadata_chksum);
} /* end if */
- /* at this point, dblock->blk should point to an uncompressed image of
+ /* at this point, dblock->blk should point to an uncompressed image of
* the direct block. If I/O filters are not enabled, this image should
* be ready to hand off to the metadata cache.
*/
@@ -2211,10 +2211,10 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
/* Use the compressed number of bytes as the size to write */
write_size = nbytes;
- /* If the size and/or location of the on disk image of the
+ /* If the size and/or location of the on disk image of the
* direct block changes, we must touch up its parent to reflect
* these changes. Do this differently depending on whether the
- * direct block's parent is an indirect block or (rarely) the
+ * direct block's parent is an indirect block or (rarely) the
* fractal heap header. In this case, the direct block is known
* as a root direct block.
*/
@@ -2233,7 +2233,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
hdr_changed = TRUE;
} /* end if */
- /* verify that the cache's last record of the compressed
+ /* verify that the cache's last record of the compressed
* size matches the heap's last record. This value will
* likely change shortly.
*/
@@ -2241,10 +2241,10 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
/* Check if we need to re-size the block on disk */
if(hdr->pline_root_direct_size != write_size || at_tmp_addr) {
- /* Check if the direct block is NOT currently allocated
- * in temp. file space
+ /* Check if the direct block is NOT currently allocated
+ * in temp. file space
*
- * (temp. file space does not need to be freed)
+ * (temp. file space does not need to be freed)
*/
if(!at_tmp_addr)
/* Release direct block's current disk space */
@@ -2255,8 +2255,8 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
if(HADDR_UNDEF == (dblock_addr = H5MF_alloc((H5F_t *)f, H5FD_MEM_FHEAP_DBLOCK, (hsize_t)write_size)))
HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap direct block")
- /* Update information about compressed direct block's
- * location & size
+ /* Update information about compressed direct block's
+ * location & size
*/
HDassert(hdr->man_dtable.table_addr == addr);
HDassert(hdr->pline_root_direct_size == len);
@@ -2285,7 +2285,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
par_changed = TRUE;
} /* end if */
- /* verify that the cache's last record of the compressed
+ /* verify that the cache's last record of the compressed
* size matches the heap's last record. This value will
* likely change shortly.
*/
@@ -2293,10 +2293,10 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
/* Check if we need to re-size the block on disk */
if(par_iblock->filt_ents[par_entry].size != write_size || at_tmp_addr) {
- /* Check if the direct block is NOT currently allocated
- * in temp. file space
+ /* Check if the direct block is NOT currently allocated
+ * in temp. file space
*
- * (temp. file space does not need to be freed)
+ * (temp. file space does not need to be freed)
*/
if(!at_tmp_addr)
/* Release direct block's current disk space */
@@ -2307,8 +2307,8 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
if(HADDR_UNDEF == (dblock_addr = H5MF_alloc((H5F_t *)f, H5FD_MEM_FHEAP_DBLOCK, (hsize_t)write_size)))
HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap direct block")
- /* Update information about compressed direct block's
- * location & size
+ /* Update information about compressed direct block's
+ * location & size
*/
HDassert(par_iblock->ents[par_entry].addr == addr);
HDassert(par_iblock->filt_ents[par_entry].size == len);
@@ -2326,21 +2326,21 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
} /* end else */
} /* end if */
else {
- /* I/O filters are not enabled -- thus all we need to do is check to
- * see if the direct block is in temporary (AKA imaginary) file
+ /* I/O filters are not enabled -- thus all we need to do is check to
+ * see if the direct block is in temporary (AKA imaginary) file
* space, and move it to real file space if it is.
*
- * As in the I/O filters case above, we will have to touch up the
+ * As in the I/O filters case above, we will have to touch up the
* direct blocks parent if the direct block is relocated.
*
- * Recall that temporary file space need not be freed, which
+ * Recall that temporary file space need not be freed, which
* simplifies matters slightly.
*/
write_buf = dblock->blk;
write_size = dblock->size;
- /* Check to see if we must re-allocate direct block from 'temp.'
- * to 'normal' file space
+ /* Check to see if we must re-allocate direct block from 'temp.'
+ * to 'normal' file space
*/
if(at_tmp_addr) {
/* Allocate 'normal' space for the direct block */
@@ -2377,9 +2377,9 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing,
} /* end if */
} /* end else */
- /* At this point, write_buf points to a buffer containing the image
+ /* At this point, write_buf points to a buffer containing the image
* of the direct block that is ready to copy into the image buffer,
- * and write_size contains the length of this buffer.
+ * and write_size contains the length of this buffer.
*
* Also, if image size or address has changed, the direct block's
* parent has been modified to reflect the change.
@@ -2419,14 +2419,14 @@ done:
/*-------------------------------------------------------------------------
* Function: H5HF__cache_dblock_serialize
*
- * Purpose: In principle, this function is supposed to construct the on
- * disk image of the direct block, and place that image in the
+ * Purpose: In principle, this function is supposed to construct the on
+ * disk image of the direct block, and place that image in the
* image buffer provided by the metadata cache.
*
- * However, since there are cases in which the pre_serialize
- * function has to construct the on disk image to determine its size
+ * However, since there are cases in which the pre_serialize
+ * function has to construct the on disk image to determine its size
* and address, this function simply copies the image prepared by
- * the pre-serialize function into the supplied image buffer, and
+ * the pre-serialize function into the supplied image buffer, and
* discards a buffer if necessary.
*
* Return: Success: SUCCEED
@@ -2437,8 +2437,8 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
-H5HF__cache_dblock_serialize(const H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *image,
+static herr_t
+H5HF__cache_dblock_serialize(const H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *image,
size_t H5_ATTR_NDEBUG_UNUSED len, void *_thing)
{
H5HF_direct_t *dblock = (H5HF_direct_t *)_thing; /* Direct block info */
@@ -2462,8 +2462,8 @@ H5HF__cache_dblock_serialize(const H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *image,
/* Copy the image from *(dblock->write_buf) to *image */
H5MM_memcpy(image, dblock->write_buf, dblock->write_size);
- /* Free *(dblock->write_buf) if it was allocated by the
- * pre-serialize function
+ /* Free *(dblock->write_buf) if it was allocated by the
+ * pre-serialize function
*/
if(dblock->write_buf != dblock->blk)
H5MM_xfree(dblock->write_buf);
@@ -2490,7 +2490,7 @@ H5HF__cache_dblock_serialize(const H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *image,
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_dblock_notify(H5AC_notify_action_t action, void *_thing)
{
H5HF_direct_t *dblock = (H5HF_direct_t *)_thing; /* Fractal heap direct block */
@@ -2560,7 +2560,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_dblock_free_icr(void *_thing)
{
H5HF_direct_t *dblock = (H5HF_direct_t *)_thing; /* Fractal heap direct block */
@@ -2597,7 +2597,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-static herr_t
+static herr_t
H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
{
const H5HF_direct_t *dblock = (const H5HF_direct_t *)_thing; /* Fractal heap direct block */
@@ -2621,9 +2621,9 @@ H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
/*------------------------------------------------------------------------
* Function: H5HF__cache_verify_hdr_descendants_clean
*
- * Purpose: Sanity checking routine that verifies that all indirect
- * and direct blocks that are descendants of the supplied
- * instance of H5HF_hdr_t are clean. Set *clean to
+ * Purpose: Sanity checking routine that verifies that all indirect
+ * and direct blocks that are descendants of the supplied
+ * instance of H5HF_hdr_t are clean. Set *clean to
* TRUE if this is the case, and to FALSE otherwise.
*
* Update -- 8/24/15
@@ -2636,41 +2636,41 @@ H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
* remain dirty.
*
* To address this, updated the sanity checks in this function
- * to treat entries whose images are up to date as clean if
+ * to treat entries whose images are up to date as clean if
* a cache serialization is in progress.
*
* Update -- 9/29/16
*
* The implementation of flush dependencies has been changed.
- * Prior to this change, a flush dependency parent could be
+ * Prior to this change, a flush dependency parent could be
* flushed if and only if all its flush dependency descendants
- * were clean. In the new definition, a flush dependency
+ * were clean. In the new definition, a flush dependency
* parent can be flushed if all its immediate flush dependency
- * children are clean, regardless of any other dirty
- * descendants.
+ * children are clean, regardless of any other dirty
+ * descendants.
*
- * Further, metadata cache entries are now allowed to have
- * multiple flush dependency parents.
+ * Further, metadata cache entries are now allowed to have
+ * multiple flush dependency parents.
*
- * This means that the fractal heap is no longer ncessarily
+ * This means that the fractal heap is no longer ncessarily
* flushed from the bottom up.
*
- * For example, it is now possible for a dirty fractal heap
+ * For example, it is now possible for a dirty fractal heap
* header to be flushed before a dirty dblock, as long as the
- * there in an interviening iblock, and the header has no
+ * there in an interviening iblock, and the header has no
* dirty immediate flush dependency children.
*
- * Also, I gather that under some circumstances, a dblock
- * will be direct a flush dependency child both of the iblock
+ * Also, I gather that under some circumstances, a dblock
+ * will be direct a flush dependency child both of the iblock
* that points to it, and of the fractal heap header.
*
* As a result of these changes, the functionality of these
* sanity checking routines has been modified significantly.
* Instead of scanning the fractal heap from a starting point
- * down, and verifying that there were no dirty entries, the
- * functions now scan downward from the starting point and
- * verify that there are no dirty flush dependency children
- * of the specified flush dependency parent. In passing,
+ * down, and verifying that there were no dirty entries, the
+ * functions now scan downward from the starting point and
+ * verify that there are no dirty flush dependency children
+ * of the specified flush dependency parent. In passing,
* they also walk the data structure, and verify it.
*
*
@@ -2709,16 +2709,16 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
/* We have three basic scenarios we have to deal with:
*
- * The first, and most common case, is that there is a root iblock.
- * In this case we need to verify that the root iblock and all its
+ * The first, and most common case, is that there is a root iblock.
+ * In this case we need to verify that the root iblock and all its
* children are clean.
*
- * The second, and much less common case, is that in which the
- * the fractal heap contains only one direct block, which is
- * pointed to by hdr->man_dtable.table_addr. In this case, all we
+ * The second, and much less common case, is that in which the
+ * the fractal heap contains only one direct block, which is
+ * pointed to by hdr->man_dtable.table_addr. In this case, all we
* need to do is verify that the root direct block is clean.
*
- * Finally, it is possible that the fractal heap is empty, and
+ * Finally, it is possible that the fractal heap is empty, and
* has neither a root indirect block nor a root direct block.
* In this case, we have nothing to do.
*/
@@ -2726,15 +2726,15 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
/* There are two ways in which we can arrive at the first scenario.
*
* By far the most common is when hdr->root_iblock contains a pointer
- * to the root iblock -- in this case the root iblock is almost certainly
+ * to the root iblock -- in this case the root iblock is almost certainly
* pinned, although we can't count on that.
*
- * However, it is also possible that there is a root iblock that
- * is no longer pointed to by the header. In this case, the on
+ * However, it is also possible that there is a root iblock that
+ * is no longer pointed to by the header. In this case, the on
* disk address of the iblock will be in hdr->man_dtable.table_addr
* and hdr->man_dtable.curr_root_rows will contain a positive value.
*
- * Since the former case is far and away the most common, we don't
+ * Since the former case is far and away the most common, we don't
* worry too much about efficiency in the second case.
*/
if(hdr->root_iblock ||
@@ -2748,7 +2748,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
/* make note of the on disk address of the root iblock */
if(root_iblock == NULL)
/* hdr->man_dtable.table_addr must contain address of root
- * iblock. Check to see if it is in cache. If it is,
+ * iblock. Check to see if it is in cache. If it is,
* protect it and put its address in root_iblock.
*/
root_iblock_addr = hdr->man_dtable.table_addr;
@@ -2786,18 +2786,18 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
/* At this point, the root iblock may be pinned, protected,
* both, or neither, and we may or may not have a pointer
- * to root iblock in memory.
+ * to root iblock in memory.
*
* Before we call H5HF__cache_verify_iblock_descendants_clean(),
- * we must ensure that the root iblock is either pinned or
- * protected or both, and that we have a pointer to it.
+ * we must ensure that the root iblock is either pinned or
+ * protected or both, and that we have a pointer to it.
* Do this as follows:
*/
if(root_iblock == NULL) { /* we don't have ptr to root iblock */
if(0 == (root_iblock_status & H5AC_ES__IS_PROTECTED)) {
/* just protect the root iblock -- this will give us
- * the pointer we need to proceed, and ensure that
- * it is locked into the metadata cache for the
+ * the pointer we need to proceed, and ensure that
+ * it is locked into the metadata cache for the
* duration.
*
* Note that the udata is only used in the load callback.
@@ -2808,9 +2808,9 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
* The tag specified in the API context we received
* as a parameter (via API context) may not be correct.
* Grab the (hopefully) correct tag from the header,
- * and load it into the API context via the H5_BEGIN_TAG and
+ * and load it into the API context via the H5_BEGIN_TAG and
* H5_END_TAG macros. Note that any error bracked by
- * these macros must be reported with HGOTO_ERROR_TAG.
+ * these macros must be reported with HGOTO_ERROR_TAG.
*/
H5_BEGIN_TAG(hdr->heap_addr)
@@ -2825,7 +2825,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
/* the root iblock is protected, and we have no
* legitimate way of getting a pointer to it.
*
- * We square this circle by using the
+ * We square this circle by using the
* H5AC_get_entry_ptr_from_addr() to get the needed
* pointer.
*
@@ -2846,14 +2846,14 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
* be unpinned is if none of its children are in cache.
* This unfortunately means that if it is protected and
* not pinned, the fractal heap is in the process of loading
- * or inserting one of its children. The obvious
- * implication is that there is a significant chance that
+ * or inserting one of its children. The obvious
+ * implication is that there is a significant chance that
* the root iblock is in an unstable state.
*
- * All this suggests that using
- * H5AC_get_entry_ptr_from_addr() to obtain the pointer
- * to the protected root iblock is questionable here.
- * However, since this is test/debugging code, I expect
+ * All this suggests that using
+ * H5AC_get_entry_ptr_from_addr() to obtain the pointer
+ * to the protected root iblock is questionable here.
+ * However, since this is test/debugging code, I expect
* that we will use this approach until it causes problems,
* or we think of a better way.
*/
@@ -2863,8 +2863,8 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
} /* end else */
} /* end if */
else { /* root_iblock != NULL */
- /* we have the pointer to the root iblock. Protect it
- * if it is neither pinned nor protected -- otherwise we
+ /* we have the pointer to the root iblock. Protect it
+ * if it is neither pinned nor protected -- otherwise we
* are ready to go.
*/
H5HF_indirect_t * iblock = NULL;
@@ -2882,9 +2882,9 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
* The tag associated specified in the API context we received
* as a parameter (via API context) may not be correct.
* Grab the (hopefully) correct tag from the header,
- * and load it into the API context via the H5_BEGIN_TAG and
+ * and load it into the API context via the H5_BEGIN_TAG and
* H5_END_TAG macros. Note that any error bracked by
- * these macros must be reported with HGOTO_ERROR_TAG.
+ * these macros must be reported with HGOTO_ERROR_TAG.
*/
H5_BEGIN_TAG(hdr->heap_addr)
@@ -2953,8 +2953,8 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "root dblock in cache and is a flush dep parent.")
*clean = !((root_dblock_status & H5AC_ES__IS_DIRTY) &&
- (((root_dblock_status &
- H5AC_ES__IMAGE_IS_UP_TO_DATE) == 0) ||
+ (((root_dblock_status &
+ H5AC_ES__IMAGE_IS_UP_TO_DATE) == 0) ||
(!H5AC_get_serialization_in_progress(f))));
*fd_clean = *clean;
@@ -2965,8 +2965,8 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr,
} /* end else */
} /* end else-if */
else {
- /* this is scenario 3 -- the fractal heap is empty, and we
- * have nothing to do.
+ /* this is scenario 3 -- the fractal heap is empty, and we
+ * have nothing to do.
*/
*fd_clean = TRUE;
*clean = TRUE;
@@ -2981,62 +2981,62 @@ done:
/*------------------------------------------------------------------------
* Function: H5HF__cache_verify_iblock_descendants_clean
*
- * Purpose: Sanity checking routine that verifies that all indirect
- * and direct blocks that are descendants of the supplied
- * instance of H5HF_indirect_t are clean. Set *clean
+ * Purpose: Sanity checking routine that verifies that all indirect
+ * and direct blocks that are descendants of the supplied
+ * instance of H5HF_indirect_t are clean. Set *clean
* to TRUE if this is the case, and to FALSE otherwise.
*
- * In passing, the function also does a cursory check to
- * spot any obvious errors in the flush dependency setup.
- * If any problems are found, the function returns failure.
- * Note that these checks are not exhaustive, thus passing
- * them does not mean that the flush dependencies are
+ * In passing, the function also does a cursory check to
+ * spot any obvious errors in the flush dependency setup.
+ * If any problems are found, the function returns failure.
+ * Note that these checks are not exhaustive, thus passing
+ * them does not mean that the flush dependencies are
* correct -- only that there is nothing obviously wrong
* with them.
*
- * WARNING: At its top level call, this function is
- * intended to be called from H5HF_cache_iblock_flush(),
- * and thus presumes that the supplied indirect block
- * is in cache. Any other use of this function and
- * its descendants must insure that this assumption is
+ * WARNING: At its top level call, this function is
+ * intended to be called from H5HF_cache_iblock_flush(),
+ * and thus presumes that the supplied indirect block
+ * is in cache. Any other use of this function and
+ * its descendants must insure that this assumption is
* met.
*
- * Note that this function and
- * H5HF__cache_verify_descendant_iblocks_clean() are
+ * Note that this function and
+ * H5HF__cache_verify_descendant_iblocks_clean() are
* recursive co-routines.
*
* Update -- 9/29/16
*
* The implementation of flush dependencies has been changed.
- * Prior to this change, a flush dependency parent could be
+ * Prior to this change, a flush dependency parent could be
* flushed if and only if all its flush dependency descendants
- * were clean. In the new definition, a flush dependency
+ * were clean. In the new definition, a flush dependency
* parent can be flushed if all its immediate flush dependency
- * children are clean, regardless of any other dirty
- * descendants.
+ * children are clean, regardless of any other dirty
+ * descendants.
*
- * Further, metadata cache entries are now allowed to have
- * multiple flush dependency parents.
+ * Further, metadata cache entries are now allowed to have
+ * multiple flush dependency parents.
*
- * This means that the fractal heap is no longer ncessarily
+ * This means that the fractal heap is no longer ncessarily
* flushed from the bottom up.
*
- * For example, it is now possible for a dirty fractal heap
+ * For example, it is now possible for a dirty fractal heap
* header to be flushed before a dirty dblock, as long as the
- * there in an interviening iblock, and the header has no
+ * there in an interviening iblock, and the header has no
* dirty immediate flush dependency children.
*
- * Also, I gather that under some circumstances, a dblock
- * will be direct a flush dependency child both of the iblock
+ * Also, I gather that under some circumstances, a dblock
+ * will be direct a flush dependency child both of the iblock
* that points to it, and of the fractal heap header.
*
* As a result of these changes, the functionality of these
* sanity checking routines has been modified significantly.
* Instead of scanning the fractal heap from a starting point
- * down, and verifying that there were no dirty entries, the
- * functions now scan downward from the starting point and
- * verify that there are no dirty flush dependency children
- * of the specified flush dependency parent. In passing,
+ * down, and verifying that there were no dirty entries, the
+ * functions now scan downward from the starting point and
+ * verify that there are no dirty flush dependency children
+ * of the specified flush dependency parent. In passing,
* they also walk the data structure, and verify it.
*
* Return: Non-negative on success/Negative on failure
@@ -3096,17 +3096,17 @@ done:
* direct blocks pointed to by the supplied indirect block
* are either clean, or not in the cache.
*
- * In passing, the function also does a cursory check to
- * spot any obvious errors in the flush dependency setup.
- * If any problems are found, the function returns failure.
- * Note that these checks are not exhaustive, thus passing
- * them does not mean that the flush dependencies are
+ * In passing, the function also does a cursory check to
+ * spot any obvious errors in the flush dependency setup.
+ * If any problems are found, the function returns failure.
+ * Note that these checks are not exhaustive, thus passing
+ * them does not mean that the flush dependencies are
* correct -- only that there is nothing obviously wrong
* with them.
*
- * WARNING: This function presumes that the supplied
- * iblock is in the cache, and will not be removed
- * during the call. Caller must ensure that this is
+ * WARNING: This function presumes that the supplied
+ * iblock is in the cache, and will not be removed
+ * during the call. Caller must ensure that this is
* the case before the call.
*
* Update -- 8/24/15
@@ -3125,35 +3125,35 @@ done:
* Update -- 9/29/16
*
* The implementation of flush dependencies has been changed.
- * Prior to this change, a flush dependency parent could be
+ * Prior to this change, a flush dependency parent could be
* flushed if and only if all its flush dependency descendants
- * were clean. In the new definition, a flush dependency
+ * were clean. In the new definition, a flush dependency
* parent can be flushed if all its immediate flush dependency
- * children are clean, regardless of any other dirty
- * descendants.
+ * children are clean, regardless of any other dirty
+ * descendants.
*
- * Further, metadata cache entries are now allowed to have
- * multiple flush dependency parents.
+ * Further, metadata cache entries are now allowed to have
+ * multiple flush dependency parents.
*
- * This means that the fractal heap is no longer ncessarily
+ * This means that the fractal heap is no longer ncessarily
* flushed from the bottom up.
*
- * For example, it is now possible for a dirty fractal heap
+ * For example, it is now possible for a dirty fractal heap
* header to be flushed before a dirty dblock, as long as the
- * there in an interviening iblock, and the header has no
+ * there in an interviening iblock, and the header has no
* dirty immediate flush dependency children.
*
- * Also, I gather that under some circumstances, a dblock
- * will be direct a flush dependency child both of the iblock
+ * Also, I gather that under some circumstances, a dblock
+ * will be direct a flush dependency child both of the iblock
* that points to it, and of the fractal heap header.
*
* As a result of these changes, the functionality of these
* sanity checking routines has been modified significantly.
* Instead of scanning the fractal heap from a starting point
- * down, and verifying that there were no dirty entries, the
- * functions now scan downward from the starting point and
- * verify that there are no dirty flush dependency children
- * of the specified flush dependency parent. In passing,
+ * down, and verifying that there were no dirty entries, the
+ * functions now scan downward from the starting point and
+ * verify that there are no dirty flush dependency children
+ * of the specified flush dependency parent. In passing,
* they also walk the data structure, and verify it.
*
* Return: Non-negative on success/Negative on failure
@@ -3165,8 +3165,8 @@ done:
*/
#ifndef NDEBUG
static herr_t
-H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
- H5HF_indirect_t *iblock, hbool_t *fd_clean, hbool_t *clean,
+H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
+ H5HF_indirect_t *iblock, hbool_t *fd_clean, hbool_t *clean,
hbool_t *has_dblocks)
{
unsigned num_direct_rows;
@@ -3224,16 +3224,16 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
(((dblock_status & H5AC_ES__IMAGE_IS_UP_TO_DATE) == 0) ||
(!H5AC_get_serialization_in_progress(f)))) {
*clean = FALSE;
-
+
if(H5AC_flush_dependency_exists(f, fd_parent_addr, dblock_addr, &fd_exists) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency")
- if(fd_exists)
+ if(fd_exists)
*fd_clean = FALSE;
} /* end if */
- /* If a child dblock is in cache, it must have a flush
- * dependency relationship with this iblock. Test this
+ /* If a child dblock is in cache, it must have a flush
+ * dependency relationship with this iblock. Test this
* here.
*/
if(H5AC_flush_dependency_exists(f, iblock_addr, dblock_addr, &fd_exists) < 0)
@@ -3246,7 +3246,7 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
i++;
} /* end while */
-
+
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5HF__cache_verify_iblocks_dblocks_clean() */
@@ -3260,17 +3260,17 @@ done:
* direct blocks pointed to by the supplied indirect block
* are either clean, or not in the cache.
*
- * In passing, the function also does a cursory check to
- * spot any obvious errors in the flush dependency setup.
- * If any problems are found, the function returns failure.
- * Note that these checks are not exhaustive, thus passing
- * them does not mean that the flush dependencies are
+ * In passing, the function also does a cursory check to
+ * spot any obvious errors in the flush dependency setup.
+ * If any problems are found, the function returns failure.
+ * Note that these checks are not exhaustive, thus passing
+ * them does not mean that the flush dependencies are
* correct -- only that there is nothing obviously wrong
* with them.
*
- * WARNING: This function presumes that the supplied
- * iblock is in the cache, and will not be removed
- * during the call. Caller must ensure that this is
+ * WARNING: This function presumes that the supplied
+ * iblock is in the cache, and will not be removed
+ * during the call. Caller must ensure that this is
* the case before the call.
*
* Update -- 8/24/15
@@ -3289,35 +3289,35 @@ done:
* Update -- 9/29/16
*
* The implementation of flush dependencies has been changed.
- * Prior to this change, a flush dependency parent could be
+ * Prior to this change, a flush dependency parent could be
* flushed if and only if all its flush dependency descendants
- * were clean. In the new definition, a flush dependency
+ * were clean. In the new definition, a flush dependency
* parent can be flushed if all its immediate flush dependency
- * children are clean, regardless of any other dirty
- * descendants.
+ * children are clean, regardless of any other dirty
+ * descendants.
*
- * Further, metadata cache entries are now allowed to have
+ * Further, metadata cache entries are now allowed to have
* multiple flush dependency parents.
*
- * This means that the fractal heap is no longer ncessarily
+ * This means that the fractal heap is no longer ncessarily
* flushed from the bottom up.
*
- * For example, it is now possible for a dirty fractal heap
+ * For example, it is now possible for a dirty fractal heap
* header to be flushed before a dirty dblock, as long as the
- * there in an interviening iblock, and the header has no
+ * there in an interviening iblock, and the header has no
* dirty immediate flush dependency children.
*
- * Also, I gather that under some circumstances, a dblock
- * will be direct a flush dependency child both of the iblock
+ * Also, I gather that under some circumstances, a dblock
+ * will be direct a flush dependency child both of the iblock
* that points to it, and of the fractal heap header.
*
* As a result of these changes, the functionality of these
* sanity checking routines has been modified significantly.
* Instead of scanning the fractal heap from a starting point
- * down, and verifying that there were no dirty entries, the
- * functions now scan downward from the starting point and
- * verify that there are no dirty flush dependency children
- * of the specified flush dependency parent. In passing,
+ * down, and verifying that there were no dirty entries, the
+ * functions now scan downward from the starting point and
+ * verify that there are no dirty flush dependency children
+ * of the specified flush dependency parent. In passing,
* they also walk the data structure, and verify it.
*
*
@@ -3388,54 +3388,54 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
*fd_clean = FALSE;
} /* end if */
- /* if the child iblock is in cache and *fd_clean is TRUE,
+ /* if the child iblock is in cache and *fd_clean is TRUE,
* we must continue to explore down the fractal heap tree
- * structure to verify that all descendant blocks that are
- * flush dependency children of the entry at parent_addr are
- * either clean, or not in the metadata cache. We do this
- * with a recursive call to
+ * structure to verify that all descendant blocks that are
+ * flush dependency children of the entry at parent_addr are
+ * either clean, or not in the metadata cache. We do this
+ * with a recursive call to
* H5HF__cache_verify_iblock_descendants_clean().
* However, we can't make this call unless the child iblock
- * is somehow locked into the cache -- typically via either
+ * is somehow locked into the cache -- typically via either
* pinning or protecting.
*
* If the child iblock is pinned, we can look up its pointer
- * on the current iblock's pinned child iblock list, and
+ * on the current iblock's pinned child iblock list, and
* and use that pointer in the recursive call.
*
* If the entry is unprotected and unpinned, we simply
* protect it.
*
- * If, however, the the child iblock is already protected,
- * but not pinned, we have a bit of a problem, as we have
+ * If, however, the the child iblock is already protected,
+ * but not pinned, we have a bit of a problem, as we have
* no legitimate way of looking up its pointer in memory.
*
* To solve this problem, I have added a new metadata cache
- * call to obtain the pointer.
+ * call to obtain the pointer.
*
- * WARNING: This call should be used only in debugging
- * routines, and it should be avoided there when
- * possible.
+ * WARNING: This call should be used only in debugging
+ * routines, and it should be avoided there when
+ * possible.
*
- * Further, if we ever multi-thread the cache,
- * this routine will have to be either discarded
+ * Further, if we ever multi-thread the cache,
+ * this routine will have to be either discarded
* or heavily re-worked.
*
- * Finally, keep in mind that the entry whose
- * pointer is obtained in this fashion may not
- * be in a stable state.
+ * Finally, keep in mind that the entry whose
+ * pointer is obtained in this fashion may not
+ * be in a stable state.
*
- * Assuming that the flush dependency code is working
- * as it should, the only reason for the child entry to
+ * Assuming that the flush dependency code is working
+ * as it should, the only reason for the child entry to
* be unpinned is if none of its children are in cache.
- * This unfortunately means that if it is protected and
+ * This unfortunately means that if it is protected and
* not pinned, the fractal heap is in the process of loading
* or inserting one of its children. The obvious implication
- * is that there is a significant chance that the child
+ * is that there is a significant chance that the child
* iblock is in an unstable state.
*
- * All this suggests that using the new call to obtain the
- * pointer to the protected child iblock is questionable
+ * All this suggests that using the new call to obtain the
+ * pointer to the protected child iblock is questionable
* here. However, since this is test/debugging code, I
* expect that we will use this approach until it causes
* problems, or we think of a better way.
@@ -3491,8 +3491,8 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
child_iblock = iblock->child_iblocks[i - first_iblock_index];
} /* end else */
- /* At this point, one way or another we should have
- * a pointer to the child iblock. Verify that we
+ /* At this point, one way or another we should have
+ * a pointer to the child iblock. Verify that we
* that we have the correct one.
*/
HDassert(child_iblock);
@@ -3504,8 +3504,8 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
if(H5HF__cache_verify_iblock_descendants_clean(f, fd_parent_addr, child_iblock, &child_iblock_status, fd_clean, clean) < 0)
HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify child iblock clean.")
- /* if iblock_addr != fd_parent_addr, verify that a flush
- * dependency relationship exists between iblock and
+ /* if iblock_addr != fd_parent_addr, verify that a flush
+ * dependency relationship exists between iblock and
* the child iblock.
*/
if(fd_parent_addr != iblock_addr) {