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

Bring over changes from revise_chunks that cleanup recent SWMR changes from

Browse Source 
code review feedback.
This commit is contained in:
Quincey Koziol 2016-12-11 00:28:05 -08:00
parent cc6eb939f4
commit feb9d1f676
5 changed files with 278 additions and 347 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
src/H5ACproxy_entry.c
View File

@ -632,165 +632,3 @@ done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5AC__proxy_entry_free_icr() */
#ifdef OLD_CODE
/*-------------------------------------------------------------------------
* Function: H5AC_virt_entry_dirty_parent
*
* Purpose: Indicate that a virtual entry's parent became dirty
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* July 23, 2016
*
*-------------------------------------------------------------------------
*/
herr_t
H5AC_virt_entry_dirty_parent(H5AC_virt_entry_t *ventry)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Sanity check */
HDassert(ventry);
HDassert(ventry->track_parents);
HDassert(ventry->nparents > 0);
/* If this is the first dirty parent or child, mark the virtual entry dirty */
if(ventry->in_cache && 0 == ventry->ndirty_parents && 0 == ventry->ndirty_children)
if(H5AC_mark_entry_dirty(ventry) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTDIRTY, FAIL, "can't mark virtual entry dirty")
/* Increment the number of dirty parents */
ventry->ndirty_parents++;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5AC_virt_entry_dirty_parent() */
/*-------------------------------------------------------------------------
* Function: H5AC_virt_entry_clean_parent
*
* Purpose: Indicate that a virtual entry's parent became clean
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* July 23, 2016
*
*-------------------------------------------------------------------------
*/
herr_t
H5AC_virt_entry_clean_parent(H5AC_virt_entry_t *ventry)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Sanity check */
HDassert(ventry);
HDassert(ventry->track_parents);
// HDassert(ventry->nparents > 0);
HDassert(ventry->ndirty_parents > 0);
/* Decrement the number of dirty parents */
ventry->ndirty_parents--;
/* If this is the last dirty parent or child, mark the virtual entry clean */
if(ventry->in_cache && 0 == ventry->ndirty_parents && 0 == ventry->ndirty_children)
if(H5AC_mark_entry_clean(ventry) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTCLEAN, FAIL, "can't mark virtual entry clean")
/* Destroy the skip list, if no more parents */
if(0 == ventry->nparents && 0 == ventry->ndirty_parents) {
// /* Sanity check */
// HDassert(0 == ventry->ndirty_parents);
if(H5SL_close(ventry->parents) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CLOSEERROR, FAIL, "can't close parent list")
ventry->parents = NULL;
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5AC_virt_entry_clean_parent() */
/*-------------------------------------------------------------------------
* Function: H5AC_virt_entry_dirty_child
*
* Purpose: Indicate that a virtual entry's child became dirty
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* July 24, 2016
*
*-------------------------------------------------------------------------
*/
herr_t
H5AC_virt_entry_dirty_child(H5AC_virt_entry_t *ventry)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Sanity check */
HDassert(ventry);
HDassert(ventry->nchildren > 0);
/* If this is the first dirty parent or child, mark the virtual entry dirty */
if(ventry->in_cache && 0 == ventry->ndirty_parents && 0 == ventry->ndirty_children)
if(H5AC_mark_entry_dirty(ventry) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTDIRTY, FAIL, "can't mark virtual entry dirty")
/* Increment the number of dirty children */
ventry->ndirty_children++;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5AC_virt_entry_dirty_child() */
/*-------------------------------------------------------------------------
* Function: H5AC_virt_entry_clean_child
*
* Purpose: Indicate that a virtual entry's child became clean
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* July 24, 2016
*
*-------------------------------------------------------------------------
*/
herr_t
H5AC_virt_entry_clean_child(H5AC_virt_entry_t *ventry)
{
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI(FAIL)
/* Sanity check */
HDassert(ventry);
HDassert(ventry->nchildren > 0);
HDassert(ventry->ndirty_children > 0);
/* Decrement the number of dirty children */
ventry->ndirty_children--;
/* If this is the last dirty parent or child, mark the virtual entry clean */
if(ventry->in_cache && 0 == ventry->ndirty_parents && 0 == ventry->ndirty_children)
if(H5AC_mark_entry_clean(ventry) < 0)
HGOTO_ERROR(H5E_CACHE, H5E_CANTCLEAN, FAIL, "can't mark virtual entry clean")
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5AC_virt_entry_clean_child() */
#endif /* OLD_CODE */

43
src/H5C.c
View File

@ -1702,6 +1702,13 @@ H5C_move_entry(H5C_t * cache_ptr,
HDassert(entry_ptr->addr == old_addr);
HDassert(entry_ptr->type == type);
/* Check for R/W status, otherwise error */
/* (Moving a R/O entry would mark it dirty, which shouldn't
* happen. QAK - 2016/12/02)
*/
if(entry_ptr->is_read_only)
HGOTO_ERROR(H5E_CACHE, H5E_CANTMOVE, FAIL, "can't move R/O entry")
H5C__SEARCH_INDEX(cache_ptr, new_addr, test_entry_ptr, FAIL)
if(test_entry_ptr != NULL) { /* we are hosed */
@ -5066,16 +5073,38 @@ H5C_flush_invalidate_cache(const H5F_t * f, hid_t dxpl_id, unsigned flags)
if(!(flags & H5C__EVICT_ALLOW_LAST_PINS_FLAG)) {
HDassert(cache_ptr->index_size == 0);
HDassert(cache_ptr->clean_index_size == 0);
HDassert(cache_ptr->dirty_index_size == 0);
HDassert(cache_ptr->slist_len == 0);
HDassert(cache_ptr->slist_size == 0);
HDassert(cache_ptr->pel_len == 0);
HDassert(cache_ptr->pel_size == 0);
HDassert(cache_ptr->pl_len == 0);
HDassert(cache_ptr->pl_size == 0);
HDassert(cache_ptr->LRU_list_len == 0);
HDassert(cache_ptr->LRU_list_size == 0);
} /* end if */
else {
H5C_cache_entry_t *entry_ptr; /* Cache entry */
unsigned u; /* Local index variable */
/* All rings except ring 4 should be empty now */
/* (Ring 4 has the superblock) */
for(u = H5C_RING_USER; u < H5C_RING_SB; u++) {
HDassert(cache_ptr->index_ring_len[u] == 0);
HDassert(cache_ptr->index_ring_size[u] == 0);
HDassert(cache_ptr->clean_index_ring_size[u] == 0);
} /* end for */
/* Check that any remaining pinned entries are in the superblock ring */
entry_ptr = cache_ptr->pel_head_ptr;
while(entry_ptr) {
/* Check ring */
HDassert(entry_ptr->ring == H5C_RING_SB);
/* Advance to next entry in pinned entry list */
entry_ptr = entry_ptr->next;
} /* end while */
} /* end else */
HDassert(cache_ptr->dirty_index_size == 0);
HDassert(cache_ptr->slist_len == 0);
HDassert(cache_ptr->slist_size == 0);
HDassert(cache_ptr->pl_len == 0);
HDassert(cache_ptr->pl_size == 0);
HDassert(cache_ptr->LRU_list_len == 0);
HDassert(cache_ptr->LRU_list_size == 0);
done:
FUNC_LEAVE_NOAPI(ret_value)

406
test/cache.c
View File

@ -93,8 +93,8 @@ struct move_entry_test_spec
{
int entry_type;
int entry_index;
hbool_t is_dirty;
hbool_t is_pinned;
hbool_t is_protected;
};
@ -154,7 +154,7 @@ static void check_flush_cache__flush_op_test(H5F_t * file_ptr,
int test_num,
unsigned int flush_flags,
int spec_size,
struct fo_flush_cache_test_spec spec[],
const struct fo_flush_cache_test_spec spec[],
int init_expected_index_len,
size_t init_expected_index_size,
int expected_index_len,
@ -166,8 +166,8 @@ static unsigned check_get_entry_status(void);
static unsigned check_expunge_entry(void);
static unsigned check_multiple_read_protect(void);
static unsigned check_move_entry(void);
static void check_move_entry__run_test(H5F_t * file_ptr, int test_num,
struct move_entry_test_spec * spec_ptr);
static void check_move_entry__run_test(H5F_t * file_ptr, unsigned test_num,
struct move_entry_test_spec * spec_ptr);
static unsigned check_pin_protected_entry(void);
static unsigned check_resize_entry(void);
static unsigned check_evictions_enabled(void);
@ -175,7 +175,6 @@ static unsigned check_flush_protected_err(void);
static unsigned check_destroy_pinned_err(void);
static unsigned check_destroy_protected_err(void);
static unsigned check_duplicate_insert_err(void);
static unsigned check_move_err(void);
static unsigned check_double_pin_err(void);
static unsigned check_double_unpin_err(void);
static unsigned check_pin_entry_errs(void);
@ -183,6 +182,7 @@ static unsigned check_double_protect_err(void);
static unsigned check_double_unprotect_err(void);
static unsigned check_mark_entry_dirty_errs(void);
static unsigned check_expunge_entry_errs(void);
static unsigned check_move_entry_errs(void);
static unsigned check_resize_entry_errs(void);
static unsigned check_unprotect_ro_dirty_err(void);
static unsigned check_protect_ro_rw_err(void);
@ -9069,7 +9069,7 @@ check_flush_cache__flush_op_test(H5F_t * file_ptr,
int test_num,
unsigned int flush_flags,
int spec_size,
struct fo_flush_cache_test_spec spec[],
const struct fo_flush_cache_test_spec spec[],
int init_expected_index_len,
size_t init_expected_index_size,
int expected_index_len,
@ -13692,42 +13692,40 @@ check_multiple_read_protect(void)
* Programmer: John Mainzer
* 4/26/06
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static unsigned
check_move_entry(void)
{
int i;
unsigned u;
H5F_t * file_ptr = NULL;
struct move_entry_test_spec test_specs[4] =
struct move_entry_test_spec test_specs[8] =
{
{
/* int entry_type = */ PICO_ENTRY_TYPE,
/* int entry_index = */ 10,
/* hbool_t is_dirty = */ FALSE,
/* hbool_t is_pinned = */ FALSE
/* int entry_type = */ PICO_ENTRY_TYPE,
/* int entry_index = */ 10,
/* hbool_t is_pinned = */ FALSE,
/* hbool_t is_protected = */ FALSE
},
{
/* int entry_type = */ PICO_ENTRY_TYPE,
/* int entry_index = */ 20,
/* hbool_t is_dirty = */ TRUE,
/* hbool_t is_pinned = */ FALSE
/* int entry_type = */ PICO_ENTRY_TYPE,
/* int entry_index = */ 20,
/* hbool_t is_pinned = */ TRUE,
/* hbool_t is_protected = */ FALSE
},
{
/* int entry_type = */ PICO_ENTRY_TYPE,
/* int entry_index = */ 30,
/* hbool_t is_dirty = */ FALSE,
/* hbool_t is_pinned = */ TRUE
/* int entry_type = */ PICO_ENTRY_TYPE,
/* int entry_index = */ 30,
/* hbool_t is_pinned = */ FALSE,
/* hbool_t is_protected = */ TRUE
},
{
/* int entry_type = */ PICO_ENTRY_TYPE,
/* int entry_index = */ 40,
/* hbool_t is_dirty = */ TRUE,
/* hbool_t is_pinned = */ TRUE
}
/* int entry_type = */ PICO_ENTRY_TYPE,
/* int entry_index = */ 40,
/* hbool_t is_pinned = */ TRUE,
/* hbool_t is_protected = */ TRUE
},
};
TESTING("H5C_move_entry() functionality");
@ -13740,13 +13738,13 @@ check_move_entry(void)
*
* At present, we should do the following tests:
*
* 1) Move a clean, unprotected, unpinned entry.
* 1) Move an unprotected, unpinned entry.
*
* 2) Move a dirty, unprotected, unpinned entry.
* 2) Move an unprotected, pinned entry.
*
* 3) Move a clean, unprotected, pinned entry.
* 3) Move a protected, unpinned entry.
*
* 4) Move a dirty, unprotected, pinned entry.
* 4) Move a protected, pinned entry.
*
* In all cases, the entry should have moved to its
* new location, and have been marked dirty if it wasn't
@ -13767,28 +13765,26 @@ check_move_entry(void)
(size_t)(1 * 1024 * 1024));
}
i = 0;
while(pass && (i < 4))
u = 0;
while(pass && (u < NELMTS(test_specs)))
{
check_move_entry__run_test(file_ptr, i, &(test_specs[i]));
i++;
check_move_entry__run_test(file_ptr, u, &(test_specs[u]));
u++;
}
if(pass) {
if(pass)
takedown_cache(file_ptr, FALSE, FALSE);
}
if(pass) { PASSED(); } else { H5_FAILED(); }
if(!pass) {
if(pass)
PASSED()
else
H5_FAILED()
if(!pass)
HDfprintf(stdout, "%s(): failure_mssg = \"%s\".\n",
FUNC, failure_mssg);
}
return (unsigned)!pass;
} /* check_move_entry() */
@ -13813,7 +13809,7 @@ check_move_entry(void)
static void
check_move_entry__run_test(H5F_t * file_ptr,
int test_num,
unsigned test_num,
struct move_entry_test_spec * spec_ptr)
{
H5C_t * cache_ptr = file_ptr->shared->cache;
@ -13827,7 +13823,7 @@ check_move_entry__run_test(H5F_t * file_ptr,
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"cache_ptr NULL on entry to move test #%d.",
"cache_ptr NULL on entry to move test #%u.",
test_num);
failure_mssg = msg;
@ -13835,7 +13831,7 @@ check_move_entry__run_test(H5F_t * file_ptr,
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"spec_ptr NULL on entry to move test #%d.",
"spec_ptr NULL on entry to move test #%u.",
test_num);
failure_mssg = msg;
@ -13854,13 +13850,10 @@ check_move_entry__run_test(H5F_t * file_ptr,
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"bad entry_ptr in move test #%d.",
"bad entry_ptr in move test #%u.",
test_num);
failure_mssg = msg;
} else if(spec_ptr->is_pinned) {
flags |= H5C__PIN_ENTRY_FLAG;
}
}
@ -13868,10 +13861,11 @@ check_move_entry__run_test(H5F_t * file_ptr,
protect_entry(file_ptr, spec_ptr->entry_type, spec_ptr->entry_index);
if(spec_ptr->is_dirty)
flags |= H5C__DIRTIED_FLAG;
if(spec_ptr->is_pinned)
pin_entry(spec_ptr->entry_type, spec_ptr->entry_index);
unprotect_entry(file_ptr, spec_ptr->entry_type, spec_ptr->entry_index, flags);
if(!spec_ptr->is_protected)
unprotect_entry(file_ptr, spec_ptr->entry_type, spec_ptr->entry_index, flags);
move_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, FALSE);
@ -13890,29 +13884,31 @@ check_move_entry__run_test(H5F_t * file_ptr,
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Pinned entry not pinned after move in test #%d.",
"Pinned entry not pinned after move in test #%u.",
test_num);
failure_mssg = msg;
}
if(pass) {
test_ptr = cache_ptr->pel_head_ptr;
if(spec_ptr->is_protected) {
} /* end if */
else {
/* Scan through the pinned entry list, looking for the entry */
test_ptr = cache_ptr->pel_head_ptr;
while((test_ptr != NULL) &&
(test_ptr != (H5C_cache_entry_t *)entry_ptr))
test_ptr = test_ptr->next;
while((test_ptr != NULL) &&
(test_ptr != (H5C_cache_entry_t *)entry_ptr))
{
test_ptr = test_ptr->next;
}
if(test_ptr == NULL) {
if(test_ptr == NULL) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Pinned entry not in pel after move in test #%d.",
test_num);
failure_mssg = msg;
}
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Pinned entry not in pel after move in test #%u.",
test_num);
failure_mssg = msg;
}
} /* end else */
}
unpin_entry(spec_ptr->entry_type, spec_ptr->entry_index);
@ -13923,21 +13919,49 @@ check_move_entry__run_test(H5F_t * file_ptr,
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unpinned entry pinned after move in test #%d.",
"Unpinned entry pinned after move in test #%u.",
test_num);
failure_mssg = msg;
}
if((entry_ptr->header.prev != NULL) ||
(cache_ptr->LRU_head_ptr != (H5C_cache_entry_t *)entry_ptr))
{
if(spec_ptr->is_protected) {
} /* end if */
else {
if((entry_ptr->header.prev != NULL) ||
(cache_ptr->LRU_head_ptr != (H5C_cache_entry_t *)entry_ptr))
{
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Entry not at head of LRU after move in test #%u.",
test_num);
failure_mssg = msg;
}
} /* end else */
}
if(spec_ptr->is_protected) {
if(!(entry_ptr->header.is_protected)) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Entry not at head of LRU after move in test #%d.",
"Protected entry not protected after move in test #%u.",
test_num);
failure_mssg = msg;
}
}
unprotect_entry(file_ptr, spec_ptr->entry_type, spec_ptr->entry_index, flags);
} /* end if */
else {
if(entry_ptr->header.is_protected) {
pass = FALSE;
HDsnprintf(msg, (size_t)128,
"Unprotected entry not unprotected after move in test #%u.",
test_num);
failure_mssg = msg;
}
} /* end else */
}
/* put the entry back where it started from */
@ -16098,100 +16122,6 @@ check_duplicate_insert_err(void)
} /* check_duplicate_insert_err() */
/*-------------------------------------------------------------------------
* Function: check_move_err()
*
* Purpose: Verify that an attempt to move an entry to the address
* of an existing entry will generate an error.
*
* Return: void
*
* Programmer: John Mainzer
* 6/24/04
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static unsigned
check_move_err(void)
{
herr_t result;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
test_entry_t * entry_0_0_ptr;
test_entry_t * entry_0_1_ptr;
test_entry_t * entry_1_0_ptr;
TESTING("move to existing entry errors");
pass = TRUE;
/* allocate a cache, and insert several entries. Try to move
* entries to other entries resident in the cache. This should
* fail. Destroy the cache -- should succeed.
*/
if(pass) {
reset_entries();
file_ptr = setup_cache((size_t)(2 * 1024),
(size_t)(1 * 1024));
cache_ptr = file_ptr->shared->cache;
insert_entry(file_ptr, 0, 0, H5C__NO_FLAGS_SET);
insert_entry(file_ptr, 0, 1, H5C__NO_FLAGS_SET);
insert_entry(file_ptr, 1, 0, H5C__NO_FLAGS_SET);
entry_0_0_ptr = &((entries[0])[0]);
entry_0_1_ptr = &((entries[0])[1]);
entry_1_0_ptr = &((entries[1])[0]);
}
if(pass) {
result = H5C_move_entry(cache_ptr, &(types[0]),
entry_0_0_ptr->addr, entry_0_1_ptr->addr);
if(result >= 0) {
pass = FALSE;
failure_mssg = "move to addr of same type succeeded.\n";
}
}
if(pass) {
result = H5C_move_entry(cache_ptr, &(types[0]),
entry_0_0_ptr->addr, entry_1_0_ptr->addr);
if(result >= 0) {
pass = FALSE;
failure_mssg = "move to addr of different type succeeded.\n";
}
}
if(pass) {
takedown_cache(file_ptr, FALSE, FALSE);
}
if(pass) { PASSED(); } else { H5_FAILED(); }
if(!pass) {
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
FUNC, failure_mssg);
}
return (unsigned)!pass;
} /* check_move_err() */
/*-------------------------------------------------------------------------
* Function: check_double_pin_err()
@ -16750,7 +16680,7 @@ check_expunge_entry_errs(void)
/* Allocate a cache, protect an entry, and then call H5C_expunge_entry()
* to expunge it -- this should fail
*
* Unprotect the the entry with the pinned flag, and then call
* Unprotect the entry with the pinned flag, and then call
* H5C_expunge_entry() again. This should fail too.
*
* Finally, unpin the entry and call H5C_expunge_entry() yet again.
@ -16840,6 +16770,140 @@ check_expunge_entry_errs(void)
} /* check_expunge_entry_errs() */
/*-------------------------------------------------------------------------
* Function: check_move_entry_errs()
*
* Purpose: Verify that invalid calls to H5C_move_entry()
* generates errors as expected.
*
* Return: void
*
* Programmer: Quincey Koziol
* 12/10/16
*
*-------------------------------------------------------------------------
*/
static unsigned
check_move_entry_errs(void)
{
herr_t result;
H5F_t * file_ptr = NULL;
H5C_t * cache_ptr = NULL;
test_entry_t * entry_ptr = NULL;
test_entry_t * entry_0_0_ptr;
test_entry_t * entry_0_1_ptr;
test_entry_t * entry_1_0_ptr;
TESTING("move entry related errors");
pass = TRUE;
/* allocate a cache, and insert several entries. Try to move
* entries to other entries resident in the cache. This should
* fail. Destroy the cache -- should succeed.
*/
if(pass) {
reset_entries();
file_ptr = setup_cache((size_t)(2 * 1024), (size_t)(1 * 1024));
cache_ptr = file_ptr->shared->cache;
insert_entry(file_ptr, 0, 0, H5C__NO_FLAGS_SET);
insert_entry(file_ptr, 0, 1, H5C__NO_FLAGS_SET);
insert_entry(file_ptr, 1, 0, H5C__NO_FLAGS_SET);
entry_0_0_ptr = &((entries[0])[0]);
entry_0_1_ptr = &((entries[0])[1]);
entry_1_0_ptr = &((entries[1])[0]);
}
if(pass) {
result = H5C_move_entry(cache_ptr, &(types[0]),
entry_0_0_ptr->addr, entry_0_1_ptr->addr);
if(result >= 0) {
pass = FALSE;
failure_mssg = "move to addr of same type succeeded.\n";
}
}
if(pass) {
result = H5C_move_entry(cache_ptr, &(types[0]),
entry_0_0_ptr->addr, entry_1_0_ptr->addr);
if(result >= 0) {
pass = FALSE;
failure_mssg = "move to addr of different type succeeded.\n";
}
}
if(pass)
takedown_cache(file_ptr, FALSE, FALSE);
/* Allocate a cache, protect an entry R/O, and then call
* H5C_move_entry() to move it -- this should fail.
*
* Finally, unprotect the entry and destroy the cache.
* This should succeed.
*/
if(pass) {
reset_entries();
file_ptr = setup_cache((size_t)(2 * 1024), (size_t)(1 * 1024));
cache_ptr = file_ptr->shared->cache;
insert_entry(file_ptr, 0, 0, H5C__NO_FLAGS_SET);
protect_entry_ro(file_ptr, 0, 0);
entry_ptr = &((entries[0])[0]);
}
if(pass) {
result = H5C_move_entry(cache_ptr, &(types[0]), entry_ptr->header.addr, entry_ptr->header.addr + 10);
if(result >= 0) {
pass = FALSE;
failure_mssg =
"Call to H5C_move_entry on a R/O protected entry succeeded.\n";
} else {
unprotect_entry(file_ptr, 0, 0, H5C__NO_FLAGS_SET);
}
}
if(pass)
takedown_cache(file_ptr, FALSE, FALSE);
if(pass)
PASSED()
else {
H5_FAILED()
HDfprintf(stdout, "%s: failure_mssg = \"%s\".\n",
FUNC, failure_mssg);
} /* end else */
return (unsigned)!pass;
} /* check_move_entry_errs() */
/*-------------------------------------------------------------------------
* Function: check_resize_entry_errs()
@ -16869,7 +16933,7 @@ check_resize_entry_errs(void)
/* Allocate a cache, protect an entry, and then call
* H5C_resize_entry() to resize it -- this should succeed.
*
* Unprotect the the entry with the pinned flag, and then call
* Unprotect the entry with the pinned flag, and then call
* H5C_resize_entry() again with new size of zero.
* This should fail.
*
@ -36308,7 +36372,6 @@ main(void)
nerrs += check_destroy_pinned_err();
nerrs += check_destroy_protected_err();
nerrs += check_duplicate_insert_err();
nerrs += check_move_err();
nerrs += check_double_pin_err();
nerrs += check_double_unpin_err();
nerrs += check_pin_entry_errs();
@ -36316,6 +36379,7 @@ main(void)
nerrs += check_double_unprotect_err();
nerrs += check_mark_entry_dirty_errs();
nerrs += check_expunge_entry_errs();
nerrs += check_move_entry_errs();
nerrs += check_resize_entry_errs();
nerrs += check_unprotect_ro_dirty_err();
nerrs += check_protect_ro_rw_err();

8
test/cache_common.c
View File

@ -721,8 +721,8 @@ notify_get_initial_load_size(void *udata, size_t *image_length)
*-------------------------------------------------------------------------
*/
static herr_t
get_final_load_size(const void *image, size_t image_len, void *udata,
size_t *actual_len, int32_t entry_type)
get_final_load_size(const void H5_ATTR_UNUSED *image, size_t H5_ATTR_UNUSED image_len,
void *udata, size_t *actual_len, int32_t entry_type)
{
test_entry_t *entry;
test_entry_t *base_addr;
@ -3906,8 +3906,8 @@ move_entry(H5C_t * cache_ptr,
HDassert( entry_ptr->type == type );
HDassert( entry_ptr == entry_ptr->self );
HDassert( entry_ptr->cache_ptr == cache_ptr );
HDassert( !(entry_ptr->is_protected) );
HDassert( !(entry_ptr->header.is_protected) );
HDassert( !entry_ptr->is_read_only );
HDassert( !entry_ptr->header.is_read_only );
if ( entry_ptr->at_main_addr && !main_addr ) {

6
test/cache_common.h
View File

@ -360,9 +360,9 @@ typedef struct test_entry_t
unsigned notify_after_insert_count; /* Count of times that entry was inserted in cache */
unsigned notify_before_evict_count; /* Count of times that entry was removed in cache */
unsigned actual_len; /* Simulate the entry's actual size for a speculative load */
unsigned max_verify_ct; /* Maximum # of times to verify an entry's checksum */
unsigned verify_ct; /* Count the # of checksum verification for an entry */
size_t actual_len; /* Simulate the entry's actual size for a speculative load */
unsigned max_verify_ct; /* Maximum # of times to verify an entry's checksum */
unsigned verify_ct; /* Count the # of checksum verification for an entry */
} test_entry_t;
/* The following are cut down test versions of the hash table manipulation