mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-12-09 07:32:32 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'develop' into develop_minor

Browse Source
This commit is contained in:
Dana Robinson 2020-08-17 09:00:42 -07:00
commit d53c9be189
17 changed files with 3637 additions and 1844 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
configure.ac
View File

@ -1594,19 +1594,19 @@ case "X-$withval" in
AM_CPPFLAGS="$AM_CPPFLAGS -I$szlib_inc"
fi
AC_CHECK_HEADERS([szlib.h],
[HAVE_SZLIB_H="yes"],
[CPPFLAGS="$saved_CPPFLAGS"; AM_CPPFLAGS="$saved_AM_CPPFLAGS"] [unset HAVE_SZLIB])
if test -n "$szlib_lib"; then
LDFLAGS="$LDFLAGS -L$szlib_lib"
AM_LDFLAGS="$AM_LDFLAGS -L$szlib_lib"
fi
if test "x$HAVE_SZLIB" = "xyes" -a "x$HAVE_SZLIB_H" = "xyes"; then
if test "x$HAVE_SZLIB" = "xyes"; then
AC_CHECK_LIB([sz], [SZ_BufftoBuffCompress],,
[CPPFLAGS="$saved_CPPFLAGS"; AM_CPPFLAGS="$saved_AM_CPPFLAGS"; LDFLAGS="$saved_LDFLAGS"; AM_LDFLAGS="$saved_AM_LDFLAGS"; unset HAVE_SZLIB])
if test -z "$HAVE_SZLIB"; then
if test -n "$HAVE_SZLIB"; then
AC_CHECK_HEADERS([szlib.h],
[HAVE_SZLIB_H="yes"],
[CPPFLAGS="$saved_CPPFLAGS"; AM_CPPFLAGS="$saved_AM_CPPFLAGS"] [unset HAVE_SZLIB])
else
AC_MSG_RESULT([Using SZ_BufftoBuffCompress from libsz in $szlib_lib failed. Szip not enabled.])
fi
fi

263
src/H5AC.c
View File

