mirror of
https://github.com/HDFGroup/hdf5.git
synced 2025-03-31 17:10:47 +08:00
Switch list lengths to unsigned integers (to align better w/cache image merge)
This commit is contained in:
parent
eb8ada9564
commit
349f41d974
@ -2094,7 +2094,7 @@ done:
|
||||
*/
|
||||
herr_t
|
||||
H5AC_get_cache_size(H5AC_t *cache_ptr, size_t *max_size_ptr, size_t *min_clean_size_ptr,
|
||||
size_t *cur_size_ptr, int32_t *cur_num_entries_ptr)
|
||||
size_t *cur_size_ptr, uint32_t *cur_num_entries_ptr)
|
||||
{
|
||||
herr_t ret_value = SUCCEED; /* Return value */
|
||||
|
||||
|
@ -344,7 +344,6 @@ H5_DLLVAR hid_t H5AC_rawdata_dxpl_id;
|
||||
#define H5AC__TAKE_OWNERSHIP_FLAG H5C__TAKE_OWNERSHIP_FLAG
|
||||
#define H5AC__FLUSH_LAST_FLAG H5C__FLUSH_LAST_FLAG
|
||||
#define H5AC__FLUSH_COLLECTIVELY_FLAG H5C__FLUSH_COLLECTIVELY_FLAG
|
||||
#define H5AC__EVICT_ALLOW_LAST_PINS_FLAG H5C__EVICT_ALLOW_LAST_PINS_FLAG
|
||||
|
||||
|
||||
/* #defines of flags used to report entry status in the
|
||||
@ -394,7 +393,7 @@ H5_DLL herr_t H5AC_remove_entry(void *entry);
|
||||
H5_DLL herr_t H5AC_get_cache_auto_resize_config(const H5AC_t * cache_ptr,
|
||||
H5AC_cache_config_t *config_ptr);
|
||||
H5_DLL herr_t H5AC_get_cache_size(H5AC_t *cache_ptr, size_t *max_size_ptr,
|
||||
size_t *min_clean_size_ptr, size_t *cur_size_ptr, int32_t *cur_num_entries_ptr);
|
||||
size_t *min_clean_size_ptr, size_t *cur_size_ptr, uint32_t *cur_num_entries_ptr);
|
||||
H5_DLL herr_t H5AC_get_cache_hit_rate(H5AC_t *cache_ptr, double *hit_rate_ptr);
|
||||
H5_DLL herr_t H5AC_reset_cache_hit_rate_stats(H5AC_t *cache_ptr);
|
||||
H5_DLL herr_t H5AC_set_cache_auto_resize_config(H5AC_t *cache_ptr,
|
||||
|
185
src/H5C.c
185
src/H5C.c
@ -868,7 +868,7 @@ H5C_expunge_entry(H5F_t *f, hid_t dxpl_id, const H5C_class_t *type,
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if(H5C_validate_lru_list(cache_ptr) < 0)
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "LRU extreme sanity check failed on entry.\n")
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "LRU extreme sanity check failed on entry")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
/* Look for entry in cache */
|
||||
@ -909,7 +909,7 @@ H5C_expunge_entry(H5F_t *f, hid_t dxpl_id, const H5C_class_t *type,
|
||||
done:
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if(H5C_validate_lru_list(cache_ptr) < 0)
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "LRU extreme sanity check failed on exit.\n")
|
||||
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "LRU extreme sanity check failed on exit")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
@ -968,12 +968,12 @@ H5C_flush_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
|
||||
{
|
||||
#if H5C_DO_SANITY_CHECKS
|
||||
int i;
|
||||
int32_t index_len = 0;
|
||||
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;
|
||||
int32_t slist_len = 0;
|
||||
uint32_t slist_len = 0;
|
||||
#endif /* H5C_DO_SANITY_CHECKS */
|
||||
H5C_ring_t ring;
|
||||
H5C_t * cache_ptr;
|
||||
@ -1020,7 +1020,7 @@ H5C_flush_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry.\n")
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
ignore_protected = ( (flags & H5C__FLUSH_IGNORE_PROTECTED_FLAG) != 0 );
|
||||
@ -1173,16 +1173,8 @@ H5C_flush_to_min_clean(H5F_t * f,
|
||||
"cache write is not permitted!?!\n");
|
||||
}
|
||||
#if 1 /* original code */
|
||||
result = H5C_make_space_in_cache(f,
|
||||
dxpl_id,
|
||||
(size_t)0,
|
||||
write_permitted);
|
||||
|
||||
if ( result < 0 ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
|
||||
"H5C_make_space_in_cache failed.")
|
||||
}
|
||||
if(H5C_make_space_in_cache(f, dxpl_id, (size_t)0, write_permitted) < 0)
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C__make_space_in_cache failed")
|
||||
#else /* modified code -- commented out for now */
|
||||
if ( cache_ptr->max_cache_size > cache_ptr->index_size ) {
|
||||
|
||||
@ -1336,8 +1328,9 @@ H5C_insert_entry(H5F_t * f,
|
||||
hbool_t set_flush_marker;
|
||||
hbool_t write_permitted = TRUE;
|
||||
size_t empty_space;
|
||||
H5C_cache_entry_t *entry_ptr;
|
||||
H5C_cache_entry_t *entry_ptr = NULL;
|
||||
H5C_cache_entry_t *test_entry_ptr;
|
||||
hbool_t entry_tagged = FALSE;
|
||||
herr_t ret_value = SUCCEED; /* Return value */
|
||||
|
||||
FUNC_ENTER_NOAPI(FAIL)
|
||||
@ -1357,14 +1350,10 @@ H5C_insert_entry(H5F_t * f,
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
/* no need to verify that entry is not already in the index as */
|
||||
/* we already make that check below. */
|
||||
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
|
||||
"an extreme sanity check failed on entry.\n");
|
||||
}
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
set_flush_marker = ( (flags & H5C__SET_FLUSH_MARKER_FLAG) != 0 );
|
||||
@ -1461,6 +1450,7 @@ H5C_insert_entry(H5F_t * f,
|
||||
/* Apply tag to newly inserted entry */
|
||||
if(H5C__tag_entry(cache_ptr, entry_ptr, dxpl_id) < 0)
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_CANTTAG, FAIL, "Cannot tag metadata entry")
|
||||
entry_tagged = TRUE;
|
||||
|
||||
H5C__RESET_CACHE_ENTRY_STATS(entry_ptr)
|
||||
|
||||
@ -1533,10 +1523,10 @@ H5C_insert_entry(H5F_t * f,
|
||||
H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, FAIL)
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) )
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed just before done.\n")
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed just before done")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
/* If the entry's type has a 'notify' callback send a 'after insertion'
|
||||
@ -1588,16 +1578,15 @@ H5C_insert_entry(H5F_t * f,
|
||||
|
||||
done:
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) )
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit.\n")
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
if(ret_value < 0 && entry_ptr->tag_info) {
|
||||
if(ret_value < 0 && entry_tagged)
|
||||
if(H5C__untag_entry(cache_ptr, entry_ptr) < 0)
|
||||
HDONE_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL, "can't remove entry from tag list")
|
||||
}
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
} /* H5C_insert_entry() */
|
||||
@ -1920,7 +1909,7 @@ H5C_move_entry(H5C_t * cache_ptr,
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry.\n")
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
H5C__SEARCH_INDEX(cache_ptr, old_addr, entry_ptr, FAIL)
|
||||
@ -2024,7 +2013,7 @@ done:
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit.\n")
|
||||
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
@ -2070,12 +2059,9 @@ H5C_resize_entry(void *thing, size_t new_size)
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_BADTYPE, FAIL, "Entry isn't pinned or protected??")
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
|
||||
"an extreme sanity check failed on entry.\n");
|
||||
}
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
/* update for change in entry size if necessary */
|
||||
@ -2172,14 +2158,10 @@ H5C_resize_entry(void *thing, size_t new_size)
|
||||
} /* end if */
|
||||
|
||||
done:
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
|
||||
"an extreme sanity check failed on exit.\n");
|
||||
}
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0))
|
||||
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
@ -2275,13 +2257,10 @@ H5C_pin_protected_entry(void *thing)
|
||||
HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
|
||||
"an extreme sanity check failed on entry.\n");
|
||||
}
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
|
||||
@ -2294,15 +2273,11 @@ H5C_pin_protected_entry(void *thing)
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_CANTPIN, FAIL, "Can't pin entry by client")
|
||||
|
||||
done:
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
|
||||
"an extreme sanity check failed on exit.\n");
|
||||
}
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
@ -2396,12 +2371,10 @@ H5C_protect(H5F_t * f,
|
||||
HDassert( H5F_addr_defined(addr) );
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "an extreme sanity check failed on entry.\n")
|
||||
}
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "an extreme sanity check failed on entry")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
read_only = ( (flags & H5C__READ_ONLY_FLAG) != 0 );
|
||||
@ -2794,10 +2767,10 @@ H5C_protect(H5F_t * f,
|
||||
|
||||
done:
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) )
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "an extreme sanity check failed on exit.\n")
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "an extreme sanity check failed on exit")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
@ -3166,13 +3139,10 @@ H5C_unpin_entry(void *_entry_ptr)
|
||||
HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
|
||||
"an extreme sanity check failed on entry.\n");
|
||||
}
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
|
||||
@ -3181,19 +3151,14 @@ H5C_unpin_entry(void *_entry_ptr)
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPIN, FAIL, "Can't unpin entry from client")
|
||||
|
||||
done:
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
|
||||
"an extreme sanity check failed on exit.\n");
|
||||
}
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
|
||||
} /* H5C_unpin_entry() */
|
||||
|
||||
|
||||
@ -3280,13 +3245,10 @@ H5C_unprotect(H5F_t * f,
|
||||
was_clean = ! ( entry_ptr->is_dirty );
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
|
||||
"an extreme sanity check failed on entry.\n");
|
||||
}
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
/* if the entry has multiple read only protects, just decrement
|
||||
@ -3481,19 +3443,14 @@ H5C_unprotect(H5F_t * f,
|
||||
H5C__UPDATE_STATS_FOR_UNPROTECT(cache_ptr)
|
||||
|
||||
done:
|
||||
|
||||
#if H5C_DO_EXTREME_SANITY_CHECKS
|
||||
if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
|
||||
( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
|
||||
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
|
||||
"an extreme sanity check failed on exit.\n");
|
||||
}
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0)) {
|
||||
HDONE_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on exit")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
|
||||
} /* H5C_unprotect() */
|
||||
|
||||
|
||||
@ -5352,8 +5309,8 @@ H5C_flush_invalidate_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
|
||||
#if H5C_DO_SANITY_CHECKS
|
||||
{
|
||||
int32_t i;
|
||||
int32_t index_len = 0;
|
||||
int32_t slist_len = 0;
|
||||
uint32_t index_len = 0;
|
||||
uint32_t slist_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;
|
||||
@ -5484,7 +5441,7 @@ H5C_flush_invalidate_ring(H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
|
||||
{
|
||||
H5C_t *cache_ptr;
|
||||
hbool_t restart_slist_scan;
|
||||
int32_t protected_entries = 0;
|
||||
uint32_t protected_entries = 0;
|
||||
int32_t i;
|
||||
int32_t cur_ring_pel_len;
|
||||
int32_t old_ring_pel_len;
|
||||
@ -5925,7 +5882,7 @@ H5C_flush_ring(H5F_t *f, hid_t dxpl_id, H5C_ring_t ring, unsigned flags)
|
||||
hbool_t ignore_protected;
|
||||
hbool_t tried_to_flush_protected_entry = FALSE;
|
||||
hbool_t restart_slist_scan;
|
||||
int32_t protected_entries = 0;
|
||||
uint32_t protected_entries = 0;
|
||||
H5SL_node_t * node_ptr = NULL;
|
||||
H5C_cache_entry_t * entry_ptr = NULL;
|
||||
H5C_cache_entry_t * next_entry_ptr = NULL;
|
||||
@ -5949,7 +5906,7 @@ H5C_flush_ring(H5F_t *f, hid_t dxpl_id, H5C_ring_t ring, unsigned flags)
|
||||
if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
|
||||
(H5C_validate_lru_list(cache_ptr) < 0))
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry.\n")
|
||||
HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry")
|
||||
#endif /* H5C_DO_EXTREME_SANITY_CHECKS */
|
||||
|
||||
ignore_protected = ( (flags & H5C__FLUSH_IGNORE_PROTECTED_FLAG) != 0 );
|
||||
@ -7077,8 +7034,8 @@ H5C_make_space_in_cache(H5F_t * f,
|
||||
int32_t clean_entries_skipped = 0;
|
||||
int32_t total_entries_scanned = 0;
|
||||
#endif /* H5C_COLLECT_CACHE_STATS */
|
||||
int32_t entries_examined = 0;
|
||||
int32_t initial_list_len;
|
||||
uint32_t entries_examined = 0;
|
||||
uint32_t initial_list_len;
|
||||
size_t empty_space;
|
||||
hbool_t prev_is_dirty = FALSE;
|
||||
hbool_t didnt_flush_entry = FALSE;
|
||||
@ -7358,9 +7315,7 @@ H5C_make_space_in_cache(H5F_t * f,
|
||||
}
|
||||
|
||||
done:
|
||||
|
||||
FUNC_LEAVE_NOAPI(ret_value)
|
||||
|
||||
} /* H5C_make_space_in_cache() */
|
||||
|
||||
|
||||
|
36
src/H5Cdbg.c
36
src/H5Cdbg.c
@ -490,12 +490,12 @@ H5C_stats(H5C_t * cache_ptr,
|
||||
average_failed_search_depth);
|
||||
|
||||
HDfprintf(stdout,
|
||||
"%s current (max) index size / length = %ld (%ld) / %ld (%ld)\n",
|
||||
"%s current (max) index size / length = %ld (%ld) / %lu (%lu)\n",
|
||||
cache_ptr->prefix,
|
||||
(long)(cache_ptr->index_size),
|
||||
(long)(cache_ptr->max_index_size),
|
||||
(long)(cache_ptr->index_len),
|
||||
(long)(cache_ptr->max_index_len));
|
||||
(unsigned long)(cache_ptr->index_len),
|
||||
(unsigned long)(cache_ptr->max_index_len));
|
||||
|
||||
HDfprintf(stdout,
|
||||
"%s current (max) clean/dirty idx size = %ld (%ld) / %ld (%ld)\n",
|
||||
@ -506,46 +506,46 @@ H5C_stats(H5C_t * cache_ptr,
|
||||
(long)(cache_ptr->max_dirty_index_size));
|
||||
|
||||
HDfprintf(stdout,
|
||||
"%s current (max) slist size / length = %ld (%ld) / %ld (%ld)\n",
|
||||
"%s current (max) slist size / length = %ld (%ld) / %lu (%lu)\n",
|
||||
cache_ptr->prefix,
|
||||
(long)(cache_ptr->slist_size),
|
||||
(long)(cache_ptr->max_slist_size),
|
||||
(long)(cache_ptr->slist_len),
|
||||
(long)(cache_ptr->max_slist_len));
|
||||
(unsigned long)(cache_ptr->slist_len),
|
||||
(unsigned long)(cache_ptr->max_slist_len));
|
||||
|
||||
HDfprintf(stdout,
|
||||
"%s current (max) PL size / length = %ld (%ld) / %ld (%ld)\n",
|
||||
"%s current (max) PL size / length = %ld (%ld) / %lu (%lu)\n",
|
||||
cache_ptr->prefix,
|
||||
(long)(cache_ptr->pl_size),
|
||||
(long)(cache_ptr->max_pl_size),
|
||||
(long)(cache_ptr->pl_len),
|
||||
(long)(cache_ptr->max_pl_len));
|
||||
(unsigned long)(cache_ptr->pl_len),
|
||||
(unsigned long)(cache_ptr->max_pl_len));
|
||||
|
||||
HDfprintf(stdout,
|
||||
"%s current (max) PEL size / length = %ld (%ld) / %ld (%ld)\n",
|
||||
"%s current (max) PEL size / length = %ld (%ld) / %lu (%lu)\n",
|
||||
cache_ptr->prefix,
|
||||
(long)(cache_ptr->pel_size),
|
||||
(long)(cache_ptr->max_pel_size),
|
||||
(long)(cache_ptr->pel_len),
|
||||
(long)(cache_ptr->max_pel_len));
|
||||
(unsigned long)(cache_ptr->pel_len),
|
||||
(unsigned long)(cache_ptr->max_pel_len));
|
||||
|
||||
HDfprintf(stdout,
|
||||
"%s current LRU list size / length = %ld / %ld\n",
|
||||
"%s current LRU list size / length = %ld / %lu\n",
|
||||
cache_ptr->prefix,
|
||||
(long)(cache_ptr->LRU_list_size),
|
||||
(long)(cache_ptr->LRU_list_len));
|
||||
(unsigned long)(cache_ptr->LRU_list_len));
|
||||
|
||||
HDfprintf(stdout,
|
||||
"%s current clean LRU size / length = %ld / %ld\n",
|
||||
"%s current clean LRU size / length = %ld / %lu\n",
|
||||
cache_ptr->prefix,
|
||||
(long)(cache_ptr->cLRU_list_size),
|
||||
(long)(cache_ptr->cLRU_list_len));
|
||||
(unsigned long)(cache_ptr->cLRU_list_len));
|
||||
|
||||
HDfprintf(stdout,
|
||||
"%s current dirty LRU size / length = %ld / %ld\n",
|
||||
"%s current dirty LRU size / length = %ld / %lu\n",
|
||||
cache_ptr->prefix,
|
||||
(long)(cache_ptr->dLRU_list_size),
|
||||
(long)(cache_ptr->dLRU_list_len));
|
||||
(unsigned long)(cache_ptr->dLRU_list_len));
|
||||
|
||||
HDfprintf(stdout,
|
||||
"%s Total hits / misses / hit_rate = %ld / %ld / %f\n",
|
||||
|
37
src/H5Cpkg.h
37
src/H5Cpkg.h
@ -209,7 +209,6 @@ if ( ( (entry_ptr) == NULL ) || \
|
||||
( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
|
||||
( (head_ptr) != (tail_ptr) ) \
|
||||
) || \
|
||||
( (len) < 0 ) || \
|
||||
( ( (len) == 1 ) && \
|
||||
( ( (head_ptr) != (tail_ptr) ) || \
|
||||
( (head_ptr) == NULL ) || ( (head_ptr)->size != (Size) ) \
|
||||
@ -494,7 +493,6 @@ if ( ( (entry_ptr) == NULL ) || \
|
||||
( ( ( (hd_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
|
||||
( (hd_ptr) != (tail_ptr) ) \
|
||||
) || \
|
||||
( (len) < 0 ) || \
|
||||
( ( (len) == 1 ) && \
|
||||
( ( (hd_ptr) != (tail_ptr) ) || ( (Size) <= 0 ) || \
|
||||
( (hd_ptr) == NULL ) || ( (hd_ptr)->size != (Size) ) \
|
||||
@ -514,7 +512,6 @@ if ( ( (entry_ptr) == NULL ) || \
|
||||
if ( ( ( ( (head_ptr) == NULL ) || ( (tail_ptr) == NULL ) ) && \
|
||||
( (head_ptr) != (tail_ptr) ) \
|
||||
) || \
|
||||
( (len) < 0 ) || \
|
||||
( ( (len) == 1 ) && \
|
||||
( ( (head_ptr) != (tail_ptr) ) || \
|
||||
( (head_ptr) == NULL ) || ( (head_ptr)->size != (Size) ) \
|
||||
@ -2500,7 +2497,6 @@ if ( ( (cache_ptr)->index_size != \
|
||||
(cache_ptr)->pel_tail_ptr, \
|
||||
(cache_ptr)->pel_len, \
|
||||
(cache_ptr)->pel_size, (fail_val)) \
|
||||
HDassert( (cache_ptr)->pel_len >= 0 ); \
|
||||
\
|
||||
} else { \
|
||||
\
|
||||
@ -2901,7 +2897,6 @@ if ( ( (cache_ptr)->index_size != \
|
||||
H5C__DLL_REMOVE((entry_ptr), (cache_ptr)->pel_head_ptr, \
|
||||
(cache_ptr)->pel_tail_ptr, (cache_ptr)->pel_len, \
|
||||
(cache_ptr)->pel_size, (fail_val)) \
|
||||
HDassert( (cache_ptr)->pel_len >= 0 ); \
|
||||
\
|
||||
/* modified LRU specific code */ \
|
||||
\
|
||||
@ -4392,16 +4387,16 @@ struct H5C_t {
|
||||
hbool_t close_warning_received;
|
||||
|
||||
/* Fields for maintaining [hash table] index of entries */
|
||||
int32_t index_len;
|
||||
uint32_t index_len;
|
||||
size_t index_size;
|
||||
int32_t index_ring_len[H5C_RING_NTYPES];
|
||||
uint32_t index_ring_len[H5C_RING_NTYPES];
|
||||
size_t index_ring_size[H5C_RING_NTYPES];
|
||||
size_t clean_index_size;
|
||||
size_t clean_index_ring_size[H5C_RING_NTYPES];
|
||||
size_t dirty_index_size;
|
||||
size_t dirty_index_ring_size[H5C_RING_NTYPES];
|
||||
H5C_cache_entry_t * index[H5C__HASH_TABLE_LEN];
|
||||
int32_t il_len;
|
||||
uint32_t il_len;
|
||||
size_t il_size;
|
||||
H5C_cache_entry_t * il_head;
|
||||
H5C_cache_entry_t * il_tail;
|
||||
@ -4413,12 +4408,12 @@ struct H5C_t {
|
||||
|
||||
/* Fields for maintaining list of in-order entries, for flushing */
|
||||
hbool_t slist_changed;
|
||||
int32_t slist_len;
|
||||
uint32_t slist_len;
|
||||
size_t slist_size;
|
||||
int32_t slist_ring_len[H5C_RING_NTYPES];
|
||||
uint32_t slist_ring_len[H5C_RING_NTYPES];
|
||||
size_t slist_ring_size[H5C_RING_NTYPES];
|
||||
H5SL_t * slist_ptr;
|
||||
int32_t num_last_entries;
|
||||
uint32_t num_last_entries;
|
||||
#if H5C_DO_SANITY_CHECKS
|
||||
int64_t slist_len_increase;
|
||||
int64_t slist_size_increase;
|
||||
@ -4429,38 +4424,38 @@ struct H5C_t {
|
||||
hbool_t ignore_tags;
|
||||
|
||||
/* Fields for tracking protected entries */
|
||||
int32_t pl_len;
|
||||
uint32_t pl_len;
|
||||
size_t pl_size;
|
||||
H5C_cache_entry_t * pl_head_ptr;
|
||||
H5C_cache_entry_t * pl_tail_ptr;
|
||||
|
||||
/* Fields for tracking pinned entries */
|
||||
int32_t pel_len;
|
||||
uint32_t pel_len;
|
||||
size_t pel_size;
|
||||
H5C_cache_entry_t * pel_head_ptr;
|
||||
H5C_cache_entry_t * pel_tail_ptr;
|
||||
|
||||
/* Fields for complete LRU list of entries */
|
||||
int32_t LRU_list_len;
|
||||
uint32_t LRU_list_len;
|
||||
size_t LRU_list_size;
|
||||
H5C_cache_entry_t * LRU_head_ptr;
|
||||
H5C_cache_entry_t * LRU_tail_ptr;
|
||||
|
||||
/* Fields for clean LRU list of entries */
|
||||
int32_t cLRU_list_len;
|
||||
uint32_t cLRU_list_len;
|
||||
size_t cLRU_list_size;
|
||||
H5C_cache_entry_t * cLRU_head_ptr;
|
||||
H5C_cache_entry_t * cLRU_tail_ptr;
|
||||
|
||||
/* Fields for dirty LRU list of entries */
|
||||
int32_t dLRU_list_len;
|
||||
uint32_t dLRU_list_len;
|
||||
size_t dLRU_list_size;
|
||||
H5C_cache_entry_t * dLRU_head_ptr;
|
||||
H5C_cache_entry_t * dLRU_tail_ptr;
|
||||
|
||||
#ifdef H5_HAVE_PARALLEL
|
||||
/* Fields for collective metadata reads */
|
||||
int32_t coll_list_len;
|
||||
uint32_t coll_list_len;
|
||||
size_t coll_list_size;
|
||||
H5C_cache_entry_t * coll_head_ptr;
|
||||
H5C_cache_entry_t * coll_tail_ptr;
|
||||
@ -4532,21 +4527,21 @@ struct H5C_t {
|
||||
int64_t total_successful_ht_search_depth;
|
||||
int64_t failed_ht_searches;
|
||||
int64_t total_failed_ht_search_depth;
|
||||
int32_t max_index_len;
|
||||
uint32_t max_index_len;
|
||||
size_t max_index_size;
|
||||
size_t max_clean_index_size;
|
||||
size_t max_dirty_index_size;
|
||||
|
||||
/* Fields for in-order skip list */
|
||||
int32_t max_slist_len;
|
||||
uint32_t max_slist_len;
|
||||
size_t max_slist_size;
|
||||
|
||||
/* Fields for protected entry list */
|
||||
int32_t max_pl_len;
|
||||
uint32_t max_pl_len;
|
||||
size_t max_pl_size;
|
||||
|
||||
/* Fields for pinned entry list */
|
||||
int32_t max_pel_len;
|
||||
uint32_t max_pel_len;
|
||||
size_t max_pel_size;
|
||||
|
||||
/* Fields for tracking 'make space in cache' (msic) operations */
|
||||
|
@ -1772,7 +1772,7 @@ H5_DLL herr_t H5C_get_cache_auto_resize_config(const H5C_t *cache_ptr,
|
||||
H5C_auto_size_ctl_t *config_ptr);
|
||||
H5_DLL herr_t H5C_get_cache_size(H5C_t *cache_ptr, size_t *max_size_ptr,
|
||||
size_t *min_clean_size_ptr, size_t *cur_size_ptr,
|
||||
int32_t *cur_num_entries_ptr);
|
||||
uint32_t *cur_num_entries_ptr);
|
||||
H5_DLL herr_t H5C_get_cache_hit_rate(H5C_t *cache_ptr, double *hit_rate_ptr);
|
||||
H5_DLL herr_t H5C_get_entry_status(const H5F_t *f, haddr_t addr,
|
||||
size_t *size_ptr, hbool_t *in_cache_ptr, hbool_t *is_dirty_ptr,
|
||||
|
@ -131,7 +131,7 @@ H5C_get_cache_size(H5C_t * cache_ptr,
|
||||
size_t * max_size_ptr,
|
||||
size_t * min_clean_size_ptr,
|
||||
size_t * cur_size_ptr,
|
||||
int32_t * cur_num_entries_ptr)
|
||||
uint32_t * cur_num_entries_ptr)
|
||||
{
|
||||
herr_t ret_value = SUCCEED; /* Return value */
|
||||
|
||||
|
@ -1177,7 +1177,7 @@ H5Fget_mdc_size(hid_t file_id, size_t *max_size_ptr, size_t *min_clean_size_ptr,
|
||||
size_t *cur_size_ptr, int *cur_num_entries_ptr)
|
||||
{
|
||||
H5F_t *file; /* File object for file ID */
|
||||
int32_t cur_num_entries;
|
||||
uint32_t cur_num_entries;
|
||||
herr_t ret_value = SUCCEED; /* Return value */
|
||||
|
||||
FUNC_ENTER_API(FAIL)
|
||||
|
@ -302,7 +302,7 @@ H5F__evict_cache_entries(H5F_t *f, hid_t dxpl_id)
|
||||
#ifndef NDEBUG
|
||||
{
|
||||
unsigned status = 0;
|
||||
int32_t cur_num_entries;
|
||||
uint32_t cur_num_entries;
|
||||
|
||||
/* Retrieve status of the superblock */
|
||||
if(H5AC_get_entry_status(f, (haddr_t)0, &status) < 0)
|
||||
|
308
test/cache.c
308
test/cache.c
@ -118,12 +118,12 @@ static void check_flush_cache__multi_entry(H5F_t * file_ptr);
|
||||
static void check_flush_cache__multi_entry_test(H5F_t * file_ptr,
|
||||
int test_num,
|
||||
unsigned int flush_flags,
|
||||
int spec_size,
|
||||
unsigned int spec_size,
|
||||
struct flush_cache_test_spec spec[]);
|
||||
static void check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
|
||||
int test_num,
|
||||
unsigned int flush_flags,
|
||||
int spec_size,
|
||||
unsigned int spec_size,
|
||||
struct pe_flush_cache_test_spec spec[]);
|
||||
static void check_flush_cache__single_entry(H5F_t * file_ptr);
|
||||
static void check_flush_cache__single_entry_test(H5F_t * file_ptr,
|
||||
@ -155,9 +155,9 @@ static void check_flush_cache__flush_op_test(H5F_t * file_ptr,
|
||||
unsigned int flush_flags,
|
||||
int spec_size,
|
||||
const struct fo_flush_cache_test_spec spec[],
|
||||
int init_expected_index_len,
|
||||
unsigned init_expected_index_len,
|
||||
size_t init_expected_index_size,
|
||||
int expected_index_len,
|
||||
unsigned expected_index_len,
|
||||
size_t expected_index_size,
|
||||
int check_size,
|
||||
struct fo_flush_entry_check check[]);
|
||||
@ -3312,7 +3312,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
{
|
||||
int test_num = 1;
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -3406,7 +3406,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
{
|
||||
int test_num = 2;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -3500,7 +3500,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
{
|
||||
int test_num = 3;
|
||||
unsigned int flush_flags = H5C__FLUSH_CLEAR_ONLY_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -3594,7 +3594,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
{
|
||||
int test_num = 4;
|
||||
unsigned int flush_flags = H5C__FLUSH_MARKED_ENTRIES_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -3689,7 +3689,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
int test_num = 5;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
|
||||
H5C__FLUSH_CLEAR_ONLY_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -3784,7 +3784,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
int test_num = 6;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
|
||||
H5C__FLUSH_MARKED_ENTRIES_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -3879,7 +3879,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
int test_num = 7;
|
||||
unsigned int flush_flags = H5C__FLUSH_CLEAR_ONLY_FLAG |
|
||||
H5C__FLUSH_MARKED_ENTRIES_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -3975,7 +3975,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
|
||||
H5C__FLUSH_CLEAR_ONLY_FLAG |
|
||||
H5C__FLUSH_MARKED_ENTRIES_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -4073,7 +4073,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
~(H5C__FLUSH_INVALIDATE_FLAG |
|
||||
H5C__FLUSH_CLEAR_ONLY_FLAG |
|
||||
H5C__FLUSH_MARKED_ENTRIES_FLAG);
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -4172,7 +4172,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
{
|
||||
int test_num = 1;
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct pe_flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -4318,7 +4318,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
{
|
||||
int test_num = 2;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct pe_flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -4448,7 +4448,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
int test_num = 3;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
|
||||
H5C__FLUSH_CLEAR_ONLY_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct pe_flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -4570,7 +4570,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
int test_num = 4;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
|
||||
H5C__FLUSH_MARKED_ENTRIES_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct pe_flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -4701,7 +4701,7 @@ check_flush_cache__multi_entry(H5F_t * file_ptr)
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG |
|
||||
H5C__FLUSH_CLEAR_ONLY_FLAG |
|
||||
H5C__FLUSH_MARKED_ENTRIES_FLAG;
|
||||
int spec_size = 8;
|
||||
unsigned int spec_size = 8;
|
||||
struct pe_flush_cache_test_spec spec[8] =
|
||||
{
|
||||
{
|
||||
@ -4845,13 +4845,13 @@ static void
|
||||
check_flush_cache__multi_entry_test(H5F_t * file_ptr,
|
||||
int test_num,
|
||||
unsigned int flush_flags,
|
||||
int spec_size,
|
||||
unsigned int spec_size,
|
||||
struct flush_cache_test_spec spec[])
|
||||
{
|
||||
H5C_t * cache_ptr = file_ptr->shared->cache;
|
||||
static char msg[128];
|
||||
herr_t result;
|
||||
int i;
|
||||
unsigned u;
|
||||
size_t total_entry_size = 0;
|
||||
test_entry_t * base_addr;
|
||||
test_entry_t * entry_ptr;
|
||||
@ -4890,43 +4890,43 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
|
||||
failure_mssg = msg;
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while(pass && (i < spec_size))
|
||||
u = 0;
|
||||
while(pass && (u < spec_size))
|
||||
{
|
||||
if((spec[i].entry_num != i) ||
|
||||
(spec[i].entry_type < 0) ||
|
||||
(spec[i].entry_type >= NUMBER_OF_ENTRY_TYPES) ||
|
||||
(spec[i].entry_index < 0) ||
|
||||
(spec[i].entry_index > max_indices[spec[i].entry_type])) {
|
||||
if(((unsigned)spec[u].entry_num != u) ||
|
||||
(spec[u].entry_type < 0) ||
|
||||
(spec[u].entry_type >= NUMBER_OF_ENTRY_TYPES) ||
|
||||
(spec[u].entry_index < 0) ||
|
||||
(spec[u].entry_index > max_indices[spec[u].entry_type])) {
|
||||
|
||||
pass = FALSE;
|
||||
HDsnprintf(msg, (size_t)128,
|
||||
"bad data in spec[%d] on entry to multi entry test #%d.",
|
||||
i, test_num);
|
||||
"bad data in spec[%u] on entry to multi entry test #%d.",
|
||||
u, test_num);
|
||||
failure_mssg = msg;
|
||||
}
|
||||
i++;
|
||||
u++;
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while(pass && (i < spec_size))
|
||||
u = 0;
|
||||
while(pass && (u < spec_size))
|
||||
{
|
||||
if(spec[i].insert_flag) {
|
||||
if(spec[u].insert_flag) {
|
||||
|
||||
insert_entry(file_ptr, spec[i].entry_type, spec[i].entry_index,
|
||||
spec[i].flags);
|
||||
insert_entry(file_ptr, spec[u].entry_type, spec[u].entry_index,
|
||||
spec[u].flags);
|
||||
|
||||
} else {
|
||||
|
||||
protect_entry(file_ptr, spec[i].entry_type, spec[i].entry_index);
|
||||
protect_entry(file_ptr, spec[u].entry_type, spec[u].entry_index);
|
||||
|
||||
unprotect_entry(file_ptr, spec[i].entry_type, spec[i].entry_index,
|
||||
spec[i].flags);
|
||||
unprotect_entry(file_ptr, spec[u].entry_type, spec[u].entry_index,
|
||||
spec[u].flags);
|
||||
}
|
||||
|
||||
total_entry_size += entry_sizes[spec[i].entry_type];
|
||||
total_entry_size += entry_sizes[spec[u].entry_type];
|
||||
|
||||
i++;
|
||||
u++;
|
||||
}
|
||||
|
||||
if(pass) {
|
||||
@ -4943,36 +4943,36 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
|
||||
}
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while(pass && (i < spec_size))
|
||||
u = 0;
|
||||
while(pass && (u < spec_size))
|
||||
{
|
||||
base_addr = entries[spec[i].entry_type];
|
||||
entry_ptr = &(base_addr[spec[i].entry_index]);
|
||||
base_addr = entries[spec[u].entry_type];
|
||||
entry_ptr = &(base_addr[spec[u].entry_index]);
|
||||
|
||||
if((entry_ptr->deserialized != spec[i].expected_deserialized) ||
|
||||
(entry_ptr->serialized != spec[i].expected_serialized) ||
|
||||
(entry_ptr->destroyed != spec[i].expected_destroyed)) {
|
||||
if((entry_ptr->deserialized != spec[u].expected_deserialized) ||
|
||||
(entry_ptr->serialized != spec[u].expected_serialized) ||
|
||||
(entry_ptr->destroyed != spec[u].expected_destroyed)) {
|
||||
|
||||
#if 0 /* This is useful debugging code. Lets keep it around. */
|
||||
|
||||
HDfprintf(stdout,
|
||||
"deslzd = %d(%d), slzd = %d(%d), dest = %d(%d)\n",
|
||||
(int)(entry_ptr->deserialized),
|
||||
(int)(spec[i].expected_deserialized),
|
||||
(int)(spec[u].expected_deserialized),
|
||||
(int)(entry_ptr->serialized),
|
||||
(int)(spec[i].expected_serialized),
|
||||
(int)(spec[u].expected_serialized),
|
||||
(int)(entry_ptr->destroyed),
|
||||
(int)(spec[i].expected_destroyed));
|
||||
(int)(spec[u].expected_destroyed));
|
||||
|
||||
#endif
|
||||
|
||||
pass = FALSE;
|
||||
HDsnprintf(msg, (size_t)128,
|
||||
"Bad status on entry %d after flush in multi entry test #%d.",
|
||||
i, test_num);
|
||||
"Bad status on entry %u after flush in multi entry test #%d.",
|
||||
u, test_num);
|
||||
failure_mssg = msg;
|
||||
}
|
||||
i++;
|
||||
u++;
|
||||
}
|
||||
|
||||
if(pass) {
|
||||
@ -5027,17 +5027,17 @@ check_flush_cache__multi_entry_test(H5F_t * file_ptr,
|
||||
}
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while(pass && (i < spec_size))
|
||||
u = 0;
|
||||
while(pass && (u < spec_size))
|
||||
{
|
||||
base_addr = entries[spec[i].entry_type];
|
||||
entry_ptr = &(base_addr[spec[i].entry_index]);
|
||||
base_addr = entries[spec[u].entry_type];
|
||||
entry_ptr = &(base_addr[spec[u].entry_index]);
|
||||
|
||||
entry_ptr->deserialized = FALSE;
|
||||
entry_ptr->serialized = FALSE;
|
||||
entry_ptr->destroyed = FALSE;
|
||||
|
||||
i++;
|
||||
u++;
|
||||
}
|
||||
|
||||
return;
|
||||
@ -5064,13 +5064,13 @@ static void
|
||||
check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
|
||||
int test_num,
|
||||
unsigned int flush_flags,
|
||||
int spec_size,
|
||||
unsigned int spec_size,
|
||||
struct pe_flush_cache_test_spec spec[])
|
||||
{
|
||||
H5C_t *cache_ptr = file_ptr->shared->cache;
|
||||
static char msg[128];
|
||||
herr_t result;
|
||||
int i;
|
||||
unsigned u;
|
||||
int j;
|
||||
size_t total_entry_size = 0;
|
||||
test_entry_t * base_addr;
|
||||
@ -5110,54 +5110,54 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
|
||||
failure_mssg = msg;
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while(pass && (i < spec_size))
|
||||
u = 0;
|
||||
while(pass && (u < spec_size))
|
||||
{
|
||||
if((spec[i].entry_num != i) ||
|
||||
(spec[i].entry_type < 0) ||
|
||||
(spec[i].entry_type >= NUMBER_OF_ENTRY_TYPES) ||
|
||||
(spec[i].entry_index < 0) ||
|
||||
(spec[i].entry_index > max_indices[spec[i].entry_type]) ||
|
||||
(spec[i].num_pins < 0) ||
|
||||
(spec[i].num_pins > MAX_PINS)) {
|
||||
if(((unsigned)spec[u].entry_num != u) ||
|
||||
(spec[u].entry_type < 0) ||
|
||||
(spec[u].entry_type >= NUMBER_OF_ENTRY_TYPES) ||
|
||||
(spec[u].entry_index < 0) ||
|
||||
(spec[u].entry_index > max_indices[spec[u].entry_type]) ||
|
||||
(spec[u].num_pins < 0) ||
|
||||
(spec[u].num_pins > MAX_PINS)) {
|
||||
|
||||
pass = FALSE;
|
||||
HDsnprintf(msg, (size_t)128,
|
||||
"bad data in spec[%d] on entry to pe multi entry test #%d.",
|
||||
i, test_num);
|
||||
"bad data in spec[%u] on entry to pe multi entry test #%d.",
|
||||
u, test_num);
|
||||
failure_mssg = msg;
|
||||
}
|
||||
i++;
|
||||
u++;
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while(pass && (i < spec_size))
|
||||
u = 0;
|
||||
while(pass && (u < spec_size))
|
||||
{
|
||||
if(spec[i].insert_flag) {
|
||||
if(spec[u].insert_flag) {
|
||||
|
||||
insert_entry(file_ptr, spec[i].entry_type, spec[i].entry_index,
|
||||
spec[i].flags);
|
||||
insert_entry(file_ptr, spec[u].entry_type, spec[u].entry_index,
|
||||
spec[u].flags);
|
||||
|
||||
} else {
|
||||
|
||||
protect_entry(file_ptr, spec[i].entry_type, spec[i].entry_index);
|
||||
protect_entry(file_ptr, spec[u].entry_type, spec[u].entry_index);
|
||||
|
||||
unprotect_entry(file_ptr, spec[i].entry_type, spec[i].entry_index,
|
||||
spec[i].flags);
|
||||
unprotect_entry(file_ptr, spec[u].entry_type, spec[u].entry_index,
|
||||
spec[u].flags);
|
||||
}
|
||||
|
||||
total_entry_size += entry_sizes[spec[i].entry_type];
|
||||
total_entry_size += entry_sizes[spec[u].entry_type];
|
||||
|
||||
for (j = 0; j < spec[i].num_pins; j++)
|
||||
for (j = 0; j < spec[u].num_pins; j++)
|
||||
{
|
||||
create_pinned_entry_dependency(file_ptr,
|
||||
spec[i].entry_type,
|
||||
spec[i].entry_index,
|
||||
spec[i].pin_type[j],
|
||||
spec[i].pin_idx[j]);
|
||||
spec[u].entry_type,
|
||||
spec[u].entry_index,
|
||||
spec[u].pin_type[j],
|
||||
spec[u].pin_idx[j]);
|
||||
}
|
||||
|
||||
i++;
|
||||
u++;
|
||||
}
|
||||
|
||||
if(pass) {
|
||||
@ -5174,36 +5174,36 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
|
||||
}
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while(pass && (i < spec_size))
|
||||
u = 0;
|
||||
while(pass && (u < spec_size))
|
||||
{
|
||||
base_addr = entries[spec[i].entry_type];
|
||||
entry_ptr = &(base_addr[spec[i].entry_index]);
|
||||
base_addr = entries[spec[u].entry_type];
|
||||
entry_ptr = &(base_addr[spec[u].entry_index]);
|
||||
|
||||
if((entry_ptr->deserialized != spec[i].expected_deserialized) ||
|
||||
(entry_ptr->serialized != spec[i].expected_serialized) ||
|
||||
(entry_ptr->destroyed != spec[i].expected_destroyed)) {
|
||||
if((entry_ptr->deserialized != spec[u].expected_deserialized) ||
|
||||
(entry_ptr->serialized != spec[u].expected_serialized) ||
|
||||
(entry_ptr->destroyed != spec[u].expected_destroyed)) {
|
||||
|
||||
#if 0 /* This is useful debugging code. Lets keep it around. */
|
||||
|
||||
HDfprintf(stdout,
|
||||
"desrlzd = %d(%d), srlzd = %d(%d), dest = %d(%d)\n",
|
||||
(int)(entry_ptr->deserialized),
|
||||
(int)(spec[i].expected_deserialized),
|
||||
(int)(spec[u].expected_deserialized),
|
||||
(int)(entry_ptr->serialized),
|
||||
(int)(spec[i].expected_serialized),
|
||||
(int)(spec[u].expected_serialized),
|
||||
(int)(entry_ptr->destroyed),
|
||||
(int)(spec[i].expected_destroyed));
|
||||
(int)(spec[u].expected_destroyed));
|
||||
|
||||
#endif
|
||||
|
||||
pass = FALSE;
|
||||
HDsnprintf(msg, (size_t)128,
|
||||
"Bad status on entry %d after flush in pe multi entry test #%d.",
|
||||
i, test_num);
|
||||
"Bad status on entry %u after flush in pe multi entry test #%d.",
|
||||
u, test_num);
|
||||
failure_mssg = msg;
|
||||
}
|
||||
i++;
|
||||
u++;
|
||||
}
|
||||
|
||||
if(pass) {
|
||||
@ -5258,17 +5258,17 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
|
||||
}
|
||||
}
|
||||
|
||||
i = 0;
|
||||
while(pass && (i < spec_size))
|
||||
u = 0;
|
||||
while(pass && (u < spec_size))
|
||||
{
|
||||
base_addr = entries[spec[i].entry_type];
|
||||
entry_ptr = &(base_addr[spec[i].entry_index]);
|
||||
base_addr = entries[spec[u].entry_type];
|
||||
entry_ptr = &(base_addr[spec[u].entry_index]);
|
||||
|
||||
entry_ptr->deserialized = FALSE;
|
||||
entry_ptr->serialized = FALSE;
|
||||
entry_ptr->destroyed = FALSE;
|
||||
|
||||
i++;
|
||||
u++;
|
||||
}
|
||||
|
||||
return;
|
||||
@ -5323,9 +5323,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 1;
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 2;
|
||||
int init_expected_index_len = 2;
|
||||
unsigned init_expected_index_len = 2;
|
||||
size_t init_expected_index_size = 2 * PICO_ENTRY_SIZE;
|
||||
int expected_index_len = 2;
|
||||
unsigned expected_index_len = 2;
|
||||
size_t expected_index_size = 2 * PICO_ENTRY_SIZE;
|
||||
struct fo_flush_cache_test_spec spec[2] =
|
||||
{
|
||||
@ -5430,9 +5430,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 2;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
|
||||
int spec_size = 2;
|
||||
int init_expected_index_len = 2;
|
||||
unsigned init_expected_index_len = 2;
|
||||
size_t init_expected_index_size = 2 * PICO_ENTRY_SIZE;
|
||||
int expected_index_len = 0;
|
||||
unsigned expected_index_len = 0;
|
||||
size_t expected_index_size = 0;
|
||||
struct fo_flush_cache_test_spec spec[2] =
|
||||
{
|
||||
@ -5534,9 +5534,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 3;
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 4;
|
||||
int expected_index_len = 1;
|
||||
unsigned expected_index_len = 1;
|
||||
size_t expected_index_size = VARIABLE_ENTRY_SIZE / 2;
|
||||
struct fo_flush_cache_test_spec spec[1] =
|
||||
{
|
||||
@ -5612,9 +5612,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 4;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 4;
|
||||
int expected_index_len = 0;
|
||||
unsigned expected_index_len = 0;
|
||||
size_t expected_index_size = 0;
|
||||
struct fo_flush_cache_test_spec spec[1] =
|
||||
{
|
||||
@ -5697,9 +5697,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 5; /* and 6 */
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE;
|
||||
int expected_index_len = 1;
|
||||
unsigned expected_index_len = 1;
|
||||
size_t expected_index_size = VARIABLE_ENTRY_SIZE / 2;
|
||||
struct fo_flush_cache_test_spec spec[1] =
|
||||
{
|
||||
@ -5814,9 +5814,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 7; /* and 8 */
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE;
|
||||
int expected_index_len = 1;
|
||||
unsigned expected_index_len = 1;
|
||||
size_t expected_index_size = VARIABLE_ENTRY_SIZE / 2;
|
||||
struct fo_flush_cache_test_spec spec[1] =
|
||||
{
|
||||
@ -5927,9 +5927,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 9; /* and 10 */
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 2;
|
||||
int expected_index_len = 1;
|
||||
unsigned expected_index_len = 1;
|
||||
size_t expected_index_size = VARIABLE_ENTRY_SIZE / 4;
|
||||
struct fo_flush_cache_test_spec spec[1] =
|
||||
{
|
||||
@ -6038,9 +6038,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 11; /* and 12 */
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = VARIABLE_ENTRY_SIZE / 2;
|
||||
int expected_index_len = 1;
|
||||
unsigned expected_index_len = 1;
|
||||
size_t expected_index_size = VARIABLE_ENTRY_SIZE / 4;
|
||||
struct fo_flush_cache_test_spec spec[1] =
|
||||
{
|
||||
@ -6152,9 +6152,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 13;
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = 1 * PICO_ENTRY_SIZE;
|
||||
int expected_index_len = 3;
|
||||
unsigned expected_index_len = 3;
|
||||
size_t expected_index_size = 3 * PICO_ENTRY_SIZE;
|
||||
struct fo_flush_cache_test_spec spec[1] =
|
||||
{
|
||||
@ -6248,9 +6248,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 14;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = 1 * PICO_ENTRY_SIZE;
|
||||
int expected_index_len = 0;
|
||||
unsigned expected_index_len = 0;
|
||||
size_t expected_index_size = (size_t)0;
|
||||
struct fo_flush_cache_test_spec spec[1] =
|
||||
{
|
||||
@ -6341,9 +6341,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 15;
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = 1 * VARIABLE_ENTRY_SIZE;
|
||||
int expected_index_len = 3;
|
||||
unsigned expected_index_len = 3;
|
||||
size_t expected_index_size = VARIABLE_ENTRY_SIZE +
|
||||
(VARIABLE_ENTRY_SIZE / 4) +
|
||||
(VARIABLE_ENTRY_SIZE / 2);
|
||||
@ -6438,9 +6438,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 16;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = 1 * VARIABLE_ENTRY_SIZE;
|
||||
int expected_index_len = 0;
|
||||
unsigned expected_index_len = 0;
|
||||
size_t expected_index_size = (size_t)0;
|
||||
struct fo_flush_cache_test_spec spec[1] =
|
||||
{
|
||||
@ -6531,9 +6531,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 17; /* and 18 */
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = 1 * VARIABLE_ENTRY_SIZE;
|
||||
int expected_index_len = 3;
|
||||
unsigned expected_index_len = 3;
|
||||
size_t expected_index_size = VARIABLE_ENTRY_SIZE +
|
||||
(VARIABLE_ENTRY_SIZE / 4) +
|
||||
(VARIABLE_ENTRY_SIZE / 2);
|
||||
@ -6658,9 +6658,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 19; /* and 20 */
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 1;
|
||||
int init_expected_index_len = 1;
|
||||
unsigned init_expected_index_len = 1;
|
||||
size_t init_expected_index_size = 1 * VARIABLE_ENTRY_SIZE;
|
||||
int expected_index_len = 3;
|
||||
unsigned expected_index_len = 3;
|
||||
size_t expected_index_size = VARIABLE_ENTRY_SIZE +
|
||||
(VARIABLE_ENTRY_SIZE / 4) +
|
||||
(VARIABLE_ENTRY_SIZE / 2);
|
||||
@ -6796,9 +6796,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 21;
|
||||
unsigned int flush_flags = H5C__FLUSH_MARKED_ENTRIES_FLAG;
|
||||
int spec_size = 4;
|
||||
int init_expected_index_len = 4;
|
||||
unsigned init_expected_index_len = 4;
|
||||
size_t init_expected_index_size = (2 * VARIABLE_ENTRY_SIZE) + (2 * PICO_ENTRY_SIZE);
|
||||
int expected_index_len = 6;
|
||||
unsigned expected_index_len = 6;
|
||||
size_t expected_index_size = (2 * VARIABLE_ENTRY_SIZE) +
|
||||
(VARIABLE_ENTRY_SIZE / 4) +
|
||||
(VARIABLE_ENTRY_SIZE / 2) +
|
||||
@ -7007,9 +7007,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 22;
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 6;
|
||||
int init_expected_index_len = 6;
|
||||
unsigned init_expected_index_len = 6;
|
||||
size_t init_expected_index_size = (2 * VARIABLE_ENTRY_SIZE) + (4 * PICO_ENTRY_SIZE);
|
||||
int expected_index_len = 10;
|
||||
unsigned expected_index_len = 10;
|
||||
size_t expected_index_size = (2 * VARIABLE_ENTRY_SIZE) +
|
||||
(2 * (VARIABLE_ENTRY_SIZE / 4)) +
|
||||
(2 * (VARIABLE_ENTRY_SIZE / 2)) +
|
||||
@ -7276,9 +7276,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 23;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
|
||||
int spec_size = 6;
|
||||
int init_expected_index_len = 6;
|
||||
unsigned init_expected_index_len = 6;
|
||||
size_t init_expected_index_size = (2 * VARIABLE_ENTRY_SIZE) + (4 * PICO_ENTRY_SIZE);
|
||||
int expected_index_len = 0;
|
||||
unsigned expected_index_len = 0;
|
||||
size_t expected_index_size = 0;
|
||||
struct fo_flush_cache_test_spec spec[6] =
|
||||
{
|
||||
@ -7538,9 +7538,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 24;
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 3;
|
||||
int init_expected_index_len = 3;
|
||||
unsigned init_expected_index_len = 3;
|
||||
size_t init_expected_index_size = 3 * PICO_ENTRY_SIZE;
|
||||
int expected_index_len = 3;
|
||||
unsigned expected_index_len = 3;
|
||||
size_t expected_index_size = 3 * PICO_ENTRY_SIZE;
|
||||
struct fo_flush_cache_test_spec spec[3] =
|
||||
{
|
||||
@ -7671,9 +7671,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 25;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
|
||||
int spec_size = 3;
|
||||
int init_expected_index_len = 3;
|
||||
unsigned init_expected_index_len = 3;
|
||||
size_t init_expected_index_size = 3 * PICO_ENTRY_SIZE;
|
||||
int expected_index_len = 0;
|
||||
unsigned expected_index_len = 0;
|
||||
size_t expected_index_size = (size_t)0;
|
||||
struct fo_flush_cache_test_spec spec[3] =
|
||||
{
|
||||
@ -7874,9 +7874,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 26;
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 10;
|
||||
int init_expected_index_len = 10;
|
||||
unsigned init_expected_index_len = 10;
|
||||
size_t init_expected_index_size = 10 * VARIABLE_ENTRY_SIZE;
|
||||
int expected_index_len = 13;
|
||||
unsigned expected_index_len = 13;
|
||||
size_t expected_index_size = 9 * VARIABLE_ENTRY_SIZE;
|
||||
struct fo_flush_cache_test_spec spec[10] =
|
||||
{
|
||||
@ -8308,9 +8308,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 27;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
|
||||
int spec_size = 10;
|
||||
int init_expected_index_len = 10;
|
||||
unsigned init_expected_index_len = 10;
|
||||
size_t init_expected_index_size = 10 * VARIABLE_ENTRY_SIZE;
|
||||
int expected_index_len = 0;
|
||||
unsigned expected_index_len = 0;
|
||||
size_t expected_index_size = (size_t)0;
|
||||
struct fo_flush_cache_test_spec spec[10] =
|
||||
{
|
||||
@ -8667,9 +8667,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 28;
|
||||
unsigned int flush_flags = H5C__NO_FLAGS_SET;
|
||||
int spec_size = 5;
|
||||
int init_expected_index_len = 5;
|
||||
unsigned init_expected_index_len = 5;
|
||||
size_t init_expected_index_size = 3 * VARIABLE_ENTRY_SIZE;
|
||||
int expected_index_len = 5;
|
||||
unsigned expected_index_len = 5;
|
||||
size_t expected_index_size = 4 * VARIABLE_ENTRY_SIZE;
|
||||
struct fo_flush_cache_test_spec spec[5] =
|
||||
{
|
||||
@ -8859,9 +8859,9 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
|
||||
int test_num = 29;
|
||||
unsigned int flush_flags = H5C__FLUSH_INVALIDATE_FLAG;
|
||||
int spec_size = 5;
|
||||
int init_expected_index_len = 5;
|
||||
unsigned init_expected_index_len = 5;
|
||||
size_t init_expected_index_size = 3 * VARIABLE_ENTRY_SIZE;
|
||||
int expected_index_len = 0;
|
||||
unsigned expected_index_len = 0;
|
||||
size_t expected_index_size = 0;
|
||||
struct fo_flush_cache_test_spec spec[5] =
|
||||
{
|
||||
@ -9070,9 +9070,9 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
|
||||
unsigned int flush_flags,
|
||||
int spec_size,
|
||||
const struct fo_flush_cache_test_spec spec[],
|
||||
int init_expected_index_len,
|
||||
unsigned init_expected_index_len,
|
||||
size_t init_expected_index_size,
|
||||
int expected_index_len,
|
||||
unsigned expected_index_len,
|
||||
size_t expected_index_size,
|
||||
int check_size,
|
||||
struct fo_flush_entry_check check[])
|
||||
@ -27433,7 +27433,7 @@ check_auto_cache_resize_aux_fcns(void)
|
||||
size_t max_size;
|
||||
size_t min_clean_size;
|
||||
size_t cur_size;
|
||||
int32_t cur_num_entries;
|
||||
uint32_t cur_num_entries;
|
||||
H5C_auto_size_ctl_t auto_size_ctl =
|
||||
{
|
||||
/* int32_t version = */ H5C__CURR_AUTO_SIZE_CTL_VER,
|
||||
|
@ -6128,7 +6128,7 @@ check_and_validate_cache_size(hid_t file_id,
|
||||
size_t min_clean_size;
|
||||
size_t expected_cur_size;
|
||||
size_t cur_size;
|
||||
int32_t expected_cur_num_entries;
|
||||
uint32_t expected_cur_num_entries;
|
||||
int cur_num_entries;
|
||||
H5F_t * file_ptr = NULL;
|
||||
H5C_t * cache_ptr = NULL;
|
||||
|
246
test/earray.c
246
test/earray.c
@ -159,15 +159,6 @@ typedef struct earray_test_t {
|
||||
|
||||
/* Local prototypes */
|
||||
|
||||
/* Metadata cache (H5AC) callbacks */
|
||||
static herr_t earray_cache_test_get_initial_load_size(void *udata, size_t *image_len);
|
||||
static void *earray_cache_test_deserialize(const void *image_ptr, size_t len,
|
||||
void *udata_ptr, hbool_t *dirty_ptr);
|
||||
static herr_t earray_cache_test_image_len(const void *thing, size_t *image_len_ptr);
|
||||
static herr_t earray_cache_test_serialize(const H5F_t *f, void *image_ptr,
|
||||
size_t len, void *thing);
|
||||
static herr_t earray_cache_test_free_icr(void *thing);
|
||||
|
||||
|
||||
/* Local variables */
|
||||
const char *FILENAME[] = {
|
||||
@ -182,24 +173,6 @@ char filename_g[EARRAY_FILENAME_LEN];
|
||||
/* Empty file size */
|
||||
h5_stat_size_t empty_size_g;
|
||||
|
||||
/* H5EA test object inherits cache-like properties from H5AC */
|
||||
const H5AC_class_t H5AC_EARRAY_TEST[1] = {{
|
||||
/* id */ H5AC_TEST_ID,
|
||||
/* name */ "earray test",
|
||||
/* mem_type */ H5FD_MEM_DEFAULT,
|
||||
/* flags */ H5AC__CLASS_SKIP_READS | H5AC__CLASS_SKIP_WRITES,
|
||||
/* get_initial_load_size */ earray_cache_test_get_initial_load_size,
|
||||
/* get_final_load_size */ NULL,
|
||||
/* verify_chksum */ NULL,
|
||||
/* deserialize */ earray_cache_test_deserialize,
|
||||
/* image_len */ earray_cache_test_image_len,
|
||||
/* pre_serialize */ NULL,
|
||||
/* serialize */ earray_cache_test_serialize,
|
||||
/* notify */ NULL,
|
||||
/* free_icr */ earray_cache_test_free_icr,
|
||||
/* fsf_size */ NULL,
|
||||
}};
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: init_cparam
|
||||
@ -617,225 +590,6 @@ error:
|
||||
return(-1);
|
||||
} /* finish() */
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: earray_cache_test_get_initial_load_size()
|
||||
*
|
||||
* Purpose: place holder function -- should never be called
|
||||
*
|
||||
* A generic discussion of metadata cache callbacks of this type
|
||||
* may be found in H5Cprivate.h.
|
||||
*
|
||||
* Return: Success: SUCCEED
|
||||
* Failure: FAIL
|
||||
*
|
||||
* Programmer: John Mainzer
|
||||
* 8/2/14
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
static herr_t
|
||||
earray_cache_test_get_initial_load_size( void *udata, size_t *image_len)
|
||||
{
|
||||
HDassert(udata);
|
||||
HDassert(image_len);
|
||||
|
||||
/* Should never be called */
|
||||
HDassert(0 && "Can't be called!");
|
||||
|
||||
*image_len = 0;
|
||||
|
||||
return(SUCCEED);
|
||||
} /* end earray_cache_test_get_initial_load_size() */
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: earray_cache_test_deserialize
|
||||
*
|
||||
* Purpose: place holder function -- should never be called.
|
||||
*
|
||||
*
|
||||
* A generic discussion of metadata cache callbacks of this type
|
||||
* may be found in H5Cprivate.h:
|
||||
*
|
||||
* Return: Success: Pointer to in core representation
|
||||
* Failure: NULL
|
||||
*
|
||||
* Programmer: John Mainzer
|
||||
* 8/2/14
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
static void *
|
||||
earray_cache_test_deserialize(const void *image_ptr,
|
||||
size_t len,
|
||||
void *udata_ptr,
|
||||
hbool_t *dirty_ptr)
|
||||
{
|
||||
HDassert(image_ptr);
|
||||
HDassert(len > 0 );
|
||||
HDassert(udata_ptr);
|
||||
HDassert(dirty_ptr);
|
||||
|
||||
/* Should never be called */
|
||||
HDassert(0 && "Can't be called!");
|
||||
|
||||
return(NULL);
|
||||
} /* end earray_cache_test_deserialize() */
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: earray_cache_test_image_len
|
||||
*
|
||||
* Purpose: test code place holder function -- just set *image_len_ptr to
|
||||
* one.
|
||||
*
|
||||
*
|
||||
* A generic discussion of metadata cache callbacks of this type
|
||||
* may be found in H5Cprivate.h:
|
||||
*
|
||||
* Return: Success: SUCCEED
|
||||
* Failure: FAIL
|
||||
*
|
||||
* Programmer: John Mainzer
|
||||
* 8/2/14
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
static herr_t
|
||||
earray_cache_test_image_len(const void *thing, size_t *image_len_ptr)
|
||||
{
|
||||
HDassert(thing);
|
||||
HDassert(image_len_ptr);
|
||||
|
||||
/* Set size value */
|
||||
/* (hard-code to 1) */
|
||||
*image_len_ptr = 1;
|
||||
|
||||
return(SUCCEED);
|
||||
} /* end earray_cache_test_image_len() */
|
||||
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: earray_cache_test_serialize
|
||||
*
|
||||
* Purpose: Validate the contents of the instance of earray_test_t.
|
||||
*
|
||||
*
|
||||
* A generic discussion of metadata cache callbacks of this type
|
||||
* may be found in H5Cprivate.h:
|
||||
*
|
||||
*
|
||||
* Return: Success: SUCCEED
|
||||
* Failure: FAIL
|
||||
*
|
||||
* Programmer: John Mainzer
|
||||
* 8/2/14
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
static herr_t
|
||||
earray_cache_test_serialize(const H5F_t *f,
|
||||
void *image_ptr,
|
||||
H5_ATTR_UNUSED size_t len,
|
||||
void *thing)
|
||||
{
|
||||
earray_test_t *test;
|
||||
|
||||
HDassert(f);
|
||||
HDassert(image_ptr);
|
||||
HDassert(thing);
|
||||
test = (earray_test_t *)thing;
|
||||
HDassert(test);
|
||||
HDassert(test->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
|
||||
HDassert((const H5AC_class_t *)(test->cache_info.type) ==
|
||||
&(H5AC_EARRAY_TEST[0]));
|
||||
|
||||
/* Check for out of order flush */
|
||||
if(test->fd_info->base_obj)
|
||||
TEST_ERROR
|
||||
|
||||
/* Check which index this entry corresponds to */
|
||||
if((uint64_t)0 == test->idx) {
|
||||
/* Check for out of order flush */
|
||||
if(test->fd_info->idx0_obj || test->fd_info->idx0_elem)
|
||||
TEST_ERROR
|
||||
|
||||
/* Set flag for object flush */
|
||||
test->fd_info->idx0_obj = TRUE;
|
||||
} /* end if */
|
||||
else if((uint64_t)1 == test->idx) {
|
||||
/* Check for out of order flush */
|
||||
if(test->fd_info->idx1_obj || test->fd_info->idx1_elem)
|
||||
TEST_ERROR
|
||||
|
||||
/* Set flag for object flush */
|
||||
test->fd_info->idx1_obj = TRUE;
|
||||
} /* end if */
|
||||
else if((uint64_t)10000 == test->idx) {
|
||||
/* Check for out of order flush */
|
||||
if(test->fd_info->idx10000_obj || test->fd_info->idx10000_elem)
|
||||
TEST_ERROR
|
||||
|
||||
/* Set flag for object flush */
|
||||
test->fd_info->idx10000_obj = TRUE;
|
||||
} /* end if */
|
||||
else if((uint64_t)-1 == test->idx) {
|
||||
/* Set flag for object flush */
|
||||
test->fd_info->base_obj = TRUE;
|
||||
} /* end if */
|
||||
|
||||
return(SUCCEED);
|
||||
|
||||
error:
|
||||
return(FAIL);
|
||||
} /* end earray_cache_test_serialize() */
|
||||
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: earray_cache_test_free_icr
|
||||
*
|
||||
* Purpose: Destroy an extensible array test object in memory.
|
||||
*
|
||||
*
|
||||
* A generic discussion of metadata cache callbacks of this type
|
||||
* may be found in H5Cprivate.h:
|
||||
*
|
||||
*
|
||||
* Return: Success: SUCCEED
|
||||
* Failure: FAIL
|
||||
*
|
||||
* Programmer: John Mainzer
|
||||
* 8/2/14
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
static herr_t
|
||||
earray_cache_test_free_icr(void *thing)
|
||||
{
|
||||
earray_test_t *test;
|
||||
|
||||
HDassert(thing);
|
||||
test = (earray_test_t *)thing;
|
||||
HDassert(test);
|
||||
|
||||
/* the metadata cache sets cache_info.magic to
|
||||
* H5C__H5C_CACHE_ENTRY_T_BAD_MAGIC before calling the
|
||||
* free_icr routine. Hence the following assert:
|
||||
*/
|
||||
|
||||
HDassert(test->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_BAD_MAGIC);
|
||||
HDassert((const H5AC_class_t *)(test->cache_info.type) ==
|
||||
&(H5AC_EARRAY_TEST[0]));
|
||||
|
||||
/* Free the shared info itself */
|
||||
HDfree(test);
|
||||
|
||||
return(SUCCEED);
|
||||
} /* end earray_cache_test_free_icr() */
|
||||
|
||||
|
||||
/*-------------------------------------------------------------------------
|
||||
* Function: test_create
|
||||
|
@ -600,7 +600,7 @@ check_group_layout(hid_t fid, const char *group_name)
|
||||
hid_t gid1 = -1, gid2 = -1; /* group IDs */
|
||||
H5G_t *grp_ptr = NULL; /* ptr to internal group struct */
|
||||
haddr_t tag1, tag2; /* MD cache tags for groups */
|
||||
int32_t before, during, after; /* cache sizes */
|
||||
uint32_t before, during, after; /* cache sizes */
|
||||
int i; /* iterator */
|
||||
|
||||
/* NOTE: The TESTING() macro is called in main() */
|
||||
@ -616,7 +616,7 @@ check_group_layout(hid_t fid, const char *group_name)
|
||||
HDprintf("\nCACHE BEFORE GROUP OPEN:\n");
|
||||
if(H5AC_dump_cache(file_ptr) < 0)
|
||||
TEST_ERROR;
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %d\n", before);
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %u\n", before);
|
||||
#endif
|
||||
|
||||
/* Open the main group and get its tag */
|
||||
@ -658,7 +658,7 @@ check_group_layout(hid_t fid, const char *group_name)
|
||||
if(H5AC_dump_cache(file_ptr) < 0)
|
||||
TEST_ERROR;
|
||||
HDprintf("MAIN GROUP TAG: %#X\n", tag1);
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %d\n", during);
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %u\n", during);
|
||||
#endif
|
||||
|
||||
/* Close the main group */
|
||||
@ -672,7 +672,7 @@ check_group_layout(hid_t fid, const char *group_name)
|
||||
HDprintf("\nCACHE AFTER CLOSING GROUPS:\n");
|
||||
if(H5AC_dump_cache(file_ptr) < 0)
|
||||
TEST_ERROR;
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %d\n", after);
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %u\n", after);
|
||||
#endif
|
||||
|
||||
/* Ensure that the cache does not contain entries with the tag */
|
||||
@ -718,7 +718,7 @@ check_dset_scheme(hid_t fid, const char *dset_name)
|
||||
H5D_t *dset_ptr = NULL; /* ptr to internal dset struct */
|
||||
haddr_t tag; /* MD cache tag for dataset */
|
||||
int *data = NULL; /* buffer for fake data */
|
||||
int32_t before, during, after; /* cache sizes */
|
||||
uint32_t before, during, after; /* cache sizes */
|
||||
|
||||
/* NOTE: The TESTING() macro is called in main() */
|
||||
|
||||
@ -737,7 +737,7 @@ check_dset_scheme(hid_t fid, const char *dset_name)
|
||||
HDprintf("\nCACHE BEFORE DATASET OPEN:\n");
|
||||
if(H5AC_dump_cache(file_ptr) < 0)
|
||||
TEST_ERROR;
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %d\n", before);
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %u\n", before);
|
||||
#endif
|
||||
|
||||
/* Open dataset and get the metadata tag */
|
||||
@ -761,7 +761,7 @@ check_dset_scheme(hid_t fid, const char *dset_name)
|
||||
if(H5AC_dump_cache(file_ptr) < 0)
|
||||
TEST_ERROR;
|
||||
HDprintf("TAG: %#X\n", tag);
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %d\n", during);
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %u\n", during);
|
||||
#endif
|
||||
|
||||
/* Close the dataset */
|
||||
@ -775,7 +775,7 @@ check_dset_scheme(hid_t fid, const char *dset_name)
|
||||
HDprintf("\nCACHE AFTER DATASET CLOSE:\n");
|
||||
if(H5AC_dump_cache(file_ptr) < 0)
|
||||
TEST_ERROR;
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %d\n", after);
|
||||
HDprintf("NUMBER OF CACHE ENTRIES: %u\n", after);
|
||||
#endif
|
||||
|
||||
/* Ensure that the cache does not contain entries with the tag */
|
||||
|
Loading…
x
Reference in New Issue
Block a user