mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-04-18 17:40:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Switch list lengths to unsigned integers (to align better w/cache image merge)

Browse Source
This commit is contained in:
Quincey Koziol 2017-01-27 20:35:14 -08:00
parent eb8ada9564
commit 349f41d974
13 changed files with 273 additions and 570 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/H5AC.c
View File

@ -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 */

3
src/H5ACprivate.h
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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 */

2
src/H5Cprivate.h
View File

@ -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,

2
src/H5Cquery.c
View File

@ -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 */

2
src/H5F.c
View File

@ -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)

2
src/H5Fio.c
View File

@ -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
View File

@ -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,

2
test/cache_common.c
View File

@ -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
View File

@ -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

16
test/evict_on_close.c
View File

@ -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 */