@ -140,8 +140,8 @@ static const H5AC_class_t *const H5AC_class_s[] = {
*
* Purpose: Initialize the interface from some other layer.
*
* Return: Success: non-negative
* Failure: negative
* Return: Success: non-negative
* Failure: negative
*
* Programmer: Quincey Koziol
* Saturday, January 18, 2003
@ -162,7 +162,7 @@ done:
/*-------------------------------------------------------------------------
* Function H5AC__init_package
* Function: H5AC__init_package
*
* Purpose: Initialize interface-specific information
*
@ -202,9 +202,9 @@ H5AC__init_package(void)
*
* Purpose: Terminate this interface.
*
* Return: Success: Positive if anything was done that might
* affect other interfaces; zero otherwise.
* Failure: Negative.
* Return: Success: Positive if anything was done that might
* affect other interfaces; zero otherwise.
* Failure: Negative.
*
* Programmer: Quincey Koziol
* Thursday, July 18, 2002
@ -281,7 +281,7 @@ herr_t
H5AC_create(const H5F_t *f, H5AC_cache_config_t *config_ptr, H5AC_cache_image_config_t * image_config_ptr)
{
#ifdef H5_HAVE_PARALLEL
char prefix[H5C__PREFIX_LEN] = "";
char prefix[H5C__PREFIX_LEN] = "";
H5AC_aux_t * aux_ptr = NULL;
#endif /* H5_HAVE_PARALLEL */
struct H5C_cache_image_ctl_t int_ci_config = H5C__DEFAULT_CACHE_IMAGE_CTL;
@ -468,6 +468,14 @@ done:
* Programmer: Robb Matzke
* Jul 9 1997
*
* Changes:
*
* In the parallel case, added code to setup the MDC slist
* before the call to H5AC__flush_entries() and take it down
* afterwards.
*
* JRM -- 7/29/20
*
*-------------------------------------------------------------------------
*/
herr_t
@ -493,58 +501,115 @@ H5AC_dest(H5F_t *f)
#endif /* H5AC_DUMP_STATS_ON_CLOSE */
/* Check if log messages are being emitted */
if(H5C_get_logging_status(f->shared->cache, &log_enabled, &curr_logging) < 0)
if(H5C_get_logging_status(f->shared->cache,
&log_enabled, &curr_logging) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to get logging status")
if(log_enabled && curr_logging)
if(log_enabled && curr_logging) {
if(H5C_log_write_destroy_cache_msg(f->shared->cache) < 0)
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to emit log message")
HDONE_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, \
"unable to emit log message")
}
/* Tear down logging */
if(log_enabled)
if(log_enabled) {
if(H5C_log_tear_down(f->shared->cache) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "mdc logging tear-down failed")
HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, \
"mdc logging tear-down failed")
}
#ifdef H5_HAVE_PARALLEL
/* destroying the cache, so clear all collective entries */
if(H5C_clear_coll_entries(f->shared->cache, FALSE) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTGET, FAIL, "H5C_clear_coll_entries() failed")
HGOTO_ERROR(H5E_CACHE, H5E_CANTGET, FAIL, \
"H5C_clear_coll_entries() failed")
aux_ptr = (H5AC_aux_t *)H5C_get_aux_ptr(f->shared->cache);
if(aux_ptr)
if(aux_ptr) {
/* Sanity check */
HDassert(aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC);
/* If the file was opened R/W, attempt to flush all entries
* from rank 0 & Bcast clean list to other ranks.
*
* Must not flush in the R/O case, as this will trigger the
* free space manager settle routines.
*/
if(H5F_ACC_RDWR & H5F_INTENT(f))
if(H5AC__flush_entries(f) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't flush")
/* If the file was opened R/W, attempt to flush all entries
* from rank 0 & Bcast clean list to other ranks.
*
* Must not flush in the R/O case, as this will trigger the
* free space manager settle routines.
*
* Must also enable the skip list before the call to
* H5AC__flush_entries() and disable it afterwards, as the
* skip list will be disabled after the previous flush.
*
* Note that H5C_dest() does slist setup and take down as well.
* Unfortunately, we can't do the setup and take down just once,
* as H5C_dest() is called directly in the test code.
*
* Fortunately, the cache should be clean or close to it at this
* point, so the overhead should be minimal.
*/
if(H5F_ACC_RDWR & H5F_INTENT(f)) {
/* enable and load the slist */
if ( H5C_set_slist_enabled(f->shared->cache, TRUE, FALSE) < 0 )
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
"set slist enabled failed")
if(H5AC__flush_entries(f) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't flush")
/* disable the slist -- should be empty */
if ( H5C_set_slist_enabled(f->shared->cache, FALSE, FALSE) < 0 )
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "disable slist failed")
}
}
#endif /* H5_HAVE_PARALLEL */
/* Destroy the cache */
if(H5C_dest(f) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTFREE, FAIL, "can't destroy cache")
f->shared->cache = NULL;
#ifdef H5_HAVE_PARALLEL
if(aux_ptr != NULL) {
if(aux_ptr->d_slist_ptr != NULL) {
HDassert(H5SL_count(aux_ptr->d_slist_ptr) == 0);
H5SL_close(aux_ptr->d_slist_ptr);
} /* end if */
if(aux_ptr->c_slist_ptr != NULL) {
HDassert(H5SL_count(aux_ptr->c_slist_ptr) == 0);
H5SL_close(aux_ptr->c_slist_ptr);
} /* end if */
if(aux_ptr->candidate_slist_ptr != NULL) {
HDassert(H5SL_count(aux_ptr->candidate_slist_ptr) == 0);
H5SL_close(aux_ptr->candidate_slist_ptr);
} /* end if */
aux_ptr->magic = 0;
aux_ptr = H5FL_FREE(H5AC_aux_t, aux_ptr);
} /* end if */
#endif /* H5_HAVE_PARALLEL */
@ -736,20 +801,20 @@ H5AC_get_entry_status(const H5F_t *f, haddr_t addr, unsigned *status)
if(in_cache) {
*status |= H5AC_ES__IN_CACHE;
if(is_dirty)
*status |= H5AC_ES__IS_DIRTY;
if(is_protected)
*status |= H5AC_ES__IS_PROTECTED;
if(is_pinned)
*status |= H5AC_ES__IS_PINNED;
if(is_corked)
*status |= H5AC_ES__IS_CORKED;
if(is_flush_dep_parent)
*status |= H5AC_ES__IS_FLUSH_DEP_PARENT;
if(is_flush_dep_child)
*status |= H5AC_ES__IS_FLUSH_DEP_CHILD;
if(image_is_up_to_date)
*status |= H5AC_ES__IMAGE_IS_UP_TO_DATE;
if(is_dirty)
*status |= H5AC_ES__IS_DIRTY;
if(is_protected)
*status |= H5AC_ES__IS_PROTECTED;
if(is_pinned)
*status |= H5AC_ES__IS_PINNED;
if(is_corked)
*status |= H5AC_ES__IS_CORKED;
if(is_flush_dep_parent)
*status |= H5AC_ES__IS_FLUSH_DEP_PARENT;
if(is_flush_dep_child)
*status |= H5AC_ES__IS_FLUSH_DEP_CHILD;
if(image_is_up_to_date)
*status |= H5AC_ES__IMAGE_IS_UP_TO_DATE;
} /* end if */
else
*status = 0;
@ -1200,6 +1265,109 @@ done:
/*-------------------------------------------------------------------------
*
* Function: H5AC_prep_for_file_flush
*
* Purpose: This function should be called just prior to the first
* call to H5AC_flush() during a file flush.
*
* Its purpose is to handly any setup required prior to
* metadata cache flush.
*
* Initially, this means setting up the slist prior to the
* flush. We do this in a seperate call because
* H5F__flush_phase2() make repeated calls to H5AC_flush().
* Handling this detail in separate calls allows us to avoid
* the overhead of setting up and taking down the skip list
* repeatedly.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: John Mainzer
* 5/5/20
*
* Changes: None.
*
*-------------------------------------------------------------------------
*/
herr_t
H5AC_prep_for_file_flush(H5F_t *f)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Sanity checks */
HDassert(f);
HDassert(f->shared);
HDassert(f->shared->cache);
if ( H5C_set_slist_enabled(f->shared->cache, TRUE, FALSE) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "slist enabled failed")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_prep_for_file_flush() */
/*-------------------------------------------------------------------------
*
* Function: H5AC_secure_from_file_flush
*
* Purpose: This function should be called just after the last
* call to H5AC_flush() during a file flush.
*
* Its purpose is to perform any necessary cleanup after the
* metadata cache flush.
*
* The objective of the call is to allow the metadata cache
* to do any necessary necessary cleanup work after a cache
* flush.
*
* Initially, this means taking down the slist after the
* flush. We do this in a seperate call because
* H5F__flush_phase2() make repeated calls to H5AC_flush().
* Handling this detail in separate calls allows us to avoid
* the overhead of setting up and taking down the skip list
* repeatedly.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: John Mainzer
* 5/5/20
*
* Changes: None.
*
*-------------------------------------------------------------------------
*/
herr_t
H5AC_secure_from_file_flush(H5F_t *f)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Sanity checks */
HDassert(f);
HDassert(f->shared);
HDassert(f->shared->cache);
if ( H5C_set_slist_enabled(f->shared->cache, FALSE, FALSE) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "slist enabled failed")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_secure_from_file_flush() */
/*-------------------------------------------------------------------------
*
* Function: H5AC_create_flush_dependency()
*
* Purpose: Create a flush dependency between two entries in the metadata
@ -1508,8 +1676,8 @@ herr_t
H5AC_unprotect(H5F_t *f, const H5AC_class_t *type, haddr_t addr, void *thing,
unsigned flags)
{
hbool_t dirtied;
hbool_t deleted;
hbool_t dirtied;
hbool_t deleted;
#ifdef H5_HAVE_PARALLEL
H5AC_aux_t * aux_ptr = NULL;
#endif /* H5_HAVE_PARALLEL */
@ -1530,14 +1698,14 @@ H5AC_unprotect(H5F_t *f, const H5AC_class_t *type, haddr_t addr, void *thing,
HDassert(((H5AC_info_t *)thing)->type == type);
dirtied = (hbool_t)(((flags & H5AC__DIRTIED_FLAG) == H5AC__DIRTIED_FLAG) ||
(((H5AC_info_t *)thing)->dirtied));
(((H5AC_info_t *)thing)->dirtied));
deleted = (hbool_t)((flags & H5C__DELETED_FLAG) == H5C__DELETED_FLAG);
/* Check if the size changed out from underneath us, if we're not deleting
* the entry.
*/
if(dirtied && !deleted) {
size_t curr_size = 0;
size_t curr_size = 0;
if((type->image_len)(thing, &curr_size) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTGETSIZE, FAIL, "Can't get size of thing")
@ -1624,7 +1792,7 @@ H5AC_get_cache_auto_resize_config(const H5AC_t *cache_ptr,
if(internal_config.rpt_fcn == NULL)
config_ptr->rpt_fcn_enabled = FALSE;
else
config_ptr->rpt_fcn_enabled = TRUE;
config_ptr->rpt_fcn_enabled = TRUE;
config_ptr->open_trace_file = FALSE;
config_ptr->close_trace_file = FALSE;
config_ptr->trace_file_name[0] = '\0';
@ -1913,7 +2081,7 @@ H5AC_validate_config(H5AC_cache_config_t *config_ptr)
/* don't bother to test trace_file_name unless open_trace_file is TRUE */
if(config_ptr->open_trace_file) {
size_t name_len;
size_t name_len;
/* Can't really test the trace_file_name field without trying to
* open the file, so we will content ourselves with a couple of
@ -2034,9 +2202,9 @@ H5_ATTR_UNUSED
*f, hbool_t *write_permitted_ptr)
{
#ifdef H5_HAVE_PARALLEL
H5AC_aux_t * aux_ptr = NULL;
H5AC_aux_t * aux_ptr = NULL;
#endif /* H5_HAVE_PARALLEL */
hbool_t write_permitted = TRUE;
hbool_t write_permitted = TRUE;
FUNC_ENTER_STATIC_NOERR
@ -2533,8 +2701,8 @@ H5AC_set_ring(H5AC_ring_t ring, H5AC_ring_t *orig_ring)
* Note that this function simply passes the call on to
* the metadata cache proper, and returns the result.
*
* Return: Success: Non-negative
* Failure: Negative
* Return: Success: Non-negative
* Failure: Negative
*
* Programmer: Quincey Koziol
* September 17, 2016
@ -2669,4 +2837,3 @@ H5AC_get_mdc_image_info(H5AC_t *cache_ptr, haddr_t *image_addr, hsize_t *image_l
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC_get_mdc_image_info() */

42
src/H5ACmpio.c
View File

@ -791,7 +791,7 @@ H5AC__log_dirtied_entry(const H5AC_info_t *entry_ptr)
else {
aux_ptr->dirty_bytes += entry_ptr->size;
#if H5AC_DEBUG_DIRTY_BYTES_CREATION
aux_ptr->unprotect_dirty_bytes += entry_size;
aux_ptr->unprotect_dirty_bytes += entry_ptr->size;
aux_ptr->unprotect_dirty_bytes_updates += 1;
#endif /* H5AC_DEBUG_DIRTY_BYTES_CREATION */
} /* end else */
@ -989,7 +989,7 @@ H5AC__log_inserted_entry(const H5AC_info_t *entry_ptr)
aux_ptr->dirty_bytes += entry_ptr->size;
#if H5AC_DEBUG_DIRTY_BYTES_CREATION
aux_ptr->insert_dirty_bytes += size;
aux_ptr->insert_dirty_bytes += entry_ptr->size;
aux_ptr->insert_dirty_bytes_updates += 1;
#endif /* H5AC_DEBUG_DIRTY_BYTES_CREATION */
@ -1875,6 +1875,8 @@ done:
* Programmer: John Mainzer
* April 28, 2010
*
* Changes: None.
*
*-------------------------------------------------------------------------
*/
static herr_t
@ -1894,7 +1896,8 @@ H5AC__rsp__p0_only__flush(H5F_t *f)
aux_ptr = (H5AC_aux_t *)H5C_get_aux_ptr(cache_ptr);
HDassert(aux_ptr != NULL);
HDassert(aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC);
HDassert(aux_ptr->metadata_write_strategy == H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY);
HDassert(aux_ptr->metadata_write_strategy == \
H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY);
/* To prevent "messages from the future" we must
* synchronize all processes before we start the flush.
@ -1903,9 +1906,12 @@ H5AC__rsp__p0_only__flush(H5F_t *f)
* However, when flushing from within the close operation from a file,
* it's possible to skip this barrier (on the second flush of the cache).
*/
if(!H5CX_get_mpi_file_flushing())
if(MPI_SUCCESS != (mpi_result = MPI_Barrier(aux_ptr->mpi_comm)))
if ( ! H5CX_get_mpi_file_flushing() ) {
if ( MPI_SUCCESS != (mpi_result = MPI_Barrier(aux_ptr->mpi_comm)) )
HMPI_GOTO_ERROR(FAIL, "MPI_Barrier failed", mpi_result)
}
/* Flush data to disk, from rank 0 process */
if(aux_ptr->mpi_rank == 0) {
@ -1921,23 +1927,30 @@ H5AC__rsp__p0_only__flush(H5F_t *f)
aux_ptr->write_permitted = FALSE;
/* Check for error on the write operation */
if(result < 0)
if ( result < 0 )
HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't flush.")
/* this code exists primarily for the test bed -- it allows us to
* enforce POSIX semantics on the server that pretends to be a
* file system in our parallel tests.
*/
if(aux_ptr->write_done)
if ( aux_ptr->write_done ) {
(aux_ptr->write_done)();
}
} /* end if */
/* Propagate cleaned entries to other ranks. */
if(H5AC__propagate_flushed_and_still_clean_entries_list(f) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't propagate clean entries list.")
if ( H5AC__propagate_flushed_and_still_clean_entries_list(f) < 0 )
HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
"Can't propagate clean entries list.")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC__rsp__p0_only__flush() */
@ -2104,16 +2117,22 @@ H5AC__run_sync_point(H5F_t *f, int sync_point_op)
/* Sanity checks */
HDassert(f != NULL);
cache_ptr = f->shared->cache;
HDassert(cache_ptr != NULL);
aux_ptr = (H5AC_aux_t *)H5C_get_aux_ptr(cache_ptr);
HDassert(aux_ptr != NULL);
HDassert(aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC);
HDassert((sync_point_op == H5AC_SYNC_POINT_OP__FLUSH_TO_MIN_CLEAN) ||
(sync_point_op == H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED));
(sync_point_op == H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED));
#if H5AC_DEBUG_DIRTY_BYTES_CREATION
HDfprintf(stdout, "%d:H5AC_propagate...:%u: (u/uu/i/iu/r/ru) = %zu/%u/%zu/%u/%zu/%u\n",
HDfprintf(stdout,
"%d:H5AC_propagate...:%u: (u/uu/i/iu/r/ru) = %zu/%u/%zu/%u/%zu/%u\n",
aux_ptr->mpi_rank,
aux_ptr->dirty_bytes_propagations,
aux_ptr->unprotect_dirty_bytes,
@ -2188,6 +2207,7 @@ HDfprintf(stdout, "%d:H5AC_propagate...:%u: (u/uu/i/iu/r/ru) = %zu/%u/%zu/%u/%zu
#endif /* H5AC_DEBUG_DIRTY_BYTES_CREATION */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC__run_sync_point() */

2
src/H5ACprivate.h
View File

@ -387,6 +387,8 @@ H5_DLL herr_t H5AC_insert_entry(H5F_t *f, const H5AC_class_t *type,
haddr_t addr, void *thing, unsigned int flags);
H5_DLL herr_t H5AC_pin_protected_entry(void *thing);
H5_DLL herr_t H5AC_prep_for_file_close(H5F_t *f);
H5_DLL herr_t H5AC_prep_for_file_flush(H5F_t *f);
H5_DLL herr_t H5AC_secure_from_file_flush(H5F_t *f);
H5_DLL herr_t H5AC_create_flush_dependency(void *parent_thing, void *child_thing);
H5_DLL void * H5AC_protect(H5F_t *f, const H5AC_class_t *type, haddr_t addr,
void *udata, unsigned flags);

1877
src/H5C.c
View File

File diff suppressed because it is too large Load Diff

51
src/H5Cdbg.c
View File

@ -260,17 +260,24 @@ H5C_dump_cache_LRU(H5C_t *cache_ptr, const char *cache_name)
/*-------------------------------------------------------------------------
*
* Function: H5C_dump_cache_skip_list
*
* Purpose: Debugging routine that prints a summary of the contents of
* the skip list used by the metadata cache metadata cache to
* maintain an address sorted list of dirty entries.
* the skip list used by the metadata cache metadata cache to
* maintain an address sorted list of dirty entries.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: John Mainzer
* 11/15/14
*
* Changes: Updated function for the slist_enabled field in H5C_t.
* Recall that to minimize slist overhead, the slist is
* empty and not maintained if cache_ptr->slist_enabled is
* false.
* JRM -- 5/6/20
*
*-------------------------------------------------------------------------
*/
#ifndef NDEBUG
@ -288,11 +295,16 @@ H5C_dump_cache_skip_list(H5C_t * cache_ptr, char * calling_fcn)
HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
HDassert(calling_fcn != NULL);
HDfprintf(stdout, "\n\nDumping metadata cache skip list from %s.\n", calling_fcn);
HDfprintf(stdout, "\n\nDumping metadata cache skip list from %s.\n",
calling_fcn);
HDfprintf(stdout, " slist enabled = %d.\n",
(int)(cache_ptr->slist_enabled));
HDfprintf(stdout, " slist len = %u.\n", cache_ptr->slist_len);
HDfprintf(stdout, " slist size = %lld.\n", (long long)(cache_ptr->slist_size));
HDfprintf(stdout, " slist size = %lld.\n",
(long long)(cache_ptr->slist_size));
if(cache_ptr->slist_len > 0) {
/* If we get this far, all entries in the cache are listed in the
* skip list -- scan the skip list generating the desired output.
*/
@ -300,13 +312,20 @@ H5C_dump_cache_skip_list(H5C_t * cache_ptr, char * calling_fcn)
"Num: Addr: Len: Prot/Pind: Dirty: Type:\n");
i = 0;
node_ptr = H5SL_first(cache_ptr->slist_ptr);
if(node_ptr != NULL)
entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
else
entry_ptr = NULL;
while(entry_ptr != NULL) {
node_ptr = H5SL_first(cache_ptr->slist_ptr);
if ( node_ptr != NULL ) {
entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
} else {
entry_ptr = NULL;
}
while ( entry_ptr != NULL ) {
HDassert( entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC );
HDfprintf(stdout,
@ -323,19 +342,27 @@ H5C_dump_cache_skip_list(H5C_t * cache_ptr, char * calling_fcn)
node_ptr, H5SL_item(node_ptr));
/* increment node_ptr before we delete its target */
node_ptr = H5SL_next(node_ptr);
if(node_ptr != NULL)
if ( node_ptr != NULL ) {
entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
else
} else {
entry_ptr = NULL;
}
i++;
} /* end while */
} /* end if */
HDfprintf(stdout, "\n\n");
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C_dump_cache_skip_list() */
#endif /* NDEBUG */

163
src/H5Cimage.c
View File

@ -431,36 +431,40 @@ done:
* Function: H5C__deserialize_prefetched_entry()
*
* Purpose: Deserialize the supplied prefetched entry entry, and return
* a pointer to the deserialized entry in *entry_ptr_ptr.
* If successful, remove the prefetched entry from the cache,
* and free it. Insert the deserialized entry into the cache.
* a pointer to the deserialized entry in *entry_ptr_ptr.
* If successful, remove the prefetched entry from the cache,
* and free it. Insert the deserialized entry into the cache.
*
* Note that the on disk image of the entry is not freed --
* a pointer to it is stored in the deserialized entries'
* image_ptr field, and its image_up_to_date field is set to
* TRUE unless the entry is dirtied by the deserialize call.
* Note that the on disk image of the entry is not freed --
* a pointer to it is stored in the deserialized entries'
* image_ptr field, and its image_up_to_date field is set to
* TRUE unless the entry is dirtied by the deserialize call.
*
* If the prefetched entry is a flush dependency child,
* destroy that flush dependency prior to calling the
* deserialize callback. If appropriate, the flush dependency
* relationship will be recreated by the cache client.
* If the prefetched entry is a flush dependency child,
* destroy that flush dependency prior to calling the
* deserialize callback. If appropriate, the flush dependency
* relationship will be recreated by the cache client.
*
* If the prefetched entry is a flush dependency parent,
* destroy the flush dependency relationship with all its
* children. As all these children must be prefetched entries,
* recreate these flush dependency relationships with
* deserialized entry after it is inserted in the cache.
* If the prefetched entry is a flush dependency parent,
* destroy the flush dependency relationship with all its
* children. As all these children must be prefetched entries,
* recreate these flush dependency relationships with
* deserialized entry after it is inserted in the cache.
*
* Since deserializing a prefetched entry is semantically
* equivalent to a load, issue an entry loaded nofification
* if the notify callback is defined.
* Since deserializing a prefetched entry is semantically
* equivalent to a load, issue an entry loaded nofification
* if the notify callback is defined.
*
* Return: SUCCEED on success, and FAIL on failure.
*
* Note that *entry_ptr_ptr is undefined on failure.
* Note that *entry_ptr_ptr is undefined on failure.
*
* Programmer: John Mainzer, 8/10/15
*
* Changes: Updated sanity checks for possibility that the slist
* is disabled.
* JRM -- 5/17/20
*
*-------------------------------------------------------------------------
*/
herr_t
@ -468,11 +472,11 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
H5C_cache_entry_t **entry_ptr_ptr, const H5C_class_t *type,
haddr_t addr, void *udata)
{
hbool_t dirty = FALSE; /* Flag indicating whether thing was
hbool_t dirty = FALSE; /* Flag indicating whether thing was
* dirtied during deserialize
*/
size_t len; /* Size of image in file */
void * thing = NULL; /* Pointer to thing loaded */
void * thing = NULL; /* Pointer to thing loaded */
H5C_cache_entry_t * pf_entry_ptr; /* pointer to the prefetched entry */
/* supplied in *entry_ptr_ptr. */
H5C_cache_entry_t * ds_entry_ptr; /* Alias for thing loaded, as cache
@ -484,8 +488,8 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
/* the prefetched entry, or NULL if */
/* that array does not exist. */
unsigned flush_flags = (H5C__FLUSH_INVALIDATE_FLAG |
H5C__FLUSH_CLEAR_ONLY_FLAG);
int i;
H5C__FLUSH_CLEAR_ONLY_FLAG);
int i;
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_PACKAGE
@ -604,73 +608,73 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
HDassert( ( dirty == FALSE ) || ( type->id == 5 || type->id == 6) );
ds_entry_ptr->magic = H5C__H5C_CACHE_ENTRY_T_MAGIC;
ds_entry_ptr->cache_ptr = f->shared->cache;
ds_entry_ptr->addr = addr;
ds_entry_ptr->size = len;
ds_entry_ptr->magic = H5C__H5C_CACHE_ENTRY_T_MAGIC;
ds_entry_ptr->cache_ptr = f->shared->cache;
ds_entry_ptr->addr = addr;
ds_entry_ptr->size = len;
HDassert(ds_entry_ptr->size < H5C_MAX_ENTRY_SIZE);
ds_entry_ptr->image_ptr = pf_entry_ptr->image_ptr;
ds_entry_ptr->image_up_to_date = !dirty;
ds_entry_ptr->type = type;
ds_entry_ptr->is_dirty = dirty | pf_entry_ptr->is_dirty;
ds_entry_ptr->dirtied = FALSE;
ds_entry_ptr->is_protected = FALSE;
ds_entry_ptr->is_read_only = FALSE;
ds_entry_ptr->ro_ref_count = 0;
ds_entry_ptr->is_pinned = FALSE;
ds_entry_ptr->in_slist = FALSE;
ds_entry_ptr->flush_marker = FALSE;
ds_entry_ptr->image_ptr = pf_entry_ptr->image_ptr;
ds_entry_ptr->image_up_to_date = !dirty;
ds_entry_ptr->type = type;
ds_entry_ptr->is_dirty = dirty | pf_entry_ptr->is_dirty;
ds_entry_ptr->dirtied = FALSE;
ds_entry_ptr->is_protected = FALSE;
ds_entry_ptr->is_read_only = FALSE;
ds_entry_ptr->ro_ref_count = 0;
ds_entry_ptr->is_pinned = FALSE;
ds_entry_ptr->in_slist = FALSE;
ds_entry_ptr->flush_marker = FALSE;
#ifdef H5_HAVE_PARALLEL
ds_entry_ptr->clear_on_unprotect = FALSE;
ds_entry_ptr->flush_immediately = FALSE;
ds_entry_ptr->coll_access = FALSE;
ds_entry_ptr->clear_on_unprotect = FALSE;
ds_entry_ptr->flush_immediately = FALSE;
ds_entry_ptr->coll_access = FALSE;
#endif /* H5_HAVE_PARALLEL */
ds_entry_ptr->flush_in_progress = FALSE;
ds_entry_ptr->destroy_in_progress = FALSE;
ds_entry_ptr->flush_in_progress = FALSE;
ds_entry_ptr->destroy_in_progress = FALSE;
ds_entry_ptr->ring = pf_entry_ptr->ring;
ds_entry_ptr->ring = pf_entry_ptr->ring;
/* Initialize flush dependency height fields */
ds_entry_ptr->flush_dep_parent = NULL;
ds_entry_ptr->flush_dep_nparents = 0;
ds_entry_ptr->flush_dep_parent_nalloc = 0;
ds_entry_ptr->flush_dep_nchildren = 0;
ds_entry_ptr->flush_dep_ndirty_children = 0;
ds_entry_ptr->flush_dep_nunser_children = 0;
ds_entry_ptr->flush_dep_parent = NULL;
ds_entry_ptr->flush_dep_nparents = 0;
ds_entry_ptr->flush_dep_parent_nalloc = 0;
ds_entry_ptr->flush_dep_nchildren = 0;
ds_entry_ptr->flush_dep_ndirty_children = 0;
ds_entry_ptr->flush_dep_nunser_children = 0;
/* Initialize fields supporting the hash table: */
ds_entry_ptr->ht_next = NULL;
ds_entry_ptr->ht_prev = NULL;
ds_entry_ptr->il_next = NULL;
ds_entry_ptr->il_prev = NULL;
ds_entry_ptr->ht_next = NULL;
ds_entry_ptr->ht_prev = NULL;
ds_entry_ptr->il_next = NULL;
ds_entry_ptr->il_prev = NULL;
/* Initialize fields supporting replacement policies: */
ds_entry_ptr->next = NULL;
ds_entry_ptr->prev = NULL;
ds_entry_ptr->next = NULL;
ds_entry_ptr->prev = NULL;
#if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
ds_entry_ptr->aux_next = NULL;
ds_entry_ptr->aux_prev = NULL;
ds_entry_ptr->aux_next = NULL;
ds_entry_ptr->aux_prev = NULL;
#endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
#ifdef H5_HAVE_PARALLEL
pf_entry_ptr->coll_next = NULL;
pf_entry_ptr->coll_prev = NULL;
pf_entry_ptr->coll_next = NULL;
pf_entry_ptr->coll_prev = NULL;
#endif /* H5_HAVE_PARALLEL */
/* Initialize cache image related fields */
ds_entry_ptr->include_in_image = FALSE;
ds_entry_ptr->lru_rank = 0;
ds_entry_ptr->image_dirty = FALSE;
ds_entry_ptr->fd_parent_count = 0;
ds_entry_ptr->fd_parent_addrs = NULL;
ds_entry_ptr->fd_child_count = pf_entry_ptr->fd_child_count;
ds_entry_ptr->fd_dirty_child_count = 0;
ds_entry_ptr->image_fd_height = 0;
ds_entry_ptr->prefetched = FALSE;
ds_entry_ptr->prefetch_type_id = 0;
ds_entry_ptr->age = 0;
ds_entry_ptr->prefetched_dirty = pf_entry_ptr->prefetched_dirty;
ds_entry_ptr->include_in_image = FALSE;
ds_entry_ptr->lru_rank = 0;
ds_entry_ptr->image_dirty = FALSE;
ds_entry_ptr->fd_parent_count = 0;
ds_entry_ptr->fd_parent_addrs = NULL;
ds_entry_ptr->fd_child_count = pf_entry_ptr->fd_child_count;
ds_entry_ptr->fd_dirty_child_count = 0;
ds_entry_ptr->image_fd_height = 0;
ds_entry_ptr->prefetched = FALSE;
ds_entry_ptr->prefetch_type_id = 0;
ds_entry_ptr->age = 0;
ds_entry_ptr->prefetched_dirty = pf_entry_ptr->prefetched_dirty;
#ifndef NDEBUG /* debugging field */
ds_entry_ptr->serialization_count = 0;
ds_entry_ptr->serialization_count = 0;
#endif /* NDEBUG */
H5C__RESET_CACHE_ENTRY_STATS(ds_entry_ptr);
@ -694,15 +698,20 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
*
* 1) Set pf_entry_ptr->image_ptr to NULL. Since we have already
* transferred the buffer containing the image to *ds_entry_ptr,
* this is not a memory leak.
* this is not a memory leak.
*
* 2) Call H5C__flush_single_entry() with the H5C__FLUSH_INVALIDATE_FLAG
* and H5C__FLUSH_CLEAR_ONLY_FLAG flags set.
*/
pf_entry_ptr->image_ptr = NULL;
if(pf_entry_ptr->is_dirty) {
HDassert(pf_entry_ptr->in_slist);
if ( pf_entry_ptr->is_dirty ) {
HDassert(((cache_ptr->slist_enabled) && (pf_entry_ptr->in_slist)) || \
((!cache_ptr->slist_enabled) && (!pf_entry_ptr->in_slist)));
flush_flags |= H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG;
} /* end if */
if(H5C__flush_single_entry(f, pf_entry_ptr, flush_flags) < 0)

185
src/H5Cmpio.c
View File

@ -18,7 +18,7 @@
* Quincey Koziol
*
* Purpose: Functions in this file implement support for parallel I/O for
* generic cache code.
* generic cache code.
*
*-------------------------------------------------------------------------
*/
@ -28,7 +28,7 @@
/****************/
#include "H5Cmodule.h" /* This source code file is part of the H5C module */
#define H5F_FRIEND /*suppress error about including H5Fpkg */
#define H5F_FRIEND /*suppress error about including H5Fpkg */
/***********/
@ -114,9 +114,9 @@ static herr_t H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring,
*
* We construct the table as follows. Let:
*
* n = num_candidates / mpi_size;
* n = num_candidates / mpi_size;
*
* m = num_candidates % mpi_size;
* m = num_candidates % mpi_size;
*
* Now allocate an array of integers of length mpi_size + 1,
* and call this array candidate_assignment_table.
@ -136,10 +136,10 @@ static herr_t H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring,
* Once the table is constructed, we determine the first and
* last entry this process is to flush as follows:
*
* first_entry_to_flush = candidate_assignment_table[mpi_rank]
* first_entry_to_flush = candidate_assignment_table[mpi_rank]
*
* last_entry_to_flush =
* candidate_assignment_table[mpi_rank + 1] - 1;
* candidate_assignment_table[mpi_rank + 1] - 1;
*
* With these values determined, we simply scan through the
* candidate list, marking all entries in the range
@ -163,6 +163,10 @@ static herr_t H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring,
* Programmer: John Mainzer
* 3/17/10
*
* Changes: Updated sanity checks to allow for the possibility that
* the slist is disabled.
* JRM -- 8/3/20
*
*-------------------------------------------------------------------------
*/
herr_t
@ -185,12 +189,15 @@ H5C_apply_candidate_list(H5F_t * f,
unsigned entries_to_clear[H5C_RING_NTYPES];
haddr_t addr;
H5C_cache_entry_t * entry_ptr = NULL;
#if H5C_DO_SANITY_CHECKS
haddr_t last_addr;
#endif /* H5C_DO_SANITY_CHECKS */
#if H5C_APPLY_CANDIDATE_LIST__DEBUG
char tbl_buf[1024];
#endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
unsigned u; /* Local index variable */
herr_t ret_value = SUCCEED; /* Return value */
@ -200,7 +207,8 @@ H5C_apply_candidate_list(H5F_t * f,
HDassert(cache_ptr != NULL);
HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
HDassert(num_candidates > 0);
HDassert(num_candidates <= cache_ptr->slist_len);
HDassert( ( ! cache_ptr->slist_enabled ) ||
( num_candidates <= cache_ptr->slist_len ));
HDassert(candidates_list_ptr != NULL);
HDassert(0 <= mpi_rank);
HDassert(mpi_rank < mpi_size);
@ -410,6 +418,7 @@ done:
/*-------------------------------------------------------------------------
*
* Function: H5C_construct_candidate_list__clean_cache
*
* Purpose: Construct the list of entries that should be flushed to
@ -425,6 +434,16 @@ done:
* Programmer: John Mainzer
* 3/17/10
*
* Changes: With the slist optimization, the slist is not maintained
* unless a flush is in progress. Thus we can not longer use
* cache_ptr->slist_size to determine the total size of
* the entries we must insert in the candidate list.
*
* To address this, we now use cache_ptr->dirty_index_size
* instead.
*
* JRM -- 7/27/20
*
*-------------------------------------------------------------------------
*/
herr_t
@ -438,60 +457,82 @@ H5C_construct_candidate_list__clean_cache(H5C_t * cache_ptr)
HDassert( cache_ptr != NULL );
HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
/* As a sanity check, set space needed to the size of the skip list.
* This should be the sum total of the sizes of all the dirty entries
* in the metadata cache.
/* As a sanity check, set space needed to the dirty_index_size. This
* should be the sum total of the sizes of all the dirty entries
* in the metadata cache. Note that if the slist is enabled,
* cache_ptr->slist_size should equal cache_ptr->dirty_index_size.
*/
space_needed = cache_ptr->slist_size;
space_needed = cache_ptr->dirty_index_size;
HDassert( ( ! cache_ptr->slist_enabled ) ||
( space_needed == cache_ptr->slist_size ) );
/* Recall that while we shouldn't have any protected entries at this
* point, it is possible that some dirty entries may reside on the
* pinned list at this point.
*/
HDassert( cache_ptr->slist_size <=
HDassert( cache_ptr->dirty_index_size <=
(cache_ptr->dLRU_list_size + cache_ptr->pel_size) );
HDassert( cache_ptr->slist_len <=
(cache_ptr->dLRU_list_len + cache_ptr->pel_len) );
HDassert( ( ! cache_ptr->slist_enabled ) ||
( cache_ptr->slist_len <=
(cache_ptr->dLRU_list_len + cache_ptr->pel_len) ) );
if(space_needed > 0) { /* we have work to do */
H5C_cache_entry_t *entry_ptr;
unsigned nominated_entries_count = 0;
size_t nominated_entries_size = 0;
haddr_t nominated_addr;
haddr_t nominated_addr;
HDassert( cache_ptr->slist_len > 0 );
HDassert( ( ! cache_ptr->slist_enabled ) ||
( cache_ptr->slist_len > 0 ) );
/* Scan the dirty LRU list from tail forward and nominate sufficient
* entries to free up the necessary space.
*/
entry_ptr = cache_ptr->dLRU_tail_ptr;
while((nominated_entries_size < space_needed) &&
(nominated_entries_count < cache_ptr->slist_len) &&
(entry_ptr != NULL)) {
while ( ( nominated_entries_size < space_needed ) &&
( ( ! cache_ptr->slist_enabled ) ||
( nominated_entries_count < cache_ptr->slist_len ) ) &&
( entry_ptr != NULL ) ) {
HDassert( ! (entry_ptr->is_protected) );
HDassert( ! (entry_ptr->is_read_only) );
HDassert( entry_ptr->ro_ref_count == 0 );
HDassert( entry_ptr->is_dirty );
HDassert( entry_ptr->in_slist );
HDassert( ( ! cache_ptr->slist_enabled ) ||
( entry_ptr->in_slist ) );
nominated_addr = entry_ptr->addr;
if(H5AC_add_candidate((H5AC_t *)cache_ptr, nominated_addr) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5AC_add_candidate() failed")
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
"H5AC_add_candidate() failed")
nominated_entries_size += entry_ptr->size;
nominated_entries_count++;
entry_ptr = entry_ptr->aux_prev;
} /* end while */
HDassert( entry_ptr == NULL );
/* it is possible that there are some dirty entries on the
* protected entry list as well -- scan it too if necessary
*/
entry_ptr = cache_ptr->pel_head_ptr;
while((nominated_entries_size < space_needed) &&
(nominated_entries_count < cache_ptr->slist_len) &&
(entry_ptr != NULL)) {
while ( ( nominated_entries_size < space_needed ) &&
( ( ! cache_ptr->slist_enabled ) ||
( nominated_entries_count < cache_ptr->slist_len ) ) &&
( entry_ptr != NULL ) ) {
if(entry_ptr->is_dirty) {
HDassert( ! (entry_ptr->is_protected) );
HDassert( ! (entry_ptr->is_read_only) );
HDassert( entry_ptr->ro_ref_count == 0 );
@ -499,22 +540,31 @@ H5C_construct_candidate_list__clean_cache(H5C_t * cache_ptr)
HDassert( entry_ptr->in_slist );
nominated_addr = entry_ptr->addr;
if(H5AC_add_candidate((H5AC_t *)cache_ptr, nominated_addr) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5AC_add_candidate() failed")
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
"H5AC_add_candidate() failed")
nominated_entries_size += entry_ptr->size;
nominated_entries_count++;
} /* end if */
entry_ptr = entry_ptr->next;
} /* end while */
HDassert( nominated_entries_count == cache_ptr->slist_len );
HDassert( ( ! cache_ptr->slist_enabled ) ||
( nominated_entries_count == cache_ptr->slist_len ) );
HDassert( nominated_entries_size == space_needed );
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5C_construct_candidate_list__clean_cache() */
@ -534,6 +584,12 @@ done:
* Programmer: John Mainzer
* 3/17/10
*
* Changes: With the slist optimization, the slist is not maintained
* unless a flush is in progress. Updated sanity checks to
* reflect this.
*
* JRM -- 7/27/20
*
*-------------------------------------------------------------------------
*/
herr_t
@ -551,54 +607,77 @@ H5C_construct_candidate_list__min_clean(H5C_t * cache_ptr)
* cache back within its min clean constraints.
*/
if(cache_ptr->max_cache_size > cache_ptr->index_size) {
if(((cache_ptr->max_cache_size - cache_ptr->index_size) +
cache_ptr->cLRU_list_size) >= cache_ptr->min_clean_size)
if ( ( (cache_ptr->max_cache_size - cache_ptr->index_size) +
cache_ptr->cLRU_list_size) >= cache_ptr->min_clean_size ) {
space_needed = 0;
else
} else {
space_needed = cache_ptr->min_clean_size -
((cache_ptr->max_cache_size - cache_ptr->index_size) +
cache_ptr->cLRU_list_size);
}
} /* end if */
else {
if(cache_ptr->min_clean_size <= cache_ptr->cLRU_list_size)
if(cache_ptr->min_clean_size <= cache_ptr->cLRU_list_size) {
space_needed = 0;
else
} else {
space_needed = cache_ptr->min_clean_size -
cache_ptr->cLRU_list_size;
}
} /* end else */
if(space_needed > 0) { /* we have work to do */
H5C_cache_entry_t *entry_ptr;
unsigned nominated_entries_count = 0;
size_t nominated_entries_size = 0;
HDassert( cache_ptr->slist_len > 0 );
HDassert( ( ! cache_ptr->slist_enabled ) ||
( cache_ptr->slist_len > 0 ) );
/* Scan the dirty LRU list from tail forward and nominate sufficient
* entries to free up the necessary space.
*/
entry_ptr = cache_ptr->dLRU_tail_ptr;
while((nominated_entries_size < space_needed) &&
(nominated_entries_count < cache_ptr->slist_len) &&
(entry_ptr != NULL) &&
(!entry_ptr->flush_me_last)) {
haddr_t nominated_addr;
while ( ( nominated_entries_size < space_needed ) &&
( ( ! cache_ptr->slist_enabled ) ||
( nominated_entries_count < cache_ptr->slist_len ) ) &&
( entry_ptr != NULL ) &&
( ! entry_ptr->flush_me_last ) ) {
haddr_t nominated_addr;
HDassert( ! (entry_ptr->is_protected) );
HDassert( ! (entry_ptr->is_read_only) );
HDassert( entry_ptr->ro_ref_count == 0 );
HDassert( entry_ptr->is_dirty );
HDassert( entry_ptr->in_slist );
HDassert( ( ! cache_ptr->slist_enabled ) ||
( entry_ptr->in_slist ) );
nominated_addr = entry_ptr->addr;
if(H5AC_add_candidate((H5AC_t *)cache_ptr, nominated_addr) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5AC_add_candidate() failed")
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
"H5AC_add_candidate() failed")
nominated_entries_size += entry_ptr->size;
nominated_entries_count++;
entry_ptr = entry_ptr->aux_prev;
} /* end while */
HDassert( nominated_entries_count <= cache_ptr->slist_len );
HDassert( ( ! cache_ptr->slist_enabled ) ||
( nominated_entries_count <= cache_ptr->slist_len ) );
HDassert( nominated_entries_size <= cache_ptr->dirty_index_size );
HDassert( nominated_entries_size >= space_needed );
} /* end if */
@ -769,7 +848,7 @@ H5C_mark_entries_as_clean(H5F_t * f,
* of the pre_serialize / serialize routines, this may
* cease to be the case -- requiring a review of this
* point.
* JRM -- 4/7/15
* JRM -- 4/7/15
*/
entries_cleared = 0;
entries_examined = 0;
@ -873,9 +952,9 @@ done:
herr_t
H5C_clear_coll_entries(H5C_t *cache_ptr, hbool_t partial)
{
uint32_t clear_cnt;
H5C_cache_entry_t * entry_ptr = NULL;
herr_t ret_value = SUCCEED;
uint32_t clear_cnt;
H5C_cache_entry_t * entry_ptr = NULL;
herr_t ret_value = SUCCEED;
FUNC_ENTER_NOAPI_NOINIT
@ -1124,17 +1203,17 @@ H5C__flush_candidate_entries(H5F_t *f, unsigned entries_to_flush[H5C_RING_NTYPES
unsigned entries_to_clear[H5C_RING_NTYPES])
{
#if H5C_DO_SANITY_CHECKS
int i;
uint32_t index_len = 0;
size_t index_size = (size_t)0;
size_t clean_index_size = (size_t)0;
size_t dirty_index_size = (size_t)0;
size_t slist_size = (size_t)0;
uint32_t slist_len = 0;
int i;
uint32_t index_len = 0;
size_t index_size = (size_t)0;
size_t clean_index_size = (size_t)0;
size_t dirty_index_size = (size_t)0;
size_t slist_size = (size_t)0;
uint32_t slist_len = 0;
#endif /* H5C_DO_SANITY_CHECKS */
H5C_ring_t ring;
H5C_ring_t ring;
H5C_t * cache_ptr;
herr_t ret_value = SUCCEED;
herr_t ret_value = SUCCEED;
FUNC_ENTER_STATIC

507
src/H5Cpkg.h
View File

@ -47,13 +47,22 @@
/* Number of epoch markers active */
#define H5C__MAX_EPOCH_MARKERS 10
/* Cache configuration settings */
#define H5C__HASH_TABLE_LEN (64 * 1024) /* must be a power of 2 */
#define H5C__H5C_T_MAGIC 0x005CAC0E
/* Initial allocated size of the "flush_dep_parent" array */
#define H5C_FLUSH_DEP_PARENT_INIT 8
/* Set to TRUE to enable the slist optimization. If this field is TRUE,
* the slist is disabled whenever a flush is not in progress.
*/
#define H5C__SLIST_OPT_ENABLED TRUE
/****************************************************************************
*
* We maintain doubly linked lists of instances of H5C_cache_entry_t for a
@ -1568,49 +1577,82 @@ if ( ( (cache_ptr)->index_size != \
* Added code to maintain the cache_ptr->slist_ring_len
* and cache_ptr->slist_ring_size arrays.
*
* JRM -- 4/29/20
* Reworked macro to support the slist_enabled field
* of H5C_t. If slist_enabled == TRUE, the macro
* functions as before. Otherwise, the macro is a no-op,
* and the slist must be empty.
*
*-------------------------------------------------------------------------
*/
/* NOTE: The H5C__INSERT_ENTRY_IN_SLIST() macro is set up so that
*
* H5C_DO_SANITY_CHECKS
*
* and
*
* H5C_DO_SLIST_SANITY_CHECKS
*
* can be selected independantly. This is easy to miss as the
* two #defines are easy to confuse.
*/
#if H5C_DO_SLIST_SANITY_CHECKS
#define ENTRY_IN_SLIST(cache_ptr, entry_ptr) \
H5C_entry_in_skip_list((cache_ptr), (entry_ptr))
#else /* H5C_DO_SLIST_SANITY_CHECKS */
#define ENTRY_IN_SLIST(cache_ptr, entry_ptr) FALSE
#endif /* H5C_DO_SLIST_SANITY_CHECKS */
#if H5C_DO_SANITY_CHECKS
#define H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, fail_val) \
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( (entry_ptr)->size > 0 ); \
HDassert( H5F_addr_defined((entry_ptr)->addr) ); \
HDassert( !((entry_ptr)->in_slist) ); \
HDassert( !ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
if(H5SL_insert((cache_ptr)->slist_ptr, entry_ptr, &(entry_ptr)->addr) < 0) \
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, (fail_val), "can't insert entry in skip list") \
if ( (cache_ptr)->slist_enabled ) { \
\
(entry_ptr)->in_slist = TRUE; \
(cache_ptr)->slist_changed = TRUE; \
(cache_ptr)->slist_len++; \
(cache_ptr)->slist_size += (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])++; \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (entry_ptr)->size; \
(cache_ptr)->slist_len_increase++; \
(cache_ptr)->slist_size_increase += (int64_t)((entry_ptr)->size); \
HDassert( (entry_ptr) ); \
HDassert( (entry_ptr)->size > 0 ); \
HDassert( H5F_addr_defined((entry_ptr)->addr) ); \
HDassert( !((entry_ptr)->in_slist) ); \
HDassert( ! ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
HDassert( (cache_ptr)->slist_len > 0 ); \
HDassert( (cache_ptr)->slist_size > 0 ); \
if ( H5SL_insert((cache_ptr)->slist_ptr, entry_ptr, \
&((entry_ptr)->addr)) < 0) \
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, (fail_val), \
"can't insert entry in skip list") \
\
(entry_ptr)->in_slist = TRUE; \
(cache_ptr)->slist_changed = TRUE; \
(cache_ptr)->slist_len++; \
(cache_ptr)->slist_size += (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])++; \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (entry_ptr)->size;\
(cache_ptr)->slist_len_increase++; \
(cache_ptr)->slist_size_increase += (int64_t)((entry_ptr)->size); \
\
HDassert( (cache_ptr)->slist_len > 0 ); \
HDassert( (cache_ptr)->slist_size > 0 ); \
\
} else { /* slist disabled */ \
\
HDassert( (cache_ptr)->slist_len == 0 ); \
HDassert( (cache_ptr)->slist_size == 0 ); \
} \
} /* H5C__INSERT_ENTRY_IN_SLIST */
#else /* H5C_DO_SANITY_CHECKS */
@ -1619,31 +1661,42 @@ if ( ( (cache_ptr)->index_size != \
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( (entry_ptr)->size > 0 ); \
HDassert( H5F_addr_defined((entry_ptr)->addr) ); \
HDassert( !((entry_ptr)->in_slist) ); \
HDassert( !ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
if(H5SL_insert((cache_ptr)->slist_ptr, entry_ptr, &(entry_ptr)->addr) < 0) \
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, (fail_val), "can't insert entry in skip list") \
if ( (cache_ptr)->slist_enabled ) { \
\
(entry_ptr)->in_slist = TRUE; \
(cache_ptr)->slist_changed = TRUE; \
(cache_ptr)->slist_len++; \
(cache_ptr)->slist_size += (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])++; \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (entry_ptr)->size; \
HDassert( (entry_ptr) ); \
HDassert( (entry_ptr)->size > 0 ); \
HDassert( ! ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) ); \
HDassert( H5F_addr_defined((entry_ptr)->addr) ); \
HDassert( !((entry_ptr)->in_slist) ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
HDassert( (cache_ptr)->slist_ptr ); \
\
HDassert( (cache_ptr)->slist_len > 0 ); \
HDassert( (cache_ptr)->slist_size > 0 ); \
if ( H5SL_insert((cache_ptr)->slist_ptr, entry_ptr, \
&((entry_ptr)->addr)) < 0) \
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, (fail_val), \
"can't insert entry in skip list") \
\
(entry_ptr)->in_slist = TRUE; \
(cache_ptr)->slist_changed = TRUE; \
(cache_ptr)->slist_len++; \
(cache_ptr)->slist_size += (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])++; \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (entry_ptr)->size;\
\
HDassert( (cache_ptr)->slist_len > 0 ); \
HDassert( (cache_ptr)->slist_size > 0 ); \
\
} else { /* slist disabled */ \
\
HDassert( (cache_ptr)->slist_len == 0 ); \
HDassert( (cache_ptr)->slist_size == 0 ); \
} \
} /* H5C__INSERT_ENTRY_IN_SLIST */
#endif /* H5C_DO_SANITY_CHECKS */
@ -1654,87 +1707,136 @@ if ( ( (cache_ptr)->index_size != \
* Function: H5C__REMOVE_ENTRY_FROM_SLIST
*
* Purpose: Remove the specified instance of H5C_cache_entry_t from the
* index skip list in the specified instance of H5C_t. Update
* the associated length and size fields.
* index skip list in the specified instance of H5C_t. Update
* the associated length and size fields.
*
* Return: N/A
*
* Programmer: John Mainzer, 5/10/04
*
* Modifications:
*
* JRM -- 7/21/04
* Updated function for the addition of the hash table.
*
* JRM - 7/27/04
* Converted from the function H5C_remove_entry_from_tree()
* to the macro H5C__REMOVE_ENTRY_FROM_TREE in the hopes of
* wringing a little more performance out of the cache.
*
* QAK -- 11/27/04
* Switched over to using skip list routines.
*
* JRM -- 3/28/07
* Updated sanity checks for the new is_read_only and
* ro_ref_count fields in H5C_cache_entry_t.
*
* JRM -- 12/13/14
* Added code to set cache_ptr->slist_changed to TRUE
* when an entry is removed from the slist.
*
* JRM -- 4/29/20
* Reworked macro to support the slist_enabled field
* of H5C_t. If slist_enabled == TRUE, the macro
* functions as before. Otherwise, the macro is a no-op,
* and the slist must be empty.
*
*-------------------------------------------------------------------------
*/
#if H5C_DO_SANITY_CHECKS
#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush) \
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (entry_ptr)->size > 0 ); \
HDassert( (entry_ptr)->in_slist ); \
HDassert( (cache_ptr)->slist_ptr ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
if ( H5SL_remove((cache_ptr)->slist_ptr, &(entry_ptr)->addr) \
!= (entry_ptr) ) \
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "can't delete entry from skip list") \
\
HDassert( (cache_ptr)->slist_len > 0 ); \
if(!(during_flush)) \
(cache_ptr)->slist_changed = TRUE; \
(cache_ptr)->slist_len--; \
HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size ); \
(cache_ptr)->slist_size -= (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--; \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >= \
(entry_ptr)->size ); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size; \
(cache_ptr)->slist_len_increase--; \
(cache_ptr)->slist_size_increase -= (int64_t)((entry_ptr)->size); \
(entry_ptr)->in_slist = FALSE; \
#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush) \
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
\
if ( (cache_ptr)->slist_enabled ) { \
\
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (entry_ptr)->size > 0 ); \
HDassert( (entry_ptr)->in_slist ); \
HDassert( (cache_ptr)->slist_ptr ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size ); \
\
if ( H5SL_remove((cache_ptr)->slist_ptr, &(entry_ptr)->addr) \
!= (entry_ptr) ) \
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, \
"can't delete entry from skip list") \
\
HDassert( (cache_ptr)->slist_len > 0 ); \
if(!(during_flush)) \
(cache_ptr)->slist_changed = TRUE; \
(cache_ptr)->slist_len--; \
HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size ); \
(cache_ptr)->slist_size -= (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--; \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >= \
(entry_ptr)->size ); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size;\
(cache_ptr)->slist_len_increase--; \
(cache_ptr)->slist_size_increase -= (int64_t)((entry_ptr)->size); \
(entry_ptr)->in_slist = FALSE; \
\
} else { /* slist disabled */ \
\
HDassert( (cache_ptr)->slist_len == 0 ); \
HDassert( (cache_ptr)->slist_size == 0 ); \
} \
} /* H5C__REMOVE_ENTRY_FROM_SLIST */
#else /* H5C_DO_SANITY_CHECKS */
#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush) \
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (entry_ptr)->in_slist ); \
HDassert( (cache_ptr)->slist_ptr ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
if ( H5SL_remove((cache_ptr)->slist_ptr, &(entry_ptr)->addr) \
!= (entry_ptr) ) \
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "can't delete entry from skip list") \
\
HDassert( (cache_ptr)->slist_len > 0 ); \
if(!(during_flush)) \
(cache_ptr)->slist_changed = TRUE; \
(cache_ptr)->slist_len--; \
HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size ); \
(cache_ptr)->slist_size -= (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--; \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >= \
(entry_ptr)->size ); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size; \
(entry_ptr)->in_slist = FALSE; \
#define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush) \
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
\
if ( (cache_ptr)->slist_enabled ) { \
\
HDassert( (entry_ptr) ); \
HDassert( !((entry_ptr)->is_read_only) ); \
HDassert( ((entry_ptr)->ro_ref_count) == 0 ); \
HDassert( (entry_ptr)->in_slist ); \
HDassert( (cache_ptr)->slist_ptr ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
if ( H5SL_remove((cache_ptr)->slist_ptr, &(entry_ptr)->addr) \
!= (entry_ptr) ) \
HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, \
"can't delete entry from skip list") \
\
HDassert( (cache_ptr)->slist_len > 0 ); \
if(!(during_flush)) \
(cache_ptr)->slist_changed = TRUE; \
(cache_ptr)->slist_len--; \
HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size ); \
(cache_ptr)->slist_size -= (entry_ptr)->size; \
((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--; \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >= \
(entry_ptr)->size ); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size;\
(entry_ptr)->in_slist = FALSE; \
\
} else { /* slist disabled */ \
\
HDassert( (cache_ptr)->slist_len == 0 ); \
HDassert( (cache_ptr)->slist_size == 0 ); \
} \
} /* H5C__REMOVE_ENTRY_FROM_SLIST */
#endif /* H5C_DO_SANITY_CHECKS */
@ -1743,7 +1845,7 @@ if ( ( (cache_ptr)->index_size != \
* Function: H5C__UPDATE_SLIST_FOR_SIZE_CHANGE
*
* Purpose: Update cache_ptr->slist_size for a change in the size of
* and entry in the slist.
* and entry in the slist.
*
* Return: N/A
*
@ -1751,24 +1853,30 @@ if ( ( (cache_ptr)->index_size != \
*
* Modifications:
*
* JRM -- 8/27/06
* Added the H5C_DO_SANITY_CHECKS version of the macro.
* JRM -- 8/27/06
* Added the H5C_DO_SANITY_CHECKS version of the macro.
*
* This version maintains the slist_size_increase field
* that are used in sanity checks in the flush routines.
* This version maintains the slist_size_increase field
* that are used in sanity checks in the flush routines.
*
* All this is needed as the fractal heap needs to be
* able to dirty, resize and/or move entries during the
* flush.
* All this is needed as the fractal heap needs to be
* able to dirty, resize and/or move entries during the
* flush.
*
* JRM -- 12/13/14
* Note that we do not set cache_ptr->slist_changed to TRUE
* in this case, as the structure of the slist is not
* modified.
* JRM -- 12/13/14
* Note that we do not set cache_ptr->slist_changed to TRUE
* in this case, as the structure of the slist is not
* modified.
*
* JRM -- 9/1/15
* Added code to maintain the cache_ptr->slist_ring_len
* and cache_ptr->slist_ring_size arrays.
* JRM -- 9/1/15
* Added code to maintain the cache_ptr->slist_ring_len
* and cache_ptr->slist_ring_size arrays.
*
* JRM -- 4/29/20
* Reworked macro to support the slist_enabled field
* of H5C_t. If slist_enabled == TRUE, the macro
* functions as before. Otherwise, the macro is a no-op,
* and the slist must be empty.
*
*-------------------------------------------------------------------------
*/
@ -1779,32 +1887,43 @@ if ( ( (cache_ptr)->index_size != \
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (old_size) > 0 ); \
HDassert( (new_size) > 0 ); \
HDassert( (old_size) <= (cache_ptr)->slist_size ); \
HDassert( (cache_ptr)->slist_len > 0 ); \
HDassert( ((cache_ptr)->slist_len > 1) || \
( (cache_ptr)->slist_size == (old_size) ) ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
(cache_ptr)->slist_size -= (old_size); \
(cache_ptr)->slist_size += (new_size); \
if ( (cache_ptr)->slist_enabled ) { \
\
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >=(old_size) ); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (new_size); \
HDassert( (old_size) > 0 ); \
HDassert( (new_size) > 0 ); \
HDassert( (old_size) <= (cache_ptr)->slist_size ); \
HDassert( (cache_ptr)->slist_len > 0 ); \
HDassert( ((cache_ptr)->slist_len > 1) || \
( (cache_ptr)->slist_size == (old_size) ) ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
(cache_ptr)->slist_size_increase -= (int64_t)(old_size); \
(cache_ptr)->slist_size_increase += (int64_t)(new_size); \
(cache_ptr)->slist_size -= (old_size); \
(cache_ptr)->slist_size += (new_size); \
\
HDassert( (new_size) <= (cache_ptr)->slist_size ); \
HDassert( ( (cache_ptr)->slist_len > 1 ) || \
( (cache_ptr)->slist_size == (new_size) ) ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] \
>= (old_size) ); \
\
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (new_size); \
\
(cache_ptr)->slist_size_increase -= (int64_t)(old_size); \
(cache_ptr)->slist_size_increase += (int64_t)(new_size); \
\
HDassert( (new_size) <= (cache_ptr)->slist_size ); \
HDassert( ( (cache_ptr)->slist_len > 1 ) || \
( (cache_ptr)->slist_size == (new_size) ) ); \
\
} else { /* slist disabled */ \
\
HDassert( (cache_ptr)->slist_len == 0 ); \
HDassert( (cache_ptr)->slist_size == 0 ); \
} \
} /* H5C__UPDATE_SLIST_FOR_SIZE_CHANGE */
#else /* H5C_DO_SANITY_CHECKS */
@ -1813,29 +1932,39 @@ if ( ( (cache_ptr)->index_size != \
{ \
HDassert( (cache_ptr) ); \
HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC ); \
HDassert( (old_size) > 0 ); \
HDassert( (new_size) > 0 ); \
HDassert( (old_size) <= (cache_ptr)->slist_size ); \
HDassert( (cache_ptr)->slist_len > 0 ); \
HDassert( ((cache_ptr)->slist_len > 1) || \
( (cache_ptr)->slist_size == (old_size) ) ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
(cache_ptr)->slist_size -= (old_size); \
(cache_ptr)->slist_size += (new_size); \
if ( (cache_ptr)->slist_enabled ) { \
\
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >=(old_size) ); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (new_size); \
HDassert( (old_size) > 0 ); \
HDassert( (new_size) > 0 ); \
HDassert( (old_size) <= (cache_ptr)->slist_size ); \
HDassert( (cache_ptr)->slist_len > 0 ); \
HDassert( ((cache_ptr)->slist_len > 1) || \
( (cache_ptr)->slist_size == (old_size) ) ); \
HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED ); \
HDassert( (entry_ptr)->ring < H5C_RING_NTYPES ); \
HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <= \
(cache_ptr)->slist_len ); \
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <= \
(cache_ptr)->slist_size ); \
\
HDassert( (new_size) <= (cache_ptr)->slist_size ); \
HDassert( ( (cache_ptr)->slist_len > 1 ) || \
( (cache_ptr)->slist_size == (new_size) ) ); \
(cache_ptr)->slist_size -= (old_size); \
(cache_ptr)->slist_size += (new_size); \
\
HDassert( (cache_ptr)->slist_ring_size[(entry_ptr->ring)] >= \
(old_size) ); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size); \
((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (new_size); \
\
HDassert( (new_size) <= (cache_ptr)->slist_size ); \
HDassert( ( (cache_ptr)->slist_len > 1 ) || \
( (cache_ptr)->slist_size == (new_size) ) ); \
\
} else { /* slist disabled */ \
\
HDassert( (cache_ptr)->slist_len == 0 ); \
HDassert( (cache_ptr)->slist_size == 0 ); \
} \
} /* H5C__UPDATE_SLIST_FOR_SIZE_CHANGE */
#endif /* H5C_DO_SANITY_CHECKS */
@ -3723,10 +3852,11 @@ typedef struct H5C_tag_info_t {
* one.
*
* entry_watched_for_removal: Pointer to an instance of H5C_cache_entry_t
* which contains the 'next' entry for an iteration. Removing
* which contains the 'next' entry for an iteration. Removing
* this entry must trigger a rescan of the iteration, so each
* entry removed from the cache is compared against this pointer
* and the pointer is reset to NULL if the watched entry is removed.
* and the pointer is reset to NULL if the watched entry is
* removed.
* (This functions similarly to a "dead man's switch")
*
*
@ -3740,6 +3870,36 @@ typedef struct H5C_tag_info_t {
* are flushed. (this has been changed -- dirty entries are now removed from
* the skip list as they are flushed. JRM - 10/25/05)
*
* Update 4/21/20:
*
* Profiling indicates that the cost of maintaining the skip list is
* significant. As it is only used on flush and close, maintaining it
* only when needed is an obvious optimization.
*
* To do this, we add a flag to control maintenanace of the skip list.
* This flag is initially set to FALSE, which disables all operations
* on the skip list.
*
* At the beginning of either flush or close, we scan the index list,
* insert all dirtly entries in the skip list, and enable operations
* on skip list by setting above control flag to true.
*
* At the end of a complete flush, we verify that the skip list is empty,
* and set the control flag back to false, so as to avoid skip list
* maintenance overhead until the next flush or close.
*
* In the case of a partial flush (i.e. flush marked entries), we remove
* all remaining entries from the skip list, and then set the control flag
* back to false -- again avoiding skip list maintenance overhead until
* the next flush or close.
*
* slist_enabled: Boolean flag used to control operation of the skip
* list. If this filed is FALSE, operations on the
* slist are no-ops, and the slist must be empty. If
* it is TRUE, operations on the slist proceed as usual,
* and all dirty entries in the metadata cache must be
* listed in the slist.
*
* slist_changed: Boolean flag used to indicate whether the contents of
* the slist has changed since the last time this flag was
* reset. This is used in the cache flush code to detect
@ -4649,6 +4809,7 @@ typedef struct H5C_tag_info_t {
* NDEBUG is not #defined.
*
****************************************************************************/
struct H5C_t {
uint32_t magic;
hbool_t flush_in_progress;
@ -4664,7 +4825,7 @@ struct H5C_t {
hbool_t evictions_enabled;
hbool_t close_warning_received;
/* Fields for maintaining [hash table] index of entries */
/* Fields for maintaining the [hash table] index of entries */
uint32_t index_len;
size_t index_size;
uint32_t index_ring_len[H5C_RING_NTYPES];
@ -4685,6 +4846,7 @@ struct H5C_t {
H5C_cache_entry_t * entry_watched_for_removal;
/* Fields for maintaining list of in-order entries, for flushing */
hbool_t slist_enabled;
hbool_t slist_changed;
uint32_t slist_len;
size_t slist_size;
@ -4882,7 +5044,8 @@ struct H5C_t {
#ifndef NDEBUG
int64_t get_entry_ptr_from_addr_counter;
#endif /* NDEBUG */
};
}; /* H5C_t */
/* Define typedef for tagged cache entry iteration callbacks */
typedef int (*H5C_tag_iter_cb_t)(H5C_cache_entry_t *entry, void *ctx);

5
src/H5Cprivate.h
View File

@ -2285,7 +2285,10 @@ H5_DLL herr_t H5C_resize_entry(void *thing, size_t new_size);
H5_DLL herr_t H5C_set_cache_auto_resize_config(H5C_t *cache_ptr, H5C_auto_size_ctl_t *config_ptr);
H5_DLL herr_t H5C_set_cache_image_config(const H5F_t *f, H5C_t *cache_ptr,
H5C_cache_image_ctl_t *config_ptr);
H5_DLL herr_t H5C_set_evictions_enabled(H5C_t *cache_ptr, hbool_t evictions_enabled);
H5_DLL herr_t H5C_set_evictions_enabled(H5C_t *cache_ptr,
hbool_t evictions_enabled);
H5_DLL herr_t H5C_set_slist_enabled(H5C_t *cache_ptr, hbool_t slist_enabled,
hbool_t clear_slist);
H5_DLL herr_t H5C_set_prefix(H5C_t *cache_ptr, char *prefix);
H5_DLL herr_t H5C_stats(H5C_t *cache_ptr, const char *cache_name,
hbool_t display_detailed_stats);

10
src/H5Fint.c
View File

@ -2144,6 +2144,11 @@ H5F__flush_phase2(H5F_t *f, hbool_t closing)
/* Sanity check arguments */
HDassert(f);
/* Inform the metadata cache that we are about to flush */
if(H5AC_prep_for_file_flush(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "prep for MDC flush failed")
/* Flush the entire metadata cache */
if(H5AC_flush(f) < 0)
/* Push error, but keep going*/
@ -2176,6 +2181,11 @@ H5F__flush_phase2(H5F_t *f, hbool_t closing)
H5CX_set_mpi_file_flushing(FALSE);
#endif /* H5_HAVE_PARALLEL */
/* Inform the metadata cache that we are done with the flush */
if(H5AC_secure_from_file_flush(f) < 0)
/* Push error, but keep going*/
HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "secure from MDC flush failed")
/* Flush out the metadata accumulator */
if(H5F__accum_flush(f->shared) < 0)
/* Push error, but keep going*/

2089
test/cache.c
View File

File diff suppressed because it is too large Load Diff

171
test/cache_common.c
View File

@ -3111,12 +3111,25 @@ expunge_entry(H5F_t * file_ptr,
* Function: flush_cache()
*
* Purpose: Flush the specified cache, destroying all entries if
requested. If requested, dump stats first.
* requested. If requested, dump stats first.
*
* Return: void
*
* Programmer: John Mainzer
* 6/23/04
* 6/23/04
*
* Changes: Added code to setup and take down the skip list before
* and after calls to H5C_flush_cache(). Do this via calls
* to the H5C_FLUSH_CACHE macro.
*
* This is necessary, as H5C_flush() is called repeatedly
* during file flush. If we setup and took down the
* skip list on H5C_flush_cache(), we would find ourselves
* doing this repeatedly -- which is contrary to the
* objective of the exercise (avoiding as many skip list
* operations as possible).
*
* JRM -- 5/14/20
*
*-------------------------------------------------------------------------
*/
@ -3139,25 +3152,30 @@ flush_cache(H5F_t * file_ptr,
cache_ptr = file_ptr->shared->cache;
if(destroy_entries)
result = H5C_flush_cache(file_ptr, H5C__FLUSH_INVALIDATE_FLAG);
if ( destroy_entries ) {
else
result = H5C_flush_cache(file_ptr, H5C__NO_FLAGS_SET);
H5C_FLUSH_CACHE(file_ptr, H5C__FLUSH_INVALIDATE_FLAG, \
"error in H5C_flush_cache().")
if(dump_stats)
H5C_stats(cache_ptr, "test cache", dump_detailed_stats);
} else {
if(result < 0) {
pass = FALSE;
failure_mssg = "error in H5C_flush_cache().";
H5C_FLUSH_CACHE(file_ptr, H5C__NO_FLAGS_SET, \
"error in H5C_flush_cache().")
}
else if((destroy_entries) && ((cache_ptr->index_len != 0)
|| (cache_ptr->index_size != 0)
|| (cache_ptr->clean_index_size != 0)
|| (cache_ptr->dirty_index_size != 0))) {
if(verbose) {
if ( dump_stats ) {
H5C_stats(cache_ptr, "test cache", dump_detailed_stats);
}
if ( ( pass ) && ( destroy_entries ) &&
( ( cache_ptr->index_len != 0 ) ||
( cache_ptr->index_size != 0 ) ||
( cache_ptr->clean_index_size != 0 ) ||
( cache_ptr->dirty_index_size != 0 ) ) ) {
if ( verbose ) {
HDfprintf(stdout,
"%s: unexpected il/is/cis/dis = %lld/%lld/%lld/%lld.\n",
FUNC,
@ -3961,14 +3979,19 @@ unprotect_entry(H5F_t * file_ptr,
* Function: row_major_scan_forward()
*
* Purpose: Do a sequence of inserts, protects, unprotects, moves,
* destroys while scanning through the set of entries. If
* pass is false on entry, do nothing.
* destroys while scanning through the set of entries. If
* pass is false on entry, do nothing.
*
* Return: void
*
* Programmer: John Mainzer
* 6/12/04
*
* Changes: Updated slist size == dirty index size checks to
* bypass the test if cache_ptr->slist_enabled is FALSE.
*
* JRM -- 5/8/20
*
*-------------------------------------------------------------------------
*/
void
@ -3983,7 +4006,7 @@ row_major_scan_forward(H5F_t * file_ptr,
hbool_t do_moves,
hbool_t move_to_main_addr,
hbool_t do_destroys,
hbool_t do_mult_ro_protects,
hbool_t do_mult_ro_protects,
int dirty_destroys,
int dirty_unprotects)
{
@ -4022,7 +4045,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "1(i, %d, %d) ", type, tmp_idx);
insert_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
tmp_idx--;
@ -4033,7 +4059,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "2(p, %d, %d) ", type, tmp_idx);
protect_entry(file_ptr, type, tmp_idx);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
tmp_idx--;
@ -4044,7 +4073,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "3(u, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
/* (don't decrement tmp_idx) */
@ -4055,7 +4087,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "4(r, %d, %d, %d) ", type, tmp_idx, (int)move_to_main_addr);
move_entry(cache_ptr, type, tmp_idx, move_to_main_addr);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
tmp_idx--;
@ -4066,7 +4101,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "5(p, %d, %d) ", type, tmp_idx);
protect_entry(file_ptr, type, tmp_idx);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
tmp_idx -= 2;
@ -4077,7 +4115,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "6(u, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
if(do_mult_ro_protects) {
@ -4089,7 +4130,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "7(p-ro, %d, %d) ", type, tmp_idx);
protect_entry_ro(file_ptr, type, tmp_idx);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
tmp_idx--;
@ -4100,7 +4144,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "8(p-ro, %d, %d) ", type, tmp_idx);
protect_entry_ro(file_ptr, type, tmp_idx);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
tmp_idx--;
@ -4111,7 +4158,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "9(p-ro, %d, %d) ", type, tmp_idx);
protect_entry_ro(file_ptr, type, tmp_idx);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
/* (don't decrement tmp_idx) */
@ -4122,7 +4172,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "10(u-ro, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
tmp_idx--;
@ -4133,7 +4186,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "11(u-ro, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
tmp_idx--;
@ -4144,7 +4200,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "12(u-ro, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
} /* if ( do_mult_ro_protects ) */
@ -4153,7 +4212,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "13(p, %d, %d) ", type, idx);
protect_entry(file_ptr, type, idx);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
tmp_idx = idx - lag + 2;
@ -4164,7 +4226,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "14(u, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
tmp_idx--;
@ -4175,7 +4240,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "15(p, %d, %d) ", type, tmp_idx);
protect_entry(file_ptr, type, tmp_idx);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
if(do_destroys) {
@ -4187,7 +4255,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "16(u, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
break;
case 1:
@ -4196,14 +4267,20 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "17(u, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, H5C__NO_FLAGS_SET);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
else {
if(verbose)
HDfprintf(stdout, "18(u, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, (dirty_unprotects ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET));
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end else */
break;
@ -4212,7 +4289,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "19(u-del, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, H5C__DELETED_FLAG);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
break;
case 3:
@ -4221,14 +4301,20 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "20(u-del, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, H5C__DELETED_FLAG);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
else {
if(verbose)
HDfprintf(stdout, "21(u-del, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, (dirty_destroys ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET) | H5C__DELETED_FLAG);
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end else */
break;
@ -4245,7 +4331,10 @@ row_major_scan_forward(H5F_t * file_ptr,
HDfprintf(stdout, "22(u, %d, %d) ", type, tmp_idx);
unprotect_entry(file_ptr, type, tmp_idx, (dirty_unprotects ? H5C__DIRTIED_FLAG : H5C__NO_FLAGS_SET));
HDassert(cache_ptr->slist_size == cache_ptr->dirty_index_size);
HDassert( ( ! cache_ptr->slist_enabled ) || \
( cache_ptr->slist_size == \
cache_ptr->dirty_index_size ) );
} /* end if */
} /* end elsef */

59
test/cache_common.h
View File

@ -134,6 +134,65 @@
(NOTIFY_ENTRY_SIZE * NUM_NOTIFY_ENTRIES))
#define ADDR_SPACE_SIZE (haddr_t)(MAX_ADDR - BASE_ADDR)
/***********************************************************************
*
* Macro: H5C_FLUSH_CACHE
*
* Purpose: Wrap a call to H5C_flush_cache() in calls to
* H5C_set_slist_enabled() to setup and take down the slist.
*
* This is necessary, as H5C_flush_cache() needs the
* slist to be active. Further, since it is called
* repeatedly during file flush, it would be inefficient
* for it to setup the slist on entry, and take it down
* on exit.
*
* Note that the slist need not be empty if the flags
* indicate a partial flush (i.e.
* H5C__FLUSH_MARKED_ENTRIES_FLAG). Compute clear_slist
* and pass it into H5C_set_slist_enabled as appropriate.
*
* On error, set pass to FALSE, and set failure_mssg
* to the supplied error message.
*
* Return: N/A
*
* Programmer: John Mainzer
* 5/14/20
*
* Changes: None.
*
***********************************************************************/
#define H5C_FLUSH_CACHE(file, flags, fail_mssg) \
{ \
hbool_t clear_slist; \
herr_t rslt; \
\
clear_slist = ( (flags & H5C__FLUSH_MARKED_ENTRIES_FLAG) != 0 ); \
\
rslt = H5C_set_slist_enabled((file)->shared->cache, TRUE, FALSE); \
\
if ( rslt >= 0 ) { \
\
rslt = H5C_flush_cache((file), (flags)); \
} \
\
if ( rslt >= 0 ) { \
\
rslt = H5C_set_slist_enabled((file)->shared->cache, FALSE, \
clear_slist); \
} \
\
if( rslt < 0 ) { \
\
pass = FALSE; \
failure_mssg = (fail_mssg); \
} \
} /* H5C_FLUSH_CACHE */
#define MAX_PINS 8 /* Maximum number of entries that can be
* directly pinned by a single entry.
*/

13
test/cache_tagging.c
View File

@ -348,11 +348,20 @@ evict_entries(hid_t fid)
/* Mark all entries investigated */
mark_all_entries_investigated(fid);
/* setup the skip list prior to calling H5C_flush_cache() */
if ( H5C_set_slist_enabled(f->shared->cache, TRUE, FALSE) < 0 )
TEST_ERROR;
/* Evict all we can from the cache to examine full tag creation tree */
/* This function will likely return failure since the root group
* is still protected. Thus, don't check its return value. */
/* This function will likely return failure since the root group
* is still protected. Thus, don't check its return value.
*/
H5C_flush_cache(f, H5C__FLUSH_INVALIDATE_FLAG);
/* shutdown the slist -- allow it to be non-empty */
if ( H5C_set_slist_enabled(f->shared->cache, FALSE, TRUE) < 0 )
TEST_ERROR;
return 0;
error:

24
test/ohdr.c
View File

@ -126,8 +126,12 @@ test_cont(char *filename, hid_t fapl)
FAIL_STACK_ERROR
if(1 != H5O_link(&oh_locB, 1))
FAIL_STACK_ERROR
if(H5AC_prep_for_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_secure_from_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5O__expunge_chunks_test(&oh_locA) < 0)
FAIL_STACK_ERROR
@ -1681,8 +1685,12 @@ main(void)
FAIL_STACK_ERROR
if(1 != H5O_link(&oh_loc, 1))
FAIL_STACK_ERROR
if(H5AC_prep_for_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_secure_from_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_expunge_entry(f, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
FAIL_STACK_ERROR
if(NULL == H5O_msg_read(&oh_loc, H5O_MTIME_NEW_ID, &ro))
@ -1698,8 +1706,12 @@ main(void)
time_new = 33333333;
if(H5O_msg_write(&oh_loc, H5O_MTIME_NEW_ID, 0, 0, &time_new) < 0)
FAIL_STACK_ERROR
if(H5AC_prep_for_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_secure_from_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_expunge_entry(f, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
FAIL_STACK_ERROR
if(NULL == H5O_msg_read(&oh_loc, H5O_MTIME_NEW_ID, &ro))
@ -1729,8 +1741,12 @@ main(void)
if(H5O_msg_create(&oh_loc, H5O_MTIME_ID, 0, 0, &time_new) < 0)
FAIL_STACK_ERROR
} /* end for */
if(H5AC_prep_for_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_secure_from_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_expunge_entry(f, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
FAIL_STACK_ERROR
@ -1772,8 +1788,12 @@ main(void)
time_new = (i + 1) * 1000 + 10;
if(H5O_msg_create(&oh_loc, H5O_MTIME_NEW_ID, 0, 0, &time_new) < 0)
FAIL_STACK_ERROR
if(H5AC_prep_for_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_secure_from_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_expunge_entry(f, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
FAIL_STACK_ERROR
} /* end for */
@ -1802,8 +1822,12 @@ main(void)
time_new = 22222222;
if(H5O_msg_create(&oh_loc, H5O_MTIME_NEW_ID, H5O_MSG_FLAG_CONSTANT, 0, &time_new) < 0)
FAIL_STACK_ERROR
if(H5AC_prep_for_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_secure_from_file_flush(f) < 0)
FAIL_STACK_ERROR
if(H5AC_expunge_entry(f, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
FAIL_STACK_ERROR
if(NULL == H5O_msg_read(&oh_loc, H5O_MTIME_NEW_ID, &ro))

8
utils/mirror_vfd/CMakeLists.txt
View File

@ -13,10 +13,10 @@ add_executable (mirror_server ${mirror_server_SOURCES})
target_include_directories (mirror_server PRIVATE "${HDF5_UITLS_DIR};${HDF5_SRC_DIR};${HDF5_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>")
if (NOT BUILD_SHARED_LIBS)
TARGET_C_PROPERTIES (mirror_server STATIC)
target_link_libraries (mirror_server PRIVATE ${HDF5_TOOLS_LIB_TARGET} ${HDF5_LIB_TARGET})
target_link_libraries (mirror_server PRIVATE ${HDF5_LIB_TARGET})
else ()
TARGET_C_PROPERTIES (mirror_server SHARED)
target_link_libraries (mirror_server PRIVATE ${HDF5_TOOLS_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
target_link_libraries (mirror_server PRIVATE ${HDF5_LIBSH_TARGET})
endif ()
set_target_properties (mirror_server PROPERTIES FOLDER utils)
set_global_variable (HDF5_UTILS_TO_EXPORT "${HDF5_UTILS_TO_EXPORT};mirror_server")
@ -31,10 +31,10 @@ add_executable (mirror_server_stop ${mirror_server_stop_SOURCES})
target_include_directories (mirror_server_stop PRIVATE "${HDF5_UITLS_DIR};${HDF5_SRC_DIR};${HDF5_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>")
if (NOT BUILD_SHARED_LIBS)
TARGET_C_PROPERTIES (mirror_server_stop STATIC)
target_link_libraries (mirror_server_stop PRIVATE ${HDF5_TOOLS_LIB_TARGET} ${HDF5_LIB_TARGET})
target_link_libraries (mirror_server_stop PRIVATE ${HDF5_LIB_TARGET})
else ()
TARGET_C_PROPERTIES (mirror_server_stop SHARED)
target_link_libraries (mirror_server_stop PRIVATE ${HDF5_TOOLS_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
target_link_libraries (mirror_server_stop PRIVATE ${HDF5_LIBSH_TARGET})
endif ()
set_target_properties (mirror_server_stop PROPERTIES FOLDER utils)
set_global_variable (HDF5_UTILS_TO_EXPORT "${HDF5_UTILS_TO_EXPORT};mirror_server_stop